วิเคราะห์เอกสาร (เช่น 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 ที่เลือกเพื่อให้เห็นเนื้อหาเฉพาะของผู้ให้บริการ ในหน้านี้ด้วย

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

Swift

คุณเรียกใช้ generateContent() เพื่อสร้างข้อความจากอินพุตข้อความและ 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

คุณเรียกใช้ 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-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

คุณเรียกใช้ 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-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

คุณเรียกใช้ 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-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

คุณเรียกใช้ 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-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

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

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

สตรีมคำตอบ

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

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



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

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

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

ประเภท MIME ของวิดีโอที่รองรับ

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

ประเภท MIME ของเอกสาร Gemini 2.0 Flash Gemini 2.0 Flash‑Lite
PDF - application/pdf
ข้อความ - text/plain

จำนวนที่จำกัดต่อคำขอ

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

  • Gemini 2.0 Flash และ Gemini 2.0 Flash‑Lite
    • ไฟล์สูงสุดต่อคำขอ: 3,000 ไฟล์
    • จำนวนหน้าสูงสุดต่อไฟล์: 1,000
    • ขนาดสูงสุดต่อไฟล์: 50 MB



คุณทำอะไรได้อีกบ้าง

  • ดูวิธีนับโทเค็น ก่อนส่งพรอมต์ยาวๆ ไปยังโมเดล
  • ตั้งค่า Cloud Storage for Firebase เพื่อให้คุณรวมไฟล์ขนาดใหญ่ในคำขอแบบมัลติโมดัลและมี โซลูชันที่มีการจัดการมากขึ้นสำหรับการระบุไฟล์ในพรอมต์ ไฟล์อาจมีรูปภาพ, PDF, วิดีโอ และเสียง
  • เริ่มคิดถึงการเตรียมพร้อมสำหรับเวอร์ชันที่ใช้งานจริง (ดูรายการตรวจสอบการผลิต) ซึ่งรวมถึง
    • ตั้งค่า Firebase App Check เพื่อปกป้อง Gemini API จากการละเมิดโดยไคลเอ็นต์ที่ไม่ได้รับอนุญาต
    • การผสานรวม Firebase Remote Config เพื่ออัปเดตค่าในแอป (เช่น ชื่อโมเดล) โดยไม่ต้องเผยแพร่แอปเวอร์ชันใหม่

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

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

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

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

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


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