Claude के साथ अपना पहला AI एजेंट कैसे बनाएं: पहले API कॉल से लेकर स्वायत्त सिस्टम तक

Anthropic में 90% कोड Claude एजेंट्स द्वारा लिखा जाता है। न कि इंजीनियरों द्वारा चैट विंडो में टाइप करके। बल्कि स्वायत्त एजेंटों द्वारा जो लूप चलाते हैं, टूल कॉल करते हैं, और टीम के सोते समय कोड शिप करते हैं।

फ्रेश AI अल्फा पाने के लिए मेरे Substack को फॉलो करें:

movez.substack.com

यही सटीक सेटअप है। स्टेप बाय स्टेप। पहले API कॉल से लेकर एक काम करने वाले एजेंट तक जिसे आप किसी भी कार्य पर लगा सकते हैं।

यह लेख कवर करेगा:

1 - क्यों ज़्यादातर लोग जिन्हें "एजेंट" कहते हैं, वे एजेंट नहीं हैं

2 - वे 5 भाग जो हर काम करने वाले एजेंट को चाहिए

3 - Claude के साथ प्रत्येक भाग को कोड के साथ कैसे बनाएं

4 - वे गलतियाँ जो एजेंट को शिप होने से पहले ही खत्म कर देती हैं

इसे बुकमार्क करें। नीचे दिया गया हर कोड ब्लॉक काम करता है।

01. अधिकांश "AI एजेंट्स" एजेंट नहीं हैं

मैंने अनगिनत एजेंट बनाए और तोड़े हैं। उन्हें पूरी रात टोकन जलाते और कुछ नहीं पैदा करते देखा है। उन्हें एक ही फ़ाइल को 30 बार फिर से लिखते देखा है। उन्हें टेस्ट को डिलीट करके अपना ही टेस्ट पास करते देखा है।

हर असफलता ने मुझे एक ही सबक सिखाया: मॉडल समस्या नहीं है। उसके चारों ओर का आर्किटेक्चर समस्या है। यह गाइड वह सब कुछ है जो मैंने सीखा, आपको देने के लिए सबसे छोटे रास्ते में संकुचित।

यहाँ वह है जो ज़्यादातर लोग बनाते हैं जब वे "AI एजेंट" कहते हैं:

1while True:
2    user_input = input("> ")
3    response = call_claude(user_input)
4    print(response)

यह एक चैटबॉट है। यह आपका इंतज़ार करता है। यह वही करता है जो आप कहते हैं। यह सत्रों के बीच सब कुछ भूल जाता है। जब आप टैब बंद करते हैं, यह रुक जाता है।

एक एजेंट एक ऐसी प्रणाली है जो आपके सामने बैठे बिना एक लक्ष्य की ओर काम करती है। यह पता लगाता है कि क्या करने की ज़रूरत है, एक योजना बनाता है, निष्पादित करता है, परिणाम की जाँच करता है, और अगर यह अभी तक पूरा नहीं हुआ है - फिर से प्रयास करता है। आप दिशा तय करते हैं। एजेंट काम करता है।

"Claude Code शून्य से कुछ महीनों में $400 मिलियन राजस्व तक पहुँच गया। यह एक हैकाथॉन प्रोजेक्ट के रूप में शुरू हुआ। यह अभी भी केवल पब्लिक API का उपयोग करता है।" -

Boris Cherny, Claude Code के प्रमुख

वही API जिस तक आपकी अभी पहुँच है। वही मॉडल। अंतर मॉडल के चारों ओर के आर्किटेक्चर में है।

02. एक वास्तविक एजेंट के 5 भाग

हर काम करने वाला एजेंट - Claude Code, Devin, Codex, या जो कुछ भी आप खुद बनाते हैं - पाँच भागों से इकट्ठा होता है। एक को छोड़ें और यह टूट जाता है।

03. API लेयर

सब कुछ यहीं से शुरू होता है। आप Claude को कॉल करते हैं, Claude जवाब देता है। लेकिन जिस तरह से आप इसे कॉल करते हैं, वह तय करता है कि आपको चैटबॉट मिलेगा या एजेंट।

तीन चीज़ें मायने रखती हैं: सिस्टम प्रॉम्प्ट, स्ट्रक्चर्ड आउटपुट, और टेम्परेचर।

सिस्टम प्रॉम्प्ट कोई अभिवादन नहीं है। यह आपके एजेंट का ऑपरेटिंग मैनुअल है। हर नियम, बाधा और व्यवहार यहाँ जाता है। इसके बिना Claude अनुमान लगाता है कि आप क्या चाहते हैं। इसके साथ Claude आपके विनिर्देश का पालन करता है।

1import anthropic
2
3client = anthropic.Anthropic()
4
5response = client.messages.create(
6    model="claude-sonnet-4-6",
7    max_tokens=4096,
8    system="""तुम एक कोड रिव्यू एजेंट हो।
9
10नियम:
11- टिप्पणी करने से पहले पूरा डिफ पढ़ें
12- केवल वास्तविक बग्स को फ़्लैग करें, स्टाइल प्राथमिकताओं को नहीं
13- अगर कुछ गलत नहीं है, तो "LGTM" कहें और रुक जाएं
14- ऐसे बदलाव कभी सुझाएं नहीं जिन्हें आपने मानसिक रूप से परखा न हो
15- आउटपुट फ़ॉर्मेट: {file, line, issue, fix} का JSON array""",
16    messages=[{"role": "user", "content": diff_content}]
17)

स्ट्रक्चर्ड आउटपुट आपके एजेंट के रिस्पॉन्स को मशीन-पठनीय बनाता है। अगर Claude फ्री टेक्स्ट लौटाता है, तो आपके कोड को इसे पार्स करना होगा। अगर Claude JSON लौटाता है, तो आपका कोड इसका सीधे उपयोग कर सकता है।

1# Claude को सटीक आकार बताकर JSON आउटपुट फ़ोर्स करें
2system = """केवल वैध JSON लौटाएं। कोई मार्कडाउन नहीं। कोई स्पष्टीकरण नहीं।
3स्कीमा:
4{
5  "status": "pass" | "fail",
6  "issues": [{"file": str, "line": int, "issue": str}],
7  "summary": str
8}"""

टेम्परेचर। डिटरमिनिस्टिक एजेंट्स के लिए इसे 0 पर सेट करें। क्रिएटिव काम के लिए इसे 0.3-0.5 पर सेट करें। डिफ़ॉल्ट (1.0) रैंडमनेस जोड़ता है जो आप एजेंट में लगभग कभी नहीं चाहते।

04. टूल्स

टूल के बिना एक मॉडल तर्क कर सकता है लेकिन कार्य नहीं कर सकता। यह आपको बता सकता है कि कौन सी फ़ाइल एडिट करनी है लेकिन इसे एडिट नहीं कर सकता। यह एक क्वेरी का वर्णन कर सकता है लेकिन इसे चला नहीं सकता।

Claude का टूल उपयोग आपको ऐसे फंक्शन परिभाषित करने देता है जिन्हें मॉडल कॉल कर सकता है। आप फंक्शन का वर्णन करते हैं। Claude तय करता है कि इसे कब कॉल करना है। आप इसे निष्पादित करते हैं और परिणाम लौटाते हैं। Claude परिणाम का उपयोग करके तर्क जारी रखता है।

1tools = [{
2    "name": "run_sql",
3    "description": "डेटाबेस के विरुद्ध केवल-पढ़ने वाली SQL क्वेरी निष्पादित करें",
4    "input_schema": {
5        "type": "object",
6        "properties": {
7            "query": {
8                "type": "string",
9                "description": "निष्पादित करने के लिए SQL SELECT क्वेरी"
10            }
11        },
12        "required": ["query"]
13    }
14},
15{
16    "name": "write_file",
17    "description": "डिस्क पर फ़ाइल में सामग्री लिखें",
18    "input_schema": {
19        "type": "object",
20        "properties": {
21            "path": {"type": "string"},
22            "content": {"type": "string"}
23        },
24        "required": ["path", "content"]
25    }
26}]

टूल का विवरण आपके विचार से अधिक मायने रखता है। Claude इसे पढ़ता है ताकि यह तय कर सके कि टूल का उपयोग कब और कैसे करना है। एक अस्पष्ट विवरण का मतलब गलत कॉल है। एक सटीक विवरण का मतलब सटीक कॉल है।

3-5 टूल से शुरू करें। फ़ाइल पढ़ें, फ़ाइल लिखें, कमांड चलाएं, खोजें, और अपने उपयोग के मामले के लिए एक डोमेन-विशिष्ट टूल। यह एजेंट के 90% कार्यों को कवर करता है।

05. लूप

यह वह भाग है जो एक स्क्रिप्ट को एजेंट में बदल देता है। लूप के बिना, आपका कोड Claude को एक बार कॉल करता है और रुक जाता है। लूप के साथ, आपका कोड Claude को कॉल करता है, परिणाम की जाँच करता है, और काम पूरा होने तक फिर से कॉल करता है।

तीन घटक:

• वेरिफायर। कुछ जो जाँचता है कि आउटपुट अच्छा है या नहीं। एक टेस्ट सूट, एक टाइप चेकर, एक लिंटर, सख्त मापदंडों के साथ एक दूसरा Claude कॉल। इसके बिना आपके पास एजेंट खुद से बार-बार सहमत होता रहेगा।
• स्टेट। क्या हुआ इसका एक रिकॉर्ड। क्या काम किया, क्या विफल रहा, आगे क्या प्रयास करना है। स्टेट के बिना एजेंट हर पास में एक ही गलती करता है।
• स्टॉप कंडीशन। लक्ष्य पूरा हो गया, या एक हार्ड लिमिट कहती है "N प्रयासों के बाद, रुकें और रिपोर्ट करें।" इसके बिना लूप हमेशा चलता रहता है और आपका खाता खाली कर देता है।

1import json
2from pathlib import Path
3
4def run_agent(task: str, max_attempts: int = 5):
5    state = {"task": task, "attempts": [], "done": False}
6
7    for i in range(max_attempts):
8        # स्टेट से कॉन्टेक्स्ट बनाएं
9        context = build_prompt(state)
10
11        # टूल्स के साथ Claude को कॉल करें
12        result = call_claude(context, tools)
13
14        # किसी भी टूल कॉल को निष्पादित करें
15        output = execute_tools(result)
16
17        # परिणाम सत्यापित करें
18        check = verify(output)
19
20        # स्टेट अपडेट करें
21        state["attempts"].append({
22            "attempt": i + 1,
23            "action": result.summary,
24            "passed": check.passed,
25            "reason": check.reason
26        })
27
28        if check.passed:
29            state["done"] = True
30            break
31
32    # अगले रन के लिए स्टेट सेव करें
33    Path("state.json").write_text(json.dumps(state, indent=2))
34    return state

यह पूरा कंकाल है। हर प्रोडक्शन एजेंट इस पैटर्न का एक रूपांतर है। विवरण बदलते हैं। आकार नहीं बदलता।

06. मेमोरी

मेमोरी के बिना, हर सत्र शून्य से शुरू होता है। एजेंट आपके प्रोजेक्ट स्ट्रक्चर को फिर से खोजता है। आपके कन्वेंशन को फिर से सीखता है। कल की गई गलतियों को फिर से करता है।

Claude एजेंट मेमोरी की तीन परतों का उपयोग करते हैं:

CLAUDE.md आपके प्रोजेक्ट की रूट पर एक मार्कडाउन फ़ाइल है। Claude Code इसे हर सत्र की शुरुआत में स्वचालित रूप से पढ़ता है। आपके नियम, आपका स्टैक, आपके कन्वेंशन। इसे एक बार लिखें, हमेशा पढ़ें।

1# CLAUDE.md
2
3## प्रोजेक्ट
4टास्क मैनेजमेंट API। Python 3.12, FastAPI, PostgreSQL।
5
6## नियम
7- सभी रिस्पॉन्स: {data, error, meta} स्कीमा
8- हर नए एंडपॉइंट के लिए टेस्ट आवश्यक
9- कमिट मैसेज: type(scope): description
10- लॉगिंग के लिए कभी print() का उपयोग न करें। structlog का उपयोग करें।
11
12## ज्ञात समस्याएं
13- Auth मिडलवेयर x-auth-token की अपेक्षा करता है, Authorization की नहीं
14- टेस्ट सूट को पूरा होने में 45 सेकंड लगते हैं। इटरेशन के लिए --filter का उपयोग करें।

स्किल्स पूरे वर्कफ़्लो को कैप्चर करते हैं। सिर्फ़ प्रॉम्प्ट नहीं - पूरा आकार: इनपुट फ़ॉर्मेट, कदम, आउटपुट फ़ॉर्मेट, वैलिडेशन नियम। पहले रन में 20 मिनट लगते हैं। रीप्ले में 30 सेकंड लगते हैं।

लर्निंग्स फ़ाइल गलतियों का एक चलता-फिरता लॉग है। एजेंट हर सत्र के बाद इसमें लिखता है। अगला सत्र इसे पढ़ता है। गलतियाँ तब तक दोहराई जाती हैं जब तक वे लिखी नहीं जातीं। फिर वे रुक जाती हैं।

1# learnings.md
2
3- Payment API हेडर में idempotency key की अपेक्षा करता है, बॉडी में नहीं
4- PostgreSQL NOTIFY को कनेक्शन पूल में स्पष्ट LISTEN की आवश्यकता है
5- रेट लिमिटर प्रति-की गिनती करता है, प्रति-IP नहीं। टेस्ट को अद्वितीय कुंजियों की आवश्यकता है।

07. वेरिफिकेशन गेट

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

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

तीन पैटर्न जो काम करते हैं:

1. स्वचालित टेस्ट। एजेंट कोड लिखता है। टेस्ट सूट चलता है। अगर टेस्ट फेल होते हैं, तो एजेंट को एरर आउटपुट मिलता है और वह फिर से प्रयास करता है। यह है कि Claude Code आंतरिक रूप से कैसे काम करता है।

1def verify(output):
2    # टेस्ट सूट चलाएं
3    result = subprocess.run(
4        ["pytest", "tests/", "-x", "--tb=short"],
5        capture_output=True, text=True
6    )
7    return {
8        "passed": result.returncode == 0,
9        "reason": result.stdout if result.returncode != 0 else "सभी टेस्ट पास"
10    }

2. टाइप चेकर / लिंटर। हर बदलाव के बाद mypy, ruff, या tsc --noEmit चलाएँ। एक भी टेस्ट लिखे बिना बग की पूरी श्रेणियों को पकड़ता है।

3. दूसरा मॉडल समीक्षक के रूप में। एक सख्त सिस्टम प्रॉम्प्ट के साथ एक अलग Claude कॉल का उपयोग करें जो केवल समस्याओं की तलाश करता है। लेखक तेज़ और सस्ता है। समीक्षक धीमा और सख्त है। यह अलगाव अधिकांश गुणवत्ता है।

1# समीक्षक प्रॉम्प्ट - निर्माता से अलग
2reviewer_system = """तुम एक सख्त कोड समीक्षक हो।
3तुम्हारा एकमात्र काम समस्याएं ढूंढना है।
4
5जाँच करें:
6- क्या कोड स्पेक से मेल खाता है?
7- क्या कोई अनकैच एज केस हैं?
8- क्या सभी टेस्ट वास्तव में सही चीज़ का परीक्षण करते हैं?
9
10अगर सब कुछ सही है, तो जवाब दें: {"passed": true}
11अगर कुछ भी गलत है, तो जवाब दें: {"passed": false, "issues": [...]}
12
13सुधारों का सुझाव न दें। केवल वास्तविक बग्स को फ़्लैग करें।"""

लेखक तेज़ और सस्ता है। समीक्षक धीमा और सख्त है। यह अलगाव अधिकांश गुणवत्ता है।

08. सब कुछ एक साथ रखना

यहाँ एक पूर्ण एजेंट है जो GitHub इश्यू URL लेता है, इश्यू पढ़ता है, कोड लिखता है, टेस्ट चलाता है, और PR खोलता है। पाँच भाग एक साथ काम कर रहे हैं।

1import anthropic, subprocess, json
2from pathlib import Path
3
4client = anthropic.Anthropic()
5CLAUDE_MD = Path("CLAUDE.md").read_text()
6LEARNINGS = Path("learnings.md").read_text()
7
8SYSTEM = f"""तुम एक कोडिंग एजेंट हो।
9इश्यू पढ़ें। फिक्स लिखें। टेस्ट चलाएं।
10
11प्रोजेक्ट कॉन्टेक्स्ट:
12{CLAUDE_MD}
13
14ज्ञात समस्याएं:
15{LEARNINGS}
16
17नियम:
18- कुछ भी बदलने से पहले पूरा कोडबेस पढ़ें
19- हर बदलाव के लिए टेस्ट लिखें
20- अगर टेस्ट फेल होते हैं, तो कोड ठीक करें, टेस्ट नहीं
21- जब सभी टेस्ट पास हो जाएं तो रुक जाएं"""
22
23TOOLS = [
24    read_file_tool,
25    write_file_tool,
26    run_command_tool,
27    search_codebase_tool,
28]
29
30def run(issue_text, max_attempts=5):
31    messages = [{"role": "user", "content": issue_text}]
32
33    for attempt in range(max_attempts):
34        # Claude को कॉल करें
35        response = client.messages.create(
36            model="claude-sonnet-4-6",
37            max_tokens=8192,
38            system=SYSTEM,
39            tools=TOOLS,
40            messages=messages
41        )
42
43        # टूल कॉल निष्पादित करें
44        messages = handle_tool_use(response, messages)
45
46        # सत्यापित करें: टेस्ट चलाएं
47        test_result = subprocess.run(
48            ["pytest", "-x", "--tb=short"],
49            capture_output=True, text=True
50        )
51
52        if test_result.returncode == 0:
53            print(f"{attempt + 1} प्रयासों में हो गया")
54            return True
55
56        # फेलबैक को लूप में वापस फीड करें
57        messages.append({
58            "role": "user",
59            "content": f"टेस्ट फेल हो गए:\n{test_result.stdout}\nठीक करें और पुनः प्रयास करें।"
60        })
61
62    return False

यह एक काम करने वाला एजेंट है। सिस्टम प्रॉम्प्ट और CLAUDE.md के साथ API लेयर। फ़ाइल ऑपरेशन के लिए टूल। रीट्री के साथ लूप। learnings.md से मेमोरी। pytest के माध्यम से एक वेरिफिकेशन गेट।

50 लाइनों से कम। वही आर्किटेक्चर जो Claude Code आंतरिक रूप से उपयोग करता है।

**

09. 5 गलतियाँ जो हर एजेंट को तोड़ देती हैं

1. कोई वेरिफिकेशन गेट नहीं। एजेंट अपना होमवर्क खुद ग्रेड करता है। यह कोड लिखता है, कहता है "ठीक लग रहा है," और आगे बढ़ जाता है। आउटपुट सही दिखता है और प्रोडक्शन में टूट जाता है।
2. कोई स्टॉप कंडीशन नहीं। लूप तब तक चलता है जब तक आपका API बिल $200 न हो जाए। हार्ड लिमिट के बिना एजेंट हमेशा के लिए पुनः प्रयास करता है, एक ही फ़ाइल को 40 बार फिर से लिखता है। हमेशा max_attempts सेट करें। हमेशा।
3. कोई स्टेट फ़ाइल नहीं। प्रयास #1 और प्रयास #50 पर एक ही गलती। एजेंट को नहीं पता कि उसने पहले से क्या प्रयास किया है। वह एक ही टूटा हुआ फिक्स तीन बार लगातार प्रस्तावित करता है क्योंकि कुछ भी विफलता रिकॉर्ड नहीं करता।
4. बहुत सारे टूल। आप Claude को 20 टूल देते हैं और वह गलत चुन लेता है। 5 स्पष्ट टूल वाला मॉडल 20 ओवरलैपिंग टूल वाले मॉडल से बेहतर विकल्प बनाता है। छोटा शुरू करें। टूल तभी जोड़ें जब एजेंट किसी दीवार से टकराए।
5. अस्पष्ट सिस्टम प्रॉम्प्ट। "एक अच्छा कोडिंग असिस्टेंट बनो" आपको सामान्य आउटपुट देता है। "सभी रिस्पॉन्स वैध JSON होने चाहिए, हर बदलाव के लिए टेस्ट आवश्यक, कभी भी /src के बाहर फ़ाइलों को संशोधित न करें" आपको एक ऐसा एजेंट देता है जो व्यवहार करता है।

निष्कर्ष:

एक काम करने वाला एजेंट कोई बेहतर प्रॉम्प्ट नहीं है। यह एक प्रणाली है: API + टूल + लूप + मेमोरी + वेरिफिकेशन गेट। पाँच भाग। एक को छोड़ें और यह टूट जाता है।

अधिकांश लोग इसे पढ़ेंगे, बुकमार्क करेंगे, और Claude को चैटबॉट के रूप में उपयोग करना जारी रखेंगे। वे एक बार में एक प्रश्न चिपकाएंगे और जवाब को अपने कोडबेस में हाथ से कॉपी करेंगे।

जो लोग लूप बनाएंगे, वे सोते समय काम शिप करेंगे। वही मॉडल। वही API। वही कीमत। अलग आर्किटेक्चर।

ऊपर दिए गए सभी कोड ब्लॉक काम करते हैं। उन्हें कॉपी करें। उन्हें चलाएं। अपने उपयोग के मामले के लिए उन्हें संशोधित करें।

इस सप्ताह एक एजेंट बनाएं। इसे एक ऐसे कार्य पर लगाएं जो आप हर दिन करते हैं। इसे चलने दें।