AI agents शुरू से कैसे सीखें: 6 चरणों की योजना

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

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

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

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

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

आवश्यक prerequisites की सूची छोटी है और अधिकांश course pages के बताए अनुसार उससे भी छोटी है।

• आप पचास पंक्तियों वाली script के स्तर पर Python या TypeScript पढ़ और लिख सकते हैं।
• आप Linux shell में सहज हैं: package install करना, file edit करना और log पढ़ना जानते हैं।
• आपके पास hosted model की API key है या ऐसा machine है जो local model चला सकता है।

बस इतनी ही सूची है। आपको machine learning theory की आवश्यकता नहीं है और न ही आपने कोई model train किया होना चाहिए। Agent के काम में gradients या training data शामिल नहीं होते। Graphics card की आवश्यकता केवल तब होती है जब आप model को स्वयं चलाने का निर्णय लेते हैं। यह अलग skill है, जिसे आप बाद में VPS पर Ollama host करके LLM को स्वयं host करना से सीख सकते हैं।

Shell वाले हिस्से को लोग अक्सर कम आंकते हैं। Agents permissions, paths, environment variables और चुपचाप बंद हो जाने वाली processes के कारण fail होते हैं। यदि PATH या file mode से संबंधित stack trace देखकर आप terminal बंद कर देते हैं, तो पहले Linux basics सीखने के लिए एक weekend दें। इससे बाद में आपका एक महीना बचेगा।

चरण 1: agent क्या है और क्या नहीं है

एक API call से शुरू करें और कोई loop न रखें। एक prompt भेजें, reply प्रिंट करें और response में token counts देखें। अब आप cost की इकाई और latency की इकाई समझते हैं।

इसके बाद tool use सीखें। पूरे क्षेत्र में यही एक वास्तविक रूप से नया विचार है। आप model को किसी function का नाम, उसका विवरण और उसके inputs के लिए JSON (JavaScript object notation) schema बताते हैं। model स्वयं कुछ नहीं चलाता। वह एक structured request भेजता है: इन arguments के साथ run_command को call करें। आपका code function चलाता है, उसके output को message के रूप में वापस भेजता है और model से फिर पूछता है। model ऐसा planner है जो text पढ़ता और text लिखता है। आपके code के पास कार्य करने की क्षमता होती है।

Chatbot एक reply के बाद रुक जाता है। Agent उस exchange को तब तक दोहराता है, जब तक model tools के लिए अनुरोध करना बंद नहीं कर देता। यही पूरा अंतर है और इसी कारण failure modes भी अलग होते हैं। Chatbot एक बार गलत उत्तर देता है। Agent के गलत उत्तर पर कोई ध्यान देने से पहले वह कई बार कार्रवाई कर सकता है।

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

किसी framework से शुरुआत न करें। 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 के साथ चलाएँ। सफल रन आपके filesystems और उनमें उपलब्ध free space का नाम बताते हुए एक पैराग्राफ प्रिंट करता है, क्योंकि model ने df -h माँगा, आपके code ने उसे चलाया, और दूसरे pass ने उस table को एक वाक्य में बदल दिया। यदि कुछ भी प्रिंट नहीं होता, तो text block आने से पहले लूप समाप्त हो गया। लूप के अंदर print(response.stop_reason) जोड़ें और मानों को बदलते हुए देखें।

अब इसे जानबूझकर खराब करें। tool_use_id वाली पंक्ति हटाकर error पढ़ें, क्योंकि matching id के बिना tool result को API अस्वीकार करती है और यह शुरुआती उपयोगकर्ताओं की सबसे सामान्य गलती है। ऐसा प्रश्न पूछें जिसके लिए दो commands आवश्यक हों और देखें कि लूप दो बार चलता है। ऐसा प्रश्न पूछें जिसका कोई संभव उत्तर न हो और देखें कि लूप या तो हार मान लेता है या हमेशा चलता रहता है।

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

Stage 3: एजेंट के पास पहले से उपलब्ध न होने वाले टूल

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

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

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

इसके लिए Node installed होना चाहिए, और directory argument ही वह एकमात्र path है जिस पर सर्वर काम करेगा। यही सुरक्षा मॉडल का संक्षिप्त रूप है: सीमा मॉडल नहीं, बल्कि सर्वर निर्धारित करता है। किसी client को इस सर्वर से जोड़ने पर आपके एजेंट को file reading और writing की सुविधा मिल जाती है, जिसे आपने स्वयं नहीं लिखा। इन्हें service account के अंतर्गत और transport विकल्पों की व्याख्या के साथ सही तरीके से चलाने का विवरण AI coding agents के लिए VPS पर MCP servers चलाना में दिया गया है।

इस stage का मुख्य पाठ यह है कि tool design ही वास्तविक कार्य है। अस्पष्ट विवरण मॉडल को अनुमान लगाने के लिए मजबूर करता है। चालीस हजार characters लौटाने वाला टूल context window को दूषित कर देता है। चीज़ें delete करने में सक्षम टूल अंततः चीज़ें delete करेगा।

चरण 4: मेमोरी, जो अधिकतर केवल फ़ाइलें हैं

शुरुआत करने वाले लोग इस चरण में vector database का उपयोग करते हैं। अभी ऐसा न करें।

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

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

Stage 5: loop ही product है

अब तक आप ऐसा agent बना सकते हैं जो आपके देखते रहने तक काम करता है। Stage 5 में उसे आपके अनुपस्थित रहने पर भी काम करने योग्य बनाना है।

चार प्रश्न तय करते हैं कि unattended agent को अकेला छोड़ना सुरक्षित है या नहीं। उसे क्या trigger करता है, ताकि वह बिना किसी काम के न चले। वह किस boundary के भीतर काम करता है, ताकि गलती का प्रभाव सीमित रहे। परिणाम का सत्यापन कैसे किया जाता है, क्योंकि अपने ही homework को grade करने वाला agent हमेशा पास होता है। कौन-सा budget उसे रोकता है, चाहे वह tokens में हो या wall clock time में। इन चार बातों को जानबूझकर design करना ही loop engineering और इस परिभाषा के दायरे में वर्णित discipline है।

अभ्यास: अपने stage 2 agent को लें, उसे ऐसा task दें जिसमें चार या पांच steps की आवश्यकता हो, और hard iteration cap जोड़ें। फिर cap हटाकर देखें कि unbounded loop आपके token bill को कैसे बढ़ाता है। इसे एक बार small budget पर करें, ताकि बड़े budget पर आपसे यह गलती कभी न हो।

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

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

Agent को अपने अलग unprivileged user के रूप में चलाएँ। इसे कभी root या अपने account के रूप में न चलाएँ। इससे संभावित नुकसान का दायरा पूरी machine के बजाय एक directory तक सीमित रहता है। Credentials को model की पहुँच से बाहर रखें। Context window में मौजूद किसी भी चीज़ को tool call के माध्यम से वापस उद्धृत किया जा सकता है। इसका समाधान helper के पीछे सीमित अवधि वाले scoped tokens रखना है, जैसा कि अपने AI agents से secrets को बाहर रखना में बताया गया है। खर्च की एक hard ceiling तय करें। बिना निगरानी चलने वाला loop हर iteration का शुल्क लेता है। इसे नियंत्रित रखने वाले caps और batching का विवरण हमेशा चालू VPS पर AI agent की लागत नियंत्रित करना में है।

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

Prompt injection भी इसी चरण में आता है। यदि आपका agent कोई web page, issue tracker या inbox पढ़ता है, तो वह text लिखने वाला व्यक्ति आपके agent के लिए instructions भी लिख रहा है। इसका बचाव अधिक clever system prompt नहीं है। बचाव boundary है। यदि agent किसी repository को delete नहीं कर सकता, तो उसे repository delete करने के लिए बहकाया नहीं जा सकता।

आपको किस मानचित्र का अनुसरण करना चाहिए?

छह पाठ्यक्रमों को थोड़ा-थोड़ा पढ़ने के बजाय एक पाठ्यक्रम चुनें और उसे पूरा करें। Microsoft ai-agents-for-beginners repository सबसे पूर्ण निःशुल्क विकल्प है। यह 18 पाठों वाला पाठ्यक्रम है और July 2026 तक इसे 70,000 से अधिक stars मिल चुके हैं। यह ऊपर बताए गए चरणों के साथ स्पष्ट रूप से मेल खाता है। लोकप्रिय agent repositories की सूचियाँ यह देखने के लिए उपयोगी हैं कि क्या उपलब्ध है, लेकिन syllabus के रूप में इनकी उपयोगिता बहुत कम है। इसका कारण यह है कि stars के आधार पर क्रमबद्ध सूची लोकप्रियता के अनुसार होती है, शिक्षण क्रम के अनुसार नहीं।

जब आप अभ्यास के लिए कोई वास्तविक project चाहते हैं, तो coding agent सबसे अच्छा पहला लक्ष्य है। इसका feedback तुरंत मिलता है, इसके tools स्पष्ट होते हैं और गलतियों को आसानी से undo किया जा सकता है। VPS पर coding AI agent चलाना में इसकी पूरी प्रक्रिया बताई गई है। यदि आप शून्य से बनाने के बजाय कार्यरत systems का अध्ययन करना चाहते हैं, तो सबसे अच्छे self hosted AI agents की तुलना दिखाती है कि कई projects एक ही loop को अलग-अलग तरीकों से कैसे हल करते हैं।

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

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

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

FAQ

AI agent बनाने के लिए क्या मुझे machine learning जानना आवश्यक है?

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

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

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

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

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

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

Chatbot एक बार उत्तर देता है। Agent एक cycle दोहराता है: model किसी tool के लिए request करता है, आपका code उसे चलाता है, result वापस जाता है और model तय करता है कि आगे क्या करना है। यही repetition agent को कई steps वाला task पूरा करने देती है। इसी कारण agents को ऐसी boundaries की आवश्यकता होती है जिनकी chatbots को नहीं होती। Chatbot का गलत उत्तर एक खराब paragraph होता है। Agent का गलत उत्तर एक खराब paragraph और उसके आधार पर किया गया कोई भी काम होता है।