Cette page a été traduite par l'API Cloud Translation.

Vertex AI in Firebase

Pour accéder à l'API Gemini et à la famille de modèles Gemini directement depuis votre application, nous vous recommandons d'utiliser le SDK Vertex AI in Firebase pour Android. Ce SDK fait partie de la plus grande plate-forme Firebase, qui vous aide à créer et à exécuter des applications full stack.

Migrer à partir du SDK client Google AI

Le SDK Vertex AI in Firebase est semblable au SDK client Google AI, mais le SDK Vertex AI in Firebase offre des options de sécurité essentielles et d'autres fonctionnalités pour les cas d'utilisation en production. Par exemple, lorsque vous utilisez Vertex AI dans Firebase, vous pouvez également utiliser les éléments suivants:

Firebase App Check pour protéger l'API Gemini des utilisations abusives par des clients non autorisés.
Firebase Remote Config pour définir et modifier de manière dynamique les valeurs de votre application dans le cloud (par exemple, les noms de modèles) sans avoir à publier une nouvelle version de votre application.
Cloud Storage for Firebase pour inclure de gros fichiers multimédias dans votre requête à l'API Gemini.

Si vous avez déjà intégré le SDK client Google AI à votre application, vous pouvez migrer vers Vertex AI in Firebase.

Premiers pas

Avant d'interagir avec l'API Gemini directement depuis votre application, vous devez d'abord effectuer quelques opérations, notamment vous familiariser avec les requêtes et configurer Firebase et votre application pour utiliser le SDK.

Tester des requêtes

Vous pouvez tester des requêtes dans Vertex AI Studio. Vertex AI Studio est un IDE permettant de concevoir et de prototyper des requêtes. 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 y revenir plus tard.

Créer la requête appropriée 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 requêtes, consultez la documentation Firebase.

Configurer un projet Firebase et associer votre application à Firebase

Lorsque vous êtes prêt à appeler l'API Gemini à partir de votre application, suivez les instructions du guide de démarrage Vertex AI in Firebase pour configurer Firebase et le SDK dans votre application. Le guide de démarrage vous aidera à effectuer toutes les tâches suivantes de ce guide.

Configurez un projet Firebase nouveau ou existant, y compris en utilisant le forfait Blaze avec paiement à l'usage et en activant les API requises.
Associez votre application à Firebase, y compris en l'enregistrant et en ajoutant votre fichier de configuration Firebase (google-services.json) à votre application.

Ajouter la dépendance Gradle

Ajoutez la dépendance Gradle suivante à votre module d'application:

KotlinJava

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

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

dependencies {

   [...]

   implementation("com.google.firebase:firebase-vertexai:16.2.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")
}

Initialiser le service Vertex AI et le modèle génératif

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

KotlinJava

val generativeModel = Firebase.vertexAI.generativeModel("gemini-2.0-flash")

GenerativeModel gm = FirebaseVertexAI.getInstance().generativeModel("gemini-2.0-flash");

Dans la documentation Firebase, vous pouvez en savoir plus sur les modèles disponibles à utiliser avec Vertex AI in Firebase. Vous pouvez également découvrir comment configurer les paramètres du modèle.

Interagir avec l'API Gemini 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 depuis votre application.

Générer du texte

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

KotlinJava

// Note: `generateContent()` is a `suspend` function, which integrates well
// with existing Kotlin code.

scope.launch {
  val response = model.generateContent("Write a story about the green robot")
}

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

GenerativeModelFutures model = GenerativeModelFutures.from(gm);

Content prompt = new Content.Builder()
    .addText("Write a story about a green robot.")
    .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 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). Vous pouvez également inclure de gros fichiers multimédias dans une requête à l'aide d'URL Cloud Storage for Firebase.

KotlinJava

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

GenerativeModelFutures model = GenerativeModelFutures.from(gm);

Bitmap bitmap = BitmapFactory.decodeResource(getResources(), R.drawable.sparky);

Content prompt = new Content.Builder()
        .addImage(bitmap)
        .addText("What developer tool is this mascot from?")
        .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);

Chat multitour

Vous pouvez également prendre en charge les conversations multi-tours. 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.

KotlinJava

val chat = generativeModel.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?")
}

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

Publisher<GenerateContentResponse> streamingResponse =
        chat.sendMessageStream(message);

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

});

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.

KotlinJava

scope.launch {
  var outputContent = ""

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

// Note that in Java the method `generateContentStream()` returns a
// Publisher from the Reactive Streams library.
// https://www.reactive-streams.org/

GenerativeModelFutures model = GenerativeModelFutures.from(gm);

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

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

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

Étapes suivantes

Consultez l'application exemple Vertex AI dans Firebase sur GitHub.
Commencez à vous préparer à la production, y compris en configurant Firebase App Check pour protéger l'API Gemini contre les utilisations abusives par des clients non autorisés.
Pour en savoir plus sur Vertex AI in Firebase, consultez la documentation Firebase.