Gerar texto usando a API Gemini

Você pode pedir a um modelo Gemini para gerar texto de um comando somente de texto ou um comando multimodais. Ao usar Firebase AI Logic, é possível fazer essa solicitação diretamente no seu 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 a partir de um comando somente de texto e de um comando multimodal básico que inclui um arquivo.

Acessar exemplos de código para entrada somente de texto Acessar exemplos de código para entrada multimodal


Consulte outros guias para conferir outras opções de trabalho com texto
Gerar saída estruturada Chat de várias interações Streaming bidirecional Gerar texto no dispositivo Gerar imagens a partir de texto

Antes de começar

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

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

Para testar e iterar comandos e até receber um snippet de código gerado, recomendamos usar Google AI Studio.

Gerar texto com base em uma entrada somente 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 clicará em um botão do provedor Gemini API escolhido para acessar o conteúdo específico do provedor nessa página.

É possível pedir que um modelo Gemini gere texto solicitando uma entrada de texto.

Swift

É possível chamar generateContent() para gerar texto a partir de uma entrada somente de texto.


import FirebaseAI

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

É possível chamar generateContent() para gerar texto a partir de uma entrada somente de texto.

No Kotlin, os métodos neste 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-2.0-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 = generativeModel.generateContent(prompt)
print(response.text)

Java

É possível chamar generateContent() para gerar texto a partir de uma entrada somente de texto.

Em Java, os métodos neste 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-2.0-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

É possível chamar generateContent() para gerar texto a partir de uma entrada somente 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-2.0-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

É possível chamar generateContent() para gerar texto a partir de uma entrada somente 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-2.0-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

É possível chamar GenerateContentAsync() para gerar texto a partir de uma entrada somente 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-2.0-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.");

Gerar texto com base em uma 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 clicará em um botão do provedor Gemini API escolhido para acessar o conteúdo específico do provedor nessa página.

É possível pedir que um modelo Gemini gere texto solicitando com texto e um arquivo, fornecendo o mimeType de cada arquivo de entrada e o arquivo em si. Confira 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 a partir de 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 são compatíveis com o fornecimento de um URL do YouTube.

Swift

É possível chamar generateContent() para gerar texto com base em entradas multimodais de arquivos de texto e vídeo.


import FirebaseAI

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

É possível chamar generateContent() para gerar texto com base em entradas multimodais de arquivos de texto e vídeo.

No Kotlin, os métodos neste 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-2.0-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 = generativeModel.generateContent(prompt)
    Log.d(TAG, response.text ?: "")
  }
}

Java

É possível chamar generateContent() para gerar texto com base em entradas multimodais de arquivos de texto e vídeo.

Em Java, os métodos neste 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-2.0-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

É possível chamar generateContent() para gerar texto com base em entradas multimodais de arquivos de texto e 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-2.0-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

É possível chamar generateContent() para gerar texto com base em entradas multimodais de arquivos de texto e 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-2.0-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

É possível chamar GenerateContentAsync() para gerar texto com base em entradas multimodais de arquivos de texto e 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-2.0-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 clicará em um botão do provedor Gemini API escolhido para acessar o conteúdo específico do provedor nessa página.

É possível alcançar interações mais rápidas sem esperar pelo resultado completo da geração do modelo e, em vez disso, usar o streaming 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ê vai receber um erro HTTP 413 se uma solicitação for muito grande.

Consulte Arquivos de entrada e requisitos compatíveis com o Vertex AI Gemini API para saber mais sobre:

  • Opções diferentes 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 modelo 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 o preço.


Enviar feedback sobre sua experiência com o Firebase AI Logic