AI agents कैसे सीखें: शून्य से शुरुआत करने की पूरी गाइड

छह चरणों में मार्ग

AI agents को शून्य से सीखने के लिए, इन छह चरणों को क्रम में पूरा करें: अवधारणाएं, आपका पहला लूप, टूल्स, मेमोरी, लूप डिज़ाइन और सुरक्षा। प्रत्येक चरण में एक ऐसी चीज़ है जिसे आप अपने हाथों से बनाएंगे। आगे के चरणों पर कूदना सबसे आम कारण है जिससे लोग अटक जाते हैं, क्योंकि कोई framework ठीक उसी हिस्से को छिपा देता है जिसे आपको समझने की आवश्यकता थी।

एक AI agent एक language model के चारों ओर बना लूप है जिसे tools का उपयोग करने की अनुमति होती है। यह वाक्य ही पूरा विषय है। इसके बाद की हर चीज़ इस बारे में विस्तार है कि लूप में क्या जाता है, tools किन चीज़ों को छू सकते हैं, और जब लूप गलत हो जाए तो उसे कैसे रोकें। यदि आप किसी और को लूप समझा सकते हैं, तो आपने इसे सीख लिया है। यदि आप केवल frameworks के नाम ले सकते हैं, तो आपने इसे नहीं सीखा है।

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

स्टेज 1 से पहले आपको वास्तव में क्या चाहिए

आवश्यकताओं की ईमानदार सूची छोटी है, और अधिकांश कोर्स पेजों के सुझाव से भी कम है।

• आप 50 लाइन की स्क्रिप्ट के स्तर पर Python या TypeScript पढ़ और लिख सकते हैं।
• आप Linux shell में सहज हैं: पैकेज इंस्टॉल करना, फाइल एडिट करना, लॉग पढ़ना।
• आपके पास किसी hosted model के लिए API key है, या ऐसी मशीन है जो local model चला सके।

पूरी सूची बस इतनी ही है। आपको machine learning थ्योरी की आवश्यकता नहीं है, और आपको कोई मॉडल ट्रेन करने की जरूरत नहीं है। एजेंट के काम में gradients या training data जैसी कोई चीज शामिल नहीं है। Graphics card केवल तब मायने रखता है जब आप मॉडल को खुद चलाने का निर्णय लेते हैं, जो कि एक अलग कौशल है जिसे आप बाद में hosting Ollama on a VPS to self host an LLM से सीख सकते हैं।

लोग जिस चीज को कम आंकते हैं, वह shell वाला हिस्सा है। एजेंट permissions, paths, environment variables और चुपचाप बंद हो जाने वाले processes के कारण विफल होते हैं। यदि PATH के बारे में कोई stack trace या file mode आपको टर्मिनल बंद करने पर मजबूर करता है, तो पहले एक सप्ताहांत Linux की बुनियादी बातों पर बिताएं। यह बाद में आपका एक महीना बचाएगा।

चरण 1: एजेंट क्या है और क्या नहीं है

एक API कॉल और बिना किसी लूप के शुरुआत करें। एक प्रॉम्प्ट भेजें, उत्तर प्रिंट करें और रिस्पॉन्स में टोकन की संख्या देखें। अब आप लागत और विलंबता (latency) की इकाई को समझ गए हैं।

इसके बाद टूल के उपयोग को समझें, जो पूरे क्षेत्र में एकमात्र वास्तविक नई अवधारणा है। आप मॉडल को एक फंक्शन का नाम, उसका विवरण और उसके इनपुट के लिए एक JSON (JavaScript object notation) स्कीमा के रूप में वर्णन करते हैं। मॉडल कुछ भी रन नहीं करता है। वह एक संरचित अनुरोध (structured request) के साथ उत्तर देता है: इन तर्कों (arguments) के साथ run_command को कॉल करें। आपका कोड फंक्शन को रन करता है, आउटपुट को एक संदेश के रूप में वापस भेजता है और मॉडल से दोबारा पूछता है। मॉडल एक योजनाकार (planner) है जो टेक्स्ट पढ़ता है और टेक्स्ट लिखता है। आपका कोड वह चीज है जिसके पास हाथ हैं।

एक चैटबॉट एक उत्तर के बाद समाप्त हो जाता है। एक एजेंट उस आदान-प्रदान को तब तक दोहराता है जब तक कि मॉडल टूल मांगना बंद न कर दे। यह पुनरावृत्ति ही पूरा अंतर है, और यही कारण है कि विफलता के तरीके (failure modes) भी अलग होते हैं। एक चैटबॉट एक बार गलत उत्तर देता है। एक एजेंट किसी के ध्यान देने से पहले कई बार गलत उत्तर पर कार्य करता है।

चरण 2: लूप को स्वयं लिखें, एक बार

किसी फ्रेमवर्क से शुरुआत न करें। लगभग तीस लाइन का Python कोड लिखें ताकि इसकी संरचना आपकी अपनी हो।

sudo apt update && sudo apt install -y python3-venv
python3 -m venv ~/agent
source ~/agent/bin/activate
pip install anthropic
export ANTHROPIC_API_KEY=your-key-here

import subprocess
import anthropic

client = anthropic.Anthropic()

tools = [{
    "name": "run_command",
    "description": "Run a read only shell command and return its output.",
    "input_schema": {
        "type": "object",
        "properties": {"command": {"type": "string"}},
        "required": ["command"],
    },
}]

messages = [{"role": "user", "content": "How much disk space is free here?"}]

while True:
    response = client.messages.create(
        model="claude-opus-5",
        max_tokens=4096,
        tools=tools,
        messages=messages,
    )
    if response.stop_reason != "tool_use":
        break
    messages.append({"role": "assistant", "content": response.content})
    results = []
    for block in response.content:
        if block.type == "tool_use":
            done = subprocess.run(
                block.input["command"], shell=True,
                capture_output=True, text=True, timeout=10,
            )
            results.append({
                "type": "tool_result",
                "tool_use_id": block.id,
                "content": done.stdout or done.stderr,
            })
    messages.append({"role": "user", "content": results})

print(next(b.text for b in response.content if b.type == "text"))

इसे python3 agent.py के साथ चलाएं। एक सफल रन आपके फाइलसिस्टम और उनकी खाली जगह का नाम बताते हुए एक पैराग्राफ प्रिंट करेगा, क्योंकि मॉडल ने df -h के लिए पूछा था, आपके कोड ने इसे चलाया, और दूसरे पास ने उस टेबल को एक वाक्य में बदल दिया। यदि यह कुछ भी प्रिंट नहीं करता है, तो टेक्स्ट ब्लॉक आने से पहले ही लूप समाप्त हो गया। लूप के अंदर print(response.stop_reason) जोड़ें और मानों को बदलते हुए देखें।

अब इसे जानबूझकर तोड़ें। tool_use_id लाइन को हटा दें और त्रुटि को पढ़ें, क्योंकि बिना मैचिंग ID वाले टूल परिणाम को API द्वारा अस्वीकार कर दिया जाता है और यह शुरुआती लोगों के लिए सबसे आम बग है। एक ऐसा प्रश्न पूछें जिसके लिए दो कमांड की आवश्यकता हो और लूप को दो बार चलते हुए देखें। कुछ असंभव पूछें और देखें कि क्या यह हार मान लेता है या हमेशा के लिए घूमता रहता है।

इस उदाहरण के बारे में एक चेतावनी। यह मॉडल आउटपुट को सीधे shell=True के साथ शेल में भेजता है, जो एक ऐसी स्क्रैच मशीन पर स्वीकार्य है जिसे आप फिर से बना सकते हैं, लेकिन बाकी हर जगह यह गलत है। चरण 6 इसे ठीक करता है। लूप के अंतर्गत आने वाली अवधारणाओं को VPS पर अपना AI एजेंट बनाना में अधिक विस्तार से कवर किया गया है।

चरण 3: वे टूल्स जो एजेंट के पास पहले से नहीं थे

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

Model Context Protocol (MCP) वह समाधान है जिसे उद्योग ने अपनाया है। एक MCP सर्वर मानक ट्रांसपोर्ट के माध्यम से टूल्स का एक सेट एक्सपोज़ करता है, और कोई भी MCP-सक्षम एजेंट बिना किसी कस्टम ग्लू कोड के इसका उपयोग कर सकता है। रेफरेंस फाइलसिस्टम सर्वर केवल एक कमांड है:

npx -y @modelcontextprotocol/server-filesystem /home/you/projects

इसके लिए Node इंस्टॉल होना आवश्यक है, और डायरेक्टरी आर्ग्युमेंट ही वह एकमात्र पाथ है जिसे सर्वर एक्सेस करेगा। यह सुरक्षा मॉडल का एक छोटा रूप है: सर्वर सीमा तय करता है, मॉडल नहीं। किसी क्लाइंट को इसकी ओर पॉइंट करें और आपका एजेंट फाइल रीडिंग और राइटिंग की क्षमता प्राप्त कर लेगा जिसे आपने स्वयं नहीं लिखा है। इन्हें सही तरीके से, सर्विस अकाउंट के तहत और ट्रांसपोर्ट विकल्पों के साथ चलाने की जानकारी AI कोडिंग एजेंटों के लिए VPS पर MCP सर्वर चलाना में दी गई है।

इस चरण का सबक यह है कि टूल डिज़ाइन ही वास्तविक कार्य है। एक अस्पष्ट विवरण मॉडल को अनुमान लगाने पर मजबूर करता है। एक टूल जो चालीस हजार कैरेक्टर लौटाता है, वह कॉन्टेक्स्ट विंडो को दूषित कर देता है। एक टूल जो चीजों को डिलीट कर सकता है, वह अंततः चीजों को डिलीट कर ही देगा।

चरण 4: मेमोरी, जो मुख्य रूप से केवल फाइलें हैं

शुरुआती लोग यहाँ vector database का उपयोग करने की कोशिश करते हैं। ऐसा न करें, कम से कम अभी तो बिल्कुल नहीं।

एक agent के पास calls के बीच कोई मेमोरी नहीं होती है। आप हर बार पूरी बातचीत फिर से भेजते हैं, यही कारण है कि एक लंबा session छोटे session की तुलना में प्रति turn अधिक महंगा होता है। इसलिए मेमोरी दो समस्याओं में विभाजित हो जाती है। पहली यह है कि अभी context window में क्या फिट बैठता है, जिसे आप सारांशित करके (summarising), पुराने tool output को हटाकर (trimming), और अपने prompt के स्थिर prefix को cache करके प्रबंधित करते हैं, ताकि आप इसके लिए कीमत का एक छोटा हिस्सा ही चुकाएं। दूसरी समस्या यह है कि restart के बाद क्या सुरक्षित रहता है, जो कि storage है।

दूसरी समस्या के लिए, एक साधारण markdown फाइल जिसे agent पढ़ और लिख सके, लगभग हर पहले प्रोजेक्ट के लिए vector database से बेहतर होती है। इसे एक फाइल दें, इसे format बताएं, और इसे निर्देश दें कि शुरू करने से पहले उस फाइल को पढ़े और कुछ नया सीखने पर उसे update करे। आपको इसका अधिकांश लाभ मिल जाता है, और आप फाइल खोलकर देख सकते हैं कि आपका agent क्या मानता है। embeddings और retrieval का उपयोग तभी करें जब notes context window में फिट होना बंद हो जाएं, उससे पहले नहीं।

चरण 5: लूप ही उत्पाद है

अब तक आप एक ऐसा एजेंट बना चुके हैं जो आपके देखते समय काम करता है। चरण 5 इसे तब काम करने योग्य बनाना है जब आप उसे न देख रहे हों।

चार प्रश्न यह तय करते हैं कि क्या एक unattended एजेंट को अकेला छोड़ना सुरक्षित है। इसे क्या ट्रिगर करता है, ताकि यह व्यर्थ न चले। यह किस सीमा के भीतर काम करता है, ताकि कोई गलती सीमित रहे। परिणाम को कैसे सत्यापित किया जाता है, क्योंकि जो एजेंट अपना होमवर्क खुद जांचता है वह हमेशा पास हो जाता है। कौन सा बजट इसे रोकता है, टोकन में या वास्तविक समय (wall clock time) में। इन चारों को सोच-समझकर डिजाइन करना ही वह अनुशासन है जिसे लूप इंजीनियरिंग, और वह परिभाषा क्या कवर करती है में वर्णित किया गया है।

अभ्यास: अपने चरण 2 वाले एजेंट को लें, उसे चार या पांच चरणों वाला कोई कार्य दें, और एक सख्त iteration cap जोड़ें। फिर उस कैप को हटा दें और देखें कि एक unbounded लूप आपके टोकन बिल का क्या हाल करता है। इसे एक बार छोटे बजट पर करें ताकि आप कभी भी गलती से इसे बड़े बजट पर न कर बैठें।

चरण 6: सुरक्षा, सीक्रेट्स और लागत

यह चरण वैकल्पिक नहीं है, और यह अंत में केवल इसलिए है क्योंकि जब तक आप कुछ काम करने योग्य नहीं बना लेते, तब तक आप जोखिम को महसूस नहीं कर सकते।

Agent को अपने स्वयं के unprivileged user के रूप में चलाएं, कभी भी root के रूप में और कभी भी अपने स्वयं के account के रूप में नहीं, ताकि blast radius पूरी मशीन के बजाय केवल एक directory तक सीमित रहे। Credentials को model की पहुँच से दूर रखें, क्योंकि context window में मौजूद कोई भी चीज़ tool call के माध्यम से वापस उद्धृत (quote) की जा सकती है, और इसका समाधान keeping secrets out of your AI agents में वर्णित अनुसार helper के पीछे short lived tokens को सीमित करना है। खर्च पर एक सख्त सीमा (hard ceiling) निर्धारित करें, क्योंकि एक unattended loop बिना किसी की निगरानी के हर iteration के लिए बिल बनाती है, और इसे नियंत्रित रखने वाली caps और batching AI agent cost control on an always on VPS में दी गई हैं।

लागत एक ठोस संख्या की हकदार है। जुलाई 2026 तक, Claude Opus 5 प्रति मिलियन input tokens के लिए $5 और प्रति मिलियन output tokens के लिए $25 का शुल्क लेता है, और एक बातूनी (chatty) agent जो बढ़ती हुई बातचीत को बार-बार भेजता है, एक ही कार्य में कुछ लाख tokens खर्च कर सकता है। Prompt caching, और routine चरणों के लिए एक छोटा model, किसी भी prompt tweak की तुलना में उस गणित को कहीं अधिक बदल देते हैं।

Prompt injection भी इसी श्रेणी में आता है। यदि आपका agent कोई web page, issue tracker, या inbox पढ़ता है, तो जो कोई भी उस text को लिखता है, वह आपके agent के लिए निर्देश भी लिख रहा होता है। Web search आमतौर पर वह tool है जो इस दरवाजे को सबसे पहले खोलता है, और pointing an agent at your own SearXNG instance इसकी वायरिंग और इसके द्वारा बनाए गए injection surface को एक साथ दिखाता है। इसका बचाव कोई चतुर system prompt नहीं है। इसका बचाव boundary (सीमा) है, क्योंकि जिस agent को repository delete करने की अनुमति नहीं है, उसे ऐसा करने के लिए राजी नहीं किया जा सकता।

आपको किस पाठ्यक्रम का पालन करना चाहिए?

छह अलग-अलग पाठ्यक्रमों को थोड़ा-थोड़ा करने के बजाय, एक पाठ्यक्रम चुनें और उसे पूरा करें। Microsoft ai-agents-for-beginners रिपॉजिटरी सबसे पूर्ण मुफ्त पाठ्यक्रम है। यह अठारह पाठों का एक कोर्स है जिसे जुलाई 2026 तक 70,000 से अधिक स्टार्स मिल चुके हैं, और यह ऊपर दिए गए चरणों के साथ पूरी तरह मेल खाता है। ट्रेंडिंग एजेंट रिपॉजिटरी की सूची यह देखने के लिए उपयोगी है कि क्या उपलब्ध है, लेकिन पाठ्यक्रम के रूप में यह कम उपयोगी है, क्योंकि स्टार्स के आधार पर क्रमबद्ध सूची लोकप्रियता दर्शाती है, न कि सीखने का सही क्रम।

जब आप अभ्यास के लिए कोई वास्तविक प्रोजेक्ट चुनना चाहें, तो एक कोडिंग एजेंट पहला सबसे अच्छा लक्ष्य है: इसमें फीडबैक तुरंत मिलता है, टूल्स स्पष्ट होते हैं, और गलतियों को सुधारना आसान होता है। VPS पर कोडिंग AI एजेंट चलाना इसे शुरू से अंत तक पूरा करने की प्रक्रिया बताता है। यदि आप शून्य से बनाने के बजाय कार्यशील सिस्टम का अध्ययन करना पसंद करते हैं, तो सर्वश्रेष्ठ self hosted AI agents में की गई तुलना दिखाती है कि कैसे कई प्रोजेक्ट्स एक ही लूप को अलग-अलग तरीकों से हल करते हैं।

इसमें कितना समय लगता है?

जो लोग पहले से प्रोग्रामिंग जानते हैं, उनके लिए चरण 1 और 2 एक शाम का काम है। चरण 3 में एक सप्ताहांत लगता है, जिसका अधिकांश समय प्रोटोकॉल के बजाय टूल विवरणों को समझने में व्यतीत होता है। चरण 4 और 5 में वास्तविक उपयोग के कुछ सप्ताह लगते हैं, क्योंकि आप केवल यह देखकर सीखते हैं कि आपका एजेंट क्या भूलता है। चरण 6 कभी पूरी तरह समाप्त नहीं होता, क्योंकि आपके द्वारा दी गई प्रत्येक नई क्षमता इसे फिर से खोल देती है।

लगातार दो महीनों की शामें अधिकांश लोगों को एक कार्यशील, सीमित और उपयोगी एजेंट बनाने तक पहुँचा देती हैं। जो लोग एक साल का समय लेते हैं, वे आमतौर पर वे होते हैं जिन्होंने निर्माण करने के बजाय केवल पढ़ना जारी रखा।

FAQ

क्या AI agent बनाने के लिए मुझे machine learning आनी चाहिए?

नहीं। Agent बनाने का अर्थ है API के माध्यम से किसी model को कॉल करना और उसके tool requests को वास्तविक functions से जोड़ना, जो कि सामान्य application programming है। आपको training, gradients या datasets को छूने की आवश्यकता नहीं होती। आपके agent के काम करने की क्षमता इस बात पर निर्भर करती है कि आप tools के लिए schema कैसे design करते हैं, error handling कैसे करते हैं और Linux permissions को कैसे प्रबंधित करते हैं। Machine learning theory केवल तब प्रासंगिक होती है जब आप किसी model को fine-tune करना चाहते हैं, जो कि एक अलग कार्य है और जिसके लिए अलग पूर्व-आवश्यकताएँ होती हैं।

क्या मुझे LangChain या CrewAI जैसे framework से शुरुआत करनी चाहिए?

पहले एक raw loop लिखें, उसके बाद ही किसी framework को अपनाएं। एक framework stage 2 की तीस लाइनों को एक configuration object से बदल देता है, जो तब सुविधाजनक होता है जब आप जानते हैं कि उसने क्या बदला है, लेकिन उससे पहले यह भ्रमित करने वाला हो सकता है। जब आपका agent गलत व्यवहार करता है, तो आपको सीधे message list और tool results के बारे में सोचना पड़ता है, और यदि आपने उन्हें पहले कभी नहीं देखा है तो यह बहुत कठिन हो जाता है। एक बार अपना loop बना लेने के बाद, framework आपके समय की बचत करता है, न कि तंत्र को छिपाता है।

AI agents सीखने में कितना खर्च आता है?

यदि आप खर्च सीमित रखें, तो यह अधिकांश लोगों की अपेक्षा से कम है। एक hosted API key और एक छोटा VPS इन छह चरणों की हर आवश्यकता को पूरा कर सकता है। वास्तविक जोखिम hourly rate नहीं है, बल्कि एक असीमित loop है जो आपके सोते समय हर iteration के लिए billing करता है। पहले दिन ही अपने API account पर एक hard spend limit सेट करें, अपने द्वारा लिखे गए हर loop में एक iteration cap जोड़ें, और नियमित कार्यों के लिए सस्ते model का उपयोग करें। Model को स्थानीय रूप से चलाने से token का बिल खत्म हो जाता है, लेकिन इसके लिए hardware की आवश्यकता बढ़ जाती है।

AI agent और chatbot में क्या अंतर है?

Chatbot केवल एक बार उत्तर देता है। Agent एक चक्र को दोहराता है: model एक tool के लिए अनुरोध करता है, आपका code उसे चलाता है, परिणाम वापस भेजा जाता है, और model तय करता है कि आगे क्या करना है। यह पुनरावृत्ति ही वह प्रक्रिया है जो agent को कई चरणों वाले कार्य को पूरा करने में सक्षम बनाती है, और यही कारण है कि agents को उन सीमाओं की आवश्यकता होती है जिनकी chatbot को नहीं होती। Chatbot से मिला गलत उत्तर केवल एक खराब paragraph हो सकता है। Agent से मिला गलत उत्तर एक खराब paragraph के साथ-साथ वह सब कुछ हो सकता है जो उसने उस गलती के कारण किया है।