अपना पहला AI एजेंट कैसे बनाएँ: एक मॉडल, कुछ उपकरण, और एक लूप

"AI एजेंट" सुनने में ऐसा लगता है जैसे इसके लिए एक फ़्रेमवर्क, एक वेक्टर डेटाबेस, और एक पूरा वीकेंड सेटअप की ज़रूरत हो। ऐसा नहीं है। Anthropic की अपनी परिभाषा तरोताज़ा कर देने वाली छोटी है: एक एजेंट एक लूप में उपकरणों का स्वायत्त रूप से उपयोग करने वाला LLM है। एक बार जब आप यह पैटर्न देख लेते हैं, तो आप सौ से भी काफ़ी कम लाइनों के कोड में एक उपयोगी पहला एजेंट बना सकते हैं — और, उतना ही ज़रूरी, यह जान सकते हैं कि कब आपको ऐसा नहीं करना चाहिए।

मूल लूप

हर एजेंट, चाहे वह कितना भी आधुनिक हो, वही चार-चरणीय चक्र है:

1. आप मॉडल को एक लक्ष्य और उन उपकरणों की सूची देते हैं जिन्हें कॉल करने की उसे अनुमति है।
2. मॉडल तय करता है कि सीधे जवाब देना है या कोई उपकरण कॉल करना है।
3. आपका कोड उस उपकरण को चलाता है और परिणाम वापस मॉडल को देता है।
4. यह तब तक दोहराते रहें जब तक मॉडल यह न कह दे कि काम पूरा हो गया।

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

एक ठोस उदाहरण

यहाँ एक न्यूनतम एजेंट है जो एक कैलकुलेटर उपकरण का उपयोग करके सवालों के जवाब दे सकता है। जो मायने रखता है वह है संरचना — यही आकार फ़ाइल संपादन, वेब खोज, या डेटाबेस क्वेरी तक स्केल करता है।

import anthropic

client = anthropic.Anthropic()

tools = [{
    "name": "calculator",
    "description": "Evaluate a basic arithmetic expression and return the result.",
    "input_schema": {
        "type": "object",
        "properties": {"expression": {"type": "string"}},
        "required": ["expression"],
    },
}]

def run_tool(name, args):
    if name == "calculator":
        # In real code, use a safe parser, not eval()
        return str(eval(args["expression"], {"__builtins__": {}}))
    return "unknown tool"

messages = [{"role": "user", "content": "What is 1894 * 37 plus 12?"}]

while True:
    resp = client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=1024,
        tools=tools,
        messages=messages,
    )
    messages.append({"role": "assistant", "content": resp.content})

    if resp.stop_reason != "tool_use":
        print(resp.content[0].text)
        break

    tool_results = []
    for block in resp.content:
        if block.type == "tool_use":
            result = run_tool(block.name, block.input)
            tool_results.append({
                "type": "tool_result",
                "tool_use_id": block.id,
                "content": result,
            })
    messages.append({"role": "user", "content": tool_results})

वह while लूप ही एजेंट है। मॉडल सवाल देखता है, calculator को "1894 * 37 + 12" के साथ कॉल करने का अनुरोध करता है, आपका कोड उसे चलाता है, 70090 वापस सौंपता है, और मॉडल अंतिम जवाब लिख देता है। कैलकुलेटर की जगह एक read_file/write_file जोड़ी रख दीजिए और आपके पास एक प्राथमिक कोडिंग एजेंट तैयार है।

उपकरण ही वह हिस्सा हैं जो असल में मायने रखता है

मॉडल उतना ही सक्षम होता है जितने उपकरण आप उसे देते हैं, और उपकरण का डिज़ाइन ही वह जगह है जहाँ ज़्यादातर पहले एजेंट विफल हो जाते हैं। एजेंटों के लिए उपकरण लिखने पर Anthropic का मार्गदर्शन कुछ नियमों में सिमट जाता है:

• उपकरणों को इस तरह नाम और विवरण दें जैसे आप किसी नए सहकर्मी के लिए लिख रहे हों। search_invoices(customer_id, date_range) एक अस्पष्ट query(sql) से बेहतर है — अनुबंध जितना स्पष्ट होगा, उतने ही कम ग़लत कॉल होंगे।
• कच्चे ढेर के बजाय उच्च-संकेत वाले परिणाम लौटाएँ। अगर कोई उपकरण 5,000 लाइन JSON लौटाता है, तो आपने मॉडल का संदर्भ बजट अभी-अभी शोर पर ख़र्च कर दिया है। जो उपयोगी है उस तक छाँट लें।
• त्रुटियों को शिक्षाप्रद बनाएँ। "File not found: did you mean config.yaml?" मॉडल को संभलने देता है; एक नंगा स्टैक ट्रेस आमतौर पर ऐसा नहीं करता।

इसे चलने देने से पहले सुरक्षा-कवच

चूँकि आपका कोड हर उपकरण-कॉल को निष्पादित करता है, सुरक्षा की ज़िम्मेदारी आपकी है। किसी एजेंट के किसी वास्तविक चीज़ को छूने से पहले जोड़ने लायक तीन सुरक्षा-कवच:

• लूप पर सीमा लगाएँ। एक अधिकतम-पुनरावृत्ति गणना जोड़ें ताकि एक उलझा हुआ एजेंट हमेशा के लिए न घूमता रहे (और बिल न चढ़ा दे)।
• विनाशकारी क्रियाओं पर पहरा लगाएँ। जो कुछ भी हटाता है, भेजता है, या भुगतान करता है, उसके लिए पुष्टि की ज़रूरत होनी चाहिए या पहले किसी सैंडबॉक्स के विरुद्ध चलना चाहिए।
• उपकरण इनपुट को सत्यापित करें। अविश्वसनीय स्ट्रिंग्स को कभी eval() न करें और न ही मॉडल के आउटपुट को सीधे किसी शेल में भेजें। हर उपकरण के तर्क (argument) को अविश्वसनीय उपयोगकर्ता इनपुट मानें — क्योंकि असल में वह यही है।

एजेंट कब नहीं बनाना चाहिए

जल्दी सीखने लायक सबसे उपयोगी बात: कई समस्याओं के लिए एजेंट की बिल्कुल ज़रूरत ही नहीं होती। अगर चरण पहले से ज्ञात हों — डेटा लाओ, उसका सारांश बनाओ, सारांश ईमेल करो — तो एक या दो मॉडल-कॉल वाली एक साधारण स्क्रिप्ट सस्ती, तेज़ और डिबग करने में आसान है। Anthropic इन्हें वर्कफ़्लो कहता है, और जब भी रास्ता पूर्वानुमेय हो तब इनकी सिफ़ारिश करता है। एक सच्चे एजेंट का सहारा तभी लें जब मॉडल को सचमुच यह तय करने की ज़रूरत हो कि जो उसे मिले उसके आधार पर आगे क्या करना है।

ऊपर दिए चार-चरणीय लूप से शुरू करें, इसे एक या दो अच्छी तरह वर्णित उपकरण दें, पुनरावृत्तियों पर सीमा लगाएँ, और एक वास्तविक काम जोड़ें। एक काम करने वाले एजेंट से आप किसी भी मात्रा के फ़्रेमवर्क दस्तावेज़ीकरण से कहीं ज़्यादा सीखेंगे।