Gemini 3.8 Flash API ट्यूटोरियल: Thinking Levels, PDF Extraction, और Python में Function Calling

Gemini 3.8 Flash क्या है?

Gemini 3.8 Flash Google का वर्कहॉर्स मॉडल है, जो 2 सितंबर, 2026 से सामान्य रूप से उपलब्ध है, मॉडल ID gemini-3.8-flash के तहत। यह 3.7 Flash के 3 सप्ताह बाद आया, और Google इसे लंबी-अवधि कोडिंग, एजेंटिक वर्कफ़्लोज़, और वित्त व कानूनी जैसे विशेष डोमेन में मल्टी-स्टेप रीज़निंग के लिए पोज़िशन करता है।

API कॉल्स के लिए मायने रखने वाले स्पेक्स 3.7 से अपरिवर्तित हैं: 

• 1M टोकन का कॉन्टेक्स्ट विंडो
• 64k अधिकतम आउटपुट टोकन
• मल्टीमॉडल इनपुट (टेक्स्ट, इमेज, वीडियो, ऑडियो, PDFs) के साथ टेक्स्ट आउटपुट
• वही प्रारंभिक मूल्य: 31 दिसंबर, 2026 तक 1M इनपुट टोकन पर $0.75 और 1M आउटपुट टोकन पर $3.75 (1 जनवरी, 2027 से बढ़कर क्रमशः $1.50 और $7.50)

जो बदला है वह व्यवहार है, सतह नहीं: Google कहता है कि 3.8 जटिल टास्क पर ज़्यादा मेहनत करता है, अतिरिक्त रीज़निंग स्टेप्स लेता है और टूल्स को क्रमिक रूप से कॉल करता है, जो उच्च प्रयास स्तरों पर टोकन उपयोग बढ़ा सकता है। 3.7 Flash उन वर्कलोड्स के लिए पूरी तरह समर्थित है जहां गहराई से अधिक दक्षता मायने रखती है।

बेंचमार्क और विस्तृत मूल्य निर्धारण के लिए, हमारा Gemini 3.8 Flash गाइड देखें, या प्लेटफ़ॉर्म का अवलोकन पाने के लिए What is Google Gemini? गाइड पढ़ें।

Gemini 3.8 Flash बनाम 3.8 Flash Cyber

लॉन्च में 2 वेरिएंट शामिल हैं, और केवल 1 का मॉडल ID है जिसे आप टाइप कर सकते हैं। 

• Gemini 3.8 Flash जनरल मॉडल है, जो आज Google AI Studio और Gemini API में उपलब्ध है। 
• Gemini 3.8 Flash Cyber एक साइबरसिक्योरिटी वेरिएंट है, जो भेद्यता खोज और स्वचालित पैचिंग के लिए ट्यून किया गया है।

Cyber वेरिएंट सार्वजनिक API पर उपलब्ध नहीं है: एक्सेस Google के Fairwind Program के माध्यम से होता है, जो स्वीकृत सरकारी प्राधिकरणों, महत्वपूर्ण-इन्फ्रास्ट्रक्चर ऑपरेटरों, और सॉफ़्टवेयर मेंटेनरों तक सीमित है।

यदि आप इस ट्यूटोरियल का पालन कर रहे हैं, तो आपका मॉडल ID gemini-3.8-flash है। नीचे दी गई किसी भी चीज़ को Cyber वेरिएंट की जरूरत नहीं है और न ही उसका उपयोग करती है।

Interactions API बनाम generateContent

Gemini 3.8 Flash को कॉल करने के लिए google-genai SDK में client.interactions.create() का उपयोग करें। Google ने Interactions API को जून 2026 में GA किया और सभी नए कार्यों के लिए इसकी सिफारिश करता है। जबकि generateContent अभी भी काम करता है, यह अब लेगेसी है। सर्वर-साइड हिस्ट्री, बैकग्राउंड एक्ज़िक्यूशन, और ऑब्ज़र्वेबल एक्ज़िक्यूशन स्टेप्स जैसी नई सुविधाएँ पहले Interactions पर आती हैं।

व्यवहार में सबसे बड़ा बदलाव स्टेट मैनेजमेंट है। अब मल्टी-टर्न कॉल्स सर्वर-साइड previous_interaction_id का उपयोग करते हैं: आप पिछली इंटरैक्शन ID पास करते हैं, और सर्वर स्टेट रिस्टोरेशन संभालता है। अब आपको अपने क्लाइंट से पूरी चैट हिस्ट्री को मैन्युअल रूप से जोड़ने या फिर से भेजने की आवश्यकता नहीं है। मॉडल टर्न्स को प्रीफिल करने से भी बचें; वह generateContent की लेगेसी पैटर्न है और Gemini 3.x पर टूट जाएगा।

एक बात जो लगभग सभी को पकड़ती है, और यह PDF सेक्शन में वापस आती है: previous_interaction_id केवल बातचीत का इतिहास बहाल करता है, और कुछ नहीं। tools, system_instruction, generation_config, और response_format इंटरैक्शन-स्कोप्ड होते हैं, इसलिए जिन भी टर्न्स में इनकी ज़रूरत है, उन्हें फिर से पास करना होगा।

sampling knobs की जगह thinking_level

पुराने Gemini मॉडलों पर, डेवलपर्स आउटपुट रैंडमनेस को नियंत्रित करने के लिए temperature, top_p, और top_k का उपयोग करते थे। Gemini 3.x इन सैंपलिंग नॉब्स को हटा देता है और उनकी जगह thinking_level लाता है, जो अब एकमात्र डायल है।

यह 3 मान स्वीकार करता है:

• low: सबसे कम रीज़निंग टोकन, सबसे तेज़ और सस्ता। एक्सट्रैक्शन, क्लासिफिकेशन, और ऐसी किसी भी चीज़ के लिए उपयुक्त जिसे आप स्वयं जांचेंगे।

• medium: डिफ़ॉल्ट, और कोड व एजेंट कार्य के लिए Google की सिफारिश।

• high: सबसे बड़ा रीज़निंग बजट, कठिन मल्टी-स्टेप लॉजिक और टूल-हेवी टास्क्स के लिए।

minimal न भेजें। यह Gemini Flash 3.7 से अमान्य है और 400 वैलिडेशन त्रुटि लौटाता है। 

3.7 से चला आ रहा एक और नियम: frequency_penalty, presence_penalty, और candidate_count अब सक्रिय API त्रुटि फेंकते हैं, इसलिए इन्हें भी लेगेसी कॉन्फ़िग्स से हटाएँ।

Gemini 3.8 Flash API कैसे सेट करें?

अपना परिवेश सेट करने में लगभग 2 मिनट लगते हैं। आपको Google AI Studio से API कुंजी और अपडेटेड google-genai Python लाइब्रेरी चाहिए।

Google AI Studio से API कुंजी प्राप्त करें

अपने ब्राउज़र में Google AI Studio पर जाएँ और अपने Google खाते से लॉग इन करें। Create API Key पर क्लिक करें, कोई Google Cloud प्रोजेक्ट चुनें या बनाएँ, और अपनी सीक्रेट कुंजी स्ट्रिंग कॉपी करें। 

अपना टर्मिनल खोलें और कुंजी को एक एनवायरनमेंट वेरिएबल के रूप में सेव करें: export GEMINI_API_KEY=<your-key>।

कुंजी को कभी भी URL में ?key= क्वेरी पैरामीटर के रूप में पास न करें; क्वेरी स्ट्रिंग्स सर्वर लॉग्स, ब्राउज़र हिस्ट्री, और प्रॉक्सी कैश में आ जाती हैं। यदि आप कोड लिखने से पहले प्लेग्राउंड में मॉडल एक्सप्लोर करना चाहते हैं, तो Google AI Studio Tutorial Chat, Build, और Stream मोड्स को कवर करता है; यह लेख API पर ही रहता है।

प्रोडक्शन सिस्टम्स के लिए, ऑथ की कहानी बदलती है: Vertex AI (अब Gemini Enterprise Agent Platform का हिस्सा) आपको कच्ची API कुंजी के बजाय OAuth, IAM रोल्स, और रीजनल एंडपॉइंट्स देता है। इस ट्यूटोरियल में सब कुछ AI Studio कुंजियों का उपयोग करता है क्योंकि यह सीखने का सबसे तेज़ मार्ग है, लेकिन वास्तविक यूज़र डेटा को छूने से पहले Vertex माइग्रेशन की योजना बनाएँ।

google-genai इंस्टॉल करें और क्लाइंट बनाएँ

कई ट्यूटोरियल अब भी google-generativeai इंस्टॉल करने को कहते हैं। वह पुराना SDK है, और उसमें Interactions API नहीं है। google-genai (संस्करण 2.3.0 या बाद का) इंस्टॉल करें:

pip install -U google-genai

इंस्टॉल होने के बाद, सत्यापित करें कि Python लाइब्रेरी लोड करता है और आपका क्लाइंट बिना त्रुटि के इनिशियलाइज़ होता है:

from google import genai # reads GEMINI_API_KEY from the environment
client = genai.Client() 
print("Client initialized successfully.")

अपना पहला Interactions API कॉल करें

Interactions API के लिए हर अनुरोध एक Interaction संसाधन बनाता है, जो पूरा टर्न रिकॉर्ड करता है: आपका इनपुट, मॉडल के विचार, कोई भी टूल कॉल, और अंतिम आउटपुट। SDK output_text सुविधा प्रॉपर्टी के माध्यम से अंतिम टेक्स्ट उपलब्ध कराता है, इसलिए आपको शायद ही कभी स्टेप्स को मैन्युअली वॉक करना पड़े।

from google import genai
client = genai.Client()
interaction = client.interactions.create(
    model="gemini-3.8-flash",
    input=(
        "Write a pandas one-liner that adds a 7-day rolling average "
        "revenue column per store_id to a DataFrame with columns "
        "date, store_id, revenue. Reply with only the code, no explanation."
    ),
    generation_config={"thinking_level": "medium"},
)
print(interaction.output_text)
usage = interaction.usage
print(
    f"input={usage.total_input_tokens} | output={usage.total_output_tokens} | "
    f"thinking={usage.total_thought_tokens} | total={usage.total_tokens}"
)

मेरी मशीन पर, मॉडल ने एक चेन किए हुए pandas वन-लाइनर के साथ उत्तर दिया, और यह उपयोग पंक्ति आई:

ये संख्याएँ 3.7 से पहला वास्तविक अंतर छिपाती हैं। मैंने वही टास्क एक बार फिर लंबे प्रॉम्प्ट और बिना आउटपुट प्रतिबंध के चलाया, और 3.8 ने 870 आउटपुट टोकन के मुकाबले 1,436 सोच टोकन खर्च किए। प्रतिबंध के साथ, उसने 42 के मुकाबले 1,515 खर्च किए। रीज़निंग बजट मुश्किल से बदला, जो 3.7 के विपरीत है, जहाँ उन्हीं 2 प्रॉम्प्ट्स ने सोच को 838 से 1,530 तक झुलाया।

दूसरे शब्दों में, 3.8 यह तय करता है कि टास्क के आधार पर कितना सोचना है, न कि आप टास्क को कैसे लिखते हैं, जो Google के इस दावे से मेल खाता है कि मॉडल जानबूझकर ज़्यादा तर्क करता और सत्यापित करता है। सोच टोकन आउटपुट रेट पर बिल होते हैं, इसलिए सीमित कॉल पर, लगभग 97% बिल किए गए टोकन वह रीज़निंग थी जो मैंने देखी ही नहीं। यही कारण है कि अगला सेक्शन मौजूद है। 

रिस्पॉन्स को स्ट्रीम करें

चैट इंटरफेस या किसी भी ऐसी चीज़ के लिए जिसे व्यक्ति देखता है, पूरे रिस्पॉन्स के लिए कई सेकंड इंतज़ार करना धीमा लगता है। client.interactions.create() को stream=True पास करें और जैसे ही चंक्स आएँ, उन्हें प्रिंट करें:

	from google import genai

	client = genai.Client()

	stream = client.interactions.create(
	   model="gemini-3.8-flash",
	   input="Explain the difference between a JOIN and a correlated subquery in SQL.",
	   generation_config={"thinking_level": "low"},
	   stream=True,
	)

	for event in stream:
	   if event.event_type == "step.delta" and event.delta.type == "text":
	       print(event.delta.text, end="", flush=True)
	print() 

जब मैंने यह चलाया, तो मॉडल ने thinking_level: "low" पर एक लंबा, सुव्यवस्थित उत्तर लौटाया: एक वैचारिक तुलना, एक सारांश तालिका, और प्रत्येक ग्राहक के सबसे हालिया ऑर्डर को खोजने के 2 SQL उदाहरण — 1 डेराइव्ड-टेबल जॉइन के साथ और 1 SELECT सूची में correlated subquery के साथ। पहले शब्द लगभग तुरंत दिखाई दिए, जो पूरा मकसद है।

वह अंतिम print() किसी वजह से है। इसके बिना, आखिरी चंक लाइन के बीच में खत्म होता है, और zsh आपके प्रॉम्प्ट से पहले एक भटका हुआ % दिखाता है, क्योंकि स्ट्रीम वहीं रुकती है जहाँ मॉडल का टेक्स्ट रुकता है। साथ ही, डेल्टाज़ केवल तभी टेक्स्ट ले जाते हैं; यदि आप प्रति अनुरोध टोकन काउंट्स लॉग करते हैं, तो उन्हें चंक्स जोड़ने के बजाय अंतिम कम्प्लीशन इवेंट से पढ़ें।

thinking_level लागत और गुणवत्ता कैसे बदलता है?

thinking_level यह सेट करता है कि Gemini 3.8 Flash उत्तर लिखने से पहले कितनी रीज़निंग करता है। रीज़निंग टोकन 1M पर $3.75 की आउटपुट दर पर बिल होते हैं, इसलिए आपका चुना स्तर सीधे लागत और विलंबता नियंत्रित करता है, और Google कहता है कि 3.8 जानबूझकर इसी पर जोर देता है: यह जटिल टास्क पर अतिरिक्त रीज़निंग स्टेप्स लेता है और 3.7 की तुलना में उच्च प्रयास स्तरों पर अधिक टोकन खर्च कर सकता है।

एक ही प्रॉम्प्ट को low, medium, और high पर चलाएँ

टेस्ट एक payment-retry फ़ंक्शन में रेस कंडीशन है, जिसे सभी 3 स्तरों पर एक ही प्रॉम्प्ट के साथ भेजा गया है। कंकरेंसी बग स्किम-रीडिंग को सज़ा देते हैं, इसलिए यदि स्तर अलग हैं, तो यही वह जगह है जहाँ यह दिखना चाहिए। यदि आप इस लेख से केवल 1 कोड ब्लॉक चलाते हैं, तो इसे ही बनाइए, क्योंकि संख्याएँ किसी भी गद्य से बेहतर तर्क देती हैं।

import time

from google import genai

client = genai.Client()

BUGGY_CODE = '''
import threading

payment_attempts = {}

def retry_payment(order_id, charge_fn, max_retries=3):
    """Retry a failed payment up to max_retries times."""
    if order_id not in payment_attempts:
        payment_attempts[order_id] = 0

    while payment_attempts[order_id] < max_retries:
        success = charge_fn(order_id)
        if success:
            del payment_attempts[order_id]
            return True
        payment_attempts[order_id] += 1
    return False
'''

PROMPT = (
    "Two worker threads can call retry_payment() with the same order_id "
    "at the same time. Identify the concurrency bug that can double-charge "
    "a customer, and rewrite the function to fix it.\n\n" + BUGGY_CODE
)

for level in ["low", "medium", "high"]:
    start = time.perf_counter()
    interaction = client.interactions.create(
        model="gemini-3.8-flash",
        input=PROMPT,
        generation_config={"thinking_level": level},
    )
    elapsed = time.perf_counter() - start
    usage = interaction.usage
    print(f"\n=== thinking_level: {level} | {elapsed:.1f}s ===")
    print(interaction.output_text)
    print(
        f"input={usage.total_input_tokens} | output={usage.total_output_tokens} | "
        f"thinking={usage.total_thought_tokens}"
    )

प्रसंग के लिए, भेद्यता payment_attempts[order_id] पर एक non-atomic check-then-act है। कंकरेंसी के तहत, 2 थ्रेड्स दोनों while शर्त पास कर सकते हैं, और दोनों काउंटर बढ़ाने से पहले charge_fn() को कॉल कर सकते हैं। इसे ठीक करने का मतलब प्रति-ऑर्डर लॉक में read-check-charge-increment फ्लो को रैप करना, या गेटवे पर एक idempotency कुंजी का उपयोग करना है।

परिणामों की तुलना

मेरी रन से परिणाम:

तीनों स्तरों ने डबल-चार्ज पाया, और तीनों ने प्रति-ऑर्डर लॉकिंग दी, ताकि असंबंधित ऑर्डर समानांतर चलें। यदि आप इसे 3.7 पर तुलना करें तो दूसरा भाग हेडलाइन है: वहाँ low ने हर चीज़ को एक ग्लोबल लॉक में लपेट दिया था जो नेटवर्क कॉल के दौरान होल्ड था, और प्रति-ऑर्डर लॉक केवल medium पर आए थे। 3.8 पर, low बिना किसी सोच टोकन के, 7.8 सेकंड में, एक तिहाई सेंट से भी कम में बेहतर डिज़ाइन लिखता है।

तो अब स्तर क्या खरीदते हैं? ऑडिट गहराई। इस कोड में 4 अलग-अलग फेल्योर मोड हैं (डबल-चार्ज, concurrent delete पर KeyError, success पथ के बाद स्टेट डिलीट होने पर re-charge, और non-atomic काउंटर इन्क्रीमेंट्स), और high ही एकमात्र स्तर था जिसने चारों का नाम लिया; low ने re-charge केस मिस किया, और medium ने काउंटर मिस किया। 

high स्तर ही एकमात्र था जिसने अपने फिक्स के failure-path semantics स्पष्ट किए: एक बार retries समाप्त हो जाने पर, बाद के कॉलर्स को फिर से चार्ज करने के बजाय False मिलता है।

सोच कॉलम Google के "3.8 ज़्यादा मेहनत करता है" दावे को टर्मिनल में दिखा रहा है। उसी प्रॉम्प्ट पर 3.7 के मुकाबले, medium 2,343 सोच टोकन से 3,158 पर गया, और high 2,217 से 4,512 पर, लगभग दोगुना, और अतिरिक्त टोकन ने अलग निर्णय के बजाय अधिक संपूर्ण विश्लेषण खरीदा। विलंबता भी इस रन में इसी क्रम में बढ़ी (7.8 s, 16.6 s, 25.5 s), लेकिन इन मॉडलों पर सिंगल-रन टाइमिंग्स झूलती हैं, इसलिए सेकंड्स के बजाय टोकन काउंट्स की तुलना करें।

डिफ़ॉल्ट चुनें और कब एस्केलेट करें

रीज़निंग स्तरों के लिए मेरा नियम:

• 3.8 पर, low ने Google के medium डिफ़ॉल्ट से बड़ा रोल कमाया: इसने 0 सोच टोकन पर एक सही, अच्छे डिज़ाइन वाला फिक्स दिया, इसलिए किसी भी ऐसी चीज़ के लिए यहाँ से शुरू करें जिसे मानवीय समीक्षा मिलेगी (ट्राएज, ड्राफ्ट, सारांश, वह कोड जिसे आप रिव्यू करेंगे)। 

• medium को वहाँ रखें जहाँ आउटपुट बिना पढ़े शिप होता है, क्योंकि अतिरिक्त सोच ने अधिक संपूर्ण फेल्योर-मोड विश्लेषण लाया, और बिना-पढ़े पाइपलाइन में वही फेल्योर मोड फायर होता है जिसे आपने सूचीबद्ध नहीं किया।

• high को उन आउटपुट्स के लिए सुरक्षित रखें जहाँ फेल्योर पाथ स्वयं प्रोडक्ट है, जैसे पेमेंट फ्लोज़, माइग्रेशन्स, या कोई भी चीज़ जिसे समीक्षक लाइन-दर-लाइन ऑडिट करेगा। मेरी रन में, यह एकमात्र स्तर था जिसने सभी 4 बग पकड़े और बताया कि retries खत्म होने के बाद क्या होता है।

low की तुलना में high पर 6.6x लागत के साथ, यह ट्रेड अभी 1M आउटपुट टोकन पर $3.75 बनाम 31 दिसंबर, 2026 के बाद $7.50 पर बहुत अलग पढ़ता है, इसलिए वैश्विक रूप से नहीं, प्रति-रिक्वेस्ट एस्केलेट करें।

एक एस्केप हैच जानना उपयोगी है कि Google बताता है कि 3.7 Flash दक्षता-प्रथम वर्कलोड्स के लिए पूरी तरह समर्थित रहता है। यदि 3.8 की अतिरिक्त मेहनत आपके टास्क की ज़रूरत से अधिक खर्च कराती है, तो उस वर्कलोड के लिए gemini-3.7-flash पर बने रहना समर्थित विकल्प है, हैक नहीं।

आप PDF से स्ट्रक्चर्ड डेटा कैसे निकालते हैं?

Gemini 3.8 Flash PDFs को सीधे इनपुट के रूप में पढ़ता है, इसलिए आप कोई इनवॉइस या रिपोर्ट भेज सकते हैं और उसके बारे में प्रश्न पूछ सकते हैं। मैंने 1-पेज विक्रेता इनवॉइस का उपयोग किया जिसमें इनवॉइस नंबर, तिथियाँ, 4 लाइन आइटम, और एक टोटल था।

प्रॉम्प्ट में PDF संलग्न करें

आइए Files API का उपयोग करके एक लोकल इनवॉइस PDF अपलोड करें। Files API Google के इन्फ्रास्ट्रक्चर पर फ़ाइल स्टोरेज और कैशिंग संभालता है:

	from google import genai
	client = genai.Client()
	print("Uploading invoice...")
	doc = client.files.upload(file="invoice_aug_2026.pdf")
	print(f"File uploaded: {doc.uri}\n")

	interaction = client.interactions.create(
	   model="gemini-3.8-flash",
	   input=[
	       {
	           "type": "text",
	           "text": "Extract the invoice number, total amount due, and due date.",
	       },
	       {"type": "document", "uri": doc.uri, "mime_type": doc.mime_type},
	   ],
	)
	print(interaction.output_text)

मेरी इनवॉइस से आउटपुट:

तीनों मान सही हैं। अपलोड एक बार होता है, और फ़ाइल बाद के अनुरोधों के लिए उपलब्ध रहती है, जो जैसे ही आप एक ही दस्तावेज़ पर 1 से अधिक प्रश्न पूछते हैं, मायने रखती है। उत्तर मार्कडाउन बुलेट्स के रूप में आता है, जो पढ़ने के लिए ठीक है और पाइपलाइन में खिलाने के लिए ठीक नहीं।

response schema के साथ JSON को बाध्य करें

गद्य के बजाय JSON पाने के लिए, response_format में स्कीमा पास करें। Interactions API पर, यह एक टॉप-लेवल पैरामीटर है; generationConfig के अंदर का responseMimeType सेटिंग जो आप पुराने ट्यूटोरियल्स में देखेंगे, वह लेगेसी generateContent एंडपॉइंट की है।

import json

from google import genai
from pydantic import BaseModel

client = genai.Client()


class Invoice(BaseModel):
    invoice_number: str
    total_due_usd: float
    due_date: str  # ISO 8601


doc = client.files.upload(file="invoice_aug_2026.pdf")

interaction = client.interactions.create(
    model="gemini-3.8-flash",
    input=[
        {
            "type": "text",
            "text": "Extract the invoice number, total amount due in USD, and due date.",
        },
        {"type": "document", "uri": doc.uri, "mime_type": doc.mime_type},
    ],
    response_format={
        "type": "text",
        "mime_type": "application/json",
        "schema": Invoice.model_json_schema(),
    },
)

invoice = json.loads(interaction.output_text)
print(invoice)

मुझे यह आउटपुट मिला: 

आपकी Pydantic क्लास आवश्यक फ़ील्ड्स और डेटा प्रकार परिभाषित करती है, जबकि model_json_schema() Gemini API द्वारा आवश्यक JSON स्कीमा जेनरेट करता है। प्रोसेस होने के बाद, json.loads() मॉडल के आउटपुट को एक मानक Python डिक्शनरी में बदल देता है। यहाँ से, स्ट्रक्चर्ड डेटा DataFrame पंक्ति में बदला जाने, डेटाबेस में कमिट होने, या Google Sheet में जोड़े जाने के लिए तैयार है।

previous_interaction_id के साथ फ़ॉलो-अप पूछें

उसी दस्तावेज़ के बारे में दूसरे प्रश्न के लिए, पहले इंटरैक्शन की id को previous_interaction_id के रूप में पास करें। सर्वर के पास पहले से PDF और पहली बातचीत है, इसलिए आप दोनों को फिर से नहीं भेजते:

follow_up = client.interactions.create(
    model="gemini-3.8-flash",
    previous_interaction_id=interaction.id,
    input="List each line item on the invoice with its amount.",
)

print(follow_up.output_text)

इसने सभी 4 आइटम क्रम में लौटाए, जिसमें repeated compute लाइन भी शामिल थी, और रिपीट पर टिप्पणी नहीं की। पूछे गए प्रश्न के लिए यही सही व्यवहार है; यदि आप विसंगतियों को फ़्लैग कराना चाहते हैं, तो उसके लिए कहें। 

जहाँ तक बात है, 3.7 ने यहाँ समान व्यवहार किया, इसलिए 3.8 की अतिरिक्त मेहनत उसके अपने रीज़निंग पर लागू होती है, न कि उन ऑडिट्स पर स्वयंसेवा करने पर जिन्हें आपने माँगा नहीं।

इस कॉल के बारे में 2 बातें जानने योग्य हैं: 

• response_format कैरी ओवर नहीं हुआ, क्योंकि यह इंटरैक्शन-स्कोप्ड है, इसलिए इस टर्न ने गद्य लौटाया। 

• और इंटरैक्शन्स डिफ़ॉल्ट रूप से संग्रहीत होते हैं (store=True) पेड टियर पर 55 दिनों के लिए और फ्री टियर पर 1 दिन के लिए; store=False कॉल को स्टेटलेस बनाता है, लेकिन तब आप उससे previous_interaction_id चेन नहीं कर सकते।

आप Gemini 3.8 Flash में फ़ंक्शन कॉलिंग कैसे जोड़ते हैं?

Gemini 3.8 Flash पर फ़ंक्शन कॉलिंग एक ही लूप है, जहाँ मॉडल टूल माँगता है, आपका कोड उसे चलाता है, आप परिणाम वापस भेजते हैं, और मॉडल अंतिम उत्तर लिखता है। यह सेक्शन वह लूप हाथ से बनाता है।

यदि आप चाहते हैं कि Google आपके लिए होस्टेड मल्टी-टूल एजेंट्स के साथ लूप चलाए, तो अगला हमारा  "Managed Agents" in the Gemini API ट्यूटोरियल पढ़ें। और यदि एजेंट्स आपका दीर्घकालिक लक्ष्य हैं, तो Building AI Agents with Google ADK कोर्स उन्हीं प्रिमिटिव्स पर एक पूरा कस्टमर-सपोर्ट असिस्टेंट बनाता है।

एक टूल परिभाषित करें और इंटरैक्शन लूप निष्पादित करें

टूल है lookup_exchange_rate(currency, date), जो एक छोटे इन-मेमोरी dict से बैक्ड है, ताकि उदाहरण किसी बाहरी API के बिना चले। डिक्लेरेशन एक JSON स्कीमा है। मॉडल फ़ंक्शन को कभी नहीं चलाता; वह एक function_call स्टेप लौटाता है जो आपके कोड से यह करने को कहता है:

import json

from google import genai

client = genai.Client()

# Local "data source" standing in for a real FX API
RATES = {
    ("USD", "2026-08-03"): 87.42,
    ("USD", "2026-08-10"): 87.15,
    ("EUR", "2026-08-03"): 95.08,
}


def lookup_exchange_rate(currency: str, date: str) -> dict:
    rate = RATES.get((currency.upper(), date))
    if rate is None:
        return {"error": f"No rate for {currency} on {date}"}
    return {"currency": currency.upper(), "date": date, "inr_rate": rate}


rate_tool = {
    "type": "function",
    "name": "lookup_exchange_rate",
    "description": "Look up the INR exchange rate for a currency on a date (YYYY-MM-DD).",
    "parameters": {
        "type": "object",
        "properties": {
            "currency": {"type": "string", "description": "ISO code, e.g. USD"},
            "date": {"type": "string", "description": "YYYY-MM-DD"},
        },
        "required": ["currency", "date"],
    },
}

# Turn 1: the model decides to call the tool
interaction = client.interactions.create(
    model="gemini-3.8-flash",
    input="What was the USD to INR exchange rate on 2026-08-03?",
    tools=[rate_tool],
)

fc_step = next(s for s in interaction.steps if s.type == "function_call")
print(f"Model requested: {fc_step.name}({fc_step.arguments})")

# Your code executes the function locally
result = lookup_exchange_rate(**fc_step.arguments)

# Turn 2: send the result back; tools must be re-specified (interaction-scoped)
final = client.interactions.create(
    model="gemini-3.8-flash",
    previous_interaction_id=interaction.id,
    input=[
        {
            "type": "function_result",
            "name": fc_step.name,
            "call_id": fc_step.id,
            "result": [{"type": "text", "text": json.dumps(result)}],
        }
    ],
    tools=[rate_tool],
)

print(final.output_text)

आउटपुट: 

यहाँ 3 बातें हुईं:  

1. टर्न 1 ने एक function_call स्टेप लौटाया जिसमें नाम, स्ट्रक्चर्ड आर्ग्युमेंट्स, और एक id था।

2. आपके Python ने लुकअप चलाया।

3. टर्न 2 ने उस कॉल को संदर्भित करते हुए एक function_result ब्लॉक भेजा। 

दूसरे टर्न पर tools पैरामीटर उसी वजह से फिर से पास किया जाता है जिस वजह से PDF सेक्शन में response_format को फिर से पास करना पड़ा: previous_interaction_id हिस्ट्री ले जाता है, कॉन्फ़िग नहीं।

Gemini 3.x पर फ़ंक्शन-कॉलिंग में होने वाली गलतियाँ

यदि कोई टूल लूप टूटता है, तो लगभग हमेशा 2 में से 1 कारण होता है। 

पहला, हर परिणाम को उसकी कॉल पर मैप होना चाहिए। Interactions API पर, यह function_result ब्लॉक पर call_id और name है; लेगेसी generateContent API पर, FunctionResponse को पिछले FunctionCall के id और name से मेल खाना चाहिए। Gemini 3.x पर इनमें से कोई भी वैकल्पिक नहीं है।

दूसरा, Malformed_Function_Call त्रुटि आमतौर पर तब होती है जब मॉडल टूल कॉल से पहले टिप्पणी प्रेषित करता है। Google के 3.8 डेवलपर गाइड में कहा गया है कि प्री-टूल अग्रणी टेक्स्ट को साफ़ करें, इनलाइन निर्देशों को \n\n से फ़ॉर्मैट करें, और कार्य नोट्स को कच्चे टेक्स्ट के बजाय एक समर्पित फ़ंक्शन कॉल में रैप करें। सिस्टम इंस्ट्रक्शन को टाइट करें; बिना सोचे-समझे रिट्राई न करें।

जब आप Gemini 3.8 Flash पर स्विच करते हैं तो क्या टूटता है?

यह इस पर निर्भर करता है कि आप कहाँ से शुरू करते हैं। 

• Gemini 3.7 Flash से: कुछ नहीं। मॉडल स्ट्रिंग को gemini-3.8-flash में बदलें, और इस लेख के हर स्निपेट बिना संशोधन के चलता है, क्योंकि API सतह समान है। 

• Gemini 3.6 Flash या पहले से, मॉडल कॉन्फ़िगरेशन को पहले की तरह ही 15-मिनट के ऑडिट की आवश्यकता है।

माइग्रेशन चेकलिस्ट (3.6 Flash या पहले से)

इन्हें क्रम में पूरा करें। आइटम 1 से 3 तुरंत 400 कराते हैं; आइटम 4 और 5 चुपचाप गुणवत्ता समस्याएँ कराते हैं।

1. मॉडल ID को gemini-3.8-flash में बदलें।

2. मृत सैंपलिंग पैरामीटर हटाएँ: temperature, top_p, और top_k Gemini 3.x पर अनदेखे या अस्वीकृत हैं, और frequency_penalty, presence_penalty, और candidate_count सक्रिय API त्रुटि फेंकते हैं। लेगेसी कॉन्फ़िग्स से सभी 6 हटाएँ।

3. thinking_budget को thinking_level से बदलें: केवल low, medium, या high का उपयोग करें। पुराना minimal मान वैलिडेशन त्रुटि लौटाता है। एक ही रिक्वेस्ट में thinking_budget और thinking_level दोनों भेजने पर 400 लौटता है।

4. प्रीफिल्ड मॉडल टर्न्स हटाएँ: जिन्हें आप बनाते हैं किसी भी बातचीत से इन्हें स्ट्रिप करें, और सुनिश्चित करें कि अंतिम यूज़र टर्न में नॉन-एम्प्टी टेक्स्ट हो। हिस्ट्री पेलोड्स मॉडल टर्न पर समाप्त नहीं हो सकते।

5. मल्टी-टर्न फ्लोज़ को मानकीकृत करें: क्लाइंट-साइड हिस्ट्री रिप्ले के बजाय previous_interaction_id पर भरोसा करें। आपको हर उस टर्न पर अपने tools, system_instruction, और generation_config फिर से निर्दिष्ट करने होंगे जहाँ वे मायने रखते हैं।

Google अधिकृत संस्करण Gemini API मॉडल डॉक्यूमेंट्स में प्रकाशित करता है, जिसमें एक स्वचालित पथ भी शामिल है यदि आपका कोडिंग एजेंट स्किल्स सपोर्ट करता है। फिर भी, इसे एक बार स्वयं पढ़ें; एक स्वचालित माइग्रेशन आपको नहीं बताएगा कि आपका temperature=0.2 पहली जगह पर क्यों था।

प्रोडक्शन में आपको मिलने वाली त्रुटियाँ

यहाँ 4 स्टेटस कोड हैं जिनके लिए हैंडलर्स वायर करना सार्थक है, और इस API पर प्रत्येक का वास्तविक मतलब क्या है:

2 और बातें यहाँ:

• thinking_level: "high" को लंबे टूल लूप्स के साथ मिलाते समय स्पष्ट क्लाइंट टाइमआउट सेट करें, क्योंकि एक अटका अनुरोध विफल अनुरोध से बदतर है, और 3.8 की अतिरिक्त मेहनत लंबे रीज़निंग रन को कम नहीं, बल्कि अधिक संभावित बनाती है। 

• और हर रिक्वेस्ट के साथ interaction.id लॉग करें; यह स्टोर की गई इंटरैक्शन्स को बाद में प्राप्त करने, डिबग करने, या डिलीट करने के लिए आपका हैंडल है।

अंतिम विचार

इस लेख की हर चीज़ 3 बदलावों पर वापस आती है। Interactions API ने कॉलिंग कन्वेंशन बदला, thinking_level ने हर सैंपलिंग नॉब की जगह ले ली जिसे आप ट्यून करते थे, और सर्वर-साइड स्टेट previous_interaction_id के माध्यम से ही था जिसने PDF फ़ॉलो-अप और टूल लूप को हिस्ट्री-रिप्ले अभ्यासों के बजाय 1-लाइनर टर्न्स बना दिया। Gemini 3.8 Flash ने उस सतह में कुछ नहीं बदला; जो बदला वह यह है कि मॉडल उसके अंदर कितनी मेहनत करता है, इसलिए इस लेख में माप 3.7 से उठा कर नहीं, 3.8 पर ताज़ा लिए गए।

मेरी स्तर सिफारिशों पर भरोसा करने से पहले, तुलना स्क्रिप्ट को अपने ही बैकलॉग के किसी टास्क पर चलाएँ; जो स्तर payment-retry रेस पर जीतता है, वह आपके SQL जेनरेशन वर्कलोड पर हार सकता है। 

जब एकल API कॉल पर्याप्त होना बंद हो जाएँ, और आप प्रोडक्शन AI सिस्टम चाहते हों, तो हमारा Associate AI Engineer for Developers ट्रैक पूरा पाथ कवर करता है, और Associate AI Engineer for Data Scientists ट्रैक डेटा पक्ष से यही करता है।