The latest Gemini models, like Gemini 3.1 Flash Image (Nano Banana 2), are available to use with Firebase AI Logic! Learn more.

Gemini 2.0 Flash and Flash-Lite models will shut down on June 1, 2026. To avoid service disruption, update to a newer model like gemini-2.5-flash-lite. Learn more.

All Imagen models will shut down on June 24, 2026. Learn about migrating your apps to use Nano Banana.

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'une requête textuelle ou multimodale. Lorsque vous utilisez Firebase AI Logic, vous pouvez effectuer cette requête directement depuis votre application.

Les requêtes multimodales peuvent inclure plusieurs types d'entrées (comme du texte avec des images, des PDF, des fichiers en texte brut, de l'audio et des vidéos).

Ce guide explique comment générer du texte à partir d'une requête textuelle et d'une requête multimodale 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 diffusées

Consultez d'autres guides pour découvrir d'autres options permettant d'utiliser du texte
Générer une sortie structurée Chat multitour Diffusion bidirectionnelle Générer du texte sur l'appareil Générer des images à partir de texte

Avant de commencer

Cliquez sur votre fournisseur Gemini API pour afficher le contenu spécifique au fournisseur et le code 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 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 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 à ce fournisseur sur cette page.

Vous pouvez demander à un Gemini modèle de générer du texte en utilisant une entrée textuelle.

Swift

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


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


// 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.

^{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")


// 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.

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


// 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.


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


// 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.


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


// 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.


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


// 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 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 à ce fournisseur sur cette page.

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

L'exemple suivant montre les bases de la génération de texte à partir d'une entrée de fichier 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.

Besoin d'un exemple de fichier vidéo ?

Vous pouvez utiliser ce fichier accessible au public avec un type MIME de video/mp4 (afficher ou télécharger le fichier). https://storage.googleapis.com/cloud-samples-data/video/animals.mp4

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-flash-preview")


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


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

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


// 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 {
    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'une entrée multimodale 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-flash-preview');


// 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-flash-preview");


// 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 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 à 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 et en utilisant plutôt la diffusion pour gérer les résultats partiels. Pour diffuser la réponse, appelez generateContentStream.

Afficher l'exemple : diffuser du texte généré à partir d'une entrée textuelle

Swift

Vous pouvez appeler generateContentStream() pour diffuser du texte généré à partir d'une entrée textuelle.


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


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

// To stream generated text output, call generateContentStream with the text input
let contentStream = try model.generateContentStream(prompt)
for try await chunk in contentStream {
  if let text = chunk.text {
    print(text)
  }
}

Kotlin

Vous pouvez appeler generateContentStream() pour diffuser du texte généré à partir d'une entrée textuelle.

^{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")


// 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 = ""
model.generateContentStream(prompt).collect { chunk ->
    print(chunk.text)
    response += chunk.text
}

Java

Vous pouvez appeler generateContentStream() pour diffuser du texte généré à partir d'une entrée textuelle.

^{Pour Java, les méthodes de diffusion de ce SDK renvoient un
Publisher type 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);


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

Web

Vous pouvez appeler generateContentStream() pour diffuser du texte généré à partir d'une entrée textuelle.


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


// 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 stream generated text output, call generateContentStream with the text input
  const result = await model.generateContentStream(prompt);

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

  console.log('aggregated response: ', await result.response);
}

run();

Dart

Vous pouvez appeler generateContentStream() pour diffuser du texte généré à partir d'une entrée textuelle.


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


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

// To stream generated text output, call generateContentStream with the text input
final response = model.generateContentStream(prompt);
await for (final chunk in response) {
  print(chunk.text);
}

Unity

Vous pouvez appeler GenerateContentStreamAsync() pour diffuser du texte généré à partir d'une entrée textuelle.


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


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

// To stream generated text output, call GenerateContentStreamAsync with the text input
var responseStream = model.GenerateContentStreamAsync(prompt);
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.

Afficher l'exemple : diffuser du texte généré à partir d'une entrée multimodale

Swift

Vous pouvez appeler generateContentStream() pour diffuser du texte généré à partir d'une entrée multimodale de texte et d'une seule 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-flash-preview")


// 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 stream generated text output, call generateContentStream with the text and video
let contentStream = try model.generateContentStream(video, prompt)
for try await chunk in contentStream {
  if let text = chunk.text {
    print(text)
  }
}

Kotlin

Vous pouvez appeler generateContentStream() pour diffuser du texte généré à partir d'une entrée multimodale de texte et d'une seule vidéo.

^{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")


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 stream generated text output, call generateContentStream with the prompt
    var fullResponse = ""
    model.generateContentStream(prompt).collect { chunk ->
        Log.d(TAG, chunk.text ?: "")
        fullResponse += chunk.text
    }
  }
}

Java

Vous pouvez appeler generateContentStream() pour diffuser du texte généré à partir d'une entrée multimodale de texte et d'une seule vidéo.

^{Pour Java, les méthodes de diffusion de ce SDK renvoient un
Publisher type 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);


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 stream generated text output, call generateContentStream with the prompt
        Publisher<GenerateContentResponse> streamingResponse =
                model.generateContentStream(prompt);

        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) {
            }
         });
    }
} catch (IOException e) {
    e.printStackTrace();
} catch (URISyntaxException e) {
    e.printStackTrace();
}

Web

Vous pouvez appeler generateContentStream() pour diffuser du texte généré à partir d'une entrée multimodale de texte et d'une seule 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-flash-preview" });


// 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 {
    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 stream generated text output, call generateContentStream with the text and video
  const result = await model.generateContentStream([prompt, videoPart]);

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

run();

Dart

Vous pouvez appeler generateContentStream() pour diffuser du texte généré à partir d'une entrée multimodale de texte et d'une seule 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-flash-preview');


// 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 stream generated text output, call generateContentStream with the text and image
final response = await model.generateContentStream([
  Content.multi([prompt,videoPart])
]);
await for (final chunk in response) {
  print(chunk.text);
}

Unity

Vous pouvez appeler GenerateContentStreamAsync() pour diffuser du texte généré à partir d'une entrée multimodale de texte et d'une seule 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-flash-preview");


// 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 stream generated text output, call GenerateContentStreamAsync with the text and video
var responseStream = model.GenerateContentStreamAsync(new [] { video, prompt });
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.

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 en transit, ce qui augmente la taille de la requête. Une erreur HTTP 413 s'affiche si une requête est trop volumineuse.

Consultez la section Fichiers d'entrée compatibles et exigences concernant la Vertex AI Gemini API pour en savoir plus sur les éléments suivants :

Différentes options permettant de fournir un fichier dans une requête (de manière intégrée ou à l'aide de l'URL ou de l'URI du fichier)
Types de fichiers compatibles
Types MIME compatibles et comment les spécifier
Exigences et bonnes pratiques concernant 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 des requêtes longues 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 dès que 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

Créer des conversations multitours (chat).
Générer du texte à partir de requêtes textuelles.
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
Diffuser des entrées et des sorties (y compris audio) à l'aide de l'API Gemini Live API.
Utiliser des outils (comme 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

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

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

Sauf indication contraire, le contenu de cette page est régi par une licence Creative Commons Attribution 4.0, et les échantillons de code sont régis par une licence Apache 2.0. Pour en savoir plus, consultez les Règles du site Google Developers. Java est une marque déposée d'Oracle et/ou de ses sociétés affiliées.

Dernière mise à jour le 2026/04/09 (UTC).