วิเคราะห์เอกสาร (เช่น PDF) โดยใช้ Gemini API

คุณสามารถขอให้โมเดล Gemini วิเคราะห์ไฟล์เอกสาร (เช่น ไฟล์ PDF และไฟล์ข้อความธรรมดา) ที่คุณระบุ แบบอินไลน์ (เข้ารหัส base64) หรือผ่าน URL ก็ได้ เมื่อใช้ Firebase AI Logic, คุณจะส่งคำขอนี้จากแอปได้โดยตรง

ความสามารถนี้ช่วยให้คุณทำสิ่งต่างๆ ได้ เช่น

  • วิเคราะห์ไดอะแกรม แผนภูมิ และตารางภายในเอกสาร
  • แยกข้อมูลเป็นรูปแบบเอาต์พุตที่มีโครงสร้าง
  • ตอบคำถามเกี่ยวกับเนื้อหาที่เป็นภาพและข้อความในเอกสาร
  • สรุปเอกสาร
  • ถอดเสียงเนื้อหาเอกสาร (เช่น เป็น HTML) โดยรักษารูปแบบและเลย์เอาต์ไว้เพื่อใช้ในแอปพลิเคชันปลายทาง (เช่น ในไปป์ไลน์ RAG)

ไปที่ตัวอย่างโค้ด ไปที่โค้ดสำหรับคำตอบที่สตรีม


ดูคำแนะนำอื่นๆ สำหรับตัวเลือกเพิ่มเติมในการทำงานกับเอกสาร (เช่น PDF)
สร้างเอาต์พุตที่มีโครงสร้าง การสนทนาหลายรอบ

ก่อนเริ่มต้น

คลิกผู้ให้บริการ Gemini API เพื่อดูเนื้อหาเฉพาะของผู้ให้บริการ และโค้ดในหน้านี้

หากยังไม่ได้ดำเนินการ ให้ทำตาม คู่มือเริ่มต้นใช้งาน ซึ่งอธิบายวิธี ตั้งค่าโปรเจ็กต์ Firebase, เชื่อมต่อแอปกับ Firebase, เพิ่ม SDK, เริ่มต้นบริการแบ็กเอนด์สำหรับผู้ให้บริการ Gemini API ที่คุณเลือก และ สร้างอินสแตนซ์ GenerativeModel

เราขอแนะนำให้ใช้ สำหรับการทดสอบและทำซ้ำพรอมต์Google AI Studio

สร้างข้อความจากไฟล์ PDF (เข้ารหัส base64)

ก่อนลองใช้ตัวอย่างนี้ ให้ทำตามส่วน ก่อนเริ่มต้นใช้งาน ของคู่มือนี้ เพื่อตั้งค่าโปรเจ็กต์และแอป
ในส่วนนั้น คุณจะต้องคลิกปุ่มสำหรับ Gemini API ที่เลือกเพื่อให้เห็นเนื้อหาเฉพาะของผู้ให้บริการ ในหน้านี้ด้วย

คุณสามารถขอให้โมเด0/}ลเพื่อ สร้างข้อความได้โดยการป้อนพรอมต์ด้วยข้อความและ PDF รวมถึงระบุ ไฟล์อินพุตแต่ละไฟล์mimeTypeและไฟล์นั้นๆGemini ดู ข้อกำหนดและคำแนะนำสำหรับไฟล์อินพุต ในส่วนท้ายของหน้านี้

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

คุณสามารถเรียกใช้ generateContent() เพื่อสร้างข้อความจากอินพุตแบบมัลติโมดัลที่เป็นข้อความและ PDF

สำหรับ Kotlin เมธอดใน SDK นี้เป็นฟังก์ชันระงับและต้องเรียกใช้ จาก ขอบเขต 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-3.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 = 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.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

คุณสามารถเรียกใช้ 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.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

คุณสามารถเรียกใช้ 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.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

คุณสามารถเรียกใช้ 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.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.");

ดูวิธีเลือกโมเดล (ไม่บังคับ) ที่เหมาะกับกรณีการใช้งานและแอปของคุณ

สตรีมคำตอบ

ก่อนลองใช้ตัวอย่างนี้ ให้ทำตามส่วน ก่อนเริ่มต้นใช้งาน ของคู่มือนี้ เพื่อตั้งค่าโปรเจ็กต์และแอป
ในส่วนนั้น คุณจะต้องคลิกปุ่มสำหรับ Gemini API ที่เลือกเพื่อให้เห็นเนื้อหาเฉพาะของผู้ให้บริการ ในหน้านี้ด้วย

คุณสามารถโต้ตอบได้เร็วขึ้นโดยไม่ต้องรอผลลัพธ์ทั้งหมดจากการสร้างโมเดล แต่ให้ใช้การสตรีมเพื่อจัดการผลลัพธ์บางส่วนแทน หากต้องการสตรีมคำตอบ ให้เรียกใช้ generateContentStream


ข้อกำหนดและคำแนะนำสำหรับเอกสารอินพุต

โปรดทราบว่าระบบจะเข้ารหัสไฟล์ที่ระบุเป็นข้อมูลอินไลน์เป็น base64 ระหว่างการส่ง ซึ่งจะเพิ่มขนาดของคำขอ คุณจะได้รับข้อผิดพลาด HTTP 413 หากคำขอมีขนาดใหญ่เกินไป

ดูรายละเอียดเกี่ยวกับสิ่งต่อไปนี้ในหน้า "ไฟล์อินพุตและข้อกำหนดที่รองรับ"

ประเภท MIME ของเอกสารที่รองรับ

โมเดลแบบมัลติโมดัลของ Gemini รองรับประเภท MIME ของเอกสารต่อไปนี้

  • PDF - application/pdf
  • ข้อความ - text/plain

ขีดจำกัดต่อคำขอ

ระบบจะถือว่า PDF เป็นรูปภาพ ดังนั้น PDF 1 หน้าจึงถือเป็นรูปภาพ 1 รูป จำนวนหน้าที่อนุญาตในพรอมต์จะจำกัดตามจำนวนรูปภาพที่โมเดลแบบมัลติโมดัลของ Gemini รองรับ

  • ไฟล์สูงสุดต่อคำขอ: 3,000 ไฟล์
  • หน้าสูงสุดต่อไฟล์: 1,000 หน้าต่อไฟล์
  • ขนาดสูงสุดต่อไฟล์: 50 MB ต่อไฟล์


เธอทำอะไรได้อีกบ้าง

ลองใช้ความสามารถอื่นๆ

ดูวิธีควบคุมการสร้างเนื้อหา

นอกจากนี้ คุณยังทดลองใช้พรอมต์และการกำหนดค่าโมเดล รวมถึงรับ ข้อมูลโค้ดที่สร้างขึ้นได้ด้วย Google AI Studio

ดูข้อมูลเพิ่มเติมเกี่ยวกับโมเดลที่รองรับ

ดูข้อมูลเกี่ยวกับ โมเดลที่พร้อมใช้งานสำหรับกรณีการใช้งานต่างๆ รวมถึง โควต้าและ การกำหนดราคา


แสดงความคิดเห็น เกี่ยวกับประสบการณ์การใช้งาน Firebase AI Logic