API Gemini pour les développeurs

Pour accéder aux modèles Gemini Pro et Flash, nous recommandons aux développeurs Android d'utiliser l'API Gemini Developer avec Firebase AI Logic. Il vous permet de vous lancer sans avoir besoin d'une carte de crédit et propose un niveau sans frais généreux. Une fois que vous avez validé votre intégration auprès d'une petite base d'utilisateurs, vous pouvez passer au forfait payant pour évoluer.

Illustration d'une application Android contenant un SDK Firebase pour Android. Une flèche pointe du SDK vers Firebase dans un environnement cloud. Depuis Firebase, une autre flèche pointe vers l'API Gemini Developer, qui est connectée à Gemini Pro et Gemini Flash, également dans le cloud.
Figure 1. Architecture d'intégration de Firebase AI Logic pour accéder à l'API Gemini Developer.

Premiers pas

Avant d'interagir avec l'API Gemini directement depuis votre application, vous devez effectuer quelques étapes. Par exemple, vous familiariser avec l'invite, et configurer Firebase et votre application pour utiliser le SDK.

Tester des requêtes

Faire des tests avec des requêtes peut vous aider à trouver la formulation, le contenu et le format les plus adaptés à votre application Android. Google AI Studio est un IDE que vous pouvez utiliser pour prototyper et concevoir des requêtes pour les cas d'utilisation de votre application.

Créer la requête idéale pour votre cas d'utilisation est un art plus qu'une science, ce qui rend l'expérimentation essentielle. Pour en savoir plus sur les invites, consultez la documentation Firebase.

Une fois que vous êtes satisfait de votre requête, cliquez sur le bouton "<>" pour obtenir des extraits de code que vous pouvez ajouter à votre code.

Configurer un projet Firebase et associer votre application à Firebase

Lorsque vous êtes prêt à appeler l'API depuis votre application, suivez les instructions de l'étape 1 du guide de démarrage de Firebase AI Logic pour configurer Firebase et le SDK dans votre application.

Ajouter la dépendance Gradle

Ajoutez la dépendance Gradle suivante au module de votre application :

Kotlin

dependencies {
  // ... other androidx dependencies

  // Import the BoM for the Firebase platform
  implementation(platform("com.google.firebase:firebase-bom:34.1.0"))

  // Add the dependency for the Firebase AI Logic library When using the BoM,
  // you don't specify versions in Firebase library dependencies
  implementation("com.google.firebase:firebase-ai")
}

Java

dependencies {
  // Import the BoM for the Firebase platform
  implementation(platform("com.google.firebase:34.1.0"))

  // Add the dependency for the Firebase AI Logic library When using the BoM,
  // you don't specify versions in Firebase library dependencies
  implementation("com.google.firebase:firebase-ai")

  // Required for one-shot operations (to use `ListenableFuture` from Guava
  // Android)
  implementation("com.google.guava:guava:31.0.1-android")

  // Required for streaming operations (to use `Publisher` from Reactive
  // Streams)
  implementation("org.reactivestreams:reactive-streams:1.0.4")
}

Initialiser le modèle génératif

Commencez par instancier un GenerativeModel et spécifier le nom du modèle :

Kotlin

val model = Firebase.ai(backend = GenerativeBackend.googleAI())
                        .generativeModel("gemini-2.5-flash")

Java

GenerativeModel firebaseAI = FirebaseAI.getInstance(GenerativeBackend.googleAI())
        .generativeModel("gemini-2.5-flash");

GenerativeModelFutures model = GenerativeModelFutures.from(firebaseAI);

En savoir plus sur les modèles disponibles à utiliser avec l'API Gemini Developer Vous pouvez également en savoir plus sur la configuration des paramètres du modèle.

Interagir avec l'API Gemini Developer depuis votre application

Maintenant que vous avez configuré Firebase et votre application pour utiliser le SDK, vous êtes prêt à interagir avec l'API Gemini Developer depuis votre application.

Générer du texte

Pour générer une réponse textuelle, appelez generateContent() avec votre requête.

Kotlin

scope.launch {
  val response = model.generateContent("Write a story about a magic backpack.")
}

Java

Content prompt = new Content.Builder()
    .addText("Write a story about a magic backpack.")
    .build();

ListenableFuture<GenerateContentResponse> response = model.generateContent(prompt);
Futures.addCallback(response, new FutureCallback<GenerateContentResponse>() {
    @Override
    public void onSuccess(GenerateContentResponse result) {
        String resultText = result.getText();
        [...]
    }

    @Override
    public void onFailure(Throwable t) {
        t.printStackTrace();
    }
}, executor);

Générer du texte à partir d'images et d'autres contenus multimédias

Vous pouvez également générer du texte à partir d'une requête incluant du texte, des images ou d'autres contenus multimédias. Lorsque vous appelez generateContent(), vous pouvez transmettre le contenu multimédia en tant que données intégrées.

Par exemple, pour utiliser un bitmap, utilisez le type de contenu image :

Kotlin

scope.launch {
  val response = model.generateContent(
    content {
      image(bitmap)
      text("what is the object in the picture?")
    }
  )
}

Java

Content content = new Content.Builder()
        .addImage(bitmap)
        .addText("what is the object in the picture?")
        .build();

ListenableFuture<GenerateContentResponse> response = model.generateContent(content);
Futures.addCallback(response, new FutureCallback<GenerateContentResponse>() {
    @Override
    public void onSuccess(GenerateContentResponse result) {
        String resultText = result.getText();
        [...]
    }

    @Override
    public void onFailure(Throwable t) {
        t.printStackTrace();
    }
}, executor);

Pour transmettre un fichier audio, utilisez le type de contenu inlineData :

Kotlin

val contentResolver = applicationContext.contentResolver
val inputStream = contentResolver.openInputStream(audioUri).use { stream ->
    stream?.let {
        val bytes = stream.readBytes()

        val prompt = content {
            inlineData(bytes, "audio/mpeg")  // Specify the appropriate audio MIME type
            text("Transcribe this audio recording.")
        }

        val response = model.generateContent(prompt)
    }
}

Java

ContentResolver resolver = getApplicationContext().getContentResolver();

try (InputStream stream = resolver.openInputStream(audioUri)) {
    File audioFile = new File(new URI(audioUri.toString()));
    int audioSize = (int) audioFile.length();
    byte audioBytes = new byte[audioSize];
    if (stream != null) {
        stream.read(audioBytes, 0, audioBytes.length);
        stream.close();

        // Provide a prompt that includes audio specified earlier and text
        Content prompt = new Content.Builder()
              .addInlineData(audioBytes, "audio/mpeg")  // Specify the appropriate audio MIME type
              .addText("Transcribe what's said in this audio recording.")
              .build();

        // To generate text output, call `generateContent` with the prompt
        ListenableFuture<GenerateContentResponse> response = model.generateContent(prompt);
        Futures.addCallback(response, new FutureCallback<GenerateContentResponse>() {
            @Override
            public void onSuccess(GenerateContentResponse result) {
                String text = result.getText();
                Log.d(TAG, (text == null) ? "" : text);
            }
            @Override
            public void onFailure(Throwable t) {
                Log.e(TAG, "Failed to generate a response", t);
            }
        }, executor);
    } else {
        Log.e(TAG, "Error getting input stream for file.");
        // Handle the error appropriately
    }
} catch (IOException e) {
    Log.e(TAG, "Failed to read the audio file", e);
} catch (URISyntaxException e) {
    Log.e(TAG, "Invalid audio file", e);
}

Pour fournir un fichier vidéo, continuez à utiliser le type de contenu inlineData :

Kotlin

val contentResolver = applicationContext.contentResolver
contentResolver.openInputStream(videoUri).use { stream ->
  stream?.let {
    val bytes = stream.readBytes()

    val prompt = content {
        inlineData(bytes, "video/mp4")  // Specify the appropriate video MIME type
        text("Describe the content of this video")
    }

    val response = model.generateContent(prompt)
  }
}

Java

ContentResolver resolver = getApplicationContext().getContentResolver();

try (InputStream stream = resolver.openInputStream(videoUri)) {
    File videoFile = new File(new URI(videoUri.toString()));
    int videoSize = (int) videoFile.length();
    byte[] videoBytes = new byte[videoSize];
    if (stream != null) {
        stream.read(videoBytes, 0, videoBytes.length);
        stream.close();

        // Provide a prompt that includes video specified earlier and text
        Content prompt = new Content.Builder()
                .addInlineData(videoBytes, "video/mp4")
                .addText("Describe the content of this video")
                .build();

        // To generate text output, call generateContent with the prompt
        ListenableFuture<GenerateContentResponse> response = model.generateContent(prompt);
        Futures.addCallback(response, new FutureCallback<GenerateContentResponse>() {
            @Override
            public void onSuccess(GenerateContentResponse result) {
                String resultText = result.getText();
                System.out.println(resultText);
            }

            @Override
            public void onFailure(Throwable t) {
                t.printStackTrace();
            }
        }, executor);
    }
} catch (IOException e) {
    e.printStackTrace();
} catch (URISyntaxException e) {
    e.printStackTrace();
}

De même, vous pouvez également transmettre des documents PDF (application/pdf) et en texte brut (text/plain) en transmettant leur type MIME respectif en tant que paramètre.

Chat multitour

Vous pouvez également prendre en charge les conversations multitours. Initialisez une discussion avec la fonction startChat(). Vous pouvez éventuellement fournir à votre modèle un historique des messages. Appelez ensuite la fonction sendMessage() pour envoyer des messages de chat.

Kotlin

val chat = model.startChat(
    history = listOf(
        content(role = "user") { text("Hello, I have 2 dogs in my house.") },
        content(role = "model") { text("Great to meet you. What would you like to know?")   }
    )
)

scope.launch {
   val response = chat.sendMessage("How many paws are in my house?")
}

Java

Content.Builder userContentBuilder = new Content.Builder();
userContentBuilder.setRole("user");
userContentBuilder.addText("Hello, I have 2 dogs in my house.");
Content userContent = userContentBuilder.build();

Content.Builder modelContentBuilder = new Content.Builder();
modelContentBuilder.setRole("model");
modelContentBuilder.addText("Great to meet you. What would you like to know?");
Content modelContent = userContentBuilder.build();

List<Content> history = Arrays.asList(userContent, modelContent);

// Initialize the chat
ChatFutures chat = model.startChat(history);

// Create a new user message
Content.Builder messageBuilder = new Content.Builder();
messageBuilder.setRole("user");
messageBuilder.addText("How many paws are in my house?");

Content message = messageBuilder.build();

// Send the message
ListenableFuture<GenerateContentResponse> response = chat.sendMessage(message);
Futures.addCallback(response, new FutureCallback<GenerateContentResponse>() {
    @Override
    public void onSuccess(GenerateContentResponse result) {
        String resultText = result.getText();
        System.out.println(resultText);
    }

    @Override
    public void onFailure(Throwable t) {
        t.printStackTrace();
    }
}, executor);

Pour en savoir plus, consultez la documentation de Firebase.

Étapes suivantes