AI agents शून्यापासून कसे शिकावे? सहा टप्प्यांचा मार्ग

सहा टप्प्यांमधील मार्ग

AI agents शून्यापासून शिकण्यासाठी सहा टप्पे क्रमाने पूर्ण करा: संकल्पना, तुमचा पहिला loop, tools, memory, loop design आणि safety. प्रत्येक टप्प्यात तुम्ही स्वतःच्या हाताने एक गोष्ट तयार कराल. पुढे जाणे हे लोक अडखळण्याचे सर्वात सामान्य कारण आहे, कारण framework तुम्हाला पाहणे आवश्यक असलेला भाग नेमका लपवते.

AI agent म्हणजे tools कॉल करण्याची अनुमती असलेल्या language model भोवती चालणारा loop होय. हे वाक्यच संपूर्ण विषय आहे. त्यानंतरचे सर्व तपशील loop मध्ये काय जाते, tools कशावर परिणाम करू शकतात आणि loop चुकीच्या पद्धतीने चालू लागल्यास तो कसा थांबवायचा यासंबंधी आहेत. तुम्ही हा loop दुसऱ्या व्यक्तीला समजावून सांगू शकत असाल, तर तुम्ही ही संकल्पना शिकला आहात. तुम्ही फक्त frameworks ची नावे सांगू शकत असाल, तर तुम्ही ती शिकलेली नाही.

खालील आराखडा तुम्ही प्रत्यक्ष बांधकाम करून शिकता, असे गृहीत धरतो. एक टप्पा वाचा, त्यातील छोटी गोष्ट तयार करा, ती जाणीवपूर्वक बिघडवा आणि मग पुढे जा. तुम्ही फक्त वाचलेला टप्पा प्रत्यक्षात पूर्ण केलेला टप्पा नाही.

stage 1 पूर्वी प्रत्यक्षात आवश्यक असलेल्या गोष्टी

आवश्यक पूर्वतयारीची यादी छोटी आहे. बहुतेक course पृष्ठांवर ती सुचवली जाते त्यापेक्षा ही यादी आणखी छोटी आहे.

• तुम्ही पन्नास ओळींच्या script च्या पातळीवर Python किंवा TypeScript वाचू आणि लिहू शकता.
• Linux shell वापरण्यात तुम्हाला अडचण नाही: package install करणे, file edit करणे आणि log वाचणे तुम्हाला जमते.
• तुमच्याकडे hosted model साठी API key आहे किंवा local model चालवू शकणारे machine आहे.

हीच संपूर्ण यादी आहे. तुम्हाला machine learning theory ची गरज नाही. तुम्ही model train केलेले असणेही आवश्यक नाही. Agent कार्यामध्ये gradients किंवा training data यांचा समावेश नसतो. तुम्ही model स्वतः चालवण्याचा निर्णय घेतल्यासच graphics card महत्त्वाचे ठरते. ते वेगळे कौशल्य आहे आणि ते तुम्ही नंतर LLM स्वतः host करण्यासाठी VPS वर Ollama host करणे यावरून शिकू शकता.

Shell संबंधीचा भाग लोक कमी लेखतात. Permissions, paths, environment variables आणि शांतपणे बंद होणाऱ्या processes मुळे agents fail होतात. PATH किंवा file mode संबंधीचा stack trace पाहून terminal बंद करावेसे वाटत असेल, तर आधी Linux basics साठी एक weekend द्या. त्यामुळे नंतरचा एक महिना वाचेल.

टप्पा 1: एजंट म्हणजे काय आणि तो काय नाही

एका API कॉलने आणि कोणत्याही लूपशिवाय सुरुवात करा. प्रॉम्प्ट पाठवा, उत्तर प्रिंट करा आणि प्रतिसादातील टोकनची संख्या पाहा. आता खर्चाचे एकक आणि विलंबाचे एकक समजले आहे.

त्यानंतर tool use शिका. संपूर्ण क्षेत्रातील हीच एकमेव खरोखर नवीन संकल्पना आहे. फंक्शनचे नाव, वर्णन आणि त्याच्या इनपुटसाठी JSON (JavaScript object notation) schema देऊन ते मॉडेलला वर्णन करा. मॉडेल स्वतः काहीही चालवत नाही. ते संरचित विनंतीसह उत्तर देते: या युक्तिवादांसह run_command कॉल करा. तुमचा कोड फंक्शन चालवतो, त्याचे आउटपुट message म्हणून परत पाठवतो आणि मॉडेलला पुन्हा विचारतो. मॉडेल मजकूर वाचून मजकूर लिहिणारा planner आहे. तुमचा कोड प्रत्यक्ष कृती करणारा भाग आहे.

Chatbot एका उत्तरानंतर थांबतो. मॉडेलने tools मागणे थांबवेपर्यंत agent हा संवाद पुन्हा पुन्हा करतो. हाच संपूर्ण फरक आहे आणि त्यामुळे failure modes देखील वेगळे असतात. Chatbot एकदा चुकीचे उत्तर देतो. कोणाच्या लक्षात येण्यापूर्वी agent चुकीच्या उत्तरावर अनेक वेळा कृती करतो.

टप्पा 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 नाकारते आणि नवशिक्यांकडून होणारी ही सर्वात सामान्य चूक आहे. दोन commands आवश्यक असलेला प्रश्न विचारा आणि लूप दोनदा चालताना पाहा. अशक्य प्रश्न विचारा आणि ते एकतर प्रयत्न सोडते किंवा कायमचे फिरत राहते.

या उदाहरणाबाबत एक इशारा. येथे मॉडेलचे आउटपुट shell=True वापरून थेट shell मध्ये दिले जाते. पुन्हा तयार करता येणाऱ्या चाचणी मशीनवर हे स्वीकार्य आहे, परंतु इतर सर्व ठिकाणी ते चुकीचे आहे. टप्पा 6 मध्ये याचे निराकरण केले आहे. लूपमागील संकल्पनांचे अधिक सविस्तर स्पष्टीकरण तुमच्या VPS वर स्वतःचा AI agent तयार करणे येथे दिले आहे.

टप्पा 3: एजंटकडे आधीपासून नसलेली साधने

तुमचे run_command साधन कार्य करते. परंतु वास्तविक एजंटला बाह्य प्रणालींशी जोडणारी साधने आवश्यक असतात: तिकीट प्रणाली, डेटाबेस आणि रिपॉझिटरी. प्रत्येक सेवेसाठी आणि प्रत्येक एजंटसाठी स्वतंत्र wrapper लिहिणे मोठ्या प्रमाणावर व्यवहार्य नाही.

उद्योगाने Model Context Protocol (MCP) यावर उपाय म्हणून मान्यता दिली आहे. MCP server प्रमाणित transport द्वारे साधनांचा संच उपलब्ध करून देतो. कोणताही MCP-सक्षम एजंट त्याचा वापर custom glue शिवाय करू शकतो. संदर्भ filesystem server सुरू करण्यासाठी एकच command आहे:

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

यासाठी Node स्थापित असणे आवश्यक आहे. तसेच, directory argument हाच server ज्या एकमेव path वर काम करेल तो path असतो. हेच या सुरक्षा मॉडेलचे संक्षिप्त रूप आहे: सीमा model ठरवत नाही, server ठरवतो. Client ला त्याकडे निर्देशित केल्यावर तुमच्या एजंटला तुम्ही स्वतः न लिहिलेली file reading आणि writing क्षमता मिळते. ही साधने योग्य प्रकारे, service account अंतर्गत आणि transport निवडींच्या स्पष्टीकरणासह चालवण्याची माहिती AI coding agents साठी VPS वर MCP servers चालवणे येथे दिली आहे.

या टप्प्याचा मुख्य धडा असा आहे की tool design हेच खरे काम आहे. अस्पष्ट वर्णनामुळे model अंदाज लावतो. चाळीस हजार characters परत करणारे साधन context window दूषित करते. वस्तू delete करू शकणारे साधन अखेरीस वस्तू delete करेल.

टप्पा 4: मेमरी, जी प्रामुख्याने फाइल्समध्ये असते

येथे नवशिके vector database वापरतात. तसे करू नका, निदान अजून तरी नाही.

एका कॉलपासून दुसऱ्या कॉलपर्यंत agent कडे मेमरी नसते. प्रत्येक वेळी संपूर्ण संभाषण पुन्हा पाठवावे लागते. त्यामुळे लहान सत्राच्या तुलनेत मोठ्या सत्रासाठी प्रत्येक turn चा खर्च अधिक असतो. त्यामुळे मेमरीचे दोन भाग होतात. पहिला भाग म्हणजे सध्या context window मध्ये काय बसते. हे तुम्ही सारांश तयार करून, जुन्या tool output मधील अनावश्यक भाग काढून आणि prompt च्या स्थिर सुरुवातीच्या भागाचे caching करून व्यवस्थापित करता. त्यामुळे त्या भागासाठी पूर्ण किंमतीचा केवळ काही अंश खर्च होतो. दुसरा भाग म्हणजे restart नंतर काय टिकून राहते. त्यासाठी storage आवश्यक असते.

दुसऱ्या समस्येसाठी, agent वाचू आणि लिहू शकेल अशी साधी markdown file जवळजवळ प्रत्येक पहिल्या प्रकल्पासाठी vector database पेक्षा अधिक उपयुक्त ठरते. त्याला एक फाइल द्या, तिचे format सांगा, काम सुरू करण्यापूर्वी ती फाइल वाचण्यास आणि काही नवीन शिकल्यावर ती अपडेट करण्यास सांगा. तुम्हाला बहुतांश लाभ मिळतो. तसेच, फाइल उघडून तुमच्या agent च्या मते काय आहे ते पाहता येते. नोंदी context window मध्ये मावेनाशा झाल्यावरच embeddings आणि retrieval वापरा. त्यापूर्वी वापरू नका.

टप्पा 5: लूप हेच उत्पादन आहे

आतापर्यंत तुम्ही निरीक्षण करत असताना कार्य करणारा agent तयार करू शकता. टप्पा 5 मध्ये, तुम्ही निरीक्षण करत नसतानाही तो कार्य करेल अशी रचना करायची आहे.

निरीक्षणाशिवाय agent सुरक्षितपणे चालू ठेवता येईल की नाही, हे चार प्रश्न ठरवतात. तो कशामुळे सुरू होतो, म्हणजे तो कोणत्याही कारणाशिवाय चालू होणार नाही. तो कोणत्या मर्यादेत कार्य करतो, म्हणजे झालेली चूक मर्यादित राहील. परिणामाची पडताळणी कशी केली जाते, कारण स्वतःचे काम स्वतः तपासणारा agent नेहमी उत्तीर्ण होतो. तसेच, tokens किंवा wall clock time मध्ये कोणते budget त्याला थांबवते. या चार बाबी जाणीवपूर्वक तयार करणे ही loop engineering आणि त्या व्याख्येत समाविष्ट असलेल्या बाबी मध्ये वर्णन केलेली शिस्त आहे.

सराव: तुमचा stage 2 agent घ्या, त्याला चार किंवा पाच चरणांची आवश्यकता असलेले task द्या आणि hard iteration cap जोडा. त्यानंतर cap काढून टाका आणि unbounded loop मुळे तुमच्या token bill वर काय परिणाम होतो ते पाहा. हे प्रथम लहान budget वर एकदा करा, म्हणजे मोठ्या budget वर ते चुकून होणार नाही.

टप्पा 6: सुरक्षितता, गुप्त माहिती आणि खर्च

हा टप्पा ऐच्छिक नाही. तो शेवटी आहे, कारण कार्यरत प्रणाली तयार करेपर्यंत जोखीम जाणवत नाही.

Agent स्वतंत्र unprivileged user म्हणून चालवा. तो root म्हणून किंवा तुमच्या स्वतःच्या account म्हणून कधीही चालवू नका. त्यामुळे संभाव्य हानीची व्याप्ती संपूर्ण machine ऐवजी एका directoryपुरती मर्यादित राहते. Credentials modelच्या आवाक्याबाहेर ठेवा. Context windowमध्ये असलेली कोणतीही माहिती tool callद्वारे पुन्हा बाहेर पाठवली जाऊ शकते. यासाठी helperच्या मागे मर्यादित कालावधीचे tokens वापरा, जसे तुमच्या AI agents पासून secrets दूर ठेवणे मध्ये सांगितले आहे. खर्चावर कठोर कमाल मर्यादा ठेवा. कारण unattended loop प्रत्येक iterationचा खर्च आकारतो आणि त्यावर लक्ष ठेवणारी व्यक्ती नसते. खर्च नियंत्रणात ठेवणाऱ्या caps आणि batchingची माहिती नेहमी सुरू असलेल्या VPS वरील AI agent cost control मध्ये दिली आहे.

खर्चासाठी एक ठोस आकडा पाहू. July 2026पर्यंत Claude Opus 5 प्रत्येक million input tokensसाठी $5 आणि प्रत्येक million output tokensसाठी $25 आकारते. वाढत जाणारे conversation पुन्हा पाठवणारा chatty agent एकाच taskमध्ये काही hundred thousand tokens वापरू शकतो. Prompt caching आणि नियमित stepsसाठी smaller model वापरणे, कोणत्याही prompt tweakपेक्षा हे गणित अधिक बदलते.

Prompt injectionचाही येथे विचार करा. तुमचा agent web page, issue tracker किंवा inbox वाचत असल्यास, तो मजकूर लिहिणारी व्यक्ती तुमच्या agentसाठी instructionsसुद्धा लिहित असते. यावरील defence अधिक clever system prompt नाही. खरी सुरक्षा boundaryमध्ये आहे. कारण repository delete करू न शकणाऱ्या agentला ते delete करण्यास प्रवृत्त करता येत नाही.

कोणता अभ्यासक्रम घ्यावा?

एकच अभ्यासक्रम निवडा आणि सहा अभ्यासक्रमांचा थोडा-थोडा अभ्यास करण्याऐवजी तो पूर्ण करा. Microsoft ai-agents-for-beginners repository हा सर्वाधिक सविस्तर मोफत अभ्यासक्रम आहे. हा 18 धड्यांचा अभ्यासक्रम असून July 2026 पर्यंत त्याला 70,000 पेक्षा जास्त stars मिळाले आहेत. तो वरील टप्प्यांशी सुसंगतपणे जुळतो. Trending agent repositories ची संकलित यादी उपलब्ध प्रकल्प समजून घेण्यासाठी उपयुक्त असते. परंतु अभ्यासक्रम म्हणून ती कमी उपयुक्त असते, कारण stars नुसार क्रम लावलेली यादी लोकप्रियतेनुसार असते, अध्यापनाच्या क्रमाने नाही.

सरावासाठी प्रत्यक्ष प्रकल्प हवा असल्यास, coding agent हे सुरुवातीचे सर्वोत्तम लक्ष्य आहे. त्याचा अभिप्राय त्वरित मिळतो, tools स्पष्ट असतात आणि चुका सहजपणे पूर्ववत करता येतात. VPS वर coding AI agent चालवणे यामध्ये एका agent ची सुरुवातीपासून शेवटपर्यंत प्रक्रिया दिली आहे. शून्यापासून system तयार करण्याऐवजी कार्यरत systems चा अभ्यास करायचा असल्यास, सर्वोत्तम self hosted AI agents मधील तुलना अनेक प्रकल्प समान 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 कार्य करतो की नाही हे ठरवणारी कौशल्ये म्हणजे tools साठी schema design, error handling आणि Linux permissions. तुम्ही model fine tune करण्याचे पुढील काम स्वीकारल्यासच machine learning theory संबंधित ठरते. ते वेगळे काम असून त्यासाठी वेगळी पूर्वअट असते.

मी LangChain किंवा CrewAI सारख्या framework पासून सुरुवात करावी का?

प्रथम एक raw loop लिहा. त्यानंतर framework स्वीकारा. Framework stage 2 मधील तीस ओळी configuration object ने बदलते. तुम्हाला त्या configuration object ने नेमके काय बदलले आहे हे माहीत असल्यास ते सोयीचे ठरते. त्यापूर्वी ते गोंधळात टाकू शकते. तुमचा agent चुकीचे वर्तन करत असल्यास message list आणि tool results यांचा थेट विचार करावा लागतो. ते आधी कधी पाहिले नसल्यास हे अधिक कठीण होते. स्वतःचा एक loop लिहिल्यानंतर framework कार्यपद्धती लपवण्याऐवजी तुमचा वेळ वाचवते.

AI agents शिकण्यासाठी किती खर्च येतो?

खर्च मर्यादित ठेवल्यास, बहुतेक लोकांच्या अपेक्षेपेक्षा कमी खर्च येतो. Hosted API key आणि छोटा VPS या सहा stages साठी पुरेसे आहेत. खरा धोका hourly rate नसून तुम्ही झोपेत असताना प्रत्येक iteration साठी शुल्क आकारणारा अमर्यादित loop हा आहे. पहिल्याच दिवशी तुमच्या API account वर कठोर spend limit सेट करा. तुम्ही लिहिलेल्या प्रत्येक loop मध्ये iteration cap जोडा. नियमित steps साठी स्वस्त model वापरा. Model स्थानिक पातळीवर चालवल्यास token चे शुल्क राहत नाही. त्याऐवजी hardware ची आवश्यकता निर्माण होते.

AI agent आणि chatbot यांच्यात काय फरक आहे?

Chatbot एकदा उत्तर देतो. Agent एक cycle पुन्हा पुन्हा चालवतो: model एखाद्या tool ची विनंती करतो, तुमचा code ते चालवतो, result परत पाठवला जातो आणि पुढे काय करायचे हे model ठरवतो. या पुनरावृत्तीमुळे agent अनेक steps असलेले task पूर्ण करू शकतो. त्यामुळे chatbot साठी आवश्यक नसलेल्या boundaries agents साठी आवश्यक असतात. Chatbot चे चुकीचे उत्तर म्हणजे खराब paragraph. Agent चे चुकीचे उत्तर म्हणजे खराब paragraph आणि त्यावर त्याने केलेली चुकीची कृती.