Créer des conversations multitours (chat) à l'aide de l'API Gemini

En utilisant Gemini API, vous pouvez créer des conversations en mode forme libre comportant plusieurs tours. Le Firebase AI Logic SDK simplifie le processus en gérant l'état de la conversation. Ainsi, contrairement à generateContent() (ou generateContentStream()), vous n'avez pas besoin de stocker vous-même l'historique des conversations .

Accéder au code pour le chat en texte seul Accéder au code pour la modification itérative d'images Accéder au code pour les réponses en streaming

Avant de commencer

Cliquez sur votre fournisseur Gemini API pour afficher le contenu spécifique au fournisseur et le code sur cette page. API Gemini pour les développeurs API Gemini Vertex AI

Si ce n'est pas déjà fait, suivez le guide de démarrage, qui explique comment configurer votre projet Firebase, associer votre application à Firebase, ajouter le SDK, initialiser le service backend pour le fournisseur Gemini API de votre choix et créer une instance GenerativeModel.

Tous nos documents supposent que vous utilisez les dernières versions des Firebase AI Logic SDK.

Pour tester et effectuer des itérations de vos requêtes, nous vous recommandons d'utiliser Google AI Studio.

Consultez des ressources utiles

Swift

Essayer l'application de démarrage rapide

Utilisez l'application de démarrage rapide pour essayer rapidement le SDK et voir une implémentation complète de différents cas d'utilisation. Vous pouvez également utiliser l'application de démarrage rapide si vous ne possédez pas votre propre application pour les plates-formes Apple. Pour utiliser l'application de démarrage rapide, vous devez l'associer à un projet Firebase.

Accéder à l'application de démarrage rapide

Regarder·un tutoriel vidéo

Cette vidéo montre comment implémenter un chat avec Firebase AI Logic en créant une application de planification de repas basée sur l'IA qui permet aux utilisateurs de discuter avec un chef cuisinier des recettes qu'ils souhaitent préparer.

Vous pouvez également télécharger et explorer la base de code de l'application dans la vidéo.

Afficher la base de code de l'application de la vidéo

Kotlin

Essayer l'application de démarrage rapide

Utilisez l'application de démarrage rapide pour essayer rapidement le SDK et voir une implémentation complète de différents cas d'utilisation. Vous pouvez également utiliser l'application de démarrage rapide si vous ne possédez pas votre propre application Android. Pour utiliser l'application de démarrage rapide, vous devez l'associer à un projet Firebase.

Accéder à l'application de démarrage rapide

Java

Essayer l'application de démarrage rapide

Utilisez l'application de démarrage rapide pour essayer rapidement le SDK et voir une implémentation complète de différents cas d'utilisation. Vous pouvez également utiliser l'application de démarrage rapide si vous ne possédez pas votre propre application Android. Pour utiliser l'application de démarrage rapide, vous devez l'associer à un projet Firebase.

Accéder à l'application de démarrage rapide

Web

Essayer l'application de démarrage rapide

Utilisez l'application de démarrage rapide pour essayer rapidement le SDK et voir une implémentation complète de différents cas d'utilisation. Vous pouvez également utiliser l'application de démarrage rapide si vous ne possédez pas votre propre application Web. Pour utiliser l'application de démarrage rapide, vous devez l'associer à un projet Firebase.

Accéder à l'application de démarrage rapide

Regarder·un tutoriel vidéo

Cette vidéo montre comment implémenter un chat avec Firebase AI Logic en créant une application de planification de repas basée sur l'IA qui permet aux utilisateurs de discuter avec un chef cuisinier des recettes qu'ils souhaitent préparer.

Vous pouvez également télécharger et explorer la base de code de l'application dans la vidéo.

Afficher la base de code de l'application de la vidéo

Dart

Essayer l'application de démarrage rapide

Utilisez l'application de démarrage rapide pour essayer rapidement le SDK et voir une implémentation complète de différents cas d'utilisation. Vous pouvez également utiliser l'application de démarrage rapide si vous ne possédez pas votre propre application Flutter. Pour utiliser l'application de démarrage rapide, vous devez l'associer à un projet Firebase.

Accéder à l'application de démarrage rapide

Unity

Essayer l'application de démarrage rapide

Utilisez l'application de démarrage rapide pour essayer rapidement le SDK et voir une implémentation complète de différents cas d'utilisation. Vous pouvez également utiliser l'application de démarrage rapide si vous ne possédez pas votre propre jeu Unity. Pour utiliser l'application de démarrage rapide, vous devez l'associer à un projet Firebase .

Accéder à l'application de démarrage rapide

Créer une expérience de chat en texte seul

Avant d'essayer cet exemple, suivez la section Avant de commencer de ce guide pour configurer votre projet et votre application. Dans cette section, vous cliquerez également sur un bouton pour le fournisseur Gemini API de votre choix afin d'afficher le contenu spécifique au fournisseur sur cette page.

Pour créer une conversation multitour (comme un chat), commencez par initialiser le chat en appelant startChat(). Utilisez ensuite sendMessage() pour envoyer un nouveau message utilisateur, qui ajoutera également le message et la réponse à l'historique du chat.

Deux options sont possibles pour role associé au contenu d'une conversation :

• user : rôle qui fournit les requêtes. Cette valeur est la valeur par défaut pour les appels à sendMessage(), et la fonction génère une exception si un rôle différent est transmis.

• model : rôle qui fournit les réponses. Ce rôle peut être utilisé lors de l'appel de startChat() avec un history existant.

Remarque : Si vous souhaitez fournir plus de contexte initial au modèle pour l'aider à orienter son comportement en fonction de vos besoins et cas d'utilisation spécifiques, envisagez de définir des instructions système.

Swift

Vous pouvez appeler startChat() et sendMessage() pour envoyer un nouveau message utilisateur :

import FirebaseAILogic

// Initialize the Gemini Developer API backend service
let ai = FirebaseAI.firebaseAI(backend: .googleAI())

// Create a `GenerativeModel` instance with a model that supports your use case
let model = ai.generativeModel(modelName: "gemini-3-flash-preview")


// Optionally specify existing chat history
let history = [
  ModelContent(role: "user", parts: "Hello, I have 2 dogs in my house."),
  ModelContent(role: "model", parts: "Great to meet you. What would you like to know?"),
]

// Initialize the chat with optional chat history
let chat = model.startChat(history: history)

// To generate text output, call sendMessage and pass in the message
let response = try await chat.sendMessage("How many paws are in my house?")
print(response.text ?? "No text in response.")

Kotlin

Vous pouvez appeler startChat() et sendMessage() pour envoyer un nouveau message utilisateur :

^{Pour Kotlin, les méthodes de ce SDK sont des fonctions de suspension et doivent être appelées à partir d'une portéeCoroutine.}

// Initialize the Gemini Developer API backend service
// Create a `GenerativeModel` instance with a model that supports your use case
val model = Firebase.ai(backend = GenerativeBackend.googleAI())
                        .generativeModel("gemini-3-flash-preview")


// Initialize the chat
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?") }
  )
)

val response = chat.sendMessage("How many paws are in my house?")
print(response.text)

Java

Vous pouvez appeler startChat() et sendMessage() pour envoyer un nouveau message utilisateur :

^{Pour Java, les méthodes de ce SDK renvoient un ListenableFuture.}

// Initialize the Gemini Developer API backend service
// Create a `GenerativeModel` instance with a model that supports your use case
GenerativeModel ai = FirebaseAI.getInstance(GenerativeBackend.googleAI())
        .generativeModel("gemini-3-flash-preview");

// Use the GenerativeModelFutures Java compatibility layer which offers
// support for ListenableFuture and Publisher APIs
GenerativeModelFutures model = GenerativeModelFutures.from(ai);


// (optional) Create previous chat history for context
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);

Web

Vous pouvez appeler startChat() et sendMessage() pour envoyer un nouveau message utilisateur :

import { initializeApp } from "firebase/app";
import { getAI, getGenerativeModel, GoogleAIBackend } from "firebase/ai";

// TODO(developer) Replace the following with your app's Firebase configuration
// See: https://firebase.google.com/docs/web/learn-more#config-object
const firebaseConfig = {
  // ...
};

// Initialize FirebaseApp
const firebaseApp = initializeApp(firebaseConfig);

// Initialize the Gemini Developer API backend service
const ai = getAI(firebaseApp, { backend: new GoogleAIBackend() });

// Create a `GenerativeModel` instance with a model that supports your use case
const model = getGenerativeModel(ai, { model: "gemini-3-flash-preview" });


async function run() {
  const chat = model.startChat({
    history: [
      {
        role: "user",
        parts: [{ text: "Hello, I have 2 dogs in my house." }],
      },
      {
        role: "model",
        parts: [{ text: "Great to meet you. What would you like to know?" }],
      },
    ],
    generationConfig: {
      maxOutputTokens: 100,
    },
  });

  const msg = "How many paws are in my house?";

  const result = await chat.sendMessage(msg);

  const text = result.response.text();
  console.log(text);
}

run();

Dart

Vous pouvez appeler startChat() et sendMessage() pour envoyer un nouveau message utilisateur :

import 'package:firebase_ai/firebase_ai.dart';
import 'package:firebase_core/firebase_core.dart';
import 'firebase_options.dart';

// Initialize FirebaseApp
await Firebase.initializeApp(
  options: DefaultFirebaseOptions.currentPlatform,
);

// Initialize the Gemini Developer API backend service
// Create a `GenerativeModel` instance with a model that supports your use case
final model =
      FirebaseAI.googleAI().generativeModel(model: 'gemini-3-flash-preview');


final chat = model.startChat();
// Provide a prompt that contains text
final prompt = [Content.text('Write a story about a magic backpack.')];

final response = await chat.sendMessage(prompt);
print(response.text);

Unity

Vous pouvez appeler StartChat() et SendMessageAsync() pour envoyer un nouveau message utilisateur :

using Firebase;
using Firebase.AI;

// Initialize the Gemini Developer API backend service
var ai = FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI());

// Create a `GenerativeModel` instance with a model that supports your use case
var model = ai.GetGenerativeModel(modelName: "gemini-3-flash-preview");


// Optionally specify existing chat history
var history = new [] {
  ModelContent.Text("Hello, I have 2 dogs in my house."),
  new ModelContent("model", new ModelContent.TextPart("Great to meet you. What would you like to know?")),
};

// Initialize the chat with optional chat history
var chat = model.StartChat(history);

// To generate text output, call SendMessageAsync and pass in the message
var response = await chat.SendMessageAsync("How many paws are in my house?");
UnityEngine.Debug.Log(response.Text ?? "No text in response.");

Découvrez comment choisir un modèle adapté à votre cas d'utilisation et à votre application.

Itérer et modifier des images à l'aide d'un chat multitour

Avant d'essayer cet exemple, suivez la section Avant de commencer de ce guide pour configurer votre projet et votre application. Dans cette section, vous cliquerez également sur un bouton pour le fournisseur Gemini API de votre choix afin d'afficher le contenu spécifique au fournisseur sur cette page.

Important : La sortie d’image de Gemini est compatible avec gemini-2.5-flash-image, mais pas avec les modèles Flash standards tels que gemini-2.5-flash.

À l'aide d'un chat multitour, vous pouvez itérer avec un Gemini modèle sur les images qu'il génère ou que vous fournissez.

Veillez à créer une instance GenerativeModel, à inclure responseModalities: ["TEXT", "IMAGE"] dans la configuration de votre modèle et à appeler startChat() et sendMessage() pour envoyer de nouveaux messages utilisateur.

Important : Si vous n'êtes pas familiarisé avec la fonctionnalité de chat des SDK, nous vous recommandons de consulter l'exemple de chat en texte seul.

Swift

import FirebaseAILogic

// Initialize the Gemini Developer API backend service
// Create a `GenerativeModel` instance with a Gemini model that supports image output
let generativeModel = FirebaseAI.firebaseAI(backend: .googleAI()).generativeModel(
  modelName: "gemini-2.5-flash-image",
  // Configure the model to respond with text and images (required)
  generationConfig: GenerationConfig(responseModalities: [.text, .image])
)

// Initialize the chat
let chat = model.startChat()

guard let image = UIImage(named: "scones") else { fatalError("Image file not found.") }

// Provide an initial text prompt instructing the model to edit the image
let prompt = "Edit this image to make it look like a cartoon"

// To generate an initial response, send a user message with the image and text prompt
let response = try await chat.sendMessage(image, prompt)

// Inspect the generated image
guard let inlineDataPart = response.inlineDataParts.first else {
  fatalError("No image data in response.")
}
guard let uiImage = UIImage(data: inlineDataPart.data) else {
  fatalError("Failed to convert data to UIImage.")
}

// Follow up requests do not need to specify the image again
let followUpResponse = try await chat.sendMessage("But make it old-school line drawing style")

// Inspect the edited image after the follow up request
guard let followUpInlineDataPart = followUpResponse.inlineDataParts.first else {
  fatalError("No image data in response.")
}
guard let followUpUIImage = UIImage(data: followUpInlineDataPart.data) else {
  fatalError("Failed to convert data to UIImage.")
}

Kotlin

// Initialize the Gemini Developer API backend service
// Create a `GenerativeModel` instance with a Gemini model that supports image output
val model = Firebase.ai(backend = GenerativeBackend.googleAI()).generativeModel(
    modelName = "gemini-2.5-flash-image",
    // Configure the model to respond with text and images (required)
    generationConfig = generationConfig {
responseModalities = listOf(ResponseModality.TEXT, ResponseModality.IMAGE) }
)

// Provide an image for the model to edit
val bitmap = BitmapFactory.decodeResource(context.resources, R.drawable.scones)

// Create the initial prompt instructing the model to edit the image
val prompt = content {
    image(bitmap)
    text("Edit this image to make it look like a cartoon")
}

// Initialize the chat
val chat = model.startChat()

// To generate an initial response, send a user message with the image and text prompt
var response = chat.sendMessage(prompt)
// Inspect the returned image
var generatedImageAsBitmap = response
    .candidates.first().content.parts.filterIsInstance<ImagePart>().firstOrNull()?.image

// Follow up requests do not need to specify the image again
response = chat.sendMessage("But make it old-school line drawing style")
generatedImageAsBitmap = response
    .candidates.first().content.parts.filterIsInstance<ImagePart>().firstOrNull()?.image

Java

// Initialize the Gemini Developer API backend service
// Create a `GenerativeModel` instance with a Gemini model that supports image output
GenerativeModel ai = FirebaseAI.getInstance(GenerativeBackend.googleAI()).generativeModel(
    "gemini-2.5-flash-image",
    // Configure the model to respond with text and images (required)
    new GenerationConfig.Builder()
        .setResponseModalities(Arrays.asList(ResponseModality.TEXT, ResponseModality.IMAGE))
        .build()
);

GenerativeModelFutures model = GenerativeModelFutures.from(ai);

// Provide an image for the model to edit
Bitmap bitmap = BitmapFactory.decodeResource(resources, R.drawable.scones);

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

// Create the initial prompt instructing the model to edit the image
Content prompt = new Content.Builder()
        .setRole("user")
        .addImage(bitmap)
        .addText("Edit this image to make it look like a cartoon")
        .build();

// To generate an initial response, send a user message with the image and text prompt
ListenableFuture<GenerateContentResponse> response = chat.sendMessage(prompt);
// Extract the image from the initial response
ListenableFuture<@Nullable Bitmap> initialRequest = Futures.transform(response, result -> {
    for (Part part : result.getCandidates().get(0).getContent().getParts()) {
        if (part instanceof ImagePart) {
            ImagePart imagePart = (ImagePart) part;
            return imagePart.getImage();
        }
    }
    return null;
}, executor);

// Follow up requests do not need to specify the image again
ListenableFuture<GenerateContentResponse> modelResponseFuture = Futures.transformAsync(
        initialRequest,
        generatedImage -> {
            Content followUpPrompt = new Content.Builder()
                    .addText("But make it old-school line drawing style")
                    .build();
            return chat.sendMessage(followUpPrompt);
        },
        executor);

// Add a final callback to check the reworked image
Futures.addCallback(modelResponseFuture, new FutureCallback<GenerateContentResponse>() {
    @Override
    public void onSuccess(GenerateContentResponse result) {
        for (Part part : result.getCandidates().get(0).getContent().getParts()) {
            if (part instanceof ImagePart) {
                ImagePart imagePart = (ImagePart) part;
                Bitmap generatedImageAsBitmap = imagePart.getImage();
                break;
            }
        }
    }

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

Web

import { initializeApp } from "firebase/app";
import { getAI, getGenerativeModel, GoogleAIBackend, ResponseModality } from "firebase/ai";

// TODO(developer) Replace the following with your app's Firebase configuration
// See: https://firebase.google.com/docs/web/learn-more#config-object
const firebaseConfig = {
  // ...
};

// Initialize FirebaseApp
const firebaseApp = initializeApp(firebaseConfig);

// Initialize the Gemini Developer API backend service
const ai = getAI(firebaseApp, { backend: new GoogleAIBackend() });

// Create a `GenerativeModel` instance with a model that supports your use case
const model = getGenerativeModel(ai, {
  model: "gemini-2.5-flash-image",
  // Configure the model to respond with text and images (required)
  generationConfig: {
    responseModalities: [ResponseModality.TEXT, ResponseModality.IMAGE],
  },
});

// Prepare an image for the model to edit
async function fileToGenerativePart(file) {
  const base64EncodedDataPromise = new Promise((resolve) => {
    const reader = new FileReader();
    reader.onloadend = () => resolve(reader.result.split(',')[1]);
    reader.readAsDataURL(file);
  });
  return {
    inlineData: { data: await base64EncodedDataPromise, mimeType: file.type },
  };
}

const fileInputEl = document.querySelector("input[type=file]");
const imagePart = await fileToGenerativePart(fileInputEl.files[0]);

// Provide an initial text prompt instructing the model to edit the image
const prompt = "Edit this image to make it look like a cartoon";

// Initialize the chat
const chat = model.startChat();

// To generate an initial response, send a user message with the image and text prompt
const result = await chat.sendMessage([prompt, imagePart]);

// Request and inspect the generated image
try {
  const inlineDataParts = result.response.inlineDataParts();
  if (inlineDataParts?.[0]) {
    // Inspect the generated image
    const image = inlineDataParts[0].inlineData;
    console.log(image.mimeType, image.data);
  }
} catch (err) {
  console.error('Prompt or candidate was blocked:', err);
}

// Follow up requests do not need to specify the image again
const followUpResult = await chat.sendMessage("But make it old-school line drawing style");

// Request and inspect the returned image
try {
  const followUpInlineDataParts = followUpResult.response.inlineDataParts();
  if (followUpInlineDataParts?.[0]) {
    // Inspect the generated image
    const followUpImage = followUpInlineDataParts[0].inlineData;
    console.log(followUpImage.mimeType, followUpImage.data);
  }
} catch (err) {
  console.error('Prompt or candidate was blocked:', err);
}

Dart

import 'package:firebase_ai/firebase_ai.dart';
import 'package:firebase_core/firebase_core.dart';
import 'firebase_options.dart';

await Firebase.initializeApp(
  options: DefaultFirebaseOptions.currentPlatform,
);

// Initialize the Gemini Developer API backend service
// Create a `GenerativeModel` instance with a Gemini model that supports image output
final model = FirebaseAI.googleAI().generativeModel(
  model: 'gemini-2.5-flash-image',
  // Configure the model to respond with text and images (required)
  generationConfig: GenerationConfig(responseModalities: [ResponseModalities.text, ResponseModalities.image]),
);

// Prepare an image for the model to edit
final image = await File('scones.jpg').readAsBytes();
final imagePart = InlineDataPart('image/jpeg', image);

// Provide an initial text prompt instructing the model to edit the image
final prompt = TextPart("Edit this image to make it look like a cartoon");

// Initialize the chat
final chat = model.startChat();

// To generate an initial response, send a user message with the image and text prompt
final response = await chat.sendMessage([
  Content.multi([prompt,imagePart])
]);

// Inspect the returned image
if (response.inlineDataParts.isNotEmpty) {
  final imageBytes = response.inlineDataParts[0].bytes;
  // Process the image
} else {
  // Handle the case where no images were generated
  print('Error: No images were generated.');
}

// Follow up requests do not need to specify the image again
final followUpResponse = await chat.sendMessage([
  Content.text("But make it old-school line drawing style")
]);

// Inspect the returned image
if (followUpResponse.inlineDataParts.isNotEmpty) {
  final followUpImageBytes = response.inlineDataParts[0].bytes;
  // Process the image
} else {
  // Handle the case where no images were generated
  print('Error: No images were generated.');
}

Unity

using Firebase;
using Firebase.AI;

// Initialize the Gemini Developer API backend service
// Create a `GenerativeModel` instance with a Gemini model that supports image output
var model = FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI()).GetGenerativeModel(
  modelName: "gemini-2.5-flash-image",
  // Configure the model to respond with text and images (required)
  generationConfig: new GenerationConfig(
    responseModalities: new[] { ResponseModality.Text, ResponseModality.Image })
);

// Prepare an image for the model to edit
var imageFile = System.IO.File.ReadAllBytes(System.IO.Path.Combine(
  UnityEngine.Application.streamingAssetsPath, "scones.jpg"));
var image = ModelContent.InlineData("image/jpeg", imageFile);

// Provide an initial text prompt instructing the model to edit the image
var prompt = ModelContent.Text("Edit this image to make it look like a cartoon.");

// Initialize the chat
var chat = model.StartChat();

// To generate an initial response, send a user message with the image and text prompt
var response = await chat.SendMessageAsync(new [] { prompt, image });

// Inspect the returned image
var imageParts = response.Candidates.First().Content.Parts
                         .OfType<ModelContent.InlineDataPart>()
                         .Where(part => part.MimeType == "image/png");
// Load the image into a Unity Texture2D object
UnityEngine.Texture2D texture2D = new(2, 2);
if (texture2D.LoadImage(imageParts.First().Data.ToArray())) {
  // Do something with the image
}

// Follow up requests do not need to specify the image again
var followUpResponse = await chat.SendMessageAsync("But make it old-school line drawing style");

// Inspect the returned image
var followUpImageParts = followUpResponse.Candidates.First().Content.Parts
                         .OfType<ModelContent.InlineDataPart>()
                         .Where(part => part.MimeType == "image/png");
// Load the image into a Unity Texture2D object
UnityEngine.Texture2D followUpTexture2D = new(2, 2);
if (followUpTexture2D.LoadImage(followUpImageParts.First().Data.ToArray())) {
  // Do something with the image
}

Diffuser la réponse en streaming

Avant d'essayer cet exemple, suivez la section Avant de commencer de ce guide pour configurer votre projet et votre application. Dans cette section, vous cliquerez également sur un bouton pour le fournisseur Gemini API de votre choix afin d'afficher le contenu spécifique au fournisseur sur cette page.

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. Pour diffuser la réponse en streaming, appelez sendMessageStream().

Afficher l'exemple : diffuser les réponses du chat en streaming

Swift

Vous pouvez appeler startChat() et sendMessageStream() pour diffuser les réponses du modèle en streaming :

import FirebaseAILogic

// Initialize the Gemini Developer API backend service
let ai = FirebaseAI.firebaseAI(backend: .googleAI())

// Create a `GenerativeModel` instance with a model that supports your use case
let model = ai.generativeModel(modelName: "gemini-3-flash-preview")


// Optionally specify existing chat history
let history = [
  ModelContent(role: "user", parts: "Hello, I have 2 dogs in my house."),
  ModelContent(role: "model", parts: "Great to meet you. What would you like to know?"),
]

// Initialize the chat with optional chat history
let chat = model.startChat(history: history)

// To stream generated text output, call sendMessageStream and pass in the message
let contentStream = try chat.sendMessageStream("How many paws are in my house?")
for try await chunk in contentStream {
  if let text = chunk.text {
    print(text)
  }
}

Kotlin

Vous pouvez appeler startChat() et sendMessageStream() pour diffuser les réponses du modèle en streaming :

^{Pour Kotlin, les méthodes de ce SDK sont des fonctions de suspension et doivent être appelées à partir d'une portéeCoroutine.}

// Initialize the Gemini Developer API backend service
// Create a `GenerativeModel` instance with a model that supports your use case
val model = Firebase.ai(backend = GenerativeBackend.googleAI())
                        .generativeModel("gemini-3-flash-preview")


// Initialize the chat
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?") }
  )
)

chat.sendMessageStream("How many paws are in my house?").collect { chunk ->
  print(chunk.text)
}

Java

Vous pouvez appeler startChat() et sendMessageStream() pour diffuser les réponses du modèle en streaming :

^{Pour Java, les méthodes de streaming de ce SDK renvoient un type Publisher de la bibliothèque Reactive Streams.}

// Initialize the Gemini Developer API backend service
// Create a `GenerativeModel` instance with a model that supports your use case
GenerativeModel ai = FirebaseAI.getInstance(GenerativeBackend.googleAI())
        .generativeModel("gemini-3-flash-preview");

// Use the GenerativeModelFutures Java compatibility layer which offers
// support for ListenableFuture and Publisher APIs
GenerativeModelFutures model = GenerativeModelFutures.from(ai);


// (optional) Create previous chat history for context
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
Publisher<GenerateContentResponse> streamingResponse =
        chat.sendMessageStream(message);

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

    // ... other methods omitted for brevity
});

Web

Vous pouvez appeler startChat() et sendMessageStream() pour diffuser les réponses du modèle en streaming :

import { initializeApp } from "firebase/app";
import { getAI, getGenerativeModel, GoogleAIBackend } from "firebase/ai";

// TODO(developer) Replace the following with your app's Firebase configuration
// See: https://firebase.google.com/docs/web/learn-more#config-object
const firebaseConfig = {
  // ...
};

// Initialize FirebaseApp
const firebaseApp = initializeApp(firebaseConfig);

// Initialize the Gemini Developer API backend service
const ai = getAI(firebaseApp, { backend: new GoogleAIBackend() });

// Create a `GenerativeModel` instance with a model that supports your use case
const model = getGenerativeModel(ai, { model: "gemini-3-flash-preview" });


async function run() {
  const chat = model.startChat({
    history: [
      {
        role: "user",
        parts: [{ text: "Hello, I have 2 dogs in my house." }],
      },
      {
        role: "model",
        parts: [{ text: "Great to meet you. What would you like to know?" }],
      },
    ],
    generationConfig: {
      maxOutputTokens: 100,
    },
  });

  const msg = "How many paws are in my house?";
  const result = await chat.sendMessageStream(msg);

  let text = '';
  for await (const chunk of result.stream) {
    const chunkText = chunk.text();
    console.log(chunkText);
    text += chunkText;
  }
}

run();

Dart

Vous pouvez appeler startChat() et sendMessageStream() pour diffuser les réponses du modèle en streaming :

import 'package:firebase_ai/firebase_ai.dart';
import 'package:firebase_core/firebase_core.dart';
import 'firebase_options.dart';

// Initialize FirebaseApp
await Firebase.initializeApp(
  options: DefaultFirebaseOptions.currentPlatform,
);

// Initialize the Gemini Developer API backend service
// Create a `GenerativeModel` instance with a model that supports your use case
final model =
      FirebaseAI.googleAI().generativeModel(model: 'gemini-3-flash-preview');


final chat = model.startChat();
// Provide a prompt that contains text
final prompt = [Content.text('Write a story about a magic backpack.')];

final response = await chat.sendMessageStream(prompt);
await for (final chunk in response) {
  print(chunk.text);
}

Unity

Vous pouvez appeler StartChat() et SendMessageStreamAsync() pour diffuser les réponses du modèle en streaming :

using Firebase;
using Firebase.AI;

// Initialize the Gemini Developer API backend service
var ai = FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI());

// Create a `GenerativeModel` instance with a model that supports your use case
var model = ai.GetGenerativeModel(modelName: "gemini-3-flash-preview");


// Optionally specify existing chat history
var history = new [] {
  ModelContent.Text("Hello, I have 2 dogs in my house."),
  new ModelContent("model", new ModelContent.TextPart("Great to meet you. What would you like to know?")),
};

// Initialize the chat with optional chat history
var chat = model.StartChat(history);

// To stream generated text output, call SendMessageStreamAsync and pass in the message
var responseStream = chat.SendMessageStreamAsync("How many paws are in my house?");
await foreach (var response in responseStream) {
  if (!string.IsNullOrWhiteSpace(response.Text)) {
    UnityEngine.Debug.Log(response.Text);
  }
}

Découvrez comment choisir un modèle adapté à votre cas d'utilisation et à votre application.

---

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

• Découvrez comment compter les jetons avant d'envoyer de longues requêtes au modèle.
• Configurez Cloud Storage for Firebase afin de pouvoir inclure des fichiers volumineux dans vos requêtes multimodales et de disposer d'une solution plus gérée pour fournir des fichiers dans les requêtes. Les fichiers peuvent inclure des images, des PDF, des vidéos et de l'audio.
• Commencez à réfléchir à la préparation de la production (consultez la checklist de production) :
  • Configurez Firebase App Check le plus tôt possible pour protéger la Gemini API contre les utilisations abusives par des clients non autorisés.
  • Intégrez Firebase Remote Config pour mettre à jour les valeurs de votre application (comme le nom du modèle) sans publier de nouvelle version de l'application.

Essayer d'autres fonctionnalités

• Générer du texte à partir de requêtes en texte seul.
• Générer du texte en utilisant différents types de fichiers, tels que des images, des PDF, des vidéos, et de l'audio.
• Générer une sortie structurée (comme JSON) à partir de requêtes textuelles et multimodales.
• Générer et modifier des images à partir de requêtes textuelles et multimodales
• Utiliser des outils (tels que l'appel de fonction et l'ancrage avec la recherche Google) pour connecter un modèle Gemini à d'autres parties de votre application, ainsi qu'à des systèmes et informations externes

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

• Comprendre la conception des requêtes, y compris les bonnes pratiques, les stratégies et des exemples de requêtes.
• Configurer les paramètres du modèle, tels que la température et le nombre maximal de jetons de sortie.
• Utiliser les paramètres de sécurité pour ajuster la probabilité d'obtenir des réponses qui peuvent être considérées comme nuisibles.

Vous pouvez également tester des requêtes et des configurations de modèle, et même obtenir un extrait de code généré à l'aide de Google AI Studio.

En savoir plus sur les modèles compatibles

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

Envoyer des commentaires sur votre expérience avec Firebase AI Logic