Você pode pedir a um modelo Gemini para gerar texto com base em um comando somente de texto ou multimodal. Ao usar Firebase AI Logic, é possível fazer essa solicitação diretamente do 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 com um comando somente de texto e com um comando multimodal básico que inclui um arquivo.
Ir para exemplos de código para entrada somente de texto Ir para exemplos de código para entrada multimodal
Confira outros guias para mais opções de trabalho com texto Gerar saída estruturada Chat de várias interações Streaming bidirecional Gerar texto no dispositivo Gerar imagens com base em 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 primeiros passos, 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 Gemini API escolhido e
criar uma instância GenerativeModel
.
Para testar e iterar em seus comandos e até mesmo receber um snippet de código gerado, recomendamos usar Google AI Studio.
Gerar texto com base em entradas somente de texto
Antes de testar esta amostra, conclua a seção
Antes de começar deste guia
para configurar seu projeto e app. Nessa seção, clique também em um botão do provedor de Gemini API escolhido para ver o conteúdo específico do provedor nesta página. |
Você pode pedir a um modelo Gemini para gerar texto usando apenas texto como entrada.
Swift
Você pode chamar
generateContent()
para gerar texto com base em entradas 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.5-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 entradas somente de texto.
// 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.5-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
Você pode chamar
generateContent()
para gerar texto com base em entradas somente de texto.
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.5-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 entradas 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.5-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 entradas 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.5-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 entradas 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.5-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 entradas de texto e arquivo (multimodais)
Antes de testar esta amostra, conclua a seção
Antes de começar deste guia
para configurar seu projeto e app. Nessa seção, clique também em um botão do provedor de Gemini API escolhido para ver o conteúdo específico do provedor nesta página. |
Você pode pedir a um modelo Gemini para
gerar texto usando um comando com texto e um arquivo, fornecendo o mimeType
de cada
arquivo de entrada e o arquivo em si. Confira os requisitos e as recomendações para arquivos de entrada mais adiante nesta página.
O exemplo a seguir mostra o básico de como gerar texto de uma entrada de arquivo analisando um único arquivo de vídeo fornecido como dados in-line (arquivo codificado em base64).
Este exemplo mostra como fornecer o arquivo inline, mas os SDKs também permitem fornecer um URL do YouTube.
Swift
Você pode 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.5-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 entradas multimodais de arquivos de texto e vídeo.
// 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.5-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
Você pode chamar
generateContent()
para gerar texto com base em entradas multimodais de arquivos de texto e vídeo.
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.5-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 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.5-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 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.5-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 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.5-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.
Mostrar composição da resposta
Antes de testar esta amostra, conclua a seção
Antes de começar deste guia
para configurar seu projeto e app. Nessa seção, clique também em um botão do provedor de Gemini API escolhido para ver o conteúdo específico do provedor nesta página. |
Para ter interações mais rápidas, não espere o resultado completo da geração do modelo. Em vez disso, use 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 in-line é 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 o Vertex AI Gemini API e saiba mais sobre:
- 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ê sabe fazer?
- Saiba como contar tokens antes de enviar comandos longos ao modelo.
- Configure o Cloud Storage for Firebase para incluir arquivos grandes nas solicitações multimodais e ter uma solução mais gerenciada para fornecer arquivos em comandos. Os arquivos podem incluir imagens, PDFs, vídeos e áudios.
-
Comece a pensar em se preparar para a produção (consulte a
lista de verificação de produção),
incluindo:
- Configurar o Firebase App Check para proteger o Gemini API contra abusos de clientes não autorizados.
- Integrar o Firebase Remote Config para atualizar valores no app (como o nome do modelo) sem lançar uma nova versão do app.
Testar outros recursos
- Crie conversas multiturno (chat).
- Gerar texto com base em comandos somente de texto.
- Gerar saída estruturada (como JSON) com base em comandos de texto e multimodais.
- Gerar imagens com base em comandos de texto (Gemini ou Imagen).
- Use a chamada de função para conectar modelos generativos a sistemas e informações externas.
Saiba como controlar a geração de conteúdo
- Entenda o design de comandos, incluindo práticas recomendadas, estratégias e exemplos de comandos.
- Configure parâmetros do modelo, como temperatura e máximo de tokens de saída (para Gemini) ou proporção e geração de pessoas (para Imagen).
- Use as configurações de segurança para ajustar a probabilidade de receber respostas que possam ser consideradas prejudiciais.
Saiba mais sobre os modelos compatíveis
Saiba mais sobre os modelos disponíveis para vários casos de uso e as respectivas cotas e preços.Enviar feedback sobre sua experiência com Firebase AI Logic