Gemini 3 में Agentic Vision: एक हैंड्स-ऑन ट्यूटोरियल

आप किसी vision API को एक छवि भेजते हैं और उससे छोटे प्राइस लेबल को पढ़ने के लिए कहते हैं। जवाब आत्मविश्वास से भरा आता है—और गलत। बिखरी हुई वस्तुओं की गिनती भी यही कहानी: मॉडल पूरी छवि पर एक नज़र डालता है और संख्या का ऐसा अनुमान लगाता है जो वास्तविकता से बहुत दूर है।

Gemini 3 Flash इसे अलग तरह से संभालता है। कोड निष्पादन चालू होने पर, यह उत्तर के बीच में ही Python लिख और चला सकता है—ताकि अंतिम उत्तर देने से पहले छवियों को क्रॉप, ज़ूम और एनोटेट कर सके। Google इसे agentic vision कहता है और vision बेंचमार्क्स पर 5–10% गुणवत्ता सुधार रिपोर्ट करता है।

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

Agentic Vision क्या है? "Think, Act, Observe" लूप

विचार सरल है। कोड निष्पादन सक्रिय होने पर, Gemini 3 उत्तर के बीच रुक सकता है, सैंडबॉक्स में Python लिख और चला सकता है, कोड ने क्या निकाला उसे देख सकता है, और अगला कदम तय कर सकता है। 

विज़न कार्यों में, इसका मतलब अक्सर होता है कि मॉडल छवि के हिस्सों को काट रहा है, उन्हें बड़ा कर रहा है, बॉन्डिंग बॉक्स बना रहा है, या कंट्रास्ट समायोजित कर रहा है ताकि वे विवरण निकाले जा सकें जो मूल रेज़ोल्यूशन पर नजर नहीं आते।

यह तीन-चरणीय लूप के रूप में चलता है।

Think चरण में, मॉडल यह देखता है कि उसके पास क्या है (मूल छवि, या उसकी कोई क्रॉप/एनोटेटेड प्रति) और अगली चाल की योजना बनाता है। वह तय कर सकता है कि प्राइस लेबल पढ़ने के लिए बहुत छोटा है और उसे क्रॉप व बड़ा करने की ज़रूरत है।

Act उस योजना को Python में बदल देता है। सैंडबॉक्स में पहले से 43 लाइब्रेरीज़ (PIL, OpenCV, matplotlib, आदि) मौजूद हैं, इसलिए मॉडल ज़रूरत के मुताबिक कोई भी इमेज प्रोसेसिंग कोड लिख सकता है।

कोड चलने के बाद, Observe लूप को बंद करता है। आउटपुट (नई छवियां, प्रिंटेड टेक्स्ट, गणना किए गए मान) फिर संदर्भ में लौट आते हैं। वहां से, मॉडल या तो उत्तर दे देता है या फिर से लूप में चला जाता है।

एक ही API कॉल इस लूप से कई बार गुजर सकता है। आगे के उदाहरणों में, आप देखेंगे कि यह एक अनुरोध में शेल्फ के सात हिस्से क्रॉप करता है। एक अन्य में, यह pandas DataFrame में टेबल डेटा निकालता है और उसी कॉल के भीतर एक बार चार्ट बनाता है। 

यदि agentic लूप की अवधारणा आपके लिए नई है, तो DataCamp का AI Agent Fundamentals ट्रैक इसे विस्तार से कवर करता है।

सीमाएँ और दायरे

• कोड निष्पादन और कस्टम फ़ंक्शन कॉलिंग एक ही अनुरोध में साथ नहीं चल सकते।
• Google के दस्तावेज़ चेतावनी देते हैं कि कोड निष्पादन गैर-विज़ुअल कार्यों पर प्रदर्शन घटा सकता है। इसे तभी चालू करें जब कार्य को इमेज मैनिपुलेशन से लाभ हो।
• पिक्सेल-स्तरीय सेगमेंटेशन (मास्क, कंटूर) agentic vision का हिस्सा नहीं है और Gemini 2.5 पर रहता है।
• कभी-कभी मॉडल एक नज़र पर्याप्त होने पर कोड निष्पादन छोड़ देता है। यह डिज़ाइन के अनुसार है, बग नहीं।

Agentic Vision के लिए अपना वातावरण तैयार करना

API कुंजी यहाँ से लें ai.google.dev और उसे अपने environment या .env फ़ाइल में GOOGLE_API_KEY के रूप में सहेजें। फिर SDK और इमेज लाइब्रेरीज़ इंस्टॉल करें:

pip install google-genai python-dotenv Pillow matplotlib opencv-python

क्लाइंट बनाकर शुरू करें:

from google import genai
from google.genai import types
from dotenv import load_dotenv
 
load_dotenv()
 
client = genai.Client(
    http_options=types.HttpOptions(timeout=600_000)
)
MODEL = "gemini-3-flash-preview"

यह timeout=600_000 मायने रखता है। Agentic vision कॉल्स में सैंडबॉक्स के अंदर कोड जनरेशन और निष्पादन के कई दौर होते हैं, और एक अनुरोध को लगभग चार मिनट लग सकते हैं। 

डिफ़ॉल्ट httpx टाइमआउट उससे पहले ही कनेक्शन मार देगा, जिससे आपके पास चुपचाप होने वाला ReadTimeout रह जाएगा और अंदाज़ा नहीं लगेगा कि क्या हुआ।

अब agentic कॉन्फ़िग सेट करें:

agentic_config = types.GenerateContentConfig(
    tools=[types.Tool(code_execution=types.ToolCodeExecution())],
	thinking_config=types.ThinkingConfig(
    	thinking_level="HIGH",
    	include_thoughts=True
	),
    media_resolution=types.MediaResolution.MEDIA_RESOLUTION_HIGH,
)

tools कोड निष्पादन का ऑन-स्विच है। यह मॉडल को 43 लाइब्रेरीज़ (numpy, pandas, PIL, matplotlib, OpenCV, आदि) वाली सैंडबॉक्स्ड Python environment देता है। हर कोड ब्लॉक को चलने के लिए 30 सेकंड मिलते हैं, और सैंडबॉक्स त्रुटियों पर अधिकतम 5 बार रीट्राइ करता है।

thinking_level="HIGH" मॉडल को कोड लिखने से पहले योजना बनाने के लिए अधिक स्वतंत्रता देता है। मल्टी-स्टेप विज़न कार्यों के लिए यह ध्यान देने योग्य फर्क लाता है। include_thoughts=True सेट करने से प्रतिक्रिया के पार्ट्स में वही तर्क दिखाई देता है, जो डिबगिंग में काम आता है।

media_resolution यह तय करता है कि लूप शुरू होने से पहले इनपुट इमेज को कितने टोकन्स मिलते हैं। MEDIA_RESOLUTION_HIGH अच्छा डिफ़ॉल्ट है। बहुत सघन छवियों के लिए आप इसे MEDIA_RESOLUTION_ULTRA_HIGH तक बढ़ा सकते हैं, या जब गति विवरण से अधिक मायने रखती हो तो MEDIA_RESOLUTION_LOW पर ला सकते हैं।

यही सेटअप थोड़े बदलावों के साथ Vertex AI पर भी काम करता है। विज़न से परे Gemini 3 API का व्यापक वॉकथ्रू देखने के लिए साथ वाला ट्यूटोरियल देखें।

Gemini 3 में Agentic Vision: क्रॉप और ज़ूम से सूक्ष्म विवरण पढ़ना

नीचे की छवि एक जर्मन किराना स्टोर की शेल्फ है जिसमें तीन पंक्तियों में प्रोडक्ट्स हैं। हर शेल्फ किनारे पर प्राइस लेबल लगे हैं, और नीचे की ओर "Liebe Kunden" (प्रिय ग्राहक) का नोटिस है। आप खुद ज़ूम करें तो लेबल पढ़े जा सकते हैं, लेकिन वे इतने छोटे हैं कि पूरी छवि को एक साथ देखने वाला मॉडल तय करता है कि वह क्या पढ़ सकता है और क्या नहीं।

मल्टी-पार्ट प्रतिक्रिया को पार्स करना

Agentic प्रतिक्रियाएँ एकल टेक्स्ट ब्लॉक नहीं होतीं। वे हिस्सों की सूची के रूप में आती हैं: सोच, मॉडल द्वारा लिखा कोड, निष्पादन परिणाम, जेनरेट की गई छवियाँ, और अंतिम उत्तर। यह हेल्पर उन्हें क्रम से पढ़ता है:

def print_response(response, show_thoughts=False):
	for part in response.candidates[0].content.parts:
    	if part.thought and show_thoughts:
        	print("[THINK]", part.text[:500])
    	elif part.executable_code:
        	print("[CODE]")
        	print(part.executable_code.code)
    	elif part.code_execution_result:
        	print(f"[RESULT] ({part.code_execution_result.outcome})")
            print(part.code_execution_result.output)
    	elif part.inline_data:
        	print(f"[IMAGE] {part.inline_data.mime_type}, "
                  f"{len(part.inline_data.data):,} bytes")
    	elif part.text:
        	print("[ANSWER]", part.text)

इस ट्यूटोरियल के हर उदाहरण में यही फ़ंक्शन उपयोग होता है, इसलिए इसे एक बार परिभाषित करें और दोबारा उपयोग करें।

अब शेल्फ इमेज लोड करें और ऐसा प्रॉम्प्ट लिखें जो मॉडल से साइन पढ़ने और हर प्रोडक्ट को उसकी कीमत सहित सूचीबद्ध करने के लिए कहे।

from pathlib import Path
 
image_path = Path("images/grocery_shelf.jpg")
image_part = types.Part.from_bytes(
	data=image_path.read_bytes(), mime_type="image/jpeg"
)
 
prompt = (
	"Read the 'Liebe Kunden' sign at the bottom of the shelf. "
	"What does it say? Also list all visible product names "
	"and their prices from the shelf labels."
)

पहले इसे कोड निष्पादन के बिना चलाएँ:

standard_config = types.GenerateContentConfig(
    media_resolution=types.MediaResolution.MEDIA_RESOLUTION_HIGH,
)
 
standard_response = client.models.generate_content(
	model=MODEL,
	contents=[image_part, prompt],
	config=standard_config,
)
print_response(standard_response)

आउटपुट का संक्षिप्त संस्करण यह है:

[ANSWER] Based on the image provided, here is the information requested:
 
### The 'Liebe Kunden' Sign
> "Dear Customers, unfortunately, we must inform you that due to
> increased demand, we cannot currently offer all products..."
 
### Product Names and Prices (from shelf labels)
 
**Top Row Labels:**
*   Uncle Ben's Express Reis Mexi-Scharf 250g: 1,69
*   Uncle Ben's Express Reis Griechisch 250g: 1,69
*   Uncle Ben's Express Reis Curry 250g: 1,69
*   Channa Masala 300g (partially obscured): 2,49
*   (Label obscured): 2,49
*   (Label obscured): 1,29
*   (Label obscured): 0,99
...
 
**Second Row Labels:**
*   Uncle Ben's Express Reis Chili con Carne 250g: 2,49
*   Uncle Ben's Spitzen-Langkorn Reis 10 Min 500g: 1,79
*   (Label obscured): 2,99
*   (Label obscured): 2,79
...

साइन का अनुवाद सही है, और मॉडल Uncle Ben’s के जो लेबल पहचान सकता है उन्हें पढ़ लेता है। लेकिन लगभग एक-तिहाई प्रविष्टियाँ "(Label obscured)" हैं, और Oryza, Reis-fit, तथा Reiskugeln जैसे ब्रांड बिल्कुल नहीं दिखते।

अब वही प्रॉम्प्ट agentic कॉन्फ़िग के साथ:

agentic_response = client.models.generate_content(
	model=MODEL,
	contents=[image_part, prompt],
	config=agentic_config,
)
print_response(agentic_response, show_thoughts=True)

आउटपुट संरचना अलग है। एकल [ANSWER] की बजाय यह पूरा Think/Act/Observe लूप दिखाता है:

[THINK] Okay, so the primary goal here is twofold: First, I need to
decipher that "Liebe Kunden" sign down there. Then, I need to build a
comprehensive list of what's on this shelf...
 
[CODE]
import PIL.Image
 
img = PIL.Image.open('input_file_0.jpeg')
width, height = img.size
 
crops = [
	{'box_2d': [630, 447, 887, 559], 'label': 'liebe_kunden_sign'},
	{'box_2d': [80, 40, 240, 560], 'label': 'shelf1_left'},
	{'box_2d': [190, 550, 310, 980], 'label': 'shelf1_right'},
	{'box_2d': [400, 0, 480, 450], 'label': 'shelf2_left'},
	{'box_2d': [410, 450, 480, 1000], 'label': 'shelf2_right'},
	{'box_2d': [630, 130, 760, 460], 'label': 'shelf3_left'},
	{'box_2d': [550, 600, 660, 990], 'label': 'shelf3_right'},
]
# ... crops and saves each region
 
[IMAGE] image/png, 135,953 bytes
[IMAGE] image/png, 90,395 bytes
[IMAGE] image/png, 125,816 bytes
[IMAGE] image/png, 102,288 bytes
[IMAGE] image/png, 173,606 bytes
[IMAGE] image/png, 283,263 bytes
[IMAGE] image/png, 100,522 bytes

मॉडल द्वारा जेनरेट किए गए ये सात क्रॉप्स:

इन क्रॉप्स को देखने के बाद, मॉडल पूरा उत्तर देता है:

[ANSWER]
**Top Shelf (Left to Right):**
*   Uncle Ben's Express Reis Mexi. Scharf 250g: 1,69 €
*   Channa Masala 285g: 2,49 €
*   Madras Curry 285g: 2,49 €
*   Steam Basmati Reis Kochbeutel 250g: 1,99 €
*   Reiskugeln Pur 4x2 St: 1,99 €
...
 
**Middle Shelf (Left to Right):**
*   Uncle Ben's Express Reis Chili con Carne 250g: 2,49 €
*   Oryza Langkorn & Wildreis 500g Kochbeutel: 2,99 €
*   Oryza Basmati & Wildreis 500g Kochbeutel: 2,79 €
*   Oryza Jasmin Reis 500g Kochbeutel: 2,79 €
...
 
**Bottom Shelf (Left to Right):**
*   Uncle Ben's Natur Reis 10-Min. Kochbeutel 1kg: 3,69 €
*   Reis-fit 10 Minuten Natur-Reis 500g: 1,89 €
*   Reis-fit Langkorn & Wildreis 500g: 1,89 €
...

दोनों कॉल्स का पूरा, बिना काटा हुआ आउटपुट यहाँ उपलब्ध है इस gist में।

Agentic प्रतिक्रिया तीनों शेल्फ़ पर 30+ प्रोडक्ट्स पढ़ लेती है। Oryza, Reis-fit, Madras Curry, Reiskugeln, और Steam Basmati जैसे आइटम, जिन्हें standard vision ने "(obscured)" कहा था, नाम और कीमत सहित दिखते हैं।

फर्क hallucination बनाम सटीकता का नहीं है; standard vision ईमानदारी से बताता है कि वह क्या नहीं पढ़ सकता। Agentic vision बस उस सीमा को नहीं मानता—और तब तक ज़ूम करता है जब तक पढ़ न ले।

यहाँ प्रॉम्प्ट की भी भूमिका है। मॉडल से "सभी दिखने वाले प्रोडक्ट नाम और उनकी कीमतें सूचीबद्ध करें" कहना एक पूर्णता का मानक तय करता है जो उसे क्रॉप की ओर धकेलता है। 

"इस छवि का वर्णन करें" जैसा अस्पष्ट प्रॉम्प्ट संभवतः कोड निष्पादन ऑन होने पर भी सिंगल-पास उत्तर देगा, क्योंकि मॉडल को आगे बढ़ने का कारण नज़र नहीं आता।