---
title: अपना पहला एआई एजेंट कैसे बनाएं (2026 ट्यूटोरियल)
canonical: "https://agenticup.dev/posts/how-to-build-first-ai-agent-hindi/"
pubDate: "2026-06-01T00:00:00.000Z"
description: आपने ChatGPT इस्तेमाल किया है। शायद Claude या Copilot भी इस्तेमाल किया है कोडिंग में मदद के लिए। लेकिन एजेंट बनाना — जो अपने आप कार्रवाई करे — एक अलग कौशल लगता है। ऐसा नहीं है। यह ट्यूटोरियल वह है जो मैं शुरू में चाहता था।
tags: [एआई एजेंट, ट्यूटोरियल, शुरुआती गाइड, एजेंट डेवलपमेंट, 2026]
---

Anthropic का [tool use डॉक्यूमेंटेशन](https://docs.anthropic.com/en/docs/build-with-claude/tool-use) इसी एजेंट लूप पैटर्न को परिभाषित करता है — मॉडल, टूल्स, और एक्सीक्यूशन लूप। यह ट्यूटोरियल उसी आर्किटेक्चर का पालन करता है।

**TL;DR:** एजेंट बस एक LLM है लूप में टूल्स के साथ — यह 20-लाइन Python लूप शुरू करने के लिए काफी है। यह ट्यूटोरियल स्क्रैच से एक कोड रिव्यू एजेंट बनाता है, कवरिंग कोर लूप, टूल डेफिनिशंस, सिस्टम प्रॉम्प्ट्स, और डिप्लॉयमेंट। कोई ML अनुभव जरूरी नहीं, सिर्फ API ऑर्केस्ट्रेशन।

आपने ChatGPT इस्तेमाल किया है। शायद Claude या Copilot भी इस्तेमाल किया है कोडिंग में मदद के लिए। लेकिन एक *एजेंट* बनाना — जो अपने आप कार्रवाई करे, फीडबैक पर लूप करे, और निर्णय ले — एक अलग कौशल लगता है।

ऐसा नहीं है। एजेंट बस एक LLM है लूप में टूल्स के साथ। बस। जादू लूप डिज़ाइन में है, मॉडल में नहीं।

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

> **मुख्य बातें:**
> - एजेंट बस एक LLM है लूप में टूल्स के साथ — जादू लूप डिज़ाइन में है, मॉडल में नहीं
> - स्क्रैच से बनाना फंडामेंटल्स सिखाता है, फ्रेमवर्क एब्स्ट्रैक्शंस से पहले
> - एक काम करता कोड रिव्यू एजेंट 50 लाइन्स से कम Python में बन सकता है
> - प्रोडक्शन एजेंट्स का सबसे मुश्किल हिस्सा लूप नहीं — रिलायबिलिटी, कॉस्ट कंट्रोल, और स्कोप मैनेजमेंट है

## स्टेप 1: स्टैक चुनो

पहले तय करो कि आप कैसे एजेंट बनाओगे:

| विकल्प | फायदे | नुकसान |
|--------|------|--------|
| स्क्रैच (Python) | पूरा कंट्रोल, फंडामेंटल्स समझ आते हैं | ज्यादा कोड लिखना पड़ता है |
| LangGraph | बिल्ट-इन स्टेट मैनेजमेंट, विजुअलाइज़ेशन | लर्निंग कर्व, वेंडर लॉक-इन |
| CrewAI | मल्टी-एजेंट सपोर्ट, आसान सेटअप | कम कंट्रोल, ज्यादा एब्स्ट्रैक्शन |

**मेरी सिफारिश:** स्क्रैच से शुरू करो। जब तक लूप समझ न आ जाए, फ्रेमवर्क मत इस्तेमाल करो।

### सेटअप

```bash
# Python 3.11+ इंस्टॉल करो
python --version  # 3.11+ होना चाहिए

# API की सेट करो
export ANTHROPIC_API_KEY="sk-ant-..."
# या OpenAI के लिए
export OPENAI_API_KEY="sk-..."
```

## स्टेप 2: कोर लूप बनाओ

यह 20-लाइन लूप है जो हर एजेंट का दिल है:

```python
import anthropic

client = anthropic.Anthropic()

def run_agent(task: str, tools: list) -> str:
    messages = [{"role": "user", "content": task}]
    
    while True:
        response = client.messages.create(
            model="claude-sonnet-4-20250514",
            max_tokens=1024,
            tools=tools,
            messages=messages
        )
        
        # अगर टूल कॉल है तो एग्जीक्यूट करो
        if response.stop_reason == "tool_use":
            tool_result = execute_tool(response.content)
            messages.append({"role": "assistant", "content": response.content})
            messages.append({"role": "user", "content": tool_result})
        else:
            # फाइनल आंसर
            return response.content[0].text
```

यह लूप क्या करता है:
1. LLM को काम देता है
2. LLM तय करता है: टूल कॉल करे या जवाब दे
3. अगर टूल कॉल है, तो एग्जीक्यूट करके रिजल्ट वापस भेजो
4. लूप तब तक चलता है जब तक LLM फाइनल जवाब न दे

## स्टेप 3: टूल्स परिभाषित करो

टूल्स वो फंक्शंस हैं जो एजेंट को बाहरी दुनिया से इंटरैक्ट करने देते हैं:

```python
tools = [
    {
        "name": "read_file",
        "description": "फाइल की सामग्री पढ़ें। जब इस्तेमाल करें: आपको किसी विशिष्ट फाइल में क्या है यह देखने की जरूरत हो।",
        "input_schema": {
            "type": "object",
            "properties": {
                "path": {
                    "type": "string",
                    "description": "पढ़ने वाली फाइल का पाथ"
                }
            },
            "required": ["path"]
        }
    },
    {
        "name": "list_files",
        "description": "डायरेक्ट्री में सभी फाइलें लिस्ट करें। जब इस्तेमाल करें: आपको देखना हो कि कौन सी फाइलें मौजूद हैं।",
        "input_schema": {
            "type": "object",
            "properties": {
                "directory": {
                    "type": "string",
                    "description": "लिस्ट करने वाली डायरेक्ट्री का पाथ"
                }
            },
            "required": ["directory"]
        }
    }
]

def execute_tool(tool_call):
    if tool_call.name == "read_file":
        with open(tool_call.input["path"]) as f:
            return f.read()
    elif tool_call.name == "list_files":
        import os
        return "\n".join(os.listdir(tool_call.input["directory"]))
```

## स्टेप 4: सिस्टम प्रॉम्प्ट लिखो

सिस्टम प्रॉम्प्ट एजेंट को बताता है कि वह कौन है और क्या करना है:

```python
system_prompt = """आप एक कोड रिव्यू एजेंट हैं। आपका काम है:
1. दी गई डायरेक्ट्री में कोड फाइलें पढ़ें
2. उनका विश्लेषण करें (बग्स, सुरक्षा, प्रदर्शन)
3. एक स्पष्ट रिपोर्ट बनाएं

संपूर्ण लेकिन संक्षिप्त रहें। असली समस्याओं पर ध्यान दें, स्टाइल प्राथमिकताओं पर नहीं।
"""
```

## स्टेप 5: पूरा एजेंट बनाओ

सब कुछ जोड़ दो:

```python
import anthropic
import os

client = anthropic.Anthropic()

tools = [
    {
        "name": "read_file",
        "description": "फाइल की सामग्री पढ़ें",
        "input_schema": {
            "type": "object",
            "properties": {
                "path": {"type": "string", "description": "फाइल का पाथ"}
            },
            "required": ["path"]
        }
    },
    {
        "name": "list_files",
        "description": "डायरेक्ट्री में फाइलें लिस्ट करें",
        "input_schema": {
            "type": "object",
            "properties": {
                "directory": {"type": "string", "description": "डायरेक्ट्री का पाथ"}
            },
            "required": ["directory"]
        }
    }
]

def execute_tool(tool_call):
    if tool_call.name == "read_file":
        with open(tool_call.input["path"]) as f:
            return f.read()
    elif tool_call.name == "list_files":
        return "\n".join(os.listdir(tool_call.input["directory"]))

def run_agent(task: str) -> str:
    messages = [{"role": "user", "content": task}]
    max_iterations = 10
    iteration = 0
    
    while iteration < max_iterations:
        response = client.messages.create(
            model="claude-sonnet-4-20250514",
            max_tokens=1024,
            system="आप एक कोड रिव्यू एजेंट हैं। कोड का विश्लेषण करें और समस्याओं की रिपोर्ट करें।",
            tools=tools,
            messages=messages
        )
        
        if response.stop_reason == "tool_use":
            tool_result = execute_tool(response.content[-1])
            messages.append({"role": "assistant", "content": response.content})
            messages.append({"role": "user", "content": [{"type": "tool_result", "tool_use_id": response.content[-1].id, "content": tool_result}]})
        else:
            return response.content[0].text
        
        iteration += 1
    
    return "एजेंट रुका: अधिकतम इटरेशन पूरे हुए"

# एजेंट चलाओ
result = run_agent("./src डायरेक्ट्री में कोड की समीक्षा करें और किसी भी समस्या की रिपोर्ट करें।")
print(result)
```

## स्टेप 6: टेस्ट करो

एजेंट को असली काम पर टेस्ट करो:

```bash
# टेस्ट 1: सिंपल फाइल रीडिंग
python agent.py "README.md फाइल पढ़ो और सारांश दो"

# टेस्ट 2: कोड रिव्यू
python agent.py "./src में कोड की समीक्षा करो और किसी भी बग की रिपोर्ट करो"

# टेस्ट 3: मल्टी-स्टेप काम
python agent.py "कोडबेस में सभी TODO कमेंट खोजो और एक सारांश बनाओ"
```

## सामान्य गलतियां

### 1. टूल विवरण अस्पष्ट हैं

```python
# गलत
{"name": "read", "description": "Reads stuff"}

# सही
{"name": "read_file", "description": "दिए गए पाथ पर फाइल की सामग्री पढ़ें। फाइल कंटेंट स्ट्रिंग के रूप में लौटाता है। फेल अगर फाइल मौजूद नहीं।"}
```

### 2. लूप लिमिट नहीं है

एजेंट अनंत लूप में फंस सकता है। हमेशा max_iterations सेट करो।

### 3. एरर हैंडलिंग नहीं है

टूल्स फेल होते हैं। अगर एरर हैंडलिंग नहीं है, तो एजेंट क्रैश होगा।

## अगले कदम

जब आपका बेसिक एजेंट काम करे, तो यह फीचर्स जोड़ो:

1. **लॉगिंग** — हर स्टेप लॉग करो ताकि डिबग कर सको
2. **कॉस्ट ट्रैकिंग** — हर रन की लागत कैलकुलेट करो
3. **स्ट्रीमिंग** — रियल-टाइम आउटपुट दिखाओ
4. **मेमोरी** — सेशंस के बीच कॉन्टेक्स्ट पर्सिस्ट करो

## प्रोडक्शन डिप्लॉयमेंट

जब एजेंट तैयार हो, तो डिप्लॉय करो:

```dockerfile
FROM python:3.11-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
CMD ["python", "agent.py"]
```

```bash
# Docker बिल्ड
docker build -t my-agent .

# रन
docker run -e ANTHROPIC_API_KEY=$ANTHROPIC_API_KEY my-agent
```

## निष्कर्ष

एआई एजेंट बनाना कॉम्प्लेक्स नहीं है। 20 लाइन Python, एक लूप, और कुछ टूल्स। शुरुआत सिंपल एजेंट से करो, फिर फीचर्स जोड़ो।

एजेंट का जादू लूप डिज़ाइन में है, मॉडल में नहीं। अच्छा लूप लिखो, एजेंट अच्छा काम करेगा।

---

*यह पोस्ट Agentic Up सीरीज़ का हिस्सा है — डेवलपर्स के लिए एआई एजेंट्स के बारे में व्यावहारिक गाइड।*


## संबंधित पोस्ट

- [एआई एजेंट क्या है](/posts/what-is-an-ai-agent-hindi/)
- [भारतीय डेवलपर्स के लिए एआई कोडिंग टूल्स](/posts/best-ai-coding-tools-india-hindi/)