लॉन्ग डिकोड

लॉन्ग डिकोड की सुविधा की मदद से Gemini 4 Argon, डीप रीज़निंग वाले टास्क के लिए 64 हज़ार से ज़्यादा टोकन जनरेट कर सकता है. यह सुविधा, 10 लाख टोकन वाली यूनिफ़ाइड कॉन्टेक्स्ट विंडो (इनपुट, थिंकिंग, और आउटपुट के लिए 10,48,576 टोकन शेयर किए जाते हैं) तक काम करती है. Interactions API पर, बैकग्राउंड में एक्ज़ीक्यूशन के साथ लॉन्ग डिकोड की सुविधा चालू की जाती है. इससे हमारे सर्वर, 64K हॉप को अपने-आप जनरेट करते हैं और उन्हें एक इंटरैक्शन में जोड़ते हैं.

डिकोड करने की प्रोसेस में कितना समय लगता है

एक मॉडल कॉल से ज़्यादा से ज़्यादा 64 हज़ार टोकन जनरेट होते हैं. जब किसी जवाब के लिए 64 हज़ार से ज़्यादा टोकन की ज़रूरत होती है, तो सर्वर उसे 64 हज़ार हॉप में जनरेट करता है. ये हॉप वहां से जारी रहते हैं जहां पिछला हॉप रुका था. हर हॉप, एक ही इंटरैक्शन आईडी के तहत interaction.steps में एक model_output जोड़ता है. इसलिए, पूरा जवाब पढ़ने के लिए इन चरणों को एक साथ जोड़ें:

1. आपने background: true और max_output_tokens के साथ 65,536 से ज़्यादा और 10 लाख तक का इंटरैक्शन बनाया हो.
2. सर्वर, पहले हॉप को जनरेट करता है. इसमें ज़्यादा से ज़्यादा 64 हज़ार टोकन हो सकते हैं.
3. सर्वर, अगले हॉप को वहीं से शुरू करता है जहां पिछला हॉप रुका था. यह प्रोसेस तब तक दोहराई जाती है, जब तक मॉडल पूरा नहीं हो जाता या 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

आउटपुट की सीमाएं

स्ट्रीमिंग और नॉन-स्ट्रीमिंग इंटरैक्शन के लिए, डिफ़ॉल्ट रूप से 64K आउटपुट टोकन की सीमा तय होती है. इसलिए, 64K टोकन तक के जवाबों के लिए, कोड में कोई बदलाव करने की ज़रूरत नहीं होती. 64 हज़ार से ज़्यादा टोकन जनरेट करने के लिए, बैकग्राउंड में एक्ज़ीक्यूशन की सुविधा चालू करें और max_output_tokens को बढ़ाएं.

लंबे डिकोड का इस्तेमाल कब करना चाहिए

ज़्यादातर अनुरोध, 64 हज़ार टोकन के अंदर पूरे हो जाते हैं. लंबे डीकोड का इस्तेमाल सिर्फ़ तब करें, जब किसी जवाब के लिए ज़्यादा सोचने और आउटपुट की ज़रूरत हो.

max_output_tokens की वैल्यू ज़्यादा सेट करने पर, मॉडल को मुश्किल सवालों के जवाब देने के लिए ज़्यादा समय मिलता है. हालांकि, मॉडल अब भी यह तय करता है कि उसे कितना लिखना है. यह तय करने के लिए कि मॉडल को जवाब देने के लिए कितनी मेहनत करनी है, thinking_level को सेट करें.

लॉन्ग डिकोड चलाने का तरीका चुनना

Interactions API पर लंबे डिकोड को चलाने का सबसे आसान तरीका, बैकग्राउंड में एक्ज़ीक्यूशन है. क्लाइंट-साइड कंटिन्यूएशन, GenerateContent API के साथ उपलब्ध है. इसमें आपका कोड हर हॉप को शुरू करता है. यह सुविधा, Interactions API में जल्द ही उपलब्ध होगी. इससे आपको अपनी परफ़ॉर्मेंस को बेहतर तरीके से मैनेज करने में मदद मिलेगी.

क्लाइंट-साइड पर कॉन्टेक्स्ट जारी रखने की सुविधा इस्तेमाल करने के लिए, GenerateContent API की मदद से लंबे कॉन्टेक्स्ट को डिकोड करना लेख पढ़ें.

स्ट्रीम को डिकोड करने में लगने वाला समय

आउटपुट और सोच की खास जानकारी को स्ट्रीम करने के लिए, stream: true और thinking_summaries: "auto" जोड़ें. लंबी स्ट्रीम ड्रॉप हो सकती हैं. इसलिए, आपके क्लाइंट को फिर से कनेक्ट करना होगा. बैकग्राउंड में एक्ज़ीक्यूशन की गाइड में दिए गए, फिर से कनेक्ट करने के पैटर्न का पालन करें. लंबे डिकोड में ये नियम जोड़े जाते हैं:

• इंटरैक्शन आईडी सेव करें: इसे interaction.created इवेंट से पढ़ें.
• Save every event_id: event_id, टेक्स्ट डेल्टा के अलावा interaction.status_update इवेंट पर भी आ सकता है.
• last_event_id से दोबारा संपर्क करें: interactions.get पर कॉल करें. इसके लिए, stream: true और आखिरी event_id का इस्तेमाल करें. इवेंट के बाद भी स्ट्रीम जारी रहती है.
• स्ट्रीम को आखिर तक पढ़ें: फिर से कनेक्ट करने के बाद, स्टेटस देखने से पहले स्ट्रीम को आखिर तक पढ़ें. इंटरैक्शन पूरा होने के बाद भी, सर्वर छूटे हुए इवेंट फिर से चलाता है.
• ज़्यादा टाइमआउट सेट करें: एचटीटीपी रीड टाइमआउट को हर स्ट्रीम के लिए 15 से 20 मिनट पर सेट करें.
• 5,000 टोकन के चंक में आउटपुट मिलने की उम्मीद करें: शुरुआती 64,000 टोकन (लगभग पहले 10 मिनट) के बाद, स्ट्रीम करीब 5,000 टोकन के चंक में आउटपुट भेजती है. चंक के बीच में रुकना सामान्य है. इंटरैक्शन में कोई समस्या नहीं है. इसलिए, कनेक्शन को चालू रखें.

बैकग्राउंड की स्थिति

बैकग्राउंड इंटरैक्शन 24 घंटे तक चल सकता है. जब स्टेटस in_progress या queued न रहे, तब टर्मिनल स्टेट को मैनेज करने के लिए इस टेबल का इस्तेमाल करें:

चल रहे इंटरैक्शन को रोकने के लिए, Python में client.interactions.cancel(id=interaction.id), JavaScript में client.interactions.cancel(interaction.id) या REST में POST /v1beta/interactions/{id}/cancel को कॉल करें.

सेट max_output_tokens

max_output_tokens, बातचीत के दौरान Gemini के सोचने और आउटपुट देने की कुल सीमा सेट करता है. इस वैल्यू को कम करने से, मॉडल ज़्यादा सटीक जवाब नहीं देता. इसके बजाय, वह जवाब को जल्दी खत्म कर देता है.

कम टोकन इस्तेमाल करने के लिए, thinking_level को कम करें. रीज़निंग से जुड़े सबसे मुश्किल टास्क के लिए, high का इस्तेमाल करें. ज़्यादातर कोडिंग और एजेंटिक काम के लिए, medium (डिफ़ॉल्ट) का इस्तेमाल करें.

टोकन की गिनती करना

interaction.usage सभी हॉप के कुल समय की रिपोर्ट देता है. इन फ़ील्ड को पढ़ें: total_input_tokens, total_cached_tokens, total_output_tokens, total_thought_tokens, और total_tokens.

total_input_tokens, हर हॉप के इनपुट टोकन जोड़ता है. हर हॉप में, आपके प्रॉम्प्ट के साथ-साथ अब तक जनरेट किया गया सारा कॉन्टेंट, मॉडल को इनपुट के तौर पर वापस भेजा जाता है. इसलिए, बाद के हर हॉप में एक ही टोकन को फिर से गिना जाता है. उदाहरण के लिए, 1,000 टोकन वाले ऐसे प्रॉम्प्ट के लिए चार हॉप लगते हैं जिससे 2,00,000 टोकन का जवाब मिलता है:

total_input_tokens में 3,97,000 टोकन की रिपोर्ट दी गई है. इसमें बार-बार हॉप इनपुट होने की वजह से, इंप्लिसिट कैश मेमोरी की सुविधा ने 95% की छूट अपने-आप दे दी है. हालांकि, कॉन्टेक्स्ट का असल साइज़ सिर्फ़ 2,01,000 टोकन है: 1,000 टोकन का प्रॉम्प्ट और 2,00,000 टोकन का जवाब.

स्ट्रीम के दौरान, step.stop और interaction.status_update, दोनों इवेंट में usage (इंटरैक्शन के लिए कुल) शामिल होता है. usage वैल्यू को जोड़ने के बजाय, उनकी नई वैल्यू पढ़ें.

बिलिंग के बारे में जानकारी

आपको हर हॉप में इस्तेमाल किए गए हर टोकन के लिए पेमेंट करना होगा. इसमें वे हॉप भी शामिल हैं जिनमें सिर्फ़ थिंकिंग प्रोसेस का इस्तेमाल किया गया है.

• कैश मेमोरी में सेव करने पर मिलने वाली छूट: इंप्लिसिट कैशिंग की सुविधा, हर हॉप में बार-बार इस्तेमाल होने वाले इनपुट को 95% तक कम कर देती है. शुरुआती अवधि के दौरान, कैश मेमोरी में सेव किए गए इनपुट के लिए, हर 10 लाख टोकन पर 2 डॉलर के बजाय 0.10 डॉलर का शुल्क लिया जाता है.
• रद्द किए गए और पूरे न हो सके इंटरैक्शन: इंटरैक्शन खत्म होने से पहले किए गए सभी काम के लिए आपको पेमेंट करना होगा.

समस्या का हल

सीमाएं

• बैकग्राउंड में प्रोसेस किए बिना लंबे समय तक डिकोड नहीं किया जा सकता: background: false के साथ इंटरैक्शन, 65,536 टोकन पर रुक जाते हैं. यह सुविधा जल्द ही उपलब्ध होगी.
• लंबाई के लिए कोई टारगेट नहीं: यह मॉडल, टोकन की लंबाई या शब्दों की संख्या के टारगेट को फ़ॉलो नहीं करता.

अगले चरण

• Gemini 4 Argon में नया क्या है
• बैकग्राउंड में कोड एक्ज़ीक्यूट होने की सुविधा
• प्रोसेस जारी है
• GenerateContent API की मदद से, लंबे इनपुट को डिकोड करना