สร้างข้อความโดยใช้ Gemini API

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

พรอมต์แบบหลายรูปแบบสามารถมีอินพุตได้หลายประเภท (เช่น ข้อความพร้อมกับรูปภาพ, PDF, ไฟล์ข้อความธรรมดา, เสียง และวิดีโอ)

คู่มือนี้แสดงวิธีสร้างข้อความจากพรอมต์ข้อความเท่านั้นและจากพรอมต์แบบหลายรูปแบบพื้นฐานที่มีไฟล์

ไปที่โค้ดสำหรับอินพุตข้อความเท่านั้น ไปที่โค้ดสำหรับอินพุตแบบหลายรูปแบบ ไปที่โค้ดสำหรับคำตอบที่สตรีม

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

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

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

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

เอกสารทั้งหมดของเราจะถือว่าคุณใช้ เวอร์ชันล่าสุด ของ Firebase AI Logic SDK

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

สร้างข้อความจากอินพุตข้อความเท่านั้น

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

คุณขอให้โมเดล Gemini สร้างข้อความได้โดยการแจ้งด้วยอินพุตข้อความเท่านั้น

Swift

คุณเรียกใช้ generateContent() เพื่อสร้างข้อความจากอินพุตข้อความเท่านั้นได้

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 a prompt that contains text
let prompt = "Write a story about a magic backpack."

// To generate text output, call generateContent with the text input
let response = try await model.generateContent(prompt)
print(response.text ?? "No text in response.")

Kotlin

คุณเรียกใช้ generateContent() เพื่อสร้างข้อความจากอินพุตข้อความเท่านั้นได้

^{สำหรับ 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-flash-preview")


// Provide a prompt that contains text
val prompt = "Write a story about a magic backpack."

// To generate text output, call generateContent with the text input
val response = model.generateContent(prompt)
print(response.text)

Java

คุณเรียกใช้ generateContent() เพื่อสร้างข้อความจากอินพุตข้อความเท่านั้นได้

^{สำหรับ 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);


// Provide a prompt that contains text
Content prompt = new Content.Builder()
    .addText("Write a story about a magic backpack.")
    .build();

// To generate text output, call generateContent with the text input
ListenableFuture<GenerateContentResponse> response = model.generateContent(prompt);
Futures.addCallback(response, new FutureCallback<GenerateContentResponse>() {
    @Override
    public void onSuccess(GenerateContentResponse result) {
        String resultText = result.getText();
        System.out.println(resultText);
    }

    @Override
    public void onFailure(Throwable t) {
        t.printStackTrace();
    }
}, executor);

Web

คุณเรียกใช้ generateContent() เพื่อสร้างข้อความจากอินพุตข้อความเท่านั้นได้

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


// Wrap in an async function so you can use await
async function run() {
  // Provide a prompt that contains text
  const prompt = "Write a story about a magic backpack."

  // To generate text output, call generateContent with the text input
  const result = await model.generateContent(prompt);

  const response = result.response;
  const text = response.text();
  console.log(text);
}

run();

Dart

คุณเรียกใช้ generateContent() เพื่อสร้างข้อความจากอินพุตข้อความเท่านั้นได้

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 prompt that contains text
final prompt = [Content.text('Write a story about a magic backpack.')];

// To generate text output, call generateContent with the text input
final response = await model.generateContent(prompt);
print(response.text);

Unity

คุณเรียกใช้ GenerateContentAsync() เพื่อสร้างข้อความจากอินพุตข้อความเท่านั้นได้

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 prompt that contains text
var prompt = "Write a story about a magic backpack.";

// To generate text output, call GenerateContentAsync with the text input
var response = await model.GenerateContentAsync(prompt);
UnityEngine.Debug.Log(response.Text ?? "No text in response.");

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

สร้างข้อความจากอินพุตข้อความและไฟล์ (แบบหลายรูปแบบ)

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

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

ตัวอย่างต่อไปนี้แสดงพื้นฐานของวิธีสร้างข้อความจากอินพุตไฟล์โดยการวิเคราะห์ไฟล์วิดีโอเดียวที่ระบุเป็นข้อมูลแบบอินไลน์ (ไฟล์ที่เข้ารหัส base64)

โปรดทราบว่าตัวอย่างนี้แสดงการระบุไฟล์แบบอินไลน์ แต่ SDK ยัง รองรับ การระบุ URL ของ YouTube ด้วย

ต้องการไฟล์วิดีโอตัวอย่างไหม

คุณใช้ไฟล์ที่เปิดเผยต่อสาธารณะนี้ที่มีประเภท MIME เป็น video/mp4 (ดูหรือดาวน์โหลดไฟล์). https://storage.googleapis.com/cloud-samples-data/video/animals.mp4

สำคัญ: ขนาดคำขอทั้งหมดต้องไม่เกิน 20 MB หากต้องการส่งไฟล์ขนาดใหญ่ โปรดดู ตัวเลือกในการระบุไฟล์ในคำขอแบบหลายรูปแบบ

Swift

คุณเรียกใช้ generateContent() เพื่อสร้างข้อความจากอินพุตแบบหลายรูปแบบของข้อความและไฟล์วิดีโอได้

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 video as `Data` with the appropriate MIME type.
let video = InlineDataPart(data: try Data(contentsOf: videoURL), mimeType: "video/mp4")

// Provide a text prompt to include with the video
let prompt = "What is in the video?"

// To generate text output, call generateContent with the text and video
let response = try await model.generateContent(video, prompt)
print(response.text ?? "No text in response.")

Kotlin

คุณเรียกใช้ generateContent() เพื่อสร้างข้อความจากอินพุตแบบหลายรูปแบบของข้อความและไฟล์วิดีโอได้

^{สำหรับ 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-flash-preview")


val contentResolver = applicationContext.contentResolver
contentResolver.openInputStream(videoUri).use { stream ->
  stream?.let {
    val bytes = stream.readBytes()

    // Provide a prompt that includes the video specified above and text
    val prompt = content {
        inlineData(bytes, "video/mp4")
        text("What is in the video?")
    }

    // To generate text output, call generateContent with the prompt
    val response = model.generateContent(prompt)
    Log.d(TAG, response.text ?: "")
  }
}

Java

คุณเรียกใช้ generateContent() เพื่อสร้างข้อความจากอินพุตแบบหลายรูปแบบของข้อความและไฟล์วิดีโอได้

^{สำหรับ 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();
try (InputStream stream = resolver.openInputStream(videoUri)) {
    File videoFile = new File(new URI(videoUri.toString()));
    int videoSize = (int) videoFile.length();
    byte[] videoBytes = new byte[videoSize];
    if (stream != null) {
        stream.read(videoBytes, 0, videoBytes.length);
        stream.close();

        // Provide a prompt that includes the video specified above and text
        Content prompt = new Content.Builder()
                .addInlineData(videoBytes, "video/mp4")
                .addText("What is in the video?")
                .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 resultText = result.getText();
                System.out.println(resultText);
            }

            @Override
            public void onFailure(Throwable t) {
                t.printStackTrace();
            }
        }, executor);
    }
} catch (IOException e) {
    e.printStackTrace();
} catch (URISyntaxException e) {
    e.printStackTrace();
}

Web

คุณเรียกใช้ generateContent() เพื่อสร้างข้อความจากอินพุตแบบหลายรูปแบบของข้อความและไฟล์วิดีโอได้

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(',')[1]);
    reader.readAsDataURL(file);
  });
  return {
    inlineData: { data: await base64EncodedDataPromise, mimeType: file.type },
  };
}

async function run() {
  // Provide a text prompt to include with the video
  const prompt = "What do you see?";

  const fileInputEl = document.querySelector("input[type=file]");
  const videoPart = await fileToGenerativePart(fileInputEl.files[0]);

  // To generate text output, call generateContent with the text and video
  const result = await model.generateContent([prompt, videoPart]);

  const response = result.response;
  const text = response.text();
  console.log(text);
}

run();

Dart

คุณเรียกใช้ generateContent() เพื่อสร้างข้อความจากอินพุตแบบหลายรูปแบบของข้อความและไฟล์วิดีโอได้

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 video
final prompt = TextPart("What's in the video?");

// Prepare video for input
final video = await File('video0.mp4').readAsBytes();

// Provide the video as `Data` with the appropriate mimetype
final videoPart = InlineDataPart('video/mp4', video);

// To generate text output, call generateContent with the text and images
final response = await model.generateContent([
  Content.multi([prompt, ...videoPart])
]);
print(response.text);

Unity

คุณเรียกใช้ GenerateContentAsync() เพื่อสร้างข้อความจากอินพุตแบบหลายรูปแบบของข้อความและไฟล์วิดีโอได้

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 the video as `data` with the appropriate MIME type.
var video = ModelContent.InlineData("video/mp4",
      System.IO.File.ReadAllBytes(System.IO.Path.Combine(
          UnityEngine.Application.streamingAssetsPath, "yourVideo.mp4")));

// Provide a text prompt to include with the video
var prompt = ModelContent.Text("What is in the video?");

// To generate text output, call GenerateContentAsync with the text and video
var response = await model.GenerateContentAsync(new [] { video, prompt });
UnityEngine.Debug.Log(response.Text ?? "No text in response.");

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

สตรีมคำตอบ

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

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

ดูตัวอย่าง: สตรีมข้อความที่สร้างขึ้นจากอินพุตข้อความเท่านั้น

Swift

คุณเรียกใช้ generateContentStream() เพื่อสตรีมข้อความที่สร้างขึ้นจากอินพุตข้อความเท่านั้นได้

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 a prompt that contains text
let prompt = "Write a story about a magic backpack."

// To stream generated text output, call generateContentStream with the text input
let contentStream = try model.generateContentStream(prompt)
for try await chunk in contentStream {
  if let text = chunk.text {
    print(text)
  }
}

Kotlin

คุณเรียกใช้ generateContentStream() เพื่อสตรีมข้อความที่สร้างขึ้นจากอินพุตข้อความเท่านั้นได้

^{สำหรับ 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-flash-preview")


// Provide a prompt that includes only text
val prompt = "Write a story about a magic backpack."

// To stream generated text output, call generateContentStream and pass in the prompt
var response = ""
model.generateContentStream(prompt).collect { chunk ->
    print(chunk.text)
    response += chunk.text
}

Java

คุณเรียกใช้ generateContentStream() เพื่อสตรีมข้อความที่สร้างขึ้นจากอินพุตข้อความเท่านั้นได้

^{สำหรับ Java เมธอดการสตรีมใน SDK นี้จะแสดงผลเป็นประเภท Publisher จาก ไลบรารี Reactive 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-3-flash-preview");

// Use the GenerativeModelFutures Java compatibility layer which offers
// support for ListenableFuture and Publisher APIs
GenerativeModelFutures model = GenerativeModelFutures.from(ai);


// Provide a prompt that contains text
Content prompt = new Content.Builder()
        .addText("Write a story about a magic backpack.")
        .build();

// To stream generated text output, call generateContentStream with the text input
Publisher<GenerateContentResponse> streamingResponse =
    model.generateContentStream(prompt);

// Subscribe to partial results from the response
final String[] fullResponse = {""};
streamingResponse.subscribe(new Subscriber<GenerateContentResponse>() {
  @Override
  public void onNext(GenerateContentResponse generateContentResponse) {
    String chunk = generateContentResponse.getText();
    fullResponse[0] += chunk;
  }

  @Override
  public void onComplete() {
    System.out.println(fullResponse[0]);
  }

  @Override
  public void onError(Throwable t) {
    t.printStackTrace();
  }

  @Override
  public void onSubscribe(Subscription s) { }
});

Web

คุณเรียกใช้ generateContentStream() เพื่อสตรีมข้อความที่สร้างขึ้นจากอินพุตข้อความเท่านั้นได้

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


// Wrap in an async function so you can use await
async function run() {
  // Provide a prompt that contains text
  const prompt = "Write a story about a magic backpack."

  // To stream generated text output, call generateContentStream with the text input
  const result = await model.generateContentStream(prompt);

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

  console.log('aggregated response: ', await result.response);
}

run();

Dart

คุณเรียกใช้ generateContentStream() เพื่อสตรีมข้อความที่สร้างขึ้นจากอินพุตข้อความเท่านั้นได้

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 prompt that contains text
final prompt = [Content.text('Write a story about a magic backpack.')];

// To stream generated text output, call generateContentStream with the text input
final response = model.generateContentStream(prompt);
await for (final chunk in response) {
  print(chunk.text);
}

Unity

คุณเรียกใช้ GenerateContentStreamAsync() เพื่อสตรีมข้อความที่สร้างขึ้นจากอินพุตข้อความเท่านั้นได้

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 prompt that contains text
var prompt = "Write a story about a magic backpack.";

// To stream generated text output, call GenerateContentStreamAsync with the text input
var responseStream = model.GenerateContentStreamAsync(prompt);
await foreach (var response in responseStream) {
  if (!string.IsNullOrWhiteSpace(response.Text)) {
    UnityEngine.Debug.Log(response.Text);
  }
}

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

ดูตัวอย่าง: สตรีมข้อความที่สร้างขึ้นจากอินพุตแบบหลายรูปแบบ

Swift

คุณเรียกใช้ generateContentStream() เพื่อสตรีมข้อความที่สร้างขึ้นจากอินพุตแบบหลายรูปแบบของข้อความและวิดีโอเดียวได้

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 video as `Data` with the appropriate MIME type
let video = InlineDataPart(data: try Data(contentsOf: videoURL), mimeType: "video/mp4")

// Provide a text prompt to include with the video
let prompt = "What is in the video?"

// To stream generated text output, call generateContentStream with the text and video
let contentStream = try model.generateContentStream(video, prompt)
for try await chunk in contentStream {
  if let text = chunk.text {
    print(text)
  }
}

Kotlin

คุณเรียกใช้ generateContentStream() เพื่อสตรีมข้อความที่สร้างขึ้นจากอินพุตแบบหลายรูปแบบของข้อความและวิดีโอเดียวได้

^{สำหรับ 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-flash-preview")


val contentResolver = applicationContext.contentResolver
contentResolver.openInputStream(videoUri).use { stream ->
  stream?.let {
    val bytes = stream.readBytes()

    // Provide a prompt that includes the video specified above and text
    val prompt = content {
        inlineData(bytes, "video/mp4")
        text("What is in the video?")
    }

    // To stream generated text output, call generateContentStream with the prompt
    var fullResponse = ""
    model.generateContentStream(prompt).collect { chunk ->
        Log.d(TAG, chunk.text ?: "")
        fullResponse += chunk.text
    }
  }
}

Java

คุณเรียกใช้ generateContentStream() เพื่อสตรีมข้อความที่สร้างขึ้นจากอินพุตแบบหลายรูปแบบของข้อความและวิดีโอเดียวได้

^{สำหรับ Java เมธอดการสตรีมใน SDK นี้จะแสดงผลเป็นประเภท Publisher จาก ไลบรารี Reactive 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-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();
try (InputStream stream = resolver.openInputStream(videoUri)) {
    File videoFile = new File(new URI(videoUri.toString()));
    int videoSize = (int) videoFile.length();
    byte[] videoBytes = new byte[videoSize];
    if (stream != null) {
        stream.read(videoBytes, 0, videoBytes.length);
        stream.close();

        // Provide a prompt that includes the video specified above and text
        Content prompt = new Content.Builder()
                .addInlineData(videoBytes, "video/mp4")
                .addText("What is in the video?")
                .build();

        // To stream generated text output, call generateContentStream with the prompt
        Publisher<GenerateContentResponse> streamingResponse =
                model.generateContentStream(prompt);

        final String[] fullResponse = {""};

        streamingResponse.subscribe(new Subscriber<GenerateContentResponse>() {
            @Override
            public void onNext(GenerateContentResponse generateContentResponse) {
                String chunk = generateContentResponse.getText();
                fullResponse[0] += chunk;
            }

            @Override
            public void onComplete() {
                System.out.println(fullResponse[0]);
            }

            @Override
            public void onError(Throwable t) {
                t.printStackTrace();
            }

            @Override
            public void onSubscribe(Subscription s) {
            }
         });
    }
} catch (IOException e) {
    e.printStackTrace();
} catch (URISyntaxException e) {
    e.printStackTrace();
}

Web

คุณเรียกใช้ generateContentStream() เพื่อสตรีมข้อความที่สร้างขึ้นจากอินพุตแบบหลายรูปแบบของข้อความและวิดีโอเดียวได้

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(',')[1]);
    reader.readAsDataURL(file);
  });
  return {
    inlineData: { data: await base64EncodedDataPromise, mimeType: file.type },
  };
}

async function run() {
  // Provide a text prompt to include with the video
  const prompt = "What do you see?";

  const fileInputEl = document.querySelector("input[type=file]");
  const videoPart = await fileToGenerativePart(fileInputEl.files[0]);

  // To stream generated text output, call generateContentStream with the text and video
  const result = await model.generateContentStream([prompt, videoPart]);

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

run();

Dart

คุณเรียกใช้ generateContentStream() เพื่อสตรีมข้อความที่สร้างขึ้นจากอินพุตแบบหลายรูปแบบของข้อความและวิดีโอเดียวได้

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 video
final prompt = TextPart("What's in the video?");

// Prepare video for input
final video = await File('video0.mp4').readAsBytes();

// Provide the video as `Data` with the appropriate mimetype
final videoPart = InlineDataPart('video/mp4', video);

// To stream generated text output, call generateContentStream with the text and image
final response = await model.generateContentStream([
  Content.multi([prompt,videoPart])
]);
await for (final chunk in response) {
  print(chunk.text);
}

Unity

คุณเรียกใช้ GenerateContentStreamAsync() เพื่อสตรีมข้อความที่สร้างขึ้นจากอินพุตแบบหลายรูปแบบของข้อความและวิดีโอเดียวได้

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 the video as `data` with the appropriate MIME type.
var video = ModelContent.InlineData("video/mp4",
      System.IO.File.ReadAllBytes(System.IO.Path.Combine(
          UnityEngine.Application.streamingAssetsPath, "yourVideo.mp4")));

// Provide a text prompt to include with the video
var prompt = ModelContent.Text("What is in the video?");

// To stream generated text output, call GenerateContentStreamAsync with the text and video
var responseStream = model.GenerateContentStreamAsync(new [] { video, prompt });
await foreach (var response in responseStream) {
  if (!string.IsNullOrWhiteSpace(response.Text)) {
    UnityEngine.Debug.Log(response.Text);
  }
}

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

---

ข้อกำหนดและคำแนะนำสำหรับไฟล์รูปภาพอินพุต

สำคัญ: ขนาดคำขอทั้งหมดต้องไม่เกิน 20 MB หากต้องการส่งไฟล์ขนาดใหญ่ โปรดดู ตัวเลือกในการระบุไฟล์ในคำขอแบบหลายรูปแบบ

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

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

• ตัวเลือกต่างๆ ในการระบุไฟล์ในคำขอ (แบบอินไลน์หรือใช้ URL หรือ URI ของไฟล์)
• ประเภทไฟล์ที่รองรับ
• ประเภท MIME ที่รองรับและวิธีระบุประเภท MIME
• ข้อกำหนดและแนวทางปฏิบัติแนะนำสำหรับไฟล์และคำขอแบบหลายรูปแบบ

---

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

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

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

• สร้างการสนทนาแบบหลายรอบ (แชท)
• สร้างข้อความจาก พรอมต์ข้อความเท่านั้น.
• สร้างเอาต์พุตที่มีโครงสร้าง (เช่น JSON) จากทั้งพรอมต์ข้อความและพรอมต์แบบหลายรูปแบบ
• สร้างและแก้ไขรูปภาพ จากทั้งพรอมต์ข้อความและพรอมต์แบบหลายรูปแบบ
• สตรีมอินพุตและเอาต์พุต (รวมถึงเสียง) โดยใช้ Gemini Live API
• ใช้เครื่องมือ (เช่น การเรียกใช้ฟังก์ชัน และ การเชื่อมต่อแหล่งข้อมูลกับ Google Search) เพื่อเชื่อมต่อโมเดล Gemini กับส่วนอื่นๆ ของแอป รวมถึงระบบและข้อมูลภายนอก

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

• ทำความเข้าใจการออกแบบพรอมต์ ซึ่งรวมถึง แนวทางปฏิบัติแนะนำ กลยุทธ์ และพรอมต์ตัวอย่าง
• กำหนดค่าพารามิเตอร์โมเดล เช่น อุณหภูมิและโทเค็นเอาต์พุตสูงสุด
• ใช้การตั้งค่าความปลอดภัย เพื่อปรับ ความน่าจะเป็นที่จะได้รับคำตอบที่อาจถือว่ามีอันตราย

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

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

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

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