Você pode pedir a um modelo Gemini para analisar arquivos de documentos (como PDFs e arquivos de texto simples) que você fornece in-line (codificados em base64) ou por URL. Ao usar Firebase AI Logic, é possível fazer essa solicitação diretamente do app.
Com esse recurso, é possível:
- Analisar diagramas, gráficos e tabelas em documentos
- Extrair informações em formatos de saída estruturados
- Responder perguntas sobre conteúdo visual e de texto em documentos
- Resumir documentos
- Transcrever o conteúdo do documento (por exemplo, em HTML), preservando layouts e formatação, para uso em aplicativos downstream (como em pipelines de RAG)
Ir para exemplos de código Ir para o código de respostas transmitidas
Consulte outros guias para mais opções de como trabalhar com documentos (como PDFs) Gerar saída estruturada Chat em várias etapas |
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 arquivos PDF (codificados em base64)
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 comandos com texto e PDFs, 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.
Swift
Você pode chamar
generateContent()
para gerar texto de entrada multimodal de texto e PDFs.
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 PDF as `Data` with the appropriate MIME type
let pdf = try InlineDataPart(data: Data(contentsOf: pdfURL), mimeType: "application/pdf")
// Provide a text prompt to include with the PDF file
let prompt = "Summarize the important results in this report."
// To generate text output, call `generateContent` with the PDF file and text prompt
let response = try await model.generateContent(pdf, prompt)
// Print the generated text, handling the case where it might be nil
print(response.text ?? "No text in response.")
Kotlin
Você pode chamar
generateContent()
para gerar texto de entrada multimodal de texto e PDFs.
// 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
// Provide the URI for the PDF file you want to send to the model
val inputStream = contentResolver.openInputStream(pdfUri)
if (inputStream != null) { // Check if the PDF file loaded successfully
inputStream.use { stream ->
// Provide a prompt that includes the PDF file specified above and text
val prompt = content {
inlineData(
bytes = stream.readBytes(),
mimeType = "application/pdf" // Specify the appropriate PDF file MIME type
)
text("Summarize the important results in this report.")
}
// To generate text output, call `generateContent` with the prompt
val response = generativeModel.generateContent(prompt)
// Log the generated text, handling the case where it might be null
Log.d(TAG, response.text ?: "")
}
} else {
Log.e(TAG, "Error getting input stream for file.")
// Handle the error appropriately
}
Java
Você pode chamar
generateContent()
para gerar texto de entrada multimodal de texto e PDFs.
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();
// Provide the URI for the PDF file you want to send to the model
try (InputStream stream = resolver.openInputStream(pdfUri)) {
if (stream != null) {
byte[] audioBytes = stream.readAllBytes();
stream.close();
// Provide a prompt that includes the PDF file specified above and text
Content prompt = new Content.Builder()
.addInlineData(audioBytes, "application/pdf") // Specify the appropriate PDF file MIME type
.addText("Summarize the important results in this report.")
.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 text = result.getText();
Log.d(TAG, (text == null) ? "" : text);
}
@Override
public void onFailure(Throwable t) {
Log.e(TAG, "Failed to generate a response", t);
}
}, executor);
} else {
Log.e(TAG, "Error getting input stream for file.");
// Handle the error appropriately
}
} catch (IOException e) {
Log.e(TAG, "Failed to read the pdf file", e);
} catch (URISyntaxException e) {
Log.e(TAG, "Invalid pdf file", e);
}
Web
Você pode chamar
generateContent()
para gerar texto de entrada multimodal de texto e PDFs.
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(','));
reader.readAsDataURL(file);
});
return {
inlineData: { data: await base64EncodedDataPromise, mimeType: file.type },
};
}
async function run() {
// Provide a text prompt to include with the PDF file
const prompt = "Summarize the important results in this report.";
// Prepare PDF file for input
const fileInputEl = document.querySelector("input[type=file]");
const pdfPart = await fileToGenerativePart(fileInputEl.files);
// To generate text output, call `generateContent` with the text and PDF file
const result = await model.generateContent([prompt, pdfPart]);
// Log the generated text, handling the case where it might be undefined
console.log(result.response.text() ?? "No text in response.");
}
run();
Dart
Você pode chamar
generateContent()
para gerar texto de entrada multimodal de texto e PDFs.
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 PDF file
final prompt = TextPart("Summarize the important results in this report.");
// Prepare the PDF file for input
final doc = await File('document0.pdf').readAsBytes();
// Provide the PDF file as `Data` with the appropriate PDF file MIME type
final docPart = InlineDataPart('application/pdf', doc);
// To generate text output, call `generateContent` with the text and PDF file
final response = await model.generateContent([
Content.multi([prompt,docPart])
]);
// Print the generated text
print(response.text);
Unity
Você pode chamar
GenerateContentAsync()
para gerar texto de entrada multimodal de texto e PDFs.
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 text prompt to include with the PDF file
var prompt = ModelContent.Text("Summarize the important results in this report.");
// Provide the PDF file as `data` with the appropriate PDF file MIME type
var doc = ModelContent.InlineData("application/pdf",
System.IO.File.ReadAllBytes(System.IO.Path.Combine(
UnityEngine.Application.streamingAssetsPath, "document0.pdf")));
// To generate text output, call `GenerateContentAsync` with the text and PDF file
var response = await model.GenerateContentAsync(new [] { prompt, doc });
// Print the generated text
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 documentos 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 com o Vertex AI Gemini API" para saber mais sobre:
- Diferentes opções para fornecer um arquivo em uma solicitação (inline ou usando o URL ou URI do arquivo)
- Requisitos e práticas recomendadas para arquivos de documentos
Tipos MIME de vídeo compatíveis
Os modelos multimodais do Gemini são compatíveis com os seguintes tipos MIME de documentos:
Tipo de documento MIME | Gemini 2.0 Flash | Gemini 2.0 Flash‑Lite |
---|---|---|
PDF - application/pdf |
||
Texto - text/plain |
Limites por solicitação
PDFs são tratados como imagens, portanto, uma única página de um PDF é tratada como uma imagem. O número de páginas permitido em um comando é limitado ao número de imagens que o modelo aceita:
- Gemini 2.0 Flash e Gemini 2.0 Flash‑Lite:
- Máximo de arquivos por solicitação: 3.000
- Máximo de páginas por arquivo: 1.000
- Tamanho máximo por arquivo: 50 MB
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