Gemini API จะแสดงผลคำตอบเป็นข้อความที่ไม่มีโครงสร้างโดยค่าเริ่มต้น อย่างไรก็ตาม กรณีการใช้งานบางรายการต้องใช้ข้อความที่มีโครงสร้าง เช่น JSON เช่น คุณอาจใช้การตอบกลับสําหรับงานดาวน์สตรีมอื่นๆ ที่จําเป็นต้องใช้สคีมาข้อมูลที่กําหนดไว้
คุณสามารถกําหนดสคีมาคำตอบเพื่อตรวจสอบว่าเอาต์พุตที่โมเดลสร้างขึ้นเป็นไปตามสคีมาที่ต้องการเสมอ ซึ่งจะทํางานเหมือนพิมพ์เขียวสําหรับคําตอบของโมเดล จากนั้นคุณจะดึงข้อมูลจากเอาต์พุตของโมเดลได้โดยตรงด้วยการประมวลผลขั้นสุดท้ายน้อยลง
โดยตัวอย่างมีดังนี้
ตรวจสอบว่าการตอบกลับของโมเดลสร้าง JSON ที่ถูกต้องและเป็นไปตามสคีมาที่คุณระบุ
ตัวอย่างเช่น โมเดลสามารถสร้างรายการแบบมีโครงสร้างสำหรับสูตรอาหารที่มีชื่อสูตร รายการส่วนผสม และขั้นตอนเสมอ จากนั้นคุณจะแยกวิเคราะห์และแสดงข้อมูลนี้ใน UI ของแอปได้ง่ายขึ้นจํากัดวิธีที่โมเดลจะตอบสนองในระหว่างงานการจัดประเภท
ตัวอย่างเช่น คุณสามารถให้โมเดลกำกับเนื้อหาด้วยชุดป้ายกำกับที่เจาะจง (เช่น ชุดค่าคงที่ที่เจาะจง เช่นpositive
และnegative
) แทนป้ายกำกับที่โมเดลสร้างขึ้น (ซึ่งอาจมีระดับความแปรปรวน เช่นgood
,positive
,negative
หรือbad
)
คู่มือนี้แสดงวิธีสร้างเอาต์พุต JSON โดยระบุ responseSchema
ในการเรียก generateContent
โดยมุ่งเน้นที่อินพุตที่เป็นข้อความเท่านั้น แต่ Gemini ยังสามารถสร้างคำตอบที่มีโครงสร้างสำหรับคำขอแบบหลายรูปแบบซึ่งมีรูปภาพ วิดีโอ และเสียงเป็นอินพุตได้ด้วย
ด้านล่างของหน้านี้มีตัวอย่างเพิ่มเติม เช่น วิธีสร้างค่า Enum เป็นเอาต์พุต หากต้องการดูตัวอย่างเพิ่มเติมเกี่ยวกับวิธีสร้างเอาต์พุตที่มีโครงสร้าง ให้ดูรายการสคีมาตัวอย่างและการตอบกลับรูปแบบในเอกสารประกอบ Google Cloud
ตัวเลือกอื่นๆ สำหรับการทำงานกับ Gemini API
หากต้องการ ให้ลองใช้ Gemini API
เวอร์ชัน "Google AI" อื่น คุณสามารถรับสิทธิ์เข้าถึงได้แบบไม่มีค่าใช้จ่าย (ภายในขีดจำกัดและเมื่อพร้อมให้บริการ) โดยใช้ Google AI Studio และ Google AI SDK ของไคลเอ็นต์ SDK เหล่านี้ควรใช้สำหรับการสร้างต้นแบบเท่านั้นในแอปบนอุปกรณ์เคลื่อนที่และเว็บเมื่อคุ้นเคยกับวิธีการทำงานของ Gemini API แล้ว ให้เปลี่ยนไปใช้ Vertex AI in FirebaseSDK (เอกสารประกอบนี้) ซึ่งมีฟีเจอร์เพิ่มเติมมากมายที่สําคัญสําหรับแอปบนอุปกรณ์เคลื่อนที่และเว็บ เช่น การปกป้อง API จากการละเมิดโดยใช้ Firebase App Check และรองรับไฟล์สื่อขนาดใหญ่ในคําขอ
เรียกใช้ Vertex AI Gemini API ฝั่งเซิร์ฟเวอร์ (เช่น ด้วย Python, Node.js หรือ Go)
ใช้ Vertex AI SDK ฝั่งเซิร์ฟเวอร์, Firebase Genkit หรือ Firebase Extensions สำหรับ Gemini API (ไม่บังคับ)
ก่อนเริ่มต้น
ทําตามคู่มือการเริ่มต้นใช้งาน Vertex AI in FirebaseSDK ให้เสร็จสมบูรณ์ หากยังไม่ได้ดำเนินการ ตรวจสอบว่าคุณได้ทำสิ่งต่อไปนี้ทั้งหมดแล้ว
ตั้งค่าโปรเจ็กต์ Firebase ใหม่หรือที่มีอยู่ รวมถึงใช้แพ็กเกจราคา Blaze และเปิดใช้ API ที่จําเป็น
เชื่อมต่อแอปกับ Firebase ซึ่งรวมถึงการลงทะเบียนแอปและเพิ่มการกําหนดค่า Firebase ลงในแอป
เพิ่ม SDK และเริ่มต้นVertex AIบริการและโมเดล Generative ในแอป
หลังจากเชื่อมต่อแอปกับ Firebase, เพิ่ม SDK และเริ่มต้นบริการ Vertex AI และ Generative Model แล้ว คุณก็พร้อมเรียกใช้ Gemini API
ขั้นตอนที่ 1: กําหนดสคีมาการตอบกลับ
กําหนดสคีมาการตอบกลับเพื่อระบุโครงสร้างของเอาต์พุตของโมเดล ชื่อช่อง และประเภทข้อมูลที่คาดไว้สําหรับแต่ละช่อง
เมื่อสร้างคำตอบ โมเดลจะใช้ชื่อช่องและบริบทจากพรอมต์ เราขอแนะนำให้ใช้โครงสร้างที่ชัดเจน ชื่อช่องที่สื่อความหมาย และคำอธิบายตามความจำเป็นเพื่อให้เจตนาของคุณชัดเจน
ข้อควรพิจารณาสำหรับสคีมาคำตอบ
โปรดคำนึงถึงสิ่งต่อไปนี้เมื่อเขียนสคีมาคำตอบ
ขนาดของสคีมาการตอบกลับจะนับรวมในขีดจํากัดของโทเค็นอินพุต
ฟีเจอร์สคีมาคำตอบรองรับประเภท MIME ของคำตอบต่อไปนี้
application/json
: เอาต์พุต JSON ตามที่ระบุไว้ในสคีมาการตอบกลับ (มีประโยชน์สำหรับข้อกำหนดเอาต์พุตที่มีโครงสร้าง)text/x.enum
: แสดงผลค่า enum ตามที่ระบุไว้ในสคีมาการตอบกลับ (มีประโยชน์สําหรับงานการจัดประเภท)
ฟีเจอร์สคีมาคำตอบรองรับฟิลด์สคีมาต่อไปนี้
enum
items
maxItems
nullable
properties
required
หากคุณใช้ฟิลด์ที่ระบบไม่รองรับ โมเดลจะยังคงจัดการคําขอได้ แต่จะละเว้นฟิลด์นั้น โปรดทราบว่ารายการข้างต้นคือชุดย่อยของออบเจ็กต์สคีมา OpenAPI 3.0 (ดูข้อมูลอ้างอิงสคีมา Vertex AI)
โดยค่าเริ่มต้น ระบบจะถือว่าช่องทั้งหมดใน Vertex AI in Firebase SDK ต้องกรอก เว้นแต่คุณจะระบุว่าเป็นช่องที่ไม่บังคับในอาร์เรย์
optionalProperties
สําหรับช่องที่ไม่บังคับเหล่านี้ โมเดลจะป้อนข้อมูลในช่องหรือข้ามช่องก็ได้โปรดทราบว่าการดำเนินการนี้ตรงข้ามกับลักษณะการทำงานเริ่มต้นของ Vertex AI Gemini API
ขั้นตอนที่ 2: ส่งพรอมต์ที่มีสคีมาการตอบกลับเพื่อสร้าง JSON
ตัวอย่างต่อไปนี้แสดงวิธีสร้างเอาต์พุต JSON ที่มีโครงสร้าง
หากต้องการสร้างเอาต์พุตที่มีโครงสร้าง คุณต้องระบุresponseMimeType
ที่เหมาะสม (ในตัวอย่างนี้คือ application/json
) ในระหว่างการเริ่มต้นใช้งานโมเดล รวมถึงresponseSchema
ที่ต้องการให้โมเดลใช้
การใช้ responseSchema
ใช้ได้กับ Gemini ทุกรุ่น (ยกเว้นรุ่น Gemini 1.0)
import FirebaseVertexAI
// Provide a JSON schema object using a standard format.
// Later, pass this schema object into `responseSchema` in the generation config.
let jsonSchema = Schema.object(
properties: [
"characters": Schema.array(
items: .object(
properties: [
"name": .string(),
"age": .integer(),
"species": .string(),
"accessory": .enumeration(values: ["hat", "belt", "shoes"]),
],
optionalProperties: ["accessory"]
)
),
]
)
// Initialize the Vertex AI service and the generative model.
let model = VertexAI.vertexAI().generativeModel(
modelName: "gemini-2.0-flash",
// In the generation config, set the `responseMimeType` to `application/json`
// and pass the JSON schema object into `responseSchema`.
generationConfig: GenerationConfig(
responseMIMEType: "application/json",
responseSchema: jsonSchema
)
)
let prompt = "For use in a children's card game, generate 10 animal-based characters."
let response = try await model.generateContent(prompt)
print(response.text ?? "No text in response.")
ดูวิธีเลือกโมเดลและตำแหน่ง (ไม่บังคับ) ที่เหมาะสมกับกรณีการใช้งานและแอป
ตัวอย่างเพิ่มเติม
หากต้องการดูตัวอย่างเพิ่มเติมเกี่ยวกับวิธีใช้และสร้างเอาต์พุตที่มีโครงสร้าง ให้ดูรายการสคีมาตัวอย่างและคำตอบจำลองในเอกสารประกอบ Google Cloud
สร้างค่า enum เป็นเอาต์พุต
ตัวอย่างต่อไปนี้แสดงวิธีใช้สคีมาคำตอบสำหรับงานการจัดประเภท ระบบจะขอให้โมเดลระบุประเภทของภาพยนตร์ตามคำอธิบาย เอาต์พุตคือค่าแบบข้อความล้วนแบบ Enum รายการเดียวที่โมเดลเลือกจากรายการค่าที่กําหนดไว้ในสคีมาการตอบกลับที่ระบุ
หากต้องการทํางานการจัดประเภทที่มีโครงสร้างนี้ คุณต้องระบุ responseMimeType
ที่เหมาะสม (ในตัวอย่างนี้คือ text/x.enum
) และ responseSchema
ที่ต้องการให้โมเดลใช้ในระหว่างการเริ่มต้นใช้งานโมเดล
import FirebaseVertexAI
// Provide an enum schema object using a standard format.
// Later, pass this schema object into `responseSchema` in the generation config.
let enumSchema = Schema.enumeration(values: ["drama", "comedy", "documentary"])
// Initialize the Vertex AI service and the generative model.
let model = VertexAI.vertexAI().generativeModel(
modelName: "gemini-2.0-flash",
// In the generation config, set the `responseMimeType` to `text/x.enum`
// and pass the enum schema object into `responseSchema`.
generationConfig: GenerationConfig(
responseMIMEType: "text/x.enum",
responseSchema: enumSchema
)
)
let prompt = """
The film aims to educate and inform viewers about real-life subjects, events, or people.
It offers a factual record of a particular topic by combining interviews, historical footage,
and narration. The primary purpose of a film is to present information and provide insights
into various aspects of reality.
"""
let response = try await model.generateContent(prompt)
print(response.text ?? "No text in response.")
ดูวิธีเลือกโมเดลและตำแหน่ง (ไม่บังคับ) ที่เหมาะสมกับกรณีการใช้งานและแอป
ตัวเลือกอื่นๆ ในการควบคุมการสร้างเนื้อหา
- ดูข้อมูลเพิ่มเติมเกี่ยวกับการออกแบบพรอมต์เพื่อให้คุณควบคุมโมเดลให้สร้างเอาต์พุตที่ตรงกับความต้องการของคุณได้
- กำหนดค่าพารามิเตอร์โมเดลเพื่อควบคุมวิธีที่โมเดลสร้างคำตอบ สําหรับโมเดล Gemini พารามิเตอร์เหล่านี้ ได้แก่ โทเค็นเอาต์พุตสูงสุด, อุณหภูมิ, topK และ topP สำหรับโมเดล Imagen รายการเหล่านี้รวมถึงสัดส่วนการแสดงผล การสร้างบุคคล ลายน้ำ ฯลฯ
- ใช้การตั้งค่าความปลอดภัยเพื่อปรับความเป็นไปได้ที่จะได้รับคำตอบที่อาจถือว่ามีอันตราย ซึ่งรวมถึงวาจาสร้างความเกลียดชังและเนื้อหาเกี่ยวกับเรื่องเพศอย่างโจ่งแจ้ง
- ตั้งค่าคำสั่งของระบบเพื่อกำหนดลักษณะการทำงานของโมเดล ฟีเจอร์นี้เปรียบเสมือน "คํานํา" ที่คุณเพิ่มก่อนที่จะแสดงรูปแบบต่อผู้ใช้ปลายทาง
แสดงความคิดเห็นเกี่ยวกับประสบการณ์การใช้งาน Vertex AI in Firebase