ถอดรหัสแบบยาว

การถอดรหัสแบบยาวช่วยให้ Gemini 4 Argon สร้างโทเค็นได้มากกว่า 64,000 รายการสำหรับงานการให้เหตุผลเชิงลึก โดยมีหน้าต่างบริบทขนาด 1 ล้านโทเค็นแบบรวม (โทเค็น 1,048,576 รายการที่ใช้ร่วมกันระหว่างอินพุต การคิด และเอาต์พุต) ใน Interactions API คุณสามารถเปิดใช้การถอดรหัสแบบยาวด้วยการดำเนินการเมื่ออยู่เบื้องหลังเพื่อให้เซิร์ฟเวอร์ของเราสร้างและรวมการข้ามแต่ละครั้ง 64, 000 รายการเป็นการโต้ตอบเดียวโดยอัตโนมัติ

วิธีการทำงานของการถอดรหัสแบบยาว

การเรียกโมเดลครั้งเดียวจะสร้างโทเค็นได้สูงสุด 64,000 รายการ เมื่อคำตอบต้องใช้โทเค็นมากกว่า 64,000 รายการ เซิร์ฟเวอร์จะสร้างคำตอบในรูปแบบการข้าม 64,000 รายการที่ดำเนินการต่อจากจุดที่การข้ามครั้งก่อนหยุด การข้ามแต่ละครั้งจะเพิ่มขั้นตอน model_output ลงใน interaction.steps ภายใต้รหัสการโต้ตอบเดียวกัน คุณจึงรวมขั้นตอนเหล่านั้นเพื่ออ่านคำตอบทั้งหมดได้โดยทำดังนี้

1. สร้างการโต้ตอบด้วย background: true และ max_output_tokens ที่มากกว่า 65,536 รายการ แต่ไม่เกิน 1 ล้านรายการ
2. เซิร์ฟเวอร์จะสร้างการข้ามครั้งแรกได้สูงสุด 64, 000 รายการ
3. เซิร์ฟเวอร์จะเริ่มการ Hop ถัดไปจากจุดที่การข้ามครั้งสุดท้ายหยุด และทำซ้ำจนกว่าโมเดลจะเสร็จสิ้นหรือใช้ max_output_tokens ทั้งหมด
4. คุณจะโพลการโต้ตอบหรือสตรีมการโต้ตอบเพื่อดูผลลัพธ์

import time
from google import genai

client = genai.Client()

interaction = client.interactions.create(
    model="gemini-4-argon",
    input="Write a complete, rigorous proof of the prime number theorem.",
    background=True,
    generation_config={
        "max_output_tokens": 262144,
        "thinking_level": "high",
    },
)

while interaction.status in ("in_progress", "queued"):
    time.sleep(5)
    interaction = client.interactions.get(id=interaction.id)

# Each hop adds a model_output step, so join the text of all of them.
text = "".join(
    content.text
    for step in interaction.steps
    if step.type == "model_output"
    for content in step.content
    if content.type == "text"
)
print(text)
print("Status:", interaction.status)
print("Usage:", interaction.usage)

import { GoogleGenAI } from "@google/genai";

const client = new GoogleGenAI({});

let interaction = await client.interactions.create({
  model: "gemini-4-argon",
  input: "Write a complete, rigorous proof of the prime number theorem.",
  background: true,
  generation_config: {
    max_output_tokens: 262144,
    thinking_level: "high",
  },
});

while (interaction.status === "in_progress" || interaction.status === "queued") {
  await new Promise((resolve) => setTimeout(resolve, 5000));
  interaction = await client.interactions.get(interaction.id);
}

// Each hop adds a model_output step, so join the text of all of them.
const text = interaction.steps
  .filter((step) => step.type === "model_output")
  .flatMap((step) => step.content ?? [])
  .filter((content) => content.type === "text")
  .map((content) => content.text)
  .join("");
console.log(text);
console.log("Status:", interaction.status);
console.log("Usage:", interaction.usage);

# 1. Create the background interaction. It returns an ID right away.
ID=$(curl -s -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemini-4-argon",
    "input": "Write a complete, rigorous proof of the prime number theorem.",
    "background": true,
    "generation_config": {"max_output_tokens": 262144, "thinking_level": "high"}
  }' | jq -r '.id')

# 2. Poll until the status is no longer in_progress or queued.
#    The REST response has no output_text field, so join the text of every model_output step.
while true; do
  RESP=$(curl -s "https://generativelanguage.googleapis.com/v1beta/interactions/$ID" \
    -H "x-goog-api-key: $GEMINI_API_KEY")
  STATUS=$(echo "$RESP" | jq -r '.status')
  if [[ "$STATUS" != "in_progress" && "$STATUS" != "queued" ]]; then
    echo "$RESP" | jq -r '[.steps[]? | select(.type == "model_output") | .content[]? | select(.type == "text") | .text] | join("")'
    echo "$RESP" | jq '{status, usage}'
    break
  fi
  sleep 5
done

ขีดจำกัดเอาต์พุต

การโต้ตอบแบบสตรีมมิงและแบบไม่สตรีมมิงมีขีดจำกัดโทเค็นเอาต์พุตเริ่มต้นที่ 64,000 รายการ ดังนั้นคำตอบที่ใช้โทเค็นไม่เกิน 64,000 รายการจึงไม่จำเป็นต้องเปลี่ยนแปลงโค้ด หากต้องการสร้างโทเค็นมากกว่า 64, 000 รายการ ให้เปิดใช้การดำเนินการเมื่ออยู่เบื้องหลังและเพิ่ม max_output_tokens

กรณีที่ควรใช้การถอดรหัสแบบยาว

คำขอส่วนใหญ่จะเสร็จสิ้นภายใน 64,000 โทเค็น ใช้การถอดรหัสแบบยาวเฉพาะเมื่อคำตอบเดียวต้องใช้การคิดและเอาต์พุตมากกว่านั้น

การตั้งค่า max_output_tokens สูงจะทำให้โมเดลมีพื้นที่ในการคิดนานขึ้นเกี่ยวกับปัญหาที่ซับซ้อน แต่โมเดลจะยังคงตัดสินใจว่าจะเขียนมากน้อยเพียงใด หากต้องการควบคุมความพยายามในการให้เหตุผลที่โมเดลใช้ ให้ตั้งค่า thinking_level

เลือกวิธีเรียกใช้การถอดรหัสแบบยาว

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

หากต้องการใช้การดำเนินการต่อฝั่งไคลเอ็นต์ โปรดดู การถอดรหัสแบบยาวด้วย GenerateContent API

สตรีมการถอดรหัสแบบยาว

หากต้องการสตรีมเอาต์พุตและข้อมูลสรุปความคิดเมื่อมาถึง ให้เพิ่ม stream: true และ thinking_summaries: "auto" สตรีมแบบยาวอาจหยุดทำงาน ดังนั้นไคลเอ็นต์ของคุณต้องเชื่อมต่ออีกครั้ง ทำตามรูปแบบการเชื่อมต่ออีกครั้งในคู่มือการดำเนินการเมื่ออยู่เบื้องหลัง การถอดรหัสแบบยาวจะเพิ่มกฎต่อไปนี้

• บันทึกรหัสการโต้ตอบ: อ่านรหัสจากเหตุการณ์ interaction.created
• บันทึก event_id ทุกรายการ: event_id อาจมาถึงในเหตุการณ์ interaction.status_update ไม่ใช่เฉพาะในส่วนต่างของข้อความ
• เชื่อมต่ออีกครั้งด้วย last_event_id: เรียก interactions.get ด้วย stream: true และ event_id ล่าสุด สตรีมจะดำเนินการต่อหลังจากเหตุการณ์นั้น
• อ่านจนจบ: หลังจากเชื่อมต่ออีกครั้ง ให้อ่านสตรีมจนจบก่อนตรวจสอบสถานะ เซิร์ฟเวอร์จะเล่นเหตุการณ์ที่พลาดไปซ้ำ แม้ว่าการโต้ตอบจะเสร็จสมบูรณ์แล้วก็ตาม
• ตั้งค่าระยะหมดเวลาแบบยาว: ตั้งค่าระยะหมดเวลาในการอ่าน HTTP เป็น 15-20 นาทีต่อสตรีม
• คาดหวังเอาต์พุตในส่วน 5,000 โทเค็น: หลังจากโทเค็น 64,000 รายการแรก (ประมาณ 10 นาทีแรก) สตรีมจะส่งเอาต์พุตในส่วนประมาณ 5,000 โทเค็น การหยุดชั่วคราวระหว่างส่วนเป็นเรื่องปกติ การโต้ตอบไม่ได้ติดขัด ดังนั้นให้เปิดการเชื่อมต่อไว้

สถานะเบื้องหลัง

การโต้ตอบเบื้องหลังสามารถทำงานได้นานสูงสุด 24 ชั่วโมง เมื่อสถานะไม่ใช่ in_progress หรือ queued อีกต่อไป ให้จัดการสถานะสิ้นสุดโดยใช้ตารางนี้

หากต้องการหยุดการโต้ตอบที่กำลังทำงาน ให้เรียก client.interactions.cancel(id=interaction.id) ใน Python, client.interactions.cancel(interaction.id) ใน JavaScript หรือ POST /v1beta/interactions/{id}/cancel ใน REST

ตั้งค่า max_output_tokens

max_output_tokens จะกำหนดขีดจำกัดรวมสำหรับการคิดและเอาต์พุตในการโต้ตอบ การลดค่านี้ไม่ได้ทำให้โมเดลคิดได้กระชับขึ้น แต่จะตัดคำตอบออกเร็วขึ้น

หากต้องการใช้โทเค็นน้อยลง ให้ลด thinking_level ใช้ high สำหรับงานการให้เหตุผลที่ซับซ้อนที่สุด ใช้ medium (ค่าเริ่มต้น) สำหรับงานการเขียนโค้ดและงานแบบ Agent ส่วนใหญ่

นับโทเค็น

interaction.usage จะรายงานยอดรวมในการข้ามทั้งหมด อ่านฟิลด์ต่อไปนี้ total_input_tokens, total_cached_tokens, total_output_tokens, total_thought_tokens และ total_tokens

total_input_tokens จะรวมโทเค็นอินพุตของการข้ามทุกครั้ง การข้ามแต่ละครั้งจะส่งพรอมต์ของคุณและทุกสิ่งที่สร้างขึ้นจนถึงตอนนี้กลับไปยังโมเดลเป็นอินพุต ดังนั้นระบบจะนับโทเค็นเดียวกันอีกครั้งในการข้ามครั้งต่อๆ ไป ตัวอย่างเช่น พรอมต์ 1,000 โทเค็นที่สร้างโทเค็นสำหรับการคิดและเอาต์พุต 200,000 รายการจะใช้การข้าม 4 ครั้ง ดังนี้

total_input_tokens จะรายงานโทเค็นประมาณ 397,000 รายการ (โดยระบบจะลดอินพุตการข้ามที่ซ้ำกันโดยอัตโนมัติ 95% ด้วยการแคชโดยนัย) แม้ว่าขนาดบริบทจริงจะมีโทเค็นเพียงประมาณ 201,000 รายการ ได้แก่ พรอมต์ 1,000 โทเค็นบวกกับโทเค็นสำหรับการคิดและเอาต์พุต 200,000 รายการ

ระหว่างสตรีม เหตุการณ์ step.stop และ interaction.status_update จะมี usage (สะสมสำหรับการโต้ตอบ) ให้อ่านค่า usage ล่าสุดแทนการรวมค่าเหล่านั้น

ทำความเข้าใจการเรียกเก็บเงิน

คุณจะต้องชำระเงินสำหรับทุกโทเค็นในการข้ามทุกครั้ง รวมถึงการข้ามที่มีเฉพาะการคิด

• ส่วนลดการแคช: การแคชโดยนัยจะลดอินพุตที่ซ้ำกันในการข้ามแต่ละครั้ง 95% อินพุตที่แคชไว้จะมีค่าใช้จ่าย $0.10 ต่อ 1 ล้านโทเค็นแทน $2.00 ในช่วงแนะนำ
• การโต้ตอบที่ยกเลิกและล้มเหลว: คุณจะต้องชำระเงินสำหรับงานทั้งหมดที่เสร็จสมบูรณ์ก่อนที่การโต้ตอบจะสิ้นสุดลง

การแก้ปัญหา

ข้อจำกัด

• ไม่มีการถอดรหัสแบบยาวโดยไม่มีการดำเนินการเมื่ออยู่เบื้องหลัง: การโต้ตอบที่มี background: false จะหยุดที่ 65,536 โทเค็น จะพร้อมให้บริการเร็วๆ นี้
• ไม่มีเป้าหมายความยาว: โมเดลไม่เป็นไปตามเป้าหมายความยาวโทเค็นหรือจำนวนคำ

ขั้นตอนถัดไป

• มีอะไรใหม่ใน Gemini 4 Argon
• การดำเนินการเมื่ออยู่เบื้องหลัง
• การคิด
• การถอดรหัสแบบยาวด้วย GenerateContent API