使用 Gemini API 分析文档（例如 PDF 文件）

您可以要求 Gemini 模型分析您以内嵌方式（base64 编码）或通过网址提供的文档文件（例如 PDF 和纯文本文件）。使用 Firebase AI Logic, 时，您可以直接从应用发出此请求。

借助此功能，您可以执行以下操作：

• 分析文档中的图表和表格
• 将信息提取为结构化输出格式
• 回答有关文档中视觉内容和文本内容的问题
• 总结文档
• 转录文档内容（例如转换为 HTML），保留布局和格式，以便在下游应用（例如 RAG 流水线）中使用

跳转到代码示例 跳转到流式响应的代码

如需了解使用文档（例如 PDF）的其他选项，请参阅其他指南 生成结构化输出 多轮对话

准备工作

点击您的 Gemini API 提供商，以查看此页面上特定于提供商的内容和代码。 Gemini Developer API Vertex AI Gemini API

如果尚未完成，请完成 入门指南，其中介绍了如何 设置 Firebase 项目、将应用连接到 Firebase、添加 SDK、 为所选的 Gemini API 提供方初始化后端服务，以及 创建 GenerativeModel 实例。

我们的所有文档都假定您使用的是 最新版本 的 Firebase AI Logic SDK。

如需测试和迭代提示，我们建议使用 Google AI Studio。

需要示例 PDF 文件吗？

您可以使用此公开提供的文件，其 MIME 类型为 application/pdf （查看或下载文件）。 https://storage.googleapis.com/cloud-samples-data/generative-ai/pdf/2403.05530.pdf

注意 Firebase AI Logic 尚不支持配置输入媒体 分辨率，但此功能即将推出！

根据 PDF 文件（base64 编码）生成文本

在尝试此示例之前，请完成本指南的 准备工作部分，以设置您的项目和应用。 在该部分中，您还需要点击所选 Gemini API提供商的按钮，以便在此页面上看到特定于提供商的内容 。

您可以要求 Gemini 模型通过文本和 PDF 提示生成文本，并提供每个输入文件的 mimeType 和文件本身。如需了解输入文件的 要求和建议 ，请参阅本页面的后续内容。

重要提示：请求总大小上限为 20 MB。 如需发送大型文件，请查看在多模态请求中提供文件的 选项。

Swift

您可以调用 generateContent() ，根据文本和 PDF 的多模态输入生成文本。

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-flash-preview")


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

您可以调用 generateContent() ，根据文本和 PDF 的多模态输入生成文本。

^{对于 Kotlin，此 SDK 中的方法是挂起函数，需要从 协程范围 调用。}

// 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-flash-preview")


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

您可以调用 generateContent() ，根据文本和 PDF 的多模态输入生成文本。

^{对于 Java，此 SDK 中的方法会返回 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-flash-preview");

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

您可以调用 generateContent() ，根据文本和 PDF 的多模态输入生成文本。

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-flash-preview" });


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

您可以调用 generateContent() ，根据文本和 PDF 的多模态输入生成文本。

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-flash-preview');


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

您可以调用 GenerateContentAsync() ，根据文本和 PDF 的多模态输入生成文本。

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-flash-preview");


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

了解如何选择适合您的应用场景和应用的模型，以及（可选）模型位置。

流式传输响应

在尝试此示例之前，请完成本指南的 准备工作部分，以设置您的项目和应用。 在该部分中，您还需要点击所选 Gemini API提供商的按钮，以便在此页面上看到特定于提供商的内容 。

您可以不等待模型生成完整结果，而是使用流式传输来处理部分结果，从而实现更快的互动。 如需流式传输响应，请调用 generateContentStream。

查看示例：流式传输根据 PDF 文件生成的文本

Swift

您可以调用 generateContentStream() ，流式传输根据文本和 PDF 的多模态输入生成的文本。

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-flash-preview")


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

您可以调用 generateContentStream() ，流式传输根据文本和 PDF 的多模态输入生成的文本。

^{对于 Kotlin，此 SDK 中的方法是挂起函数，需要从 协程范围 调用。}

// 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-flash-preview")


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 = ""
        model.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

您可以调用 generateContentStream() ，流式传输根据文本和 PDF 的多模态输入生成的文本。

^{对于 Java，此 SDK 中的流式传输方法会返回 Reactive Streams 库中的 Publisher类型。}

// 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-flash-preview");

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

您可以调用 generateContentStream() ，流式传输根据文本和 PDF 的多模态输入生成的文本。

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-flash-preview" });


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

您可以调用 generateContentStream() ，流式传输根据文本和 PDF 的多模态输入生成的文本。

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-flash-preview');


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

您可以调用 GenerateContentStreamAsync() ，流式传输根据文本和 PDF 的多模态输入生成的文本。

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-flash-preview");


// 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);
  }
}

了解如何选择适合您的应用场景和应用的模型，以及（可选）模型位置。

---

输入文档的要求和建议

重要提示：请求总大小上限为 20 MB。 如需发送大型文件，请查看在多模态请求中提供文件的 选项。

请注意，以内嵌数据形式提供的文件在传输过程中会编码为 base64，这会增加请求的大小。如果请求过大，您会收到 HTTP 413 错误。

如需详细了解以下内容，请参阅“支持的输入文件和要求”页面：

• 在请求中提供文件的不同选项 （以内嵌方式或使用文件的网址或 URI）
• 文档文件的要求和最佳实践

支持的文档 MIME 类型

Gemini 多模态模型支持以下文档 MIME 类型：

• PDF - application/pdf
• 文本 - text/plain

每个请求的限制

PDF 文件被视为图片，因此 PDF 文件的单页被视为一张 图片。提示中允许的页数取决于 Gemini多模态模型可以支持的图片数量。

• 每个请求的文件数量上限：3,000 个文件
• 每个文件的页数上限：1,000 页
• 每个文件的大小上限：50 MB

---

你还可以做些什么？

• 了解如何在 计算 token 数 向模型发送长提示之前。
• 设置 Cloud Storage for Firebase ，以便您可以在多模态请求中包含大型文件，并获得 更易于管理的方式来在提示中提供文件。 文件可以包括图片、PDF、视频和音频。
• 开始考虑为正式版做准备（请参阅 正式版核对清单）：
  • 尽早设置 Firebase App Check 以帮助保护 Gemini API 免遭未经授权的客户端滥用。
  • 集成 Firebase Remote Config ，以便在不发布新应用 版本的情况下更新应用中的值（例如模型名称）。

试用其他功能

• 构建多轮对话（聊天）。
• 根据 纯文本提示生成文本。
• 根据文本和多模态提示 生成结构化输出（例如 JSON）。
• 根据文本和多模态提示 生成和修改图片。
• 使用工具（例如 函数调用 和 依托 Google 搜索进行接地）将 Gemini 模型连接到应用的其他部分以及外部 系统和信息。

了解如何控制内容生成

• 了解提示设计，包括 最佳实践、策略和示例提示。
• 配置模型参数，例如 温度和输出 token 数上限。
• 使用安全设置来调整 收到可能被视为有害的响应的可能性。

您还可以使用 Google AI Studio 试用提示和模型配置，甚至获取 生成的代码段。 Google AI Studio

详细了解支持的模型

了解适用于各种应用场景的 模型 及其 配额和 定价。

提供反馈 就您使用 Firebase AI Logic 的体验