कोड में एजेंट लूप
एक एजेंट एक लूप होता है: मॉडल देखता है, फ़ैसला करता है, काम करता है, और फिर से देखता है। Python के लगभग 30 लाइनों में यह लूप खुद लिखें, स्टॉप कंडीशन्स और स्टेप लिमिट के साथ।
60 सेकंड में
कोड में एजेंट लूप
एक एजेंट एक लूप होता है: मॉडल देखता है, फ़ैसला करता है, काम करता है, और फिर से देखता है। Python के लगभग 30 लाइनों में यह लूप खुद लिखें, स्टॉप कंडीशन्स और स्टेप लिमिट के साथ।
तीन कदम, बार-बार
- 1
Observe (देखें)
एजेंट अभी जो जानता है उसे इकट्ठा करें: काम (टास्क), पिछले मैसेज और टूल का ताज़ा रिज़ल्ट। - 2
Think (सोचें)
यह सब मॉडल को भेजें। वह या तो किसी टूल कॉल के साथ जवाब देता है या फिर कोई फ़ाइनल जवाब देता है। - 3
Act (काम करें)
अगर उसने किसी टूल के लिए कहा है, तो आपका कोड उस टूल को चलाता है और उसके रिज़ल्ट को मैसेजेस में जोड़ देता है। - 4
स्टॉप कंडीशन्स चेक करें
फ़ाइनल जवाब मिल गया? स्टेप लिमिट पूरी हो गई? कोई ऐसी गड़बड़ी (एरर) जो ठीक नहीं हो सकती? अगर नहीं, तो वापस Observe पर जाएं।
एक पूरा लूप जिसे आप ऑफ़लाइन चला सकते हैं
call_model() की जगह टूल्स इनेबल करके अपने प्रोवाइडर की चैट API कॉल लगाते हैं, और उसके रिप्लाई को इसी तरह की एक छोटी डिक्शनरी में बदल देते हैं।def get_weather(city: str) -> str:
fake = {"Chennai": "34 C and humid", "Shimla": "12 C and clear"}
return fake.get(city, "error: unknown city " + city)
TOOLS = {"get_weather": get_weather}
def call_model(messages: list) -> dict:
# Placeholder model. Plug in your provider here and convert its reply to
# {"tool": name, "args": {...}} or {"answer": text}.
last = messages[-1]
if last["role"] == "user":
return {"tool": "get_weather", "args": {"city": "Chennai"}}
return {"answer": "It is " + last["content"] + " in Chennai. Carry water."}
def run_agent(task: str, max_steps: int = 5) -> str:
messages = [{"role": "user", "content": task}]
for step in range(max_steps):
reply = call_model(messages) # think
if "answer" in reply: # stop: model is done
return reply["answer"]
name, args = reply.get("tool"), reply.get("args", {})
if name not in TOOLS:
result = "error: there is no tool called " + str(name)
else:
try:
result = TOOLS[name](**args) # act
except Exception as err:
result = "error: " + str(err)
messages.append({"role": "tool", "content": result}) # observe
return "Stopped: reached the step limit without an answer."
print(run_agent("Do I need to carry water in Chennai today?"))स्टॉप कंडीशन्स: वह हिस्सा जिसे लोग भूल जाते हैं
| स्टॉप कंडीशन | आपको इसकी ज़रूरत क्यों है |
|---|---|
| मॉडल फ़ाइनल जवाब दे देता है | सामान्य, सुखद अंत। |
| स्टेप लिमिट (max steps) | बेकाबू लूप्स को रोकता है। कोई भी अंदाज़ा लगाने के बजाय असली टेस्ट्स से एक नंबर चुनें। |
| बजट लिमिट (टोकन, पैसे या समय) | किसी एक काम को ज़रूरत से कहीं ज़्यादा खर्च करने से रोकता है। |
| लगातार एक जैसी टूल कॉल | अगर वही कॉल उन्हीं तर्कों (arguments) के साथ तीन बार फ़ेल होती है, तो वह चौथी बार भी काम नहीं करेगी। |
| जोखिम भरे काम के लिए मंज़ूरी चाहिए | सीधे काम करने के बजाय रुकें और किसी इंसान से पूछें (देखें इंसान को लूप में रखना)। |
एरर वापस मॉडल के पास जाते हैं
- कोई स्टेप लिमिट नहीं:
while True - टूल का एक एक्सेप्शन पूरे रन को क्रैश कर देता है
- मॉडल के टूल के नाम पर भरोसा करके उसे सीधे कॉल कर लिया जाता है
- चुपचाप रुक जाता है और कुछ भी नहीं लौटाता
- एक स्टेप लिमिट और एक बजट लिमिट
- टूल एरर पढ़ने लायक टूल रिज़ल्ट बन जाते हैं
- सिर्फ़ आपकी
TOOLSटेबल वाले नाम ही चल सकते हैं - हर स्टॉप की एक साफ़ वजह होती है
tool मैसेजेस के रूप में जोड़ता है, सिस्टम निर्देशों के रूप में कभी नहीं। देखें इनडायरेक्ट इंजेक्शन: अदृश्य नोट।और देखें और पढ़ें
लैब
एक छोटा एजेंट जो बिना किसी API key के फ़ेक मॉडल और फ़ेक ट्रेन-स्टेटस टूल के साथ ऑफ़लाइन चलता है, तीन स्टॉप कंडीशन्स के साथ।
समस्या
एक छोटा एजेंट बनाएं जो बिना किसी API key के "क्या ट्रेन 12345 लेट चल रही है?" जैसे सवालों के जवाब देता हो।
- स्टार्टर कोड कॉपी करें। इसमें एक फ़ेक
train_statusटूल और एक फ़ेक मॉडल है। run_agentपूरा करें: मॉडल को कॉल करें, अगर कहा जाए तो टूल चलाएं, रिज़ल्ट को एकtoolमैसेज के रूप में जोड़ें, और फ़ाइनल जवाब लौटाएं।- तीन स्टॉप कंडीशन्स जोड़ें: फ़ाइनल जवाब,
max_steps, और "वही टूल कॉल उन्हीं arguments के साथ 3 बार हुई"। - तीन मामलों की जांच करें: एक पहचानी हुई ट्रेन, एक अनजान ट्रेन (टूल एरर लौटाता है), और एक फ़ेक मॉडल जो हमेशा के लिए लूप करता रहता है। हर रन के रुकने का कारण प्रिंट करें।
प्रैक्टिस लैब
कोड में बदलाव करें और इसे रन करें। Python आपके ब्राउज़र में चलता है — हमारे सर्वर पर कुछ नहीं भेजा जाता।
कोई आउटपुट नहीं। वैल्यूज़ देखने के लिए print(...) जोड़ें।
आपका काम तब पूरा होगा जब
कठिन सवाल
उत्तर देखने से पहले ख़ुद जवाब देने की कोशिश करें। अगर आप इनके जवाब दे सकते हैं, तो आप पाठ समझ गए हैं।
Q1आपकी स्टेप लिमिट 10 है, लेकिन एक स्टेप में टोकन की संख्या बहुत अलग हो सकती है। लागत को कंट्रोल करने के लिए सिर्फ़ स्टेप लिमिट ही काफ़ी क्यों नहीं है?दिखाएं
एक स्टेप छोटी कॉल हो सकती है, और दूसरे में बहुत बड़ा टूल रिज़ल्ट (एक लंबा वेब पेज या फ़ाइल) शामिल हो सकता है जो कॉन्टेक्स्ट को भर देता है। इसके बाद के स्टेप्स फिर वह सारा टेक्स्ट दोबारा भेजते हैं। इसलिए लागत केवल स्टेप्स की संख्या से नहीं, बल्कि कॉन्टेक्स्ट के साइज़ के साथ बढ़ती है। हर काम के लिए एक टोकन या पैसे का बजट जोड़ें और बड़े टूल रिज़ल्ट्स को छांटें या उनका सारांश बनाएं।
Q2"वही टूल तीन बार" की तुलना में "वही कॉल तीन बार" लूप पकड़ने का बेहतर तरीका क्यों है?दिखाएं
अलग-अलग arguments के साथ एक ही टूल को कई बार कॉल करना अक्सर सामान्य काम होता है, उदाहरण के लिए तीन ट्रेनों की जांच करना। इसे एक जैसे arguments के साथ कॉल करना और वही एरर मिलना यह दिखाता है कि एजेंट अटक गया है। पूरी कॉल की तुलना करने से अच्छे रन रुकने से बचते हैं और लूप्स भी पकड़ में आ जाते हैं।
अक्सर पूछे जाने वाले सवाल
क्या एजेंट बनाने के लिए मुझे किसी फ्रेमवर्क की ज़रूरत है?
नहीं। एक बेसिक एजेंट का मतलब लूप, एक मॉडल कॉल और टूल्स की एक टेबल है, जैसा कि आपने देखा। फ्रेमवर्क उपयोगी चीज़ें जोड़ते हैं जैसे ट्रेसिंग, री-ट्राई और कई रेडीमेड टूल्स। लूप को एक बार खुद लिखें, ताकि आप समझ सकें कि फ्रेमवर्क आपके लिए क्या करता है।
असली APIs किसी टूल कॉल को कैसे लौटाती हैं?
टूल या फ़ंक्शन कॉलिंग वाली ज़्यादातर चैट APIs रिप्लाई में एक स्ट्रक्चर्ड हिस्सा लौटाती हैं: टूल का नाम और JSON के रूप में arguments, अक्सर एक id के साथ। आप टूल रिज़ल्ट को उसी id के साथ वापस भेजते हैं। प्रोवाइडर के हिसाब से सटीक फ़ॉर्मेट अलग होता है, इसलिए अपने प्रोवाइडर के मौजूदा डॉक्स देखें और इसे ऊपर दी गई डिक्शनरी जैसे एक आसान आकार में बदल लें।
max_steps की अच्छी वैल्यू क्या है?
यह काम पर निर्भर करता है। अपने एजेंट को असली कामों पर चलाएं, देखें कि सफल रनों में कितने स्टेप्स लगते हैं, और लिमिट को उससे थोड़ा ऊपर सेट करें। एक आसान खोज (lookup) के लिए 3 से 5 स्टेप्स की ज़रूरत हो सकती है; एक लंबे रिसर्च वाले काम के लिए और ज़्यादा लग सकते हैं। एक बजट लिमिट भी जोड़ें, क्योंकि स्टेप्स के खर्च में बहुत अंतर हो सकता है।
क्या मॉडल किसी ऐसे टूल को कॉल कर सकता है जो मेरी लिस्ट में नहीं है?
वह मनगढ़ंत नामों समेत कोई भी नाम लिख सकता है। इसीलिए आपका कोड उस नाम को आपकी अपनी टेबल से मिलाता है और किसी भी अन्य चीज़ के लिए एरर लौटाता है। मॉडल कभी भी सीधे कोड नहीं चलाता।
पाठ का टेस्ट
5 सवाल। पास होने और इस पाठ को पूरा करने के लिए 3 सही होने चाहिए (60%)।