วิเคราะห์ไฟล์เสียงโดยใช้ Gemini API

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

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

• อธิบาย สรุป หรือตอบคำถามเกี่ยวกับเนื้อหาเสียง
• ถอดเสียงเนื้อหาเสียง
• วิเคราะห์เสียงบางส่วนโดยใช้การประทับเวลา

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

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

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

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

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

คู่มือนี้ถือว่าคุณใช้ SDK เวอร์ชันล่าสุด Firebase AI Logic หากยังใช้ SDK "Vertex AI in Firebase" อยู่ โปรดดูคำแนะนำในการย้ายข้อมูล

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

หากต้องการไฟล์เสียงตัวอย่าง

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

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

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

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

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

Swift

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

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 audio as `Data`
guard let audioData = try? Data(contentsOf: audioURL) else {
    print("Error loading audio data.")
    return // Or handle the error appropriately
}

// Specify the appropriate audio MIME type
let audio = InlineDataPart(data: audioData, mimeType: "audio/mpeg")


// Provide a text prompt to include with the audio
let prompt = "Transcribe what's said in this audio recording."

// To generate text output, call `generateContent` with the audio and text prompt
let response = try await model.generateContent(audio, prompt)

// Print the generated text, handling the case where it might be nil
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-2.5-flash")


val contentResolver = applicationContext.contentResolver

val inputStream = contentResolver.openInputStream(audioUri)

if (inputStream != null) {  // Check if the audio loaded successfully
    inputStream.use { stream ->
        val bytes = stream.readBytes()

        // Provide a prompt that includes the audio specified above and text
        val prompt = content {
            inlineData(bytes, "audio/mpeg")  // Specify the appropriate audio MIME type
            text("Transcribe what's said in this audio recording.")
        }

        // 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 audio.")
    // Handle the error appropriately
}

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-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();

try (InputStream stream = resolver.openInputStream(audioUri)) {
    File audioFile = new File(new URI(audioUri.toString()));
    int audioSize = (int) audioFile.length();
    byte audioBytes = new byte[audioSize];
    if (stream != null) {
        stream.read(audioBytes, 0, audioBytes.length);
        stream.close();

        // Provide a prompt that includes the audio specified above and text
        Content prompt = new Content.Builder()
              .addInlineData(audioBytes, "audio/mpeg")  // Specify the appropriate audio MIME type
              .addText("Transcribe what's said in this audio recording.")
              .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 audio file", e);
} catch (URISyntaxException e) {
    Log.e(TAG, "Invalid audio file", e);
}

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-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 audio
  const prompt = "Transcribe what's said in this audio recording.";

  // Prepare audio for input
  const fileInputEl = document.querySelector("input[type=file]");
  const audioPart = await fileToGenerativePart(fileInputEl.files);

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

  // Log the generated text, handling the case where it might be undefined
  console.log(result.response.text() ?? "No text in response.");
}

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


// Provide a text prompt to include with the audio
final prompt = TextPart("Transcribe what's said in this audio recording.");

// Prepare audio for input
final audio = await File('audio0.mp3').readAsBytes();

// Provide the audio as `Data` with the appropriate audio MIME type
final audioPart = InlineDataPart('audio/mpeg', audio);

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

// Print the generated text
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-2.5-flash");


// Provide a text prompt to include with the audio
var prompt = ModelContent.Text("Transcribe what's said in this audio recording.");

// Provide the audio as `data` with the appropriate audio MIME type
var audio = ModelContent.InlineData("audio/mpeg",
      System.IO.File.ReadAllBytes(System.IO.Path.Combine(
        UnityEngine.Application.streamingAssetsPath, "audio0.mp3")));

// To generate text output, call `GenerateContentAsync` with the text and audio
var response = await model.GenerateContentAsync(new [] { prompt, audio });

// Print the generated text
UnityEngine.Debug.Log(response.Text ?? "No text in response.");

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

สตรีมคำตอบ

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

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

ดูตัวอย่าง: สตรีมข้อความที่สร้างขึ้นจากไฟล์เสียง

Swift

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

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 audio as `Data`
guard let audioData = try? Data(contentsOf: audioURL) else {
    print("Error loading audio data.")
    return // Or handle the error appropriately
}

// Specify the appropriate audio MIME type
let audio = InlineDataPart(data: audioData, mimeType: "audio/mpeg")


// Provide a text prompt to include with the audio
let prompt = "Transcribe what's said in this audio recording."

// To stream generated text output, call `generateContentStream` with the audio and text prompt
let contentStream = try model.generateContentStream(audio, 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() เพื่อสตรีมข้อความที่สร้างขึ้นจากอินพุตข้อความและไฟล์เสียงเดียวที่ทำงานได้หลายรูปแบบ

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

val inputStream = contentResolver.openInputStream(audioUri)

if (inputStream != null) {  // Check if the audio loaded successfully
    inputStream.use { stream ->
        val bytes = stream.readBytes()

        // Provide a prompt that includes the audio specified above and text
        val prompt = content {
            inlineData(bytes, "audio/mpeg")  // Specify the appropriate audio MIME type
            text("Transcribe what's said in this audio recording.")
        }

        // To stream generated text output, call `generateContentStream` with the prompt
        var fullResponse = ""
        generativeModel.generateContentStream(prompt).collect { chunk ->
            // Log the generated text, handling the case where it might be null
            Log.d(TAG, chunk.text?: "")
            fullResponse += chunk.text?: ""
        }
    }
} else {
    Log.e(TAG, "Error getting input stream for audio.")
    // Handle the error appropriately
}

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-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();

try (InputStream stream = resolver.openInputStream(audioUri)) {
    File audioFile = new File(new URI(audioUri.toString()));
    int audioSize = (int) audioFile.length();
    byte audioBytes = new byte[audioSize];
    if (stream != null) {
        stream.read(audioBytes, 0, audioBytes.length);
        stream.close();

        // Provide a prompt that includes the audio specified above and text
        Content prompt = new Content.Builder()
              .addInlineData(audioBytes, "audio/mpeg")  // Specify the appropriate audio MIME type
              .addText("Transcribe what's said in this audio recording.")
              .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 audio file", e);
} catch (URISyntaxException e) {
    Log.e(TAG, "Invalid audio file", e);
}

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-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 audio
  const prompt = "Transcribe what's said in this audio recording.";

  // Prepare audio for input
  const fileInputEl = document.querySelector("input[type=file]");
  const audioPart = await fileToGenerativePart(fileInputEl.files);

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

  // Log the generated text
  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-2.5-flash');


// Provide a text prompt to include with the audio
final prompt = TextPart("Transcribe what's said in this audio recording.");

// Prepare audio for input
final audio = await File('audio0.mp3').readAsBytes();

// Provide the audio as `Data` with the appropriate audio MIME type
final audioPart = InlineDataPart('audio/mpeg', audio);

// To stream generated text output, call `generateContentStream` with the text and audio
final response = await model.generateContentStream([
  Content.multi([prompt, audioPart])
]);

// Print the generated text
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-2.5-flash");


// Provide a text prompt to include with the audio
var prompt = ModelContent.Text("Transcribe what's said in this audio recording.");

// Provide the audio as `data` with the appropriate audio MIME type
var audio = ModelContent.InlineData("audio/mpeg",
      System.IO.File.ReadAllBytes(System.IO.Path.Combine(
        UnityEngine.Application.streamingAssetsPath, "audio0.mp3")));

// To stream generated text output, call `GenerateContentStreamAsync` with the text and audio
var responseStream = model.GenerateContentStreamAsync(new [] { prompt, audio });

// 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 หากคำขอมีขนาดใหญ่เกินไป

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

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

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

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

ประเภท MIME ของเสียง	Gemini 2.0 Flash	Gemini 2.0 Flash‑Lite
AAC - audio/aac
FLAC - audio/flac
MP3 - audio/mp3
MPA - audio/m4a
MPEG - audio/mpeg
MPGA - audio/mpga
MP4 - audio/mp4
OPUS - audio/opus
PCM - audio/pcm
WAV - audio/wav
WEBM - audio/webm

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

คุณใส่ไฟล์เสียง 1 ไฟล์ในคำขอพรอมต์ได้สูงสุด

---

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

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

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

• สร้างการสนทนาแบบหลายรอบ (แชท)
• สร้างข้อความจาก พรอมต์ข้อความเท่านั้น
• สร้างเอาต์พุตที่มีโครงสร้าง (เช่น JSON) จากทั้งข้อความและพรอมต์มัลติโมดัล
• สร้างรูปภาพจากพรอมต์ข้อความ (Gemini หรือ Imagen)
• ใช้การเรียกใช้ฟังก์ชันเพื่อเชื่อมต่อ โมเดล Generative AI กับระบบและข้อมูลภายนอก

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

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

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

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

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

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