SDK client Google AI

Le SDK client Google AI vous permet d'appeler l'API Gemini et d'utiliser la famille de modèles Gemini directement depuis votre application Android.

Une version sans frais vous permet de tester sans frais. Pour en savoir plus sur les tarifs, consultez la grille tarifaire.

Architecture d'intégration de l'IA de Google
Image 1. Architecture d'intégration de l'IA de Google.

Premiers pas

Avant d'interagir avec l'API Gemini directement à partir de votre application, vous devez d'abord effectuer quelques opérations, y compris vous familiariser avec les requêtes, générer une clé API et configurer votre application pour qu'elle utilise le SDK.

Tester des requêtes

Commencez par créer un prototype de votre requête dans Google AI Studio.

Google AI Studio est un IDE conçu pour la conception et le prototypage d'invites. Il vous permet d'importer des fichiers pour tester des requêtes avec du texte et des images, et d'enregistrer une requête pour la consulter plus tard.

Créer la bonne invite pour votre cas d'utilisation est plus un art qu'une science, ce qui rend l'expérimentation essentielle. Pour en savoir plus sur les requêtes, consultez la documentation officielle de Google AI.

Google AI Studio
Figure 2. Google AI Studio

Pour en savoir plus sur les fonctionnalités avancées de Google AI Studio, consultez le guide de démarrage rapide de Google AI Studio.

Générer votre clé API

Une fois que vous êtes satisfait de votre requête, cliquez sur Obtenir une clé API pour générer votre clé API Gemini. La clé sera fournie avec votre application, ce qui est acceptable pour les tests et le prototypage, mais non recommandé pour les cas d'utilisation en production.

Pour éviter que votre clé API ne soit validée dans votre dépôt de code source, utilisez le plug-in Gradle Secrets.

Ajouter la dépendance Gradle

Ajoutez la dépendance du SDK client Google AI à votre application:

Kotlin

dependencies {
  [...]
 implementation("com.google.ai.client.generativeai:generativeai:0.7.0")
}

Java

dependencies {
  [...]
  implementation("com.google.ai.client.generativeai:generativeai:0.7.0")

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

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

Créer un élément GenerativeModel

Commencez par instancier un GenerativeModel en fournissant les éléments suivants:

  • Le nom du modèle: gemini-1.5-flash, gemini-1.5-pro ou gemini-1.0-pro
  • Votre clé API générée avec Google AI Studio.

Vous pouvez définir les paramètres du modèle et fournir des valeurs pour la température, le topK, le topP et les jetons de sortie maximum.

Vous pouvez également définir les fonctionnalités de sécurité pour les sujets suivants:

  • HARASSMENT
  • HATE_SPEECH
  • SEXUALLY_EXPLICIT
  • DANGEROUS_CONTENT

Kotlin

val model = GenerativeModel(
  model = "gemini-1.5-flash-001",
  apiKey = BuildConfig.apikey,
  generationConfig = generationConfig {
    temperature = 0.15f
    topK = 32
    topP = 1f
    maxOutputTokens = 4096
  },
  safetySettings = listOf(
    SafetySetting(HarmCategory.HARASSMENT, BlockThreshold.MEDIUM_AND_ABOVE),
    SafetySetting(HarmCategory.HATE_SPEECH, BlockThreshold.MEDIUM_AND_ABOVE),
    SafetySetting(HarmCategory.SEXUALLY_EXPLICIT, BlockThreshold.MEDIUM_AND_ABOVE),
    SafetySetting(HarmCategory.DANGEROUS_CONTENT, BlockThreshold.MEDIUM_AND_ABOVE),
  )
)

Java

GenerationConfig.Builder configBuilder = new GenerationConfig.Builder();
configBuilder.temperature = 0.15f;
configBuilder.topK = 32;
configBuilder.topP = 1f;
configBuilder.maxOutputTokens = 4096;

ArrayList<SafetySetting> safetySettings = new ArrayList();
safetySettings.add(new SafetySetting(HarmCategory.HARASSMENT, BlockThreshold.MEDIUM_AND_ABOVE));
safetySettings.add(new SafetySetting(HarmCategory.HATE_SPEECH, BlockThreshold.MEDIUM_AND_ABOVE));
safetySettings.add(new SafetySetting(HarmCategory.SEXUALLY_EXPLICIT, BlockThreshold.MEDIUM_AND_ABOVE));
safetySettings.add(new SafetySetting(HarmCategory.DANGEROUS_CONTENT, BlockThreshold.MEDIUM_AND_ABOVE));

GenerativeModel gm = new GenerativeModel(
    "gemini-1.5-flash-001",
    BuildConfig.apiKey,
    configBuilder.build(),
    safetySettings
);

Utiliser le SDK client Google AI dans votre application

Maintenant que vous disposez d'une clé API et que vous avez configuré votre application pour utiliser le SDK, vous pouvez interagir avec l'API Gemini.

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 green robot.")
}

Java

// In Java, create a GenerativeModelFutures from the GenerativeModel.
// generateContent() returns a ListenableFuture.
// Learn more:
// https://developer.android.com/develop/background-work/background-tasks/asynchronous/listenablefuture

GenerativeModelFutures model = GenerativeModelFutures.from(gm);

Content content = new Content.Builder()
      .addText("Write a story about a green robot.")
      .build();
Executor executor = // ...

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);

Notez que generateContent() est une fonction suspend, qui s'intègre bien au code Kotlin existant.

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 qui inclut 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 (comme illustré dans l'exemple ci-dessous).

Kotlin

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

Java

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

Executor executor = // ...

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);

Chat multitour

Vous pouvez également prendre en charge les conversations multitours. Initialisez une discussion avec la fonction startChat(). Vous pouvez éventuellement fournir 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();

// (Optional) create message history
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);

Content.Builder userMessageBuilder = new Content.Builder();
userMessageBuilder.setRole("user");
userMessageBuilder.addText("How many paws are in my house?");
Content userMessage = userMessageBuilder.build();

Executor executor = // ...

ListenableFuture<GenerateContentResponse> response = chat.sendMessage(userMessage);

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);

Afficher la réponse de manière progressive

Vous pouvez accélérer les interactions en n'attendant pas le résultat complet de la génération du modèle, et en utilisant plutôt le streaming pour gérer les résultats partiels. Utilisez generateContentStream() pour diffuser une réponse.

Kotlin

someScope.launch {
  var outputContent = ""
  
  generativeModel.generateContentStream(inputContent)
    .collect { response ->
      outputContent += response.text
    }
}

Java

// In Java, the method generateContentStream() returns a Publisher
// from the Reactive Streams library.
// https://www.reactive-streams.org/

Publisher<GenerateContentResponse> streamingResponse =
    model.generateContentStream(content);

StringBuilder outputContent = new StringBuilder();

streamingResponse.subscribe(new Subscriber<GenerateContentResponse>() {
  @Override
  public void onNext(GenerateContentResponse generateContentResponse) {
    String chunk = generateContentResponse.getText();
    outputContent.append(chunk);
  }

    @Override
    public void onComplete() {
        // ...
    }

    @Override
    public void onError(Throwable t) {
        t.printStackTrace();
    }

    @Override
    public void onSubscribe(Subscription s) {
       s.request(Long.MAX_VALUE);  // Request all messages
 }
});

Android Studio

Android Studio fournit des outils supplémentaires pour vous aider à démarrer.

  • Modèle de démarrage de l'API Gemini: ce modèle de démarrage vous aide à créer une clé API directement depuis Android Studio et génère un projet qui inclut les dépendances Android nécessaires pour utiliser les API Gemini.
  • Exemple d'IA générative: cet exemple vous permet d'importer le SDK client Google AI pour l'application exemple Android dans Android Studio.

Étapes suivantes