Gerar texto usando a API Gemini

É possível pedir a um modelo Gemini para gerar texto com base em um comando de texto ou multimodal. Ao usar Firebase AI Logic, você pode fazer esta solicitação diretamente do app.

Os comandos multimodais podem incluir vários tipos de entrada (como texto com imagens, PDFs, arquivos de texto simples, áudio e vídeo).

Este guia mostra como gerar texto com base em um comando de texto e em um comando multimodal básico que inclui um arquivo.

Pular para o código de entrada de texto Pular para o código de entrada multimodal Pular para o código de respostas transmitidas


Consulte outros guias para mais opções de trabalho com texto
Gerar saída estruturada Conversa multiturno Gerar texto no dispositivo Conversão de texto em voz (TTS) Gerar imagens com base em texto

Antes de começar

Clique no seu provedor Gemini API para conferir o conteúdo específico do provedor e o código nesta página.

Se ainda não fez isso, conclua o guia de introdução, que descreve como configurar seu projeto do Firebase, conectar o app ao Firebase, adicionar o SDK, inicializar o serviço de back-end para o provedor Gemini API escolhido e criar uma instância GenerativeModel.

Para testar e iterar seus comandos, recomendamos o uso do Google AI Studio.

Gerar texto com base em entrada de texto

Antes de testar este exemplo, conclua a seção Antes de começar deste guia para configurar seu projeto e app.
Nessa seção, você também vai clicar em um botão para o provedor da API Gemini escolhido Gemini API para que o conteúdo específico do provedor seja exibido nesta página.

Você pode pedir a um Gemini modelo para gerar texto com base em uma entrada de texto.

Swift

Você pode chamar generateContent() para gerar texto com base em entrada de texto.


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

Você pode chamar generateContent() para gerar texto com base em entrada de texto.

Para Kotlin, os métodos nesse SDK são funções de suspensão e precisam ser chamados de um escopo de corrotina. 

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

Você pode chamar generateContent() para gerar texto com base em entrada de texto.

Para Java, os métodos nesse SDK retornam um 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.7-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

Você pode chamar generateContent() para gerar texto com base em entrada de texto.


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

Você pode chamar generateContent() para gerar texto com base em entrada de texto.


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

Você pode chamar GenerateContentAsync() para gerar texto com base em entrada de texto.


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

Saiba como escolher um modelo adequado para seu caso de uso e app.

Gerar texto com base em entrada de texto e arquivo (multimodal)

Antes de testar este exemplo, conclua a seção Antes de começar deste guia para configurar seu projeto e app.
Nessa seção, você também vai clicar em um botão para o provedor da API Gemini escolhido Gemini API para que o conteúdo específico do provedor seja exibido nesta página.

Você pode pedir a um Gemini modelo para gerar texto com base em texto e um arquivo, fornecendo o mimeType e o arquivo de cada entrada. Encontre os requisitos e recomendações para arquivos de entrada mais adiante nesta página.

O exemplo a seguir mostra o básico de como gerar texto com base em uma entrada de arquivo analisando um único arquivo de vídeo fornecido como dados inline (arquivo codificado em base64).

Observe que este exemplo mostra como fornecer o arquivo inline, mas os SDKs também oferecem suporte ao fornecimento de um URL do YouTube.

Swift

Você pode chamar generateContent() para gerar texto com base em entrada multimodal de texto e arquivos de vídeo.


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

Você pode chamar generateContent() para gerar texto com base em entrada multimodal de texto e arquivos de vídeo.

Para Kotlin, os métodos nesse SDK são funções de suspensão e precisam ser chamados de um escopo de corrotina. 

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

Você pode chamar generateContent() para gerar texto com base em entrada multimodal de texto e arquivos de vídeo.

Para Java, os métodos nesse SDK retornam um 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.7-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

Você pode chamar generateContent() para gerar texto com base em entrada multimodal de texto e arquivos de vídeo.


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

Você pode chamar generateContent() para gerar texto com base em entrada multimodal de texto e arquivos de vídeo.


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

Você pode chamar GenerateContentAsync() para gerar texto com base em entrada multimodal de texto e arquivos de vídeo.


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

Saiba como escolher um modelo adequado para seu caso de uso e app.

Transmitir a resposta

Antes de testar este exemplo, conclua a seção Antes de começar deste guia para configurar seu projeto e app.
Nessa seção, você também vai clicar em um botão para o provedor da API Gemini escolhido Gemini API para que o conteúdo específico do provedor seja exibido nesta página.

Você pode ter interações mais rápidas sem esperar o resultado completo da geração do modelo e, em vez disso, usar a transmissão para processar resultados parciais. Para transmitir a resposta, chame generateContentStream.


Requisitos e recomendações para arquivos de imagem de entrada

Um arquivo fornecido como dados inline é codificado em base64 em trânsito, o que aumenta o tamanho da solicitação. Você recebe um erro HTTP 413 se uma solicitação for muito grande.

Consulte Arquivos de entrada e requisitos compatíveis para Agent Platform Gemini API (formerly Vertex AI) para saber mais detalhes sobre o seguinte:

  • Diferentes opções para fornecer um arquivo em uma solicitação (inline ou usando o URL ou URI do arquivo)
  • Tipos de arquivos compatíveis
  • Tipos MIME compatíveis e como especificá-los
  • Requisitos e práticas recomendadas para arquivos e solicitações multimodais


O que mais você pode fazer?

Testar outros recursos

Saiba como controlar a geração de conteúdo

Você também pode testar comandos e configurações de modelos e até mesmo receber um snippet de código gerado usando Google AI Studio.

Saiba mais sobre os modelos compatíveis

Saiba mais sobre os modelos disponíveis para vários casos de uso e as cotas e preços deles.


Envie feedback sobre sua experiência com Firebase AI Logic