Générer du texte à l'aide de l'API Gemini

Vous pouvez demander à un modèle Gemini de générer du texte à partir d'un prompt textuel ou multimodal. Lorsque vous utilisez Firebase AI Logic, vous pouvez effectuer cette requête directement depuis votre application.

Les prompts multimodaux peuvent inclure plusieurs types d'entrées (comme du texte, des images, des PDF, des fichiers en texte brut, de l'audio et de la vidéo).

Ce guide explique comment générer du texte à partir d'un prompt textuel et d'un prompt multimodal de base incluant un fichier.

Accéder au code pour une entrée textuelle Accéder au code pour une entrée multimodale Accéder au code pour les réponses en streaming


Consultez d'autres guides pour découvrir d'autres options de traitement du texte
Générer une sortie structurée Chat multitour Générer du texte sur l'appareil Synthèse vocale Générer des images à partir de texte

Avant de commencer

Cliquez sur votre fournisseur Gemini API pour afficher le contenu et le code spécifiques au fournisseur sur cette page.

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

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

Générer du texte à partir d'une entrée textuelle

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

Vous pouvez demander à un modèle Gemini de générer du texte en lui fournissant une requête textuelle.

Swift

Vous pouvez appeler generateContent() pour générer du texte à partir d'une entrée textuelle uniquement.


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.8-flash")


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

// To generate text output, call generateContent with the text input
let response = try await model.generateContent(prompt)
print(response.text ?? "No text in response.")

Kotlin

Vous pouvez appeler generateContent() pour générer du texte à partir d'une entrée textuelle uniquement.

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. 

// 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.8-flash")


// 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 = model.generateContent(prompt)
print(response.text)

Java

Vous pouvez appeler generateContent() pour générer du texte à partir d'une entrée textuelle uniquement.

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.8-flash");

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


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

Web

Vous pouvez appeler generateContent() pour générer du texte à partir d'une entrée textuelle uniquement.


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.8-flash" });


// Wrap in an async function so you can use await
async function run() {
  // Provide a prompt that contains text
  const prompt = "Write a story about a magic backpack."

  // To generate text output, call generateContent with the text input
  const result = await model.generateContent(prompt);

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

run();

Dart

Vous pouvez appeler generateContent() pour générer du texte à partir d'une entrée textuelle uniquement.


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.8-flash');


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

// To generate text output, call generateContent with the text input
final response = await model.generateContent(prompt);
print(response.text);

Unity

Vous pouvez appeler GenerateContentAsync() pour générer du texte à partir d'une entrée textuelle uniquement.


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.8-flash");


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

// To generate text output, call GenerateContentAsync with the text input
var response = await model.GenerateContentAsync(prompt);
UnityEngine.Debug.Log(response.Text ?? "No text in response.");

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

Générer du texte à partir d'une entrée texte et fichier (multimodale)

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

Vous pouvez demander à un modèle Gemini de générer du texte en lui fournissant une requête textuelle et un fichier, en indiquant le mimeType de chaque fichier d'entrée et le fichier lui-même. Vous trouverez les exigences et recommandations concernant les fichiers d'entrée plus loin sur cette page.

L'exemple suivant montre comment générer du texte à partir d'un fichier d'entrée en analysant un seul fichier vidéo fourni en tant que données intégrées (fichier encodé en base64).

Notez que cet exemple montre comment fournir le fichier de manière intégrée, mais les SDK permettent également de fournir une URL YouTube.

Swift

Vous pouvez appeler generateContent() pour générer du texte à partir d'une entrée multimodale de fichiers texte et vidéo.


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.8-flash")


// Provide the video as `Data` with the appropriate MIME type.
let video = InlineDataPart(data: try Data(contentsOf: videoURL), mimeType: "video/mp4")

// Provide a text prompt to include with the video
let prompt = "What is in the video?"

// To generate text output, call generateContent with the text and video
let response = try await model.generateContent(video, prompt)
print(response.text ?? "No text in response.")

Kotlin

Vous pouvez appeler generateContent() pour générer du texte à partir d'une entrée multimodale de fichiers texte et vidéo.

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. 

// 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.8-flash")


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

    // Provide a prompt that includes the video specified above and text
    val prompt = content {
        inlineData(bytes, "video/mp4")
        text("What is in the video?")
    }

    // To generate text output, call generateContent with the prompt
    val response = model.generateContent(prompt)
    Log.d(TAG, response.text ?: "")
  }
}

Java

Vous pouvez appeler generateContent() pour générer du texte à partir d'une entrée multimodale de fichiers texte et vidéo.

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.8-flash");

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


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 the video specified above and text
        Content prompt = new Content.Builder()
                .addInlineData(videoBytes, "video/mp4")
                .addText("What is in the 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();
}

Web

Vous pouvez appeler generateContent() pour générer du texte à partir d'une entrée multimodale de fichiers texte et vidéo.


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.8-flash" });


// Converts a File object to a Part object.
async function fileToGenerativePart(file) {
  const base64EncodedDataPromise = new Promise((resolve) => {
    const reader = new FileReader();
    reader.onloadend = () => resolve(reader.result.split(',')[1]);
    reader.readAsDataURL(file);
  });
  return {
    type: "inlineData",
    inlineData: { data: await base64EncodedDataPromise, mimeType: file.type },
  };
}

async function run() {
  // Provide a text prompt to include with the video
  const prompt = "What do you see?";

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

  // To generate text output, call generateContent with the text and video
  const result = await model.generateContent([prompt, videoPart]);

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

run();

Dart

Vous pouvez appeler generateContent() pour générer du texte à partir d'entrées multimodales de fichiers texte et vidéo.


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.8-flash');


// Provide a text prompt to include with the video
final prompt = TextPart("What's in the video?");

// Prepare video for input
final video = await File('video0.mp4').readAsBytes();

// Provide the video as `Data` with the appropriate mimetype
final videoPart = InlineDataPart('video/mp4', video);

// To generate text output, call generateContent with the text and images
final response = await model.generateContent([
  Content.multi([prompt, videoPart])
]);
print(response.text);

Unity

Vous pouvez appeler GenerateContentAsync() pour générer du texte à partir d'une entrée multimodale de fichiers texte et vidéo.


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.8-flash");


// Provide the video as `data` with the appropriate MIME type.
var video = ModelContent.InlineData("video/mp4",
      System.IO.File.ReadAllBytes(System.IO.Path.Combine(
          UnityEngine.Application.streamingAssetsPath, "yourVideo.mp4")));

// Provide a text prompt to include with the video
var prompt = ModelContent.Text("What is in the video?");

// To generate text output, call GenerateContentAsync with the text and video
var response = await model.GenerateContentAsync(new [] { video, prompt });
UnityEngine.Debug.Log(response.Text ?? "No text in response.");

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

Diffuser la réponse

Avant d'essayer cet exemple, suivez les instructions de la section Avant de commencer de ce guide pour configurer votre projet et votre application.
Dans cette section, vous cliquerez également sur un bouton correspondant au fournisseur Gemini API de votre choix afin d'afficher le contenu spécifique à ce 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, mais en utilisant le streaming pour gérer les résultats partiels. Pour diffuser la réponse, appelez generateContentStream.


Exigences et recommandations concernant les fichiers image d'entrée

Notez qu'un fichier fourni en tant que données intégrées est encodé en base64 lors du transfert, ce qui augmente la taille de la requête. Vous obtenez une erreur HTTP 413 si une requête est trop volumineuse.

Consultez Fichiers d'entrée compatibles et exigences pour Agent Platform Gemini API (formerly Vertex AI) pour en savoir plus sur les points suivants :

  • Différentes options pour fournir un fichier dans une requête (soit de manière intégrée, soit en utilisant l'URL ou l'URI du fichier)
  • Types de fichiers compatibles
  • Types MIME compatibles et comment les spécifier
  • Exigences et bonnes pratiques pour les fichiers et les requêtes multimodales


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 pour pouvoir inclure des fichiers volumineux dans vos requêtes multimodales et disposer d'une solution plus gérée pour fournir des fichiers dans les prompts. Les fichiers peuvent inclure des images, des PDF, des vidéos et des fichiers audio.
  • Commencez à réfléchir à la préparation de la production (consultez la checklist de production) :

Essayer d'autres fonctionnalités

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

Vous pouvez également tester des prompts 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 leurs tarifs.


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