I/O is live! Tune in for livestreamed keynotes and sessions May 20-21 starting at 10 AM PT. Watch now.

Esta página foi traduzida pela API Cloud Translation.

Analisar documentos (como PDFs) usando a API Gemini
Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Você pode pedir a um modelo Gemini para analisar arquivos de documento (como PDFs e arquivos de texto simples) que você fornece inline (codificados em base64) ou por URL. Ao usar Firebase AI Logic, é possível fazer essa solicitação diretamente no app.

Com esse recurso, é possível:

Analisar diagramas, gráficos e tabelas nos documentos
Extrair informações em formatos de saída estruturados
Responder a 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 das respostas transmitidas por streaming

Consulte outros guias para conferir outras opções de trabalho com documentos (como PDFs)
Gerar saída estruturada Chat com várias mensagens

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.

Precisa de um arquivo PDF de exemplo?

Você pode usar esse arquivo disponível publicamente com um tipo MIME de application/pdf (visualizar ou fazer o download do arquivo). https://storage.googleapis.com/cloud-samples-data/generative-ai/pdf/2403.05530.pdf

Gerar texto de arquivos PDF (codificado em base64)

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 a um modelo Gemini para gerar texto solicitando com texto e PDFs, 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.

Swift

É possível chamar generateContent() para gerar texto a partir 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.0-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

É possível chamar generateContent() para gerar texto a partir de entrada multimodal de texto e PDFs.

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

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

É possível chamar generateContent() para gerar texto a partir de entrada multimodal de texto e PDFs.

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

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

É possível chamar generateContent() para gerar texto a partir 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.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(','));
    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

É possível chamar generateContent() para gerar texto a partir 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.0-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

É possível chamar generateContent() para gerar texto a partir 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.0-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.

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.

Exemplo: transmitir texto gerado de arquivos PDF

Swift

É possível chamar generateContentStream() para transmitir o texto gerado a partir da 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.0-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 stream generated text output, call `generateContentStream` with the PDF file and text prompt
let contentStream = try model.generateContentStream(pdf, prompt)

// Print the generated text, handling the case where it might be nil
for try await chunk in contentStream {
  if let text = chunk.text {
    print(text)
  }
}

Kotlin

É possível chamar generateContentStream() para transmitir o texto gerado a partir da entrada multimodal de texto e PDFs.

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

// Provide the URI for the PDF 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 stream generated text output, call `generateContentStream` with the prompt
        var fullResponse = ""
        generativeModel.generateContentStream(prompt).collect { chunk ->
            // Log the generated text, handling the case where it might be null
            val chunkText = chunk.text ?: ""
            Log.d(TAG, chunkText)
            fullResponse += chunkText
        }
    }
} else {
    Log.e(TAG, "Error getting input stream for file.")
    // Handle the error appropriately
}

Java

É possível chamar generateContentStream() para transmitir o texto gerado a partir da entrada multimodal de texto e PDFs.

^{Em Java, os métodos de streaming neste SDK retornam um
tipo Publisher da biblioteca Reative 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-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();

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

        StringBuilder fullResponse = new StringBuilder();

        streamingResponse.subscribe(new Subscriber<GenerateContentResponse>() {
            @Override
            public void onNext(GenerateContentResponse generateContentResponse) {
                String chunk = generateContentResponse.getText();
                String text = (chunk == null) ? "" : chunk;
                Log.d(TAG, text);
                fullResponse.append(text);
            }

            @Override
            public void onComplete() {
                Log.d(TAG, fullResponse.toString());
            }

            @Override
            public void onError(Throwable t) {
                Log.e(TAG, "Failed to generate a response", t);
            }

            @Override
            public void onSubscribe(Subscription s) {
            }
         });
    } 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

É possível chamar generateContentStream() para transmitir o texto gerado a partir da 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.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(','));
    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 stream generated text output, call `generateContentStream` with the text and PDF file
  const result = await model.generateContentStream([prompt, pdfPart]);

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

run();

Dart

É possível chamar generateContentStream() para transmitir o texto gerado a partir da 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.0-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 `generateContentStream` with the text and PDF file
final response = await model.generateContentStream([
  Content.multi([prompt,docPart])
]);

// Print the generated text
await for (final chunk in response) {
  print(chunk.text);
}

Unity

É possível chamar generateContentStream() para transmitir o texto gerado a partir 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.0-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 stream generated text output, call `GenerateContentStreamAsync` with the text and PDF file
var responseStream = model.GenerateContentStreamAsync(new [] { prompt, doc });

// Print the generated text
await foreach (var response in responseStream) {
  if (!string.IsNullOrWhiteSpace(response.Text)) {
    UnityEngine.Debug.Log(response.Text);
  }
}

Requisitos e recomendações para documentos 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 o seguinte:

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 Gemini são compatíveis com os seguintes tipos MIME de documento:

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ê pode fazer?

Saiba como contar tokens antes de enviar comandos longos para o modelo.
Configure 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 áudio.
Comece a pensar na preparação para a produção (consulte a lista de verificação de produção), incluindo:
- Configurar Firebase App Check para proteger o Gemini API contra abusos de clientes não autorizados.
- Integração de 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 com vários turnos (chat).
Gerar texto com base em comandos somente de texto.
Gere saída estruturada (como JSON) com comandos de texto e multimodais.
Gerar imagens com base em comandos de texto.
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 podem ser consideradas nocivas.

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

Exceto em caso de indicação contrária, o conteúdo desta página é licenciado de acordo com a Licença de atribuição 4.0 do Creative Commons, e as amostras de código são licenciadas de acordo com a Licença Apache 2.0. Para mais detalhes, consulte as políticas do site do Google Developers. Java é uma marca registrada da Oracle e/ou afiliadas.

Última atualização 2025-05-21 UTC.