สรุปสั้นๆ
Gemini 4 Hydrogen API สามารถใช้งานได้ผ่าน Gemini API ของ Google และเกตเวย์บุคคลที่สามที่รองรับอย่าง CometAPI เลือกเส้นทางก่อน: ใช้ Google เมื่อต้องการฟีเจอร์เฉพาะผู้ให้บริการและการควบคุมบัญชี หรือใช้ CometAPI เมื่อต้องการเกตเวย์โมเดลแบบรวมศูนย์หรือไคลเอนต์ที่เข้ากันได้กับ OpenAI เริ่มด้วยคำขอข้อความขนาดเล็ก จากนั้นค่อยเพิ่มการสตรีม ประวัติการสนทนา ไฟล์ และเครื่องมือ
คุณต้องมี Python 3.10 ขึ้นไป คีย์สำหรับเส้นทางที่เลือก และสิทธิ์เข้าถึง gemini-4-hydrogen ตัวอย่าง JavaScript (เลือกใช้) ต้องใช้ Node.js 22 ขึ้นไป เก็บข้อมูลระบุตัวตนไว้ในสภาพแวดล้อมฝั่งเซิร์ฟเวอร์ตลอดบทเรียนนี้
ประเด็นสำคัญ
- ใช้
gemini-4-hydrogenเป็นรหัสโมเดลสำหรับ Gemini 4 Hydrogen API - Google และ CometAPI มีข้อมูลระบุตัวตนและการเรียกเก็บเงินแยกกัน จับคู่คีย์กับเอ็นด์พอยต์ที่คุณเลือก
- เริ่มด้วย GenerateContent แบบเนทีฟ; ใช้อินเทอร์เฟซที่เข้ากันได้กับ OpenAI ของ CometAPI เมื่อเหมาะกับไคลเอนต์แชตที่มีอยู่
- เก็บรักษาคำตอบของโมเดลแบบครบถ้วนในประวัติหลายเทิร์น รวมถึงลายเซ็น ก่อนจะส่งคำตอบถัดไปหรือผลลัพธ์เครื่องมือ
- เปรียบเทียบการใช้โทเค็นจริงและงานที่เสร็จสิ้นเมื่อเลือกเส้นทาง; ตัวอย่างราคาตามโทเค็นมาตรฐานอยู่ในส่วนราคา
Gemini 4 Hydrogen API คืออะไร?
Google เปิดตัว Hydrogen เมื่อวันที่ 12 พฤศจิกายน 2026 API นี้รับพรอมป์ตและไฟล์ที่รองรับ จากนั้นส่งคืนข้อความที่สร้างขึ้นหรือการเรียกใช้ฟังก์ชันแบบมีโครงสร้างเพื่อให้แอปพลิเคชันของคุณจัดการ คุณไม่จำเป็นต้องโฮสต์โมเดลเอง
เริ่มจากคำขอแบบข้อความเท่านั้น และตรวจสอบข้อความที่ส่งกลับ เหตุผลที่สิ้นสุด และการใช้โทเค็นก่อนเพิ่มเครื่องมือหรือไฟล์ เมื่อทำงานได้แล้ว ค่อยเพิ่มสถานะการสนทนาหรือเครื่องมือธุรกิจแบบอ่านอย่างเดียว แทนที่จะสร้างเวิร์กโฟลว์ทั้งหมดในครั้งเดียว
ข้อกำหนดของ Gemini 4 Hydrogen API
| ข้อกำหนด | ความสามารถของโมเดลตามเอกสารของ Google |
|---|---|
| รหัสโมเดล | gemini-4-hydrogen |
| อินพุต | ข้อความ รูปภาพ เสียง วิดีโอ และเอกสารที่รองรับ |
| เอาต์พุต | ข้อความ พร้อมส่วนการเรียกใช้ฟังก์ชันแบบมีโครงสร้างเมื่อใช้เครื่องมือ |
| งบประมาณบริบทแบบรวม | 1,048,576 โทเค็นรวมอินพุตและเอาต์พุต |
| ส่วนผลลัพธ์ส่วนหน้าแบบเดี่ยว | สูงสุด 65,536 โทเค็น รวมเหตุผลและการเรียกใช้ฟังก์ชัน |
| ฟีเจอร์สำหรับแอปพลิเคชัน | การควบคุมระดับการคิด เอาต์พุตแบบมีโครงสร้าง และการเรียกใช้ฟังก์ชัน |
นี่คือความสามารถของโมเดล ไม่ได้เป็นการรับประกันว่าเกตเวย์ทุกแห่งจะเปิดฟีเจอร์ของผู้ให้บริการทุกราย ตัวอย่างด้านล่างใช้ฟิลด์คำขอมาตรฐานและการสร้างผลลัพธ์ส่วนหน้าที่สั้น
Google Official API เทียบกับ CometAPI
ทั้งสองเส้นทางรองรับคำขอ Gemini แต่ใช้เอ็นด์พอยต์ ข้อมูลระบุตัวตน และระบบการเรียกเก็บเงินที่แตกต่างกัน ใช้ Google เมื่อคุณต้องการฟีเจอร์เฉพาะผู้ให้บริการ ใช้ CometAPI เมื่อคุณต้องการเกตเวย์แบบรวมศูนย์หรือไคลเอนต์ที่เข้ากันได้กับ OpenAI
| การตัดสินใจ | Google Gemini Developer API | การผสานรวม Gemini ของ CometAPI |
|---|---|---|
| โฮสต์ API แบบเนทีฟ | generativelanguage.googleapis.com | api.cometapi.com |
| คีย์ API ในคู่มือนี้ | GEMINI_API_KEY | COMETAPI_KEY |
| บัญชีและการเรียกเก็บเงิน | จัดการผ่าน Google | จัดการผ่าน CometAPI |
| จุดเริ่มต้นที่เหมาะ | ฟีเจอร์เฉพาะ Google และการควบคุมบัญชี | การเข้าถึงโมเดลแบบรวม หรือไคลเอนต์ที่เข้ากันได้กับ OpenAI |
คงพรอมป์ตและงบประมาณเอาต์พุตให้เหมือนกันเมื่อทดสอบสองเส้นทางเพื่อให้ผลลัพธ์เปรียบเทียบกันได้ ตัวอย่าง JavaScript และตัวเลือกที่เข้ากันได้กับ OpenAI ถูกกำหนดค่าไว้ชัดเจนสำหรับ CometAPI
วิธีใช้ Gemini 4 Hydrogen API แบบทีละขั้นตอน
ขั้นตอนที่ 1: สร้างคีย์ API
สำหรับ CometAPI ให้สร้างบัญชีและสร้างคีย์ใน คอนโซลโทเค็น API สำหรับการเข้าถึงโดยตรงของ Google ให้สร้างคีย์ Gemini API ใน Google AI Studio ยืนยันสิทธิ์เข้าถึงโมเดลและการเรียกเก็บเงินหรือโควตาที่มีอยู่ของบัญชีที่เลือก
จัดเก็บคีย์อย่างปลอดภัย คีย์ของ CometAPI ไม่สามารถยืนยันตัวตนคำขอไปยังเอ็นด์พอยต์ของ Google และคีย์ของ Google ไม่สามารถยืนยันตัวตนคำขอไปยัง CometAPI
ตั้งค่าคีย์สำหรับเส้นทางที่คุณเลือกใน Bash; คุณต้องตั้งค่าเพียงหนึ่งรายการ
export COMETAPI_KEY="YOUR_COMETAPI_KEY"
# หรือ สำหรับการเข้าถึงโดยตรงผ่าน Google:
export GEMINI_API_KEY="YOUR_GEMINI_API_KEY"
ตั้งค่าคีย์ที่สอดคล้องกันใน PowerShell บน Windows
$env:COMETAPI_KEY = "YOUR_COMETAPI_KEY"
# หรือ สำหรับการเข้าถึงโดยตรงผ่าน Google:
$env:GEMINI_API_KEY = "YOUR_GEMINI_API_KEY"
ขั้นตอนที่ 2: ส่งคำขอแรกด้วย cURL
ส่งคำขอข้อความแบบเนทีฟผ่าน CometAPI จากเทอร์มินัล Bash
curl "https://api.cometapi.com/v1beta/models/gemini-4-hydrogen:generateContent" \
-H "x-goog-api-key: $COMETAPI_KEY" \
-H "Content-Type: application/json" \
-X POST \
-d '{
"contents": [
{
"role": "user",
"parts": [
{
"text": "อธิบายการทำงานของตัวแทนเขียนโค้ด AI เป็น 5 ขั้นตอน"
}
]
}
],
"generationConfig": {
"maxOutputTokens": 4096,
"thinkingConfig": {
"thinkingLevel": "MEDIUM"
}
}
}'
หรือส่งคำขอแบบเนทีฟเดียวกันโดยตรงไปยัง Google ด้วยคีย์ API ของ Google
curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-4-hydrogen:generateContent" \
-H "x-goog-api-key: $GEMINI_API_KEY" \
-H "Content-Type: application/json" \
-X POST \
-d '{
"contents": [
{
"role": "user",
"parts": [
{
"text": "อธิบายการทำงานของตัวแทนเขียนโค้ด AI เป็น 5 ขั้นตอน"
}
]
}
],
"generationConfig": {
"maxOutputTokens": 4096,
"thinkingConfig": {
"thinkingLevel": "MEDIUM"
}
}
}'
หลังคำขอสําเร็จ ให้ตรวจสอบสามฟิลด์: candidates[0].content.parts สำหรับข้อความที่มองเห็นได้, finishReason สำหรับสถานะการสิ้นสุด และ usageMetadata สำหรับการใช้โทเค็น แก้ไขปัญหาการยืนยันตัวตนหรือข้อผิดพลาดของคำขอก่อนที่จะเพิ่มโค้ดแอปพลิเคชันเพิ่มเติม
ขั้นตอนที่ 3: ตั้งค่าไคลเอนต์ Python และส่งคำขอ
ติดตั้งแพ็กเกจที่ใช้ในตัวอย่าง Python
python -m pip install requests openai
บันทึกผู้ช่วยนี้เป็น hydrogen_client.py คงค่าของ PROVIDER เป็น cometapi สำหรับ CometAPI หรือเปลี่ยนเป็น google เพื่อเข้าถึง Gemini Developer API โดยตรง ต่อไปตัวอย่างแบบเนทีฟจะ import ไฟล์นี้ ดังนั้นจะคงเส้นทางที่เลือกไว้
กำหนดค่าเอ็นด์พอยต์ที่เลือกและประกาศผู้ช่วยสำหรับคำขอและข้อความที่นำกลับมาใช้ซ้ำได้
import os
import requests
MODEL = "gemini-4-hydrogen"
PROVIDER = "cometapi" # เปลี่ยนเป็น "google" สำหรับการเข้าถึงโดยตรง
ROUTES = {
"cometapi": ("https://api.cometapi.com", "COMETAPI_KEY"),
"google": ("https://generativelanguage.googleapis.com", "GEMINI_API_KEY"),
}
BASE_URL, KEY_NAME = ROUTES[PROVIDER]
API_KEY = os.environ[KEY_NAME]
URL = f"{BASE_URL}/v1beta/models/{MODEL}:generateContent"
def generate(payload):
response = requests.post(
URL,
headers={"x-goog-api-key": API_KEY},
json=payload,
timeout=120,
)
response.raise_for_status()
return response.json()
def visible_text(data):
candidates = data.get("candidates") or []
if not candidates:
raise ValueError("ไม่มี candidate ถูกส่งกลับ; ตรวจสอบ promptFeedback.")
candidate = candidates[0]
parts = candidate.get("content", {}).get("parts", [])
text = "".join(
part.get("text", "") for part in parts
if not part.get("thought", False)
)
if not text:
raise ValueError(
f"ไม่มีข้อความที่มองเห็นได้; ตรวจสอบ parts และ finishReason: "
f"{candidate.get('finishReason')}"
)
return text
บันทึกสิ่งต่อไปนี้เป็น hydrogen.py ไว้ข้างไฟล์ผู้ช่วย มันจะพิมพ์คำตอบ เหตุผลที่สิ้นสุด และสถิติการใช้งาน เพื่อให้คุณแยกแยะคำตอบที่สมบูรณ์ออกจากเอาต์พุตที่หยุดเพราะถึงขีดจำกัดโทเค็น
ส่งคำขอข้อความโดยใช้ผู้ให้บริการที่กำหนดค่าไว้
from hydrogen_client import generate, visible_text
data = generate({
"contents": [{"role": "user", "parts": [{
"text": "อธิบายการจำกัดอัตราการเรียกใช้ API (rate limiting) เป็น 3 ประโยค"
}]}],
"generationConfig": {
"maxOutputTokens": 4096,
"thinkingConfig": {"thinkingLevel": "MEDIUM"},
},
})
print(visible_text(data))
candidate = data["candidates"][0]
print("เหตุผลที่สิ้นสุด:", candidate.get("finishReason"))
print("การใช้งาน:", data.get("usageMetadata", {}))
รันสคริปต์ในเทอร์มินัลที่คุณได้ตั้งค่าคีย์ API ที่เลือกไว้
python hydrogen.py
อ่านคำตอบ จากนั้นตรวจสอบ finishReason เพื่อดูเหตุผลที่การสร้างผลลัพธ์หยุดลง ใน usageMetadata ให้ตรวจสอบจำนวนโทเค็นที่คำขอใช้ MAX_TOKENS หมายถึงคำตอบอาจไม่สมบูรณ์ แม้ว่าคำขอ HTTP จะสำเร็จก็ตาม
ใช้ JavaScript หรือไคลเอนต์ที่เข้ากันได้กับ OpenAI
เลือกตัวอย่างที่เหมาะกับแอปพลิเคชันของคุณ ตัวอย่าง Node.js ส่งคำขอ Gemini แบบเนทีฟ หากคุณใช้งาน OpenAI SDK อยู่แล้ว ให้ข้ามไปยังตัวอย่าง Python ด้านล่าง
JavaScript กับ Node.js
บันทึกสิ่งต่อไปนี้เป็น hydrogen.js และรัน node hydrogen.js มันจะส่งคำขอแบบเนทีฟในรูปแบบเดียวกันและดึงข้อความที่มองเห็นได้ทั้งหมด
ส่งคำขอ GenerateContent แบบเนทีฟจาก Node.js
const apiKey = process.env.COMETAPI_KEY;
if (!apiKey) throw new Error("ตั้งค่า COMETAPI_KEY ก่อนรันสคริปต์นี้.");
const baseUrl = "https://api.cometapi.com";
const model = "gemini-4-hydrogen";
async function main() {
const response = await fetch(
`${baseUrl}/v1beta/models/${model}:generateContent`,
{
method: "POST",
headers: {
"Content-Type": "application/json",
"x-goog-api-key": apiKey
},
body: JSON.stringify({
contents: [
{
role: "user",
parts: [
{
text: "อธิบายการทำงานของตัวแทนเขียนโค้ด AI"
}
]
}
],
generationConfig: {
maxOutputTokens: 4096,
thinkingConfig: {
thinkingLevel: "MEDIUM"
}
}
})
}
);
if (!response.ok) {
throw new Error(
`ข้อผิดพลาด API: ${response.status} ${await response.text()}`
);
}
const data = await response.json();
const candidate = data.candidates?.[0];
const text = (candidate?.content?.parts || [])
.filter(part => !part.thought)
.map(part => part.text || "")
.join("");
if (!text) {
throw new Error(`ไม่มีข้อความที่มองเห็นได้; finishReason=${candidate?.finishReason}`);
}
console.log(text);
}
main().catch(console.error);
Python กับ OpenAI SDK
หากแอปพลิเคชันของคุณใช้งาน OpenAI SDK อยู่แล้ว CometAPI ก็เปิดให้ใช้ POST /v1/chat/completions เช่นกัน วิธีโยกย้ายที่ง่ายที่สุดคือเปลี่ยนคีย์ API, base URL และรหัสโมเดล ใช้เส้นทางนี้สำหรับเวิร์กโฟลว์แชตทั่วไป; ใช้เอ็นด์พอยต์ Gemini แบบเนทีฟเมื่อคุณต้องการฟิลด์เฉพาะของ Gemini
สร้างคำขอ Chat Completions ผ่าน CometAPI
import os
from openai import OpenAI
client = OpenAI(
api_key=os.environ["COMETAPI_KEY"],
base_url="https://api.cometapi.com/v1"
)
response = client.chat.completions.create(
model="gemini-4-hydrogen",
messages=[
{
"role": "user",
"content": "อธิบายการทำงานของตัวแทนเขียนโค้ด AI"
}
]
)
print(response.choices[0].message.content)
ตัวอย่างแบบเนทีฟใช้ contents และ generationConfig; ส่วน Chat Completions ใช้ messages และฟิลด์คำขอของตนเอง เก็บคำขอแต่ละแบบให้อยู่ในฟอร์แมตเดียว อย่าคัดลอกฟิลด์แบบเนทีฟไปยังการเรียก SDK ที่ไม่รองรับฟิลด์นั้น
ฟีเจอร์ขั้นสูงของ Gemini 4 Hydrogen API
ตัวอย่างต่อไปนี้ใช้ซ้ำ hydrogen_client.py จากส่วนการตั้งค่า จึงทำงานกับผู้ให้บริการที่เลือกไว้ใน PROVIDER ตัวอย่างการสตรีมด้านล่างใช้ไคลเอนต์ CometAPI Chat Completions แยกต่างหาก ซึ่งเหมาะกับแอปพลิเคชันที่เข้ากันได้กับ OpenAI ที่มีอยู่
กำหนดเหตุผลและเอาต์พุตแบบมีโครงสร้าง
ใช้ generationConfig เพื่อกำหนด thinkingConfig.thinkingLevel เป็น LOW, MEDIUM, HIGH หรือ XHIGH เลือกงบประมาณเอาต์พุตที่เผื่อพื้นที่ทั้งสำหรับเหตุผลและคำตอบที่มองเห็นได้ เมื่อแอปพลิเคชันคาดหวัง JSON ให้ใช้ responseMimeType และ responseSchema แทนการพึ่งพาคำสั่งจัดรูปแบบด้วยภาษาธรรมชาติ
กำหนดงบประมาณเอาต์พุตและระดับเหตุผลสำหรับคำขอแบบเนทีฟ
{
"generationConfig": {
"maxOutputTokens": 4096,
"thinkingConfig": {"thinkingLevel": "MEDIUM"}
}
}
สตรีมคำตอบผ่าน CometAPI
การสตรีมจะส่งคืนเนื้อหาที่สร้างขึ้นแบบทยอย แทนการรอคำตอบที่สมบูรณ์ เหมาะสำหรับอินเทอร์เฟซแชต ผู้ช่วยเขียนโค้ด และแอปพลิเคชันที่ให้ความสำคัญกับความหน่วงที่รับรู้
CometAPI มีเอกสารเกี่ยวกับ การสตรีม Chat Completions ด้วย stream=true ตัวอย่าง Python จัดการชังก์ที่ไม่มี choices ซึ่งอาจเกิดขึ้นในการสตรีม
พิมพ์ข้อความตามที่เข้ามาผ่านเอ็นด์พอยต์ที่เข้ากันได้กับ OpenAI
import os
from openai import OpenAI
client = OpenAI(
api_key=os.environ["COMETAPI_KEY"],
base_url="https://api.cometapi.com/v1"
)
stream = client.chat.completions.create(
model="gemini-4-hydrogen",
messages=[
{
"role": "user",
"content": (
"เขียนฟังก์ชัน Python สำหรับตรวจสอบความถูกต้องของอีเมล "
"และอธิบายการตรวจหลักๆ"
)
}
],
stream=True
)
for chunk in stream:
if not chunk.choices:
continue
delta = chunk.choices[0].delta
if delta and delta.content:
print(delta.content, end="", flush=True)
print()
สำหรับไคลเอนต์แบบเนทีฟ CometAPI มีเอกสารเกี่ยวกับ streamGenerateContent ด้วย Server-Sent Events เส้นทางนั้นจะส่งคืนออบเจ็กต์คำตอบ GenerateContent แทนเดลตาของ Chat Completions รักษาตัวแยกวิเคราะห์ให้ตรงกับเส้นทาง; พฤติกรรมการสตรีมอาจแตกต่างกันระหว่างเอ็นด์พอยต์ Gemini แบบเนทีฟและเกตเวย์ที่เข้ากันได้กับ OpenAI ทดสอบเส้นทาง Hydrogen ที่แอปพลิเคชันของคุณใช้จริงก่อนย้ายไคลเอนต์สตรีมที่มีอยู่
รักษาประวัติการสนทนาแบบหลายเทิร์น
ส่งเทิร์นของผู้ใช้และโมเดลก่อนหน้าไปกับคำขอถัดไป เก็บออบเจ็กต์เนื้อหาของโมเดลแบบครบถ้วนแทนการสร้างใหม่จากข้อความที่มองเห็นได้; วิธีนี้จะคงเมตาดาต้าที่ส่งกลับไว้สำหรับเทิร์นถัดไป บันทึกตัวอย่างนี้เป็น hydrogen_history.py ไว้ข้างไฟล์ผู้ช่วยที่ใช้ร่วมกัน
ทำคำขอสองรายการที่เกี่ยวข้องกัน พร้อมรักษาคำตอบโมเดลครั้งแรกแบบเต็มไว้
from hydrogen_client import generate, visible_text
history = [{"role": "user", "parts": [{
"text": "แนะนำสถาปัตยกรรมงานเบื้องหลังแบบคิวอย่างง่าย"
}]}]
config = {
"maxOutputTokens": 4096,
"thinkingConfig": {"thinkingLevel": "MEDIUM"},
}
first = generate({"contents": history, "generationConfig": config})
print(visible_text(first))
candidate = first["candidates"][0]
if candidate.get("finishReason") != "STOP":
raise RuntimeError("เทิร์นแรกไม่ได้สิ้นสุดตามปกติ.")
history.append(candidate["content"])
history.append({"role": "user", "parts": [{
"text": "จากนั้นระบุ 3 สถานการณ์ความล้มเหลวในแบบออกแบบนั้น"
}]})
second = generate({"contents": history, "generationConfig": config})
print(visible_text(second))
print("เหตุผลที่สิ้นสุด:", second["candidates"][0].get("finishReason"))
รัน python hydrogen_history.py คำตอบที่สองควรอ้างอิงการออกแบบจากเทิร์นแรก เก็บพรีฟิกซ์ของการสนทนาก่อนหน้าให้ไม่เปลี่ยนแปลงในตัวอย่างนี้; แอปที่รันยาวต้องมีกลยุทธ์แยกต่างหากสำหรับการย่อและขีดจำกัดบริบท
ส่งรูปภาพและ PDF
Hydrogen รองรับความเข้าใจรูปภาพและเอกสาร ในรูปแบบคำขอ Gemini แบบเนทีฟ ให้เพิ่มส่วน inlineData ควบคู่กับคำสั่งข้อความ สิ่งนี้มีประโยชน์สำหรับการวิเคราะห์ภาพหน้าจอ ไดอะแกรมสถาปัตยกรรม ฟอร์มสแกน และการสกัดรายงาน
บันทึกตัวอย่างนี้เป็น analyze_file.py ไว้ข้าง hydrogen_client.py มันจะส่งรูปภาพหรือ PDF ภายในเครื่องหนึ่งไฟล์ จึงสามารถใช้โค้ดเดียวกันกับอินพุตทั้งสองแบบ เริ่มจากไฟล์ขนาดเล็กสำหรับคำขอแรก; Base64 จะเพิ่มขนาดคำขอ
วิเคราะห์ PNG, JPEG หรือ PDF ในเครื่อง โดยใช้ไคลเอนต์แบบเนทีฟที่ใช้ร่วมกัน
import base64
import sys
from pathlib import Path
from hydrogen_client import generate, visible_text
path = Path(sys.argv[1])
mime_types = {
".png": "image/png", ".jpg": "image/jpeg",
".jpeg": "image/jpeg", ".pdf": "application/pdf",
}
mime_type = mime_types.get(path.suffix.lower())
if mime_type is None:
raise ValueError("เลือกไฟล์ PNG, JPEG หรือ PDF.")
data = generate({
"contents": [{"role": "user", "parts": [
{"text": "สรุปไฟล์นี้และระบุประเด็นค้นพบสำคัญ"},
{"inlineData": {
"mimeType": mime_type,
"data": base64.b64encode(path.read_bytes()).decode("ascii"),
}},
]}],
"generationConfig": {"maxOutputTokens": 4096},
})
print(visible_text(data))
รันตัวอย่างไฟล์ด้วยเอกสารหรือรูปภาพของคุณเอง
python analyze_file.py report.pdf
python analyze_file.py diagram.png
ไบต์ของไฟล์ต้องตรงกับ MIME type ที่ประกาศไว้ การเปลี่ยนนามสกุลไฟล์ไม่ใช่การแปลงไฟล์ หากการอัปโหลดถูกปฏิเสธ ให้ตรวจสอบข้อผิดพลาดเรื่องขนาดหรือขีดจำกัดรูปแบบก่อนลองใหม่; อย่าคิดว่า URI ของไฟล์ที่โฮสต์โดย Google จะเข้าถึงได้ผ่านเกตเวย์ของบุคคลที่สาม
เชื่อมต่อเครื่องมือที่ควบคุมโดยแอปพลิเคชัน
Function calling ช่วยให้โมเดลร้องขอการทำงานที่แอปพลิเคชันของคุณเป็นผู้ดำเนินการ โมเดลจะส่งคืนการเรียกใช้ฟังก์ชันแบบมีโครงสร้าง; แอปพลิเคชันของคุณตรวจสอบอาร์กิวเมนต์ ดำเนินการฟังก์ชัน และส่งผลลัพธ์กลับไป
ตัวอย่างนี้ใช้ฐานข้อมูลคำสั่งซื้อตัวอย่างขนาดเล็ก บันทึกเป็น order_agent.py ไว้ข้างไคลเอนต์ที่ใช้ร่วมกัน มันทำงานแบบรอบไป-กลับ จำกัดลูปที่สี่คำขอ และเก็บรักษาเนื้อหาโมเดลแบบเต็ม—รวมทั้งลายเซ็น—ระหว่างเทิร์น
รันลูปเรียกใช้ฟังก์ชันแบบมีขีดจำกัดกับฐานข้อมูลสาธิตในเครื่อง
from hydrogen_client import generate, visible_text
orders = {"DEMO-1001": {"status": "จัดส่งแล้ว", "carrier": "ผู้ให้บริการตัวอย่าง"}}
tools = [{"functionDeclarations": [{
"name": "lookup_order",
"description": "ดึงข้อมูลคำสั่งซื้อตัวอย่างตามรหัสคำสั่งซื้อ",
"parameters": {
"type": "OBJECT",
"properties": {"order_id": {"type": "STRING"}},
"required": ["order_id"],
},
}]}]
history = [{"role": "user", "parts": [{
"text": "ใช้ lookup_order เพื่อตรวจสอบสถานะของ DEMO-1001."
}]}]
for _ in range(4):
data = generate({
"contents": history,
"tools": tools,
"generationConfig": {"maxOutputTokens": 4096},
})
candidates = data.get("candidates") or []
if not candidates or not candidates[0].get("content"):
raise RuntimeError("ไม่มีเนื้อหาของโมเดลถูกส่งกลับ.")
model_content = candidates[0]["content"]
calls = [
part["functionCall"] for part in model_content.get("parts", [])
if "functionCall" in part
]
if not calls:
print(visible_text(data))
break
history.append(model_content) # เก็บรักษาทุกส่วนและลายเซ็น
results = []
for call in calls:
args = call.get("args", {})
order_id = args.get("order_id") if isinstance(args, dict) else None
if call.get("name") != "lookup_order":
raise ValueError("พบชื่อฟังก์ชันที่ไม่คาดคิด.")
if not isinstance(order_id, str) or not order_id:
raise ValueError("order_id ต้องเป็นสตริงที่ไม่ว่างเปล่า.")
result = orders.get(order_id, {"error": "ไม่พบคำสั่งซื้อ"})
reply = {"name": call["name"], "response": result}
if "id" in call:
reply["id"] = call["id"]
results.append({"functionResponse": reply})
history.append({"role": "user", "parts": results})
else:
raise RuntimeError("ถึงขีดจำกัดการเรียกใช้เครื่องมือก่อนที่จะได้คำตอบสุดท้าย.")
รัน python order_agent.py คำตอบสุดท้ายควรสะท้อนข้อมูลในเครื่องสำหรับ DEMO-1001 ในบริการจริง ควรตรวจสอบสิทธิ์ผู้ใช้ก่อนเข้าถึงคำสั่งซื้อ; การที่โมเดลเลือกใช้รหัสคำสั่งซื้อไม่ได้เป็นหลักฐานยืนยันสิทธิ์
Gemini 4 Hydrogen API มีค่าใช้จ่ายเท่าไร?
อัตราด้านล่างเป็นดอลลาร์สหรัฐต่อหนึ่งล้านโทเค็น ตรวจสอบเมื่อวันที่ 17 พฤศจิกายน 2026 เปรียบเทียบการอินพุตและเอาต์พุตมาตรฐานที่ไม่แคช ไม่รวมแบบแบตช์ ความสำคัญ คอนเทนต์แคชอินพุต หรือการใช้งานเครื่องมือที่คิดเงินแยกต่างหาก
| ประเภทโทเค็น | มาตรฐานทั่วโลกของ Google | Gemini 4 Hydrogen API ใน CometAPI |
|---|---|---|
| โทเค็นขาเข้า / 1M | $1.50 | $1.20 |
| โทเค็นขาออก / 1M | $7.50 | $6.00 |
สำหรับโทเค็นขาเข้า 100,000 และโทเค็นขาออกที่คิดเงิน 10,000 การประมาณของ CometAPI คือ 0.1 × $1.20 + 0.01 × $6.00 = $0.18 ปริมาณเดียวกันที่อัตรามาตรฐานที่ระบุของ Google มีค่าใช้จ่าย $0.225 ซึ่งต่างกัน 20% รวมโทเค็นเหตุผลไว้ในการใช้งานเอาต์พุตและตรวจสอบการใช้งานที่เรียกเก็บเงินจริงของบัญชีเมื่อประเมินเวิร์กโฟลว์จริง
จะย้ายการใช้งานไปยัง Gemini 4 Hydrogen API ได้อย่างไร?
อะไรเปลี่ยนไปเมื่อย้ายจาก Gemini 3.8 Flash?
ก่อนเปลี่ยนรหัสโมเดล ให้ตรวจสอบการตั้งค่าการให้เหตุผล งบประมาณบริบท และประวัติการสนทนาที่ไคลเอนต์ของคุณส่งกับแต่ละคำขอ
| รายละเอียดการผสานรวม | Gemini 3.8 Flash | Gemini 4 Hydrogen |
|---|---|---|
| ระดับการคิดเริ่มต้น | MEDIUM | HIGH |
| การคิดบัญชีบริบท | ขีดจำกัดอินพุตและเอาต์พุตแยกกัน | งบประมาณอินพุต/เอาต์พุตแบบรวมเดียว |
| สถานะแบบหลายเทิร์น | ทบทวนการจัดการประวัติของไคลเอนต์ที่มีอยู่ | เก็บรักษาส่วนเนื้อหาและลายเซ็นของโมเดลแบบครบถ้วน; การแก้พรีฟิกซ์ต้องการการจัดการพิเศษ |
การเปลี่ยนแปลงสำหรับการย้ายที่มีเอกสารไว้ สำคัญที่สุดเมื่อแอปของคุณพึ่งพาค่าเริ่มต้น ย่อประวัติ หรือรันหลายรอบเครื่องมือ กำหนดระดับเหตุผลอย่างชัดเจนและทดสอบเวิร์กโฟลว์สั้นๆ ที่มีอยู่ก่อนเปลี่ยนโมเดลในโปรดักชัน
อัปเดตการผสานรวมที่มีอยู่
สร้างการกำหนดค่าทดสอบด้วยรหัสโมเดลใหม่ ในขณะที่คงคีย์และเอ็นด์พอยต์ให้เข้าคู่กัน รันเวิร์กโฟลว์ตัวแทนเดียวกันกับทั้งสองการกำหนดค่าเพื่อเปรียบเทียบพฤติกรรม
- ส่งคำขอข้อความใหม่และยืนยันเหตุผลที่สิ้นสุดและการใช้โทเค็น
- เล่นซ้ำงานหลายเทิร์นและรอบการเรียกเครื่องมือ โดยใช้ออบเจ็กต์คำตอบของโมเดลแบบครบถ้วน
- ลบการควบคุมที่ไม่เข้ากันตามที่ระบุไว้ในส่วนข้อจำกัดก่อนเปรียบเทียบผลลัพธ์คำขอ
- ทดลองเส้นทางย้อนกลับของคุณในบทสนทนาใหม่; อย่าคิดว่าโมเดลอื่นจะยอมรับเมตาดาตาเหตุผลที่บันทึกของ Hydrogen
ตัดสินใจว่าการย้ายมีประโยชน์กับงานของคุณหรือไม่
ใช้การกำหนดค่าใหม่เมื่อมันตอบโจทย์คุณภาพและความหน่วงของงานที่ยอมรับได้ที่ต้นทุนต่อภารกิจที่เสร็จสิ้นที่เหมาะสม หากไคลเอนต์ปัจจุบันตอบโจทย์อยู่แล้ว ให้ใช้การทดสอบนำร่องแบบจำกัดเพื่อยืนยันประโยชน์ก่อนย้ายคำขอทั้งหมด คงพรอมป์ต อินพุต และเกณฑ์การให้คะแนนให้สอดคล้องกันระหว่างการประเมิน
ข้อจำกัดของ Gemini 4 Hydrogen API
คู่มือสำหรับนักพัฒนา Hydrogen อธิบายข้อจำกัดที่ส่งผลต่อไคลเอนต์ที่มีอยู่ แก้ไขที่การสร้างคำขอแทนการลองส่ง payload เดิมซ้ำ
- ฟิลด์ที่ไม่รองรับ: ลบ thinkingBudget, thinkingLevel ที่ตั้งเป็น MINIMAL, frequencyPenalty, presencePenalty และ candidateCount ที่มากกว่าหนึ่ง
- การตั้งค่าการสุ่มที่ถูกเพิกเฉย: temperature, topP และ topK แบบกำหนดเองจะไม่ควบคุมเอาต์พุตของ Hydrogen
- การแคช: ไม่รองรับ cachedContent แบบชัดเจน พรีฟิกซ์พรอมป์ตที่คงที่อาจใช้การแคชโดยนัยได้ แต่ไม่ได้ทำให้เกิดส่วนลดแคชเฉพาะเกตเวย์
- เอาต์พุตยาว: ไคลเอนต์ตัวอย่างในคู่มือนี้รองรับเฉพาะคำขอแบบซิงโครนัส ยังไม่ครอบคลุมการถอดรหัสยาวเบื้องหลังหรือเวิร์กโฟลว์การทำต่อเนื่องเฉพาะผู้ให้บริการ
- การเปลี่ยนการสนทนา: การแก้ไขพรอมป์ตหรือคำจำกัดความเครื่องมือก่อนหน้าอาจทำให้สถานะเหตุผลใช้ไม่ได้อีก เก็บรักษาพรีฟิกซ์ไว้ หรือใช้งานพฤติกรรมที่จัดทำเอกสารไว้สำหรับกรณี prefix-mismatch ของเส้นทางที่เลือก
การตรวจสอบการตั้งค่าทั่วไป
| อาการ | ตรวจสอบอย่างแรก |
|---|---|
| 401 หรือ 403 | ยืนยันว่าข้อมูลระบุตัวตนเป็นของเอ็นด์พอยต์นั้น และมีสิทธิ์เข้าถึงโมเดลที่เลือก |
| 400 | อ่านเนื้อหาข้อผิดพลาด; ตรวจสอบฟิลด์ที่ไม่รองรับ JSON ที่ผิดรูป และเมตาดาตาการสนทนา |
| ไม่มีข้อความที่มองเห็นได้ | ตรวจสอบ promptFeedback, ส่วน candidate, และ finishReason; คำตอบอาจถูกบล็อก ไม่สมบูรณ์ หรือร้องขอเครื่องมือ |
| MAX_TOKENS | ปฏิบัติต่อข้อความว่าอาจไม่สมบูรณ์ และทบทวนงบประมาณเอาต์พุตก่อนยอมรับ |
| คำขอไฟล์ถูกปฏิเสธ | ตรวจสอบ MIME type จริงและขีดจำกัด payload ของเส้นทางที่เลือก |
สำหรับความล้มเหลวที่ไม่คาดคิด ให้บันทึกโมเดล เส้นทาง สถานะ เวลา และรหัสคำขอเมื่อมี อย่าใส่คีย์ API และเนื้อหาไฟล์ที่อ่อนไหวลงในล็อกทั่วไป
คำถามที่พบบ่อย
ควรลองใหม่ (retry) เมื่อเจอข้อผิดพลาดการจำกัดอัตราของ Gemini 4 Hydrogen API อย่างไร?
สำหรับ HTTP 429 ให้ลดความขนานและลองใหม่ด้วย exponential backoff และ jitter พร้อมจำนวนครั้งสูงสุดที่ตายตัว เก็บรหัสคำขอไว้เมื่อเกตเวย์ให้มา อย่าลองใหม่คำขอที่ไม่ถูกต้องหรือการยืนยันตัวตนที่ล้มเหลวโดยไม่แก้ไข; คู่มือของ CometAPI เกี่ยวกับ ข้อผิดพลาดและกลยุทธ์การลองใหม่ แยกแยะสิ่งเหล่านั้นออกจากความล้มเหลวชั่วคราวได้ การหมดเวลา (timeout) อาจเกิดขึ้นหลังเริ่มประมวลผลแล้ว ดังนั้นให้ป้องกันการดำเนินการฝั่งแอปพลิเคชันซ้ำซ้อน
สามารถเรียก Gemini 4 Hydrogen API โดยตรงจากเว็บแอปได้ไหม?
ส่งคำขอผ่านแบ็กเอนด์ของคุณเอง คีย์ที่ฝังใน JavaScript ฝั่งหน้าเว็บสามารถถูกดึงได้โดยผู้เข้าชม แม้โค้ดจะถูกรวม (bundle) หรือทำให้ย่อ (minify) ให้แบ็กเอนด์ยืนยันตัวตนผู้ใช้ กำหนดขีดจำกัดการใช้งาน และส่งคำขอไปยังโมเดล สำหรับการสตรีม ให้ส่งต่อคำตอบแบบทยอยไปยังเบราว์เซอร์โดยไม่เปิดเผยคีย์ API ต้นทาง
ควรจัดการสตรีมของ Gemini 4 Hydrogen ที่ถูกขัดจังหวะอย่างไร?
ถือว่าข้อความที่ได้รับเป็นผลลัพธ์บางส่วนจนกว่าคำตอบจะสมบูรณ์ คำขอใหม่คือการเริ่มการสร้างใหม่; จะไม่กู้คืนสตรีมที่ขาดตอนให้ต่อที่โทเค็นเดิมโดยอัตโนมัติ แยกผลลัพธ์บางส่วนออกจากคำตอบที่ลองใหม่ และอย่าดำเนินการจาก JSON ที่ไม่สมบูรณ์หรืออาร์กิวเมนต์เครื่องมือที่ยังไม่จบ แสดงการกระทำให้ลองใหม่อย่างชัดเจนแทนการเชื่อมสองการสร้างเข้าด้วยกันแบบเงียบๆ
บทสรุป
ใช้ภารกิจตัวแทนเป็นการตรวจรับครั้งแรก: คำขอควรสำเร็จ แอปควรดึงผลลัพธ์ตามที่ตั้งใจไว้ และการใช้โทเค็นที่บันทึกควรอยู่ในงบประมาณ เพิ่มฟีเจอร์ทีละอย่างและเก็บการตรวจรับนั้นไว้ในชุดการทดสอบการผสานรวม ไคลเอนต์ขนาดเล็กที่สังเกตได้ง่ายจะต่อยอดได้ง่ายกว่เวิร์กโฟลว์ขนาดใหญ่ที่แกะรอยความล้มเหลวยากกว่า

