AI एजेंट्स बनानामध्यमपाठ 1967 मिनट का पाठ

कोड में एजेंट लूप

एक एजेंट एक लूप होता है: मॉडल देखता है, फ़ैसला करता है, काम करता है, और फिर से देखता है। Python के लगभग 30 लाइनों में यह लूप खुद लिखें, स्टॉप कंडीशन्स और स्टेप लिमिट के साथ।

पाठ वीडियो में

60 सेकंड में

कोड में एजेंट लूप

एक एजेंट एक लूप होता है: मॉडल देखता है, फ़ैसला करता है, काम करता है, और फिर से देखता है। Python के लगभग 30 लाइनों में यह लूप खुद लिखें, स्टॉप कंडीशन्स और स्टेप लिमिट के साथ।

1/5
आसान शब्दों में
पहली बार डोसा बनाने वाले किसी रसोइए के बारे में सोचें। वह तवे को देखती है, फ़ैसला करती है "बहुत गरम है", आंच धीमी करती है, और फिर से देखती है। वह तब तक करती रहती है जब तक डोसा बन न जाए, या जब तक वह हार मानकर खाना ऑर्डर न कर दे। एक एजेंट भी इसी तरह काम करता है: देखना, फ़ैसला करना, काम करना, फिर देखना, और सही समय पर रुक जाना।
आप चैटबॉट से एजेंट तक से पहले ही जानते हैं कि एजेंट का मतलब है: मॉडल प्लस एक लक्ष्य, टूल्स, मेमोरी और एक लूप। यह पाठ खुद उस लूप के बारे में है। ज़्यादातर एजेंट फ्रेमवर्क इसे छिपा देते हैं, लेकिन इसका मुख्य हिस्सा बहुत छोटा होता है। एक बार जब आप इसे खुद लिख लेते हैं, तो हर फ्रेमवर्क को समझना और डिबग करना आसान हो जाता है।

तीन कदम, बार-बार

  1. 1

    Observe (देखें)

    एजेंट अभी जो जानता है उसे इकट्ठा करें: काम (टास्क), पिछले मैसेज और टूल का ताज़ा रिज़ल्ट।
  2. 2

    Think (सोचें)

    यह सब मॉडल को भेजें। वह या तो किसी टूल कॉल के साथ जवाब देता है या फिर कोई फ़ाइनल जवाब देता है।
  3. 3

    Act (काम करें)

    अगर उसने किसी टूल के लिए कहा है, तो आपका कोड उस टूल को चलाता है और उसके रिज़ल्ट को मैसेजेस में जोड़ देता है।
  4. 4

    स्टॉप कंडीशन्स चेक करें

    फ़ाइनल जवाब मिल गया? स्टेप लिमिट पूरी हो गई? कोई ऐसी गड़बड़ी (एरर) जो ठीक नहीं हो सकती? अगर नहीं, तो वापस Observe पर जाएं।
ध्यान दें कि कौन क्या करता है। मॉडल सिर्फ़ टेक्स्ट लिखता है: एक रिक्वेस्ट जैसे "get_weather को city Chennai के साथ कॉल करो"। आपका कोड यह तय करता है कि इसे चलाना है या नहीं, इसे चलाता है, और तय करता है कि कब रुकना है। एजेंट बनाने में यह बंटवारा सबसे ज़रूरी विचार है।

एक पूरा लूप जिसे आप ऑफ़लाइन चला सकते हैं

नीचे दिया गया मॉडल फ़ेक (नकली) है, इसलिए कोड बिना किसी API key के चलता है। यह हमेशा मौसम के बारे में पूछता है, फिर जवाब देता है। एक असली एजेंट में आप call_model() की जगह टूल्स इनेबल करके अपने प्रोवाइडर की चैट API कॉल लगाते हैं, और उसके रिप्लाई को इसी तरह की एक छोटी डिक्शनरी में बदल देते हैं।
agent_loop.py: observe, think, act, with a step limitpython
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) के साथ तीन बार फ़ेल होती है, तो वह चौथी बार भी काम नहीं करेगी।
जोखिम भरे काम के लिए मंज़ूरी चाहिएसीधे काम करने के बजाय रुकें और किसी इंसान से पूछें (देखें इंसान को लूप में रखना)।
नोट
जब लूप समय से पहले रुक जाए, तो साफ़-साफ़ बताएं। किसी मनगढ़ंत जवाब की तुलना में "Stopped: step limit reached" यूज़र के लिए और डिबग करते समय आपके लिए कहीं ज़्यादा काम का होता है।

एरर वापस मॉडल के पास जाते हैं

ऊपर दिए गए कोड में, किसी टूल के क्रैश होने से एजेंट क्रैश नहीं होता। एरर एक टूल रिज़ल्ट बन जाता है, और मॉडल इसे अगले स्टेप पर देखता है। अक्सर यह समस्या को खुद ही ठीक कर सकता है, उदाहरण के लिए शहर की कोई दूसरी स्पेलिंग आज़माकर। केवल तभी रुकें जब यह साफ़ हो कि एरर को मॉडल द्वारा ठीक नहीं किया जा सकता।
एक कमज़ोर लूप
  • कोई स्टेप लिमिट नहीं: while True
  • टूल का एक एक्सेप्शन पूरे रन को क्रैश कर देता है
  • मॉडल के टूल के नाम पर भरोसा करके उसे सीधे कॉल कर लिया जाता है
  • चुपचाप रुक जाता है और कुछ भी नहीं लौटाता
एक मज़बूत लूप
  • एक स्टेप लिमिट और एक बजट लिमिट
  • टूल एरर पढ़ने लायक टूल रिज़ल्ट बन जाते हैं
  • सिर्फ़ आपकी TOOLS टेबल वाले नाम ही चल सकते हैं
  • हर स्टॉप की एक साफ़ वजह होती है
सावधान रहें
टूल के रिज़ल्ट बाहरी दुनिया से आते हैं, इसलिए उन पर भरोसा नहीं किया जा सकता। टूल से लौटाया गया कोई वेब पेज या ईमेल मॉडल के लिए निर्देश रख सकता है। ऊपर दिया गया लूप रिज़ल्ट्स को tool मैसेजेस के रूप में जोड़ता है, सिस्टम निर्देशों के रूप में कभी नहीं। देखें इनडायरेक्ट इंजेक्शन: अदृश्य नोट।
इसे आज़माएं। फ़ेक मॉडल को बदलें ताकि वह हर बार "Mumbai" के मौसम के बारे में पूछे और कभी जवाब न दे। इसे चलाएं। कौन सी स्टॉप कंडीशन आपको बचाती है?

और देखें और पढ़ें

लैब

एक छोटा एजेंट जो बिना किसी API key के फ़ेक मॉडल और फ़ेक ट्रेन-स्टेटस टूल के साथ ऑफ़लाइन चलता है, तीन स्टॉप कंडीशन्स के साथ।

~30 min

समस्या

एक छोटा एजेंट बनाएं जो बिना किसी API key के "क्या ट्रेन 12345 लेट चल रही है?" जैसे सवालों के जवाब देता हो।

  1. स्टार्टर कोड कॉपी करें। इसमें एक फ़ेक train_status टूल और एक फ़ेक मॉडल है।
  2. run_agent पूरा करें: मॉडल को कॉल करें, अगर कहा जाए तो टूल चलाएं, रिज़ल्ट को एक tool मैसेज के रूप में जोड़ें, और फ़ाइनल जवाब लौटाएं।
  3. तीन स्टॉप कंडीशन्स जोड़ें: फ़ाइनल जवाब, max_steps, और "वही टूल कॉल उन्हीं arguments के साथ 3 बार हुई"।
  4. तीन मामलों की जांच करें: एक पहचानी हुई ट्रेन, एक अनजान ट्रेन (टूल एरर लौटाता है), और एक फ़ेक मॉडल जो हमेशा के लिए लूप करता रहता है। हर रन के रुकने का कारण प्रिंट करें।

प्रैक्टिस लैब

कोड में बदलाव करें और इसे रन करें। Python आपके ब्राउज़र में चलता है — हमारे सर्वर पर कुछ नहीं भेजा जाता।

आउटपुट

कोई आउटपुट नहीं। वैल्यूज़ देखने के लिए print(...) जोड़ें।

आपका काम तब पूरा होगा जब

कठिन सवाल

उत्तर देखने से पहले ख़ुद जवाब देने की कोशिश करें। अगर आप इनके जवाब दे सकते हैं, तो आप पाठ समझ गए हैं।

Q1आपकी स्टेप लिमिट 10 है, लेकिन एक स्टेप में टोकन की संख्या बहुत अलग हो सकती है। लागत को कंट्रोल करने के लिए सिर्फ़ स्टेप लिमिट ही काफ़ी क्यों नहीं है?दिखाएं

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

Q2"वही टूल तीन बार" की तुलना में "वही कॉल तीन बार" लूप पकड़ने का बेहतर तरीका क्यों है?दिखाएं

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

जारी रखने के लिए कृपया साइन इन करें।

अक्सर पूछे जाने वाले सवाल

क्या एजेंट बनाने के लिए मुझे किसी फ्रेमवर्क की ज़रूरत है?

नहीं। एक बेसिक एजेंट का मतलब लूप, एक मॉडल कॉल और टूल्स की एक टेबल है, जैसा कि आपने देखा। फ्रेमवर्क उपयोगी चीज़ें जोड़ते हैं जैसे ट्रेसिंग, री-ट्राई और कई रेडीमेड टूल्स। लूप को एक बार खुद लिखें, ताकि आप समझ सकें कि फ्रेमवर्क आपके लिए क्या करता है।

असली APIs किसी टूल कॉल को कैसे लौटाती हैं?

टूल या फ़ंक्शन कॉलिंग वाली ज़्यादातर चैट APIs रिप्लाई में एक स्ट्रक्चर्ड हिस्सा लौटाती हैं: टूल का नाम और JSON के रूप में arguments, अक्सर एक id के साथ। आप टूल रिज़ल्ट को उसी id के साथ वापस भेजते हैं। प्रोवाइडर के हिसाब से सटीक फ़ॉर्मेट अलग होता है, इसलिए अपने प्रोवाइडर के मौजूदा डॉक्स देखें और इसे ऊपर दी गई डिक्शनरी जैसे एक आसान आकार में बदल लें।

max_steps की अच्छी वैल्यू क्या है?

यह काम पर निर्भर करता है। अपने एजेंट को असली कामों पर चलाएं, देखें कि सफल रनों में कितने स्टेप्स लगते हैं, और लिमिट को उससे थोड़ा ऊपर सेट करें। एक आसान खोज (lookup) के लिए 3 से 5 स्टेप्स की ज़रूरत हो सकती है; एक लंबे रिसर्च वाले काम के लिए और ज़्यादा लग सकते हैं। एक बजट लिमिट भी जोड़ें, क्योंकि स्टेप्स के खर्च में बहुत अंतर हो सकता है।

क्या मॉडल किसी ऐसे टूल को कॉल कर सकता है जो मेरी लिस्ट में नहीं है?

वह मनगढ़ंत नामों समेत कोई भी नाम लिख सकता है। इसीलिए आपका कोड उस नाम को आपकी अपनी टेबल से मिलाता है और किसी भी अन्य चीज़ के लिए एरर लौटाता है। मॉडल कभी भी सीधे कोड नहीं चलाता।

पाठ का टेस्ट

5 सवाल। पास होने और इस पाठ को पूरा करने के लिए 3 सही होने चाहिए (60%)।

टेस्ट देने और अपनी प्रोग्रेस सेव करने के लिए साइन इन करें