Menganalisis dokumen (seperti PDF) menggunakan Gemini API

Anda dapat meminta model Gemini untuk menganalisis file dokumen (seperti PDF dan file teks biasa) yang Anda berikan baik secara inline (berenkode base64) atau melalui URL. Saat menggunakan Firebase AI Logic, Anda dapat membuat permintaan ini langsung dari aplikasi Anda.

Dengan kemampuan ini, Anda dapat melakukan hal-hal seperti:

  • Menganalisis diagram, bagan, dan tabel di dalam dokumen
  • Mengekstrak informasi ke dalam format output terstruktur
  • Menjawab pertanyaan tentang konten visual dan teks dalam dokumen
  • Meringkas dokumen
  • Mentranskripsikan konten dokumen (misalnya, ke dalam HTML), dengan mempertahankan tata letak dan pemformatan, untuk digunakan dalam aplikasi hilir (seperti dalam pipeline RAG)

Langsung ke contoh kode Langsung ke kode untuk respons yang di-streaming


Lihat panduan lain untuk opsi tambahan dalam menangani dokumen (seperti PDF)
Membuat output terstruktur Chat multi-turn

Sebelum memulai

Klik penyedia Gemini API untuk melihat konten dan kode khusus penyedia di halaman ini.

Jika belum melakukannya, selesaikan panduan memulai, yang menjelaskan cara menyiapkan project Firebase, menghubungkan aplikasi ke Firebase, menambahkan SDK, menginisialisasi layanan backend untuk penyedia Gemini API yang Anda pilih, dan membuat instance GenerativeModel.

Untuk menguji dan melakukan iterasi pada perintah Anda, serta mendapatkan cuplikan kode yang dihasilkan, sebaiknya gunakan Google AI Studio.

Membuat teks dari file PDF (berenkode base64)

Sebelum mencoba sampel ini, selesaikan bagian Sebelum memulai dalam panduan ini untuk menyiapkan project dan aplikasi Anda.
Di bagian tersebut, Anda juga akan mengklik tombol untuk penyedia Gemini API yang Anda pilih agar Anda dapat melihat konten khusus penyedia di halaman ini.

Anda dapat meminta model Gemini untuk membuat teks dengan memberikan perintah menggunakan teks dan PDF—dengan memberikan mimeType setiap file input dan file itu sendiri. Temukan persyaratan dan rekomendasi untuk file input di bagian selanjutnya pada halaman ini.

Swift

Anda dapat memanggil generateContent() untuk membuat teks dari input multimodal berupa teks dan PDF.


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

Anda dapat memanggil generateContent() untuk membuat teks dari input multimodal berupa teks dan PDF.

Untuk Kotlin, metode dalam SDK ini adalah fungsi penangguhan dan perlu dipanggil dari cakupan Coroutine.

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

Anda dapat memanggil generateContent() untuk membuat teks dari input multimodal berupa teks dan PDF.

Untuk Java, metode dalam SDK ini menampilkan 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

Anda dapat memanggil generateContent() untuk membuat teks dari input multimodal berupa teks dan 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-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

Anda dapat memanggil generateContent() untuk membuat teks dari input multimodal berupa teks dan 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-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

Anda dapat memanggil GenerateContentAsync() untuk membuat teks dari input multimodal berupa teks dan 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-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.");

Pelajari cara memilih model yang sesuai untuk kasus penggunaan dan aplikasi Anda.

Streaming respons

Sebelum mencoba sampel ini, selesaikan bagian Sebelum memulai dalam panduan ini untuk menyiapkan project dan aplikasi Anda.
Di bagian tersebut, Anda juga akan mengklik tombol untuk penyedia Gemini API yang Anda pilih agar Anda dapat melihat konten khusus penyedia di halaman ini.

Anda dapat mencapai interaksi yang lebih cepat dengan tidak menunggu seluruh hasil dari pembuatan model, dan menggunakan streaming untuk menangani hasil parsial. Untuk melakukan streaming respons, panggil generateContentStream.



Persyaratan dan rekomendasi untuk dokumen input

Perhatikan bahwa file yang disediakan sebagai data inline dienkode ke base64 saat transit, yang meningkatkan ukuran permintaan. Anda akan mendapatkan error HTTP 413 jika permintaan terlalu besar.

Lihat "File input yang didukung dan persyaratan untuk Vertex AI Gemini API" untuk mempelajari informasi mendetail tentang hal berikut:

Jenis MIME video yang didukung

Model multimodal Gemini mendukung jenis MIME dokumen berikut:

Jenis MIME dokumen Gemini 2.0 Flash Gemini 2.0 Flash‑Lite
PDF - application/pdf
Teks - text/plain

Batas per permintaan

PDF diperlakukan sebagai gambar, sehingga satu halaman PDF diperlakukan sebagai satu gambar. Jumlah halaman yang diizinkan dalam perintah dibatasi hingga jumlah gambar yang dapat didukung model:

  • Gemini 2.0 Flash dan Gemini 2.0 Flash‑Lite:
    • File maksimum per permintaan: 3.000
    • Halaman maksimum per file: 1.000
    • Ukuran maksimum per file: 50 MB



Kamu bisa apa lagi?

Mencoba kemampuan lainnya

Mempelajari cara mengontrol pembuatan konten

Anda juga dapat bereksperimen dengan perintah dan konfigurasi model, bahkan mendapatkan cuplikan kode yang dihasilkan menggunakan Google AI Studio.

Pelajari lebih lanjut model yang didukung

Pelajari model yang tersedia untuk berbagai kasus penggunaan dan kuota serta harganya.


Memberikan masukan tentang pengalaman Anda dengan Firebase AI Logic