एआई एजेंट क्या है? शुरुआती लोगों के लिए पूरी गाइड
एक डेवलपर को एआई एजेंट्स के बारे में सब कुछ जानना चाहिए — आर्किटेक्चर, ट्रेडऑफ्स, और कैसे तय करें कि आपको एक बनाना चाहिए या नहीं।
TL;DR: एआई एजेंट एक LLM है जो टूल्स के साथ लूप में चलता है और तब तक चलता है जब तक काम पूरा न हो जाए। यह गाइड तीन कंपोनेंट्स — मॉडल, लूप, और टूल्स — को व्यावहारिक सलाह के साथ तोड़ती है। प्लस कब एजेंट नहीं बनाना चाहिए।
“एआई एजेंट” एक ऐसा शब्द है जो सब इस्तेमाल करते हैं और कोई लगातार परिभाषित नहीं करता। पांच डेवलपर्स से पूछो कि एजेंट क्या है तो छह परिभाषाएं मिलेंगी।
मैं 18 महीने से एजेंट्स बना रहा हूं। मेरी सबसे स्पष्ट परिभाषा: एआई एजेंट एक LLM है लूप में, टूल्स के साथ, जो तब तक चलता है जब तक काम पूरा न हो जाए।
यह कोर है। बाकी सब — मल्टी-एजेंट सिस्टम, प्लानिंग, मेमोरी — इस बेसिक पैटर्न का एक्सटेंशन है।
Anthropic का tool use डॉक्यूमेंटेशन तीन-कम्पोनेंट पैटर्न — मॉडल, लूप, और टूल्स — को एजेंट आर्किटेक्चर की नींव के रूप में परिभाषित करता है। ReAct पेपर (Yao et al., 2022) ने पहली बार इस LLM-इन-ए-लूप पैटर्न को formalise किया।
मुख्य बातें:
- एआई एजेंट एक LLM है लूप में, टूल्स के साथ, जो तब तक चलता है जब तक काम पूरा न हो जाए
- तीन कंपोनेंट्स हैं: मॉडल (LLM), लूप (कंट्रोल फ्लो), और टूल्स (फंक्शंस)
- मॉडल चुनाव सबसे जरूरी आर्किटेक्चरल डिसीजन है — लागत, स्पीड, और विश्वसनीयता प्रभावित होती है
- ज्यादातर प्रोडक्शन एजेंट जनरल-पर्पज नहीं होते — संकुचित, उद्देश्य-निर्मित वर्टिकल एजेंट होते हैं
क्या चीज़ को एजेंट बनाती है
LLM चैट और एजेंट के बीच की रेखा धुंधली है। मैं ऐसे खींचता हूं:
| क्षमता | LLM चैट | सिंपल एजेंट | प्रोडक्शन एजेंट |
|---|---|---|---|
| प्रॉम्प्ट्स का जवाब देता है | ✅ | ✅ | ✅ |
| कन्वर्सेशन कॉन्टेक्स्ट बनाए रखता है | ✅ | ✅ | ✅ |
| एक्सटर्नल टूल्स कॉल करता है | ❌ | ✅ | ✅ |
| मल्टी-स्टेप प्लान एग्जीक्यूट करता है | ❌ | ✅ | ✅ |
| एरर से रिकवर करता है | ❌ | ❌ | ✅ |
| प्रति रन लागत ट्रैक करता है | ❌ | ❌ | ✅ |
| सेशंस के बीच स्टेट पर्सिस्ट करता है | ❌ | ❌ | ✅ |
| स्वतंत्र रूप से चलता है | ❌ | ❌ | ✅ |
अगर आपका सिस्टम LLM को कॉल करके जवाब देता है, तो वह चैटबॉट है। अगर यह LLM को कॉल करता है, तय करता है कि टूल कॉल करे या रिजल्ट लौटाए, टूल रिजल्ट्स पर लूप करता है, और तब तक चलता है जब तक शर्त पूरी न हो — तो वह एजेंट है।
आर्किटेक्चर
हर एजेंट जो मैंने बनाया है, वही कोर लूप शेयर करता है:
┌─────────────────────────────┐
│ LLM │
│ (कॉन्टेक्स्ट + उपलब्ध टूल्स │
│ के आधार पर निर्णय लेता है) │
└──────────┬──────────────────┘
│
┌───────────┴───────────┐
│ │
टूल कॉल? फाइनल रिस्पॉन्स?
│ │
▼ ▼
┌─────────────────┐ ┌──────────────┐
│ टूल एग्जीक्यूट │ │ रिजल्ट लौटाएं │
│ (फाइल पढ़ें, │ └──────────────┘
│ कमांड चलाएं, │
│ API कॉल करें) │
└────────┬────────┘
│
▼
┌─────────────────┐
│ रिजल्ट को │
│ कॉन्टेक्स्ट में │
│ जोड़ें, लूप │
│ जारी रखें │
└────────┬────────┘तीन कंपोनेंट्स
1. मॉडल (LLM)
मॉडल निर्णय लेता है। यह सबसे जरूरी चुनाव है क्योंकि यह लागत, स्पीड, और विश्वसनीयता सब प्रभावित करता है।
मॉडल सिलेक्शन गाइड:
| उपयोग | अनुशंसित मॉडल | प्रति 1M टोकन लागत | नोट्स |
|---|---|---|---|
| सिंपल काम | GPT-4o-mini | $0.15 | तेज़, सस्ता, काफी अच्छा |
| कॉम्प्लेक्स रीज़निंग | Claude Sonnet | $3 | गुणवत्ता और लागत का सबसे अच्छा संतुलन |
| अधिकतम गुणवत्ता | GPT-4o / Claude Opus | $15 | केवल तब इस्तेमाल करें जब एरर महंगे हों |
| लोकल/ऑफलाइन | Llama 3.1 70B | फ्री | GPU चाहिए, प्रोटोटाइपिंग के लिए अच्छा |
2. लूप (कंट्रोल फ्लो)
लूप तय करता है कि एजेंट आगे क्या करे। यह वह जगह है जहां ज्यादातर एजेंट फेल होते हैं।
सिंपल लूप पैटर्न:
while True:
response = llm.call(context)
if response.has_tool_call:
result = execute_tool(response.tool_call)
context.add(result)
else:
return response.textप्रोडक्शन लूप पैटर्न (एरर हैंडलिंग के साथ):
max_iterations = 15
iteration = 0
while iteration < max_iterations:
response = llm.call(context)
if response.has_tool_call:
try:
result = execute_tool(response.tool_call)
context.add(result)
except ToolError as e:
context.add(f"Error: {e}. Try a different approach.")
else:
return response.text
iteration += 1
return "Agent stopped: max iterations reached"3. टूल्स (फंक्शंस)
टूल्स वो फंक्शंस हैं जो एजेंट को बाहरी दुनिया से इंटरैक्ट करने देते हैं।
अच्छा टूल विवरण लिखने का फॉर्मूला:
# बुरा विवरण
def read_file(path: str):
"""Reads a file."""
# अच्छा विवरण
def read_file(path: str):
"""दिए गए पाथ पर फाइल की सामग्री पढ़ें।
जब इस्तेमाल करें: आपको किसी विशिष्ट फाइल में क्या है यह समझने की जरूरत हो।
रिटर्न: फाइल कंटेंट स्ट्रिंग के रूप में।
फेल: अगर फाइल मौजूद नहीं है।"""एजेंट प्रकार
| प्रकार | विवरण | उदाहरण |
|---|---|---|
| सिंपल एजेंट | सिंगल लूप, बेसिक टूल्स | ”यह फाइल पढ़ो और सारांश दो” |
| मल्टी-स्टेप एजेंट | कई टूल्स, प्लानिंग | ”सभी TODO कमेंट खोजो और इश्यू बनाओ” |
| ऑटोनॉमस एजेंट | बिना इंसानी इनपुट के चलता है | ”इस सर्वर की निगरानी करो और समस्याएं ठीक करो” |
| मल्टी-एजेंट | कई एजेंट एक साथ काम करते हैं | ”एक एजेंट कोड लिखता है, दूसरा रिव्यू करता है” |
सामान्य गलतियां
1. टूल विवरण बहुत अस्पष्ट हैं
# गलत
def process_data(data):
"""Processes data."""
# सही
def process_data(data: list[dict]) -> dict:
"""ग्राहक रिकॉर्ड्स की लिस्ट लेता है और एकत्रित मेट्रिक्स लौटाता है।
इनपुट: 'name', 'email', 'spent' कुंजियों वाले डिक्ट्स की लिस्ट
आउटपुट: 'total_spent', 'avg_spent', 'top_customer' वाला डिक्ट
जब इस्तेमाल करें: जब आपको ग्राहक खर्च डेटा सारांशित करने की जरूरत हो।"""2. लूप लिमिट नहीं है
एजेंट अनंत लूप में फंस सकता है। हमेशा अधिकतम इटरेशन सेट करो।
3. एरर हैंडलिंग नहीं है
एजेंट टूल्स फेल होते हैं। अगर एरर हैंडलिंग नहीं है, तो एजेंट क्रैश होगा या गलत रिजल्ट देगा।
4. कॉन्टेक्स्ट बहुत बड़ा हो गया
LLM के कॉन्टेक्स्ट विंडो सीमित हैं। अगर बहुत ज्यादा डेटा जोड़ोगे, तो मॉडल स्लो होगा या जरूरी चीज़ भूल जाएगा।
कब एजेंट बनाना है, कब नहीं
| स्थिति | समाधान |
|---|---|
| सिंगल LLM कॉल (वर्गीकरण, सारांश) | प्रॉम्प्ट, एजेंट नहीं |
| स्पष्ट नियम, अनुमानित फ्लो | स्क्रिप्ट |
| कई स्टेप, टूल्स चाहिए | एजेंट |
| एरर बहुत महंगे हैं | लूप में इंसान |
| रियल-टाइम रिस्पॉन्स चाहिए | एजेंट (स्ट्रीमिंग के साथ) |
एजेंट बनाने का रोडमैप
हफ्ता 1: बेसिक एजेंट
- एक सिंपल एजेंट बनाओ (फाइल रीडर या वेब सर्चर)
- लूप लागू करो
- 2-3 टूल्स लिखो
- एरर हैंडलिंग जोड़ो
हफ्ता 2: प्रोडक्शन रेडी
- लॉगिंग जोड़ो
- कॉस्ट ट्रैकिंग लागू करो
- अधिकतम इटरेशन सेट करो
- टूल विवरण सुधारो
हफ्ता 3: एडवांस्ड फीचर्स
- मल्टी-स्टेप प्लानिंग
- स्टेट पर्सिस्टेंस
- कई टूल्स ऑर्केस्ट्रेशन
- टेस्टिंग फ्रेमवर्क
टूल्स और रिसोर्सेज
- LangChain — एजेंट फ्रेमवर्क (Python)
- CrewAI — मल्टी-एजेंट ऑर्केस्ट्रेशन
- OpenAI API — LLM एक्सेस
- Anthropic API — Claude एक्सेस
- Ollama — लोकल मॉडल चलाना
निष्कर्ष
एआई एजेंट कॉम्प्लेक्स नहीं हैं। एक LLM है, एक लूप है, और टूल्स हैं। मॉडल चुनो, लूप लिखो, टूल्स परिभाषित करो।
शुरुआत सिंपल एजेंट से करो। जब तक प्रोडक्शन में न डालो, तब तक कॉम्प्लेक्स फीचर्स मत जोड़ो।
एजेंट्स का भविष्य उज्ज्वल है। अगर आप अभी सीख रहे हो, तो आप जल्दी हो। शुरू करो।
यह पोस्ट Agentic Up सीरीज़ का हिस्सा है — डेवलपर्स के लिए एआई एजेंट्स के बारे में व्यावहारिक गाइड।