Faites vos premiers pas avec l'API Gemini à l'aide des SDK Vertex AI pour Firebase


Ce guide explique comment effectuer des appels vers l'API Gemini directement à partir de votre application à l'aide du SDK Vertex AI pour Firebase.

Prérequis

Dans ce guide, nous partons du principe que vous savez utiliser Android Studio pour développer des applications pour Android.

  • Assurez-vous que votre environnement de développement et votre application Android répondent aux exigences suivantes:

    • Android Studio (dernière version)
    • Votre application Android doit cibler le niveau d'API 21 ou supérieur.

  • (Facultatif) Découvrez l'application exemple.

    Télécharger l'application exemple

    Vous pouvez tester rapidement le SDK, consulter une implémentation complète de différents cas d'utilisation ou utiliser l'application exemple si vous ne possédez pas votre propre application Android. Pour utiliser l'application exemple, vous devez la connecter à un projet Firebase.

Étape 1: Configurez un projet Firebase et connectez votre application à Firebase

Si vous avez déjà un projet et une application associés à Firebase

  1. Dans la console Firebase, accédez à la page Build with Gemini (Compiler avec Gemini), puis cliquez sur la deuxième fiche pour lancer un workflow qui vous aide à effectuer les tâches suivantes. Si la mise en page en cartes ne s'affiche pas, cela signifie que ces tâches sont terminées.

  2. Passez à l'étape suivante de ce guide pour ajouter le SDK à votre application.

Si vous n'avez pas encore de projet Firebase et d'application connectée à Firebase

Étape 2: Ajouter le SDK

Une fois votre projet Firebase configuré et votre application connectée à Firebase (voir l'étape précédente), vous pouvez y ajouter le SDK Vertex AI pour Firebase.

Le SDK Vertex AI pour Android (firebase-vertexai) permet d'accéder à l'API Gemini.

Dans le fichier de configuration Gradle de votre module (au niveau de l'application) (comme <project>/<app-module>/build.gradle.kts), ajoutez la dépendance pour le SDK Vertex AI pour Android:

Kotlin+KTX 

dependencies {
  // ... other androidx dependencies

  // add the dependency for the Vertex AI SDK for Android
  implementation("com.google.firebase:firebase-vertexai:16.0.0-alpha02")
}

Java

Pour Java, vous devez ajouter deux bibliothèques supplémentaires.

dependencies {
  // ... other androidx dependencies

  // add the dependency for the Vertex AI SDK for Android
  implementation("com.google.firebase:firebase-vertexai:16.0.0-alpha02")

  // 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")
}

Étape 3: Initialiser le service Vertex AI et le modèle génératif

Avant de pouvoir effectuer des appels d'API, vous devez initialiser le service Vertex AI et le modèle génératif.

Kotlin+KTX 

// Initialize the Vertex AI service and the generative model
// Specify a model that supports your use case
// Gemini 1.5 Pro is versatile and can accept both text-only and multimodal prompt inputs
val generativeModel = Firebase.vertexAI.generativeModel("gemini-1.5-pro-preview-0409")
Pour Kotlin, les méthodes de ce SDK sont des fonctions de suspension et doivent être appelées à partir d'un champ d'application de coroutine. Si vous ne connaissez pas les coroutines, consultez la page Coroutines Kotlin sur Android.

Java 

// Initialize the Vertex AI service and the generative model
// Specify a model that supports your use case
// Gemini 1.5 Pro is versatile and can accept both text-only and multimodal prompt inputs
GenerativeModel gm = FirebaseVertexAI.getInstance()
        .generativeModel("gemini-1.5-pro-preview-0409");

// Use the GenerativeModelFutures Java compatibility layer which offers
// support for ListenableFuture and Publisher APIs
GenerativeModelFutures model = GenerativeModelFutures.from(gm);
Pour Java, les méthodes de traitement par flux de ce SDK renvoient un type Publisher provenant de la bibliothèque Reactive Streams.

Une fois que vous avez terminé le guide de démarrage, découvrez comment choisir un modèle Gemini adapté à votre cas d'utilisation.

Étape 4: Appeler l'API Gemini

Maintenant que vous avez connecté votre application à Firebase, ajouté le SDK et initialisé le service Vertex AI et le modèle génératif, vous êtes prêt à appeler l'API Gemini.

Indiquez si vous souhaitez diffuser la réponse (generateContentStream) ou l'attendre jusqu'à ce que l'intégralité du résultat soit générée (generateContent).

Flux

Par défaut, le modèle renvoie une réponse une fois l'ensemble du processus de génération terminé. Toutefois, vous pouvez obtenir des interactions plus rapides en n'attendant pas le résultat complet et en utilisant plutôt un flux pour gérer les résultats partiels.

Vous pouvez utiliser generateContentStream() pour diffuser du texte généré à partir d'une requête de requête n'incluant que du texte:

Kotlin+KTX 

// Initialize the Vertex AI service and the generative model
// Specify a model that supports your use case
// Gemini 1.5 Pro is versatile and can accept both text-only and multimodal prompt inputs
val generativeModel = Firebase.vertexAI.generativeModel("gemini-1.5-pro-preview-0409")

// Provide a prompt that includes only text
val prompt = "Write a story about a magic backpack."

// To stream generated text output, call generateContentStream and pass in the prompt
var response = ""
generativeModel.generateContentStream(prompt).collect { chunk ->
    print(chunk.text)
    response += chunk.text
}
Pour Kotlin, les méthodes de ce SDK sont des fonctions de suspension et doivent être appelées à partir d'un champ d'application de coroutine. Si vous ne connaissez pas les coroutines, consultez la page Coroutines Kotlin sur Android.

Java 

// Initialize the Vertex AI service and the generative model
// Specify a model that supports your use case
// Gemini 1.5 Pro is versatile and can accept both text-only and multimodal prompt inputs
GenerativeModel gm = FirebaseVertexAI.getInstance()
        .generativeModel("gemini-1.5-pro-preview-0409");
GenerativeModelFutures model = GenerativeModelFutures.from(gm);

// Provide a prompt that contains text
Content prompt = new Content.Builder()
        .addText("Write a story about a magic backpack.")
        .build();

// To stream generated text output, call generateContentStream with the text input
Publisher<GenerateContentResponse> streamingResponse =
    model.generateContentStream(prompt);

// Subscribe to partial results from the response
final String[] fullResponse = {""};
streamingResponse.subscribe(new Subscriber<GenerateContentResponse>() {
  @Override
  public void onNext(GenerateContentResponse generateContentResponse) {
    String chunk = generateContentResponse.getText();
    fullResponse[0] += chunk;
  }

  @Override
  public void onComplete() {
    System.out.println(fullResponse[0]);
  }

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

  @Override
  public void onSubscribe(Subscription s) { }
});
Pour Java, les méthodes de traitement par flux de ce SDK renvoient un type Publisher provenant de la bibliothèque Reactive Streams.

Sans streaming

Vous pouvez également attendre l'intégralité du résultat au lieu de le diffuser. Le résultat n'est renvoyé qu'une fois que le modèle a terminé l'ensemble du processus de génération.

Vous pouvez utiliser generateContent() pour générer du texte à partir d'une requête de requête qui n'inclut que du texte:

Kotlin+KTX 

// Initialize the Vertex AI service and the generative model
// Specify a model that supports your use case
// Gemini 1.5 Pro is versatile and can accept both text-only and multimodal prompt inputs
val generativeModel = Firebase.vertexAI.generativeModel("gemini-1.5-pro-preview-0409")

// Provide a prompt that contains text
val prompt = "Write a story about a magic backpack."

// To generate text output, call generateContent with the text input
val response = generativeModel.generateContent(prompt)
print(response.text)
Pour Kotlin, les méthodes de ce SDK sont des fonctions de suspension et doivent être appelées à partir d'un champ d'application de coroutine. Si vous ne connaissez pas les coroutines, consultez la page Coroutines Kotlin sur Android.

Java 

// Initialize the Vertex AI service and the generative model
// Specify a model that supports your use case
// Gemini 1.5 Pro is versatile and can accept both text-only and multimodal prompt inputs
GenerativeModel gm = FirebaseVertexAI.getInstance()
        .generativeModel("gemini-1.5-pro-preview-0409");
GenerativeModelFutures model = GenerativeModelFutures.from(gm);

// Provide a prompt that contains text
Content prompt = new Content.Builder()
    .addText("Write a story about a magic backpack.")
    .build();

// To generate text output, call generateContent with the text input
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);
Pour Java, les méthodes de ce SDK renvoient un ListenableFuture. Si vous ne connaissez pas cette API, consultez la documentation Android sur l'utilisation d'un ListenableFuture.

Qu'est-ce que tu sais faire d'autre ?

En savoir plus sur les modèles Gemini

Découvrez les modèles disponibles pour différents cas d'utilisation, ainsi que leurs quotas et leur tarification.

Tester d'autres fonctionnalités de l'API Gemini

Découvrez comment contrôler la génération de contenu

Vous pouvez également tester des requêtes et des configurations de modèle à l'aide de Vertex AI Studio.


Donnez-nous votre avis sur votre expérience avec les SDK Vertex AI pour Firebase.