AI agents‌ను మొదటి నుంచి ఎలా నేర్చుకోవాలి

ఆరు దశల్లో మార్గం

AI agents‌ను మొదటి నుంచి నేర్చుకోవడానికి, ఈ ఆరు దశలను క్రమంగా పూర్తి చేయండి: భావనలు, మీ మొదటి loop, tools, memory, loop రూపకల్పన మరియు safety. ప్రతి దశలో మీరు స్వయంగా నిర్మించాల్సిన ఒక అంశం ఉంటుంది. ముందుకు దూకడం వల్లనే చాలామంది సాధారణంగా ఆగిపోతారు. కారణం, framework‌లు మీరు చూడాల్సిన ముఖ్యమైన భాగాన్నే దాచేస్తాయి.

AI agent అనేది tools‌ను పిలవడానికి అనుమతించబడిన language model చుట్టూ పనిచేసే loop. ఈ వాక్యమే మొత్తం విషయం. ఆ తరువాతి అంశాలన్నీ loop‌లో ఏమి చేర్చాలి, tools ఏ భాగాలను తాకవచ్చు, loop తప్పుగా పనిచేసినప్పుడు దాన్ని ఎలా ఆపాలి అనే వివరాలే. మీరు ఈ loop‌ను మరొకరికి వివరించగలిగితే, మీరు విషయాన్ని నేర్చుకున్నారు. framework‌ల పేర్లు మాత్రమే చెప్పగలిగితే, మీరు ఇంకా నేర్చుకోలేదు.

క్రింది ప్రణాళిక మీరు నిర్మిస్తూ నేర్చుకుంటారని భావిస్తుంది. ఒక దశను చదవండి, ఆ చిన్న అంశాన్ని నిర్మించండి, ఉద్దేశపూర్వకంగా దాన్ని విఫలమయ్యేలా చేయండి, తరువాత ముందుకు సాగండి. మీరు కేవలం చదివిన దశను పూర్తిచేసిన దశగా పరిగణించలేం.

stage 1 ప్రారంభించడానికి వాస్తవంగా అవసరమైనవి

వాస్తవ అవసరాల జాబితా చిన్నదే. చాలా కోర్సు పేజీలు సూచించేదానికంటే ఇది ఇంకా చిన్నది.

• మీరు fifty line script స్థాయిలో Python లేదా TypeScript కోడ్‌ను చదవగలరు, రాయగలరు.
• మీరు Linux shellలో సౌకర్యంగా పనిచేయగలరు: ప్యాకేజీని install చేయడం, ఫైల్‌ను edit చేయడం, logను చదవడం.
• మీ వద్ద hosted model కోసం API key ఉండాలి. లేదా local modelను run చేయగల machine ఉండాలి.

ఇదే పూర్తి జాబితా. మీకు machine learning theory అవసరం లేదు. మీరు modelను train చేసి ఉండాల్సిన అవసరం కూడా లేదు. agent పనిలో gradients లేదా training data ఉండవు. మీరు modelను స్వయంగా run చేయాలని నిర్ణయించుకుంటేనే graphics card అవసరం. అది వేరే skill. తరువాత VPSలో Ollamaను host చేసి LLMను స్వయంగా host చేయడం ద్వారా దాన్ని నేర్చుకోవచ్చు.

చాలామంది తక్కువగా అంచనా వేసేది shellకు సంబంధించిన భాగం. Permissions, paths, environment variables, అలాగే నిశ్శబ్దంగా ఆగిపోయే processes కారణంగా agents విఫలమవుతాయి. PATH లేదా file mode గురించి stack trace కనిపించినప్పుడు మీరు terminalను మూసేస్తే, ముందుగా Linux basics నేర్చుకోవడానికి ఒక వారాంతాన్ని కేటాయించండి. అది తరువాత మీకు ఒక నెల సమయాన్ని ఆదా చేస్తుంది.

దశ 1: agent అంటే ఏమిటి, అది ఏమి కాదు

మొదట ఒక API call మాత్రమే చేయండి; loop ఉపయోగించవద్దు. ఒక prompt పంపి, వచ్చిన reply ను print చేయండి. response లోని token counts ను పరిశీలించండి. ఇప్పుడు ఖర్చు యొక్క యూనిట్, latency యొక్క యూనిట్ మీకు అర్థమవుతాయి.

తర్వాత tool use నేర్చుకోండి. మొత్తం రంగంలో నిజంగా కొత్త ఆలోచన ఇదొక్కటే. ఒక function ను model కు name, description, అలాగే దాని inputs కోసం JSON (JavaScript object notation) schema రూపంలో వివరించండి. model స్వయంగా ఏదీ run చేయదు. అది structured request ను పంపుతుంది: ఈ arguments తో run_command ను call చేయండి. మీ code ఆ function ను run చేసి, దాని output ను message గా తిరిగి పంపి, model ను మళ్లీ అడుగుతుంది. model text ను చదివి text ను రాసే planner. మీ code పనులను నిర్వహిస్తుంది.

chatbot ఒక reply తర్వాత ఆగిపోతుంది. model tools కోసం అడగడం ఆపే వరకు agent ఈ మార్పిడిని పునరావృతం చేస్తుంది. మొత్తం తేడా ఇదే. అందుకే 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 పేర్లు మరియు వాటిలోని ఖాళీ స్థలాన్ని తెలిపే ఒక పేరాగ్రాఫ్‌ను ముద్రిస్తుంది. దీనికి కారణం model df -hను అడగడం, మీ code దాన్ని అమలు చేయడం, అలాగే రెండో pass ఆ పట్టికను ఒక వాక్యంగా మార్చడం. ఏదీ ముద్రించకపోతే, text block వచ్చేలోపే loop ముగిసింది. Loop‌లో print(response.stop_reason)ను చేర్చి, విలువలు ఎలా మారుతున్నాయో గమనించండి.

ఇప్పుడు ఉద్దేశపూర్వకంగా లోపం సృష్టించండి. tool_use_id పంక్తిని తొలగించి, error‌ను చదవండి. సరిపోలే id లేని tool result‌ను API తిరస్కరిస్తుంది. ప్రారంభంలో ఎక్కువగా ఎదురయ్యే bug ఇదే. రెండు commands అవసరమైన ప్రశ్న అడిగి, loop రెండుసార్లు ఎలా నడుస్తుందో గమనించండి. సాధ్యం కాని ప్రశ్న అడిగి, అది ఎలా ఆగిపోతుందో లేదా నిరవధికంగా ఎలా తిరుగుతుందో చూడండి.

ఈ ఉదాహరణ గురించి ఒక హెచ్చరిక. ఇది model output‌ను shell=Trueతో నేరుగా shell‌కు పంపుతుంది. తిరిగి నిర్మించగల scratch machine‌లో ఇది ఆమోదయోగ్యం. ఇతర అన్ని సందర్భాల్లో ఇది తప్పు. Stage 6లో దీనికి పరిష్కారం చూపుతాము. Loop‌కు సంబంధించిన భావనలను మీ స్వంత AI agent‌ను VPSలో నిర్మించడంలో మరింత విస్తృతంగా వివరించాము.

దశ 3: ఏజెంట్ వద్ద ఇప్పటికే లేని సాధనాలు

మీ run_command సాధనం పనిచేస్తుంది. కానీ వాస్తవ ఏజెంట్‌కు సిస్టమ్ వెలుపల ఉన్న వనరులను చేరుకునే సాధనాలు అవసరం: టికెట్ సిస్టమ్, డేటాబేస్, రిపాజిటరీ. ప్రతి సేవ కోసం, ప్రతి ఏజెంట్ కోసం ప్రత్యేక wrapper రాయడం విస్తరించగల విధానం కాదు.

Model Context Protocol (MCP)నే పరిశ్రమ స్వీకరించిన పరిష్కారం. MCP server ప్రామాణిక transport ద్వారా సాధనాల సమితిని అందిస్తుంది. ఏ MCP-aware agent అయినా custom glue లేకుండా దాన్ని ఉపయోగించగలదు. Reference filesystem server కోసం ఒకే command సరిపోతుంది:

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

దీనికి Node ఇన్‌స్టాల్ అయి ఉండాలి. Directory argument మాత్రమే server తాకగల path. ఇది భద్రతా నమూనాను సంక్షిప్తంగా చూపిస్తుంది: సరిహద్దును model కాదు, server నిర్ణయిస్తుంది. Client‌ను దానికి అనుసంధానిస్తే, మీరు స్వయంగా రాయకపోయిన file reading మరియు writing సామర్థ్యాలు మీ agent‌కు లభిస్తాయి. వీటిని service account కింద, సరైన transport ఎంపికలతో అమలు చేసే విధానం AI coding agents కోసం VPSలో MCP servers అమలు చేయడంలో వివరించబడింది.

ఈ దశలోని ప్రధాన పాఠం ఏమిటంటే, tool designనే అసలు పని. అస్పష్టమైన వివరణ modelను ఊహించుకునేలా చేస్తుంది. 40000 charactersను తిరిగి ఇచ్చే tool context windowను దెబ్బతీస్తుంది. విషయాలను తొలగించగల tool చివరికి విషయాలను తొలగిస్తుంది.

దశ 4: మెమరీ, ఇది ఎక్కువగా ఫైళ్లే

ఇక్కడ ప్రారంభకులు vector databaseను ఉపయోగిస్తారు. కనీసం ఇప్పటికైతే అలా చేయవద్దు.

Calls మధ్య agentకు మెమరీ ఉండదు. ప్రతి సారి మొత్తం conversationను మళ్లీ పంపాలి. అందుకే చిన్న sessionతో పోలిస్తే, పొడవైన sessionలో ప్రతి turnకు ఎక్కువ ఖర్చవుతుంది. కాబట్టి మెమరీని రెండు సమస్యలుగా విభజించాలి. మొదటిది, ప్రస్తుతం context windowలో ఏ సమాచారం సరిపోతుంది అనేది. దీన్ని summarising చేయడం, పాత tool outputను తొలగించడం, అలాగే మీ promptలో స్థిరంగా ఉండే ప్రారంభ భాగాన్ని caching చేయడం ద్వారా నిర్వహించవచ్చు. దీనివల్ల ఆ భాగానికి చెల్లించే ఖర్చు కొంతమేరకు తగ్గుతుంది. రెండవది, restart తర్వాత ఏ సమాచారం నిలిచి ఉంటుంది అనేది. దీనికి storage అవసరం.

రెండవ సమస్య కోసం, agent చదివి రాయగలిగే సాధారణ markdown file దాదాపు ప్రతి మొదటి projectలో vector database కంటే మెరుగైనది. దానికి ఒక file ఇవ్వండి. దాని formatను చెప్పండి. ప్రారంభించే ముందు ఆ fileను చదవాలని, ఏదైనా నేర్చుకున్నప్పుడు దాన్ని update చేయాలని చెప్పండి. దీనివల్ల ఎక్కువ ప్రయోజనం పొందుతారు. అలాగే fileను తెరిచి, మీ agent ఏది నమ్ముతుందో చూడవచ్చు. Notes context windowలో సరిపోనప్పుడు మాత్రమే embeddings మరియు retrievalను ఉపయోగించండి. అంతకు ముందు ఉపయోగించవద్దు.

దశ 5: లూప్‌నే ఉత్పత్తి

ఇప్పటికి మీరు గమనిస్తూ ఉన్నప్పుడు పనిచేసే agent‌ను రూపొందించగలరు. దశ 5లో, మీరు గమనించకపోయినా అది పనిచేసేలా చేయాలి.

పర్యవేక్షణ లేకుండా agent‌ను సురక్షితంగా వదిలేయవచ్చో లేదో నాలుగు ప్రశ్నలు నిర్ణయిస్తాయి. అది దేనితో ప్రారంభమవుతుంది, అంటే ఖాళీగా ఉన్నప్పుడు అమలు కాకుండా ఎలా నిరోధిస్తారు. అది ఏ పరిమితి లోపల పనిచేస్తుంది, అంటే పొరపాటు జరిగినా దాని ప్రభావం చిన్నదిగా ఎలా ఉంటుంది. ఫలితాన్ని ఎలా ధృవీకరిస్తారు, ఎందుకంటే తన పనిని తానే మూల్యాంకనం చేసుకునే agent ఎల్లప్పుడూ ఉత్తీర్ణమవుతుంది. దాన్ని ఏ budget ఆపుతుంది, tokensలో లేదా wall clock సమయంలో. ఈ నాలుగింటినీ ఉద్దేశపూర్వకంగా రూపొందించడమే 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 ద్వారా తిరిగి బయటకు పంపబడవచ్చు. దీనికి పరిష్కారం, మీ AI agents నుండి secrets ను దూరంగా ఉంచడం లో వివరించినట్లుగా, helper వెనుక స్వల్పకాలిక tokens ను పరిమిత పరిధితో ఉపయోగించడం. ఖర్చుపై కఠినమైన గరిష్ఠ పరిమితిని పెట్టండి. ఎవరూ పర్యవేక్షించని unattended loop ప్రతి iteration కు billing చేస్తుంది. దీన్ని నియంత్రించే 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 మార్పు కంటే ఈ లెక్కను చాలా ఎక్కువగా మారుస్తాయి.

Prompt injection కూడా ఇక్కడే పరిగణించాలి. మీ agent ఒక web page, issue tracker లేదా inbox ను చదివితే, ఆ text ను రాసిన వ్యక్తి మీ agent కు instructions కూడా ఇస్తున్నట్లే. దీనికి పరిష్కారం మరింత తెలివైన system prompt కాదు. అసలు రక్షణ boundary. ఒక repository ను delete చేయలేని agent ను, దాన్ని delete చేయమని ఒప్పించలేరు.

మీరు ఏ మార్గాన్ని అనుసరించాలి?

ఆరు పాఠ్య ప్రణాళికలను కొద్దికొద్దిగా ప్రయత్నించే బదులుగా, ఒకదాన్ని ఎంచుకుని పూర్తిచేయండి. Microsoft ai-agents-for-beginners repository ఉచితంగా లభించే వాటిలో అత్యంత సమగ్రది. ఇందులో పద్దెనిమిది పాఠాలు ఉన్నాయి. 2026 జూలై నాటికి దీనికి 70,000 కంటే ఎక్కువ stars వచ్చాయి. ఇది పైన పేర్కొన్న దశలకు సులభంగా సరిపోతుంది. ట్రెండింగ్ agent repositories సంకలనాలు అందుబాటులో ఉన్న ప్రాజెక్టులను తెలుసుకోవడానికి ఉపయోగపడతాయి. అయితే పాఠ్య ప్రణాళికగా అవి అంతగా ఉపయోగపడవు. stars ఆధారంగా క్రమబద్ధీకరించిన జాబితా బోధనా క్రమం కాకుండా ప్రజాదరణ ఆధారంగా ఉంటుంది.

అభ్యాసం కోసం నిజమైన project కావాలనుకుంటే, coding agent ఉత్తమమైన మొదటి ఎంపిక. ఫలితం వెంటనే కనిపిస్తుంది. tools స్పష్టంగా ఉంటాయి. చేసిన పొరపాట్లను సులభంగా రద్దు చేయవచ్చు. VPSలో coding AI agentను అమలు చేయడం ద్వారా ఒకదాన్ని మొదటి నుంచి చివరి వరకు అమలు చేసే విధానం తెలుస్తుంది. సున్నా నుంచి నిర్మించడానికి బదులుగా ఇప్పటికే పనిచేస్తున్న systemsను అధ్యయనం చేయాలనుకుంటే, ఉత్తమ self hosted AI agentsలోని పోలిక అనేక projects ఒకే loopను ఎలా విభిన్నంగా పరిష్కరిస్తాయో చూపిస్తుంది.

దీనికి ఎంత సమయం పడుతుంది?

ఇప్పటికే ప్రోగ్రామింగ్ చేసే వారికి, దశలు 1 మరియు 2 ఒక సాయంత్రంలో పూర్తవుతాయి. దశ 3కి ఒక వారాంతం పడుతుంది. అందులో ఎక్కువ సమయం ప్రోటోకాల్‌పై కాకుండా, సాధనాల వివరణలపై వెచ్చించబడుతుంది. దశలు 4 మరియు 5కి వాస్తవ వినియోగంలో కొన్ని వారాలు పడతాయి. మీ agent ఏమి మర్చిపోతుందో, అది మర్చిపోతున్నప్పుడు గమనించడం ద్వారానే మీరు తెలుసుకుంటారు. ప్రతి కొత్త సామర్థ్యాన్ని మీరు మంజూరు చేసినప్పుడు ఈ పని మళ్లీ ప్రారంభమవుతుంది కాబట్టి, దశ 6 ఎప్పుడూ పూర్తిగా ముగియదు.

నిరంతరంగా రెండు నెలలు సాయంత్రాలు కేటాయిస్తే, చాలా మంది పనిచేసే, పరిమిత పరిధి కలిగిన, ఉపయోగకరమైన agent‌ను రూపొందించగలరు. ఒక సంవత్సరం పట్టే వారు సాధారణంగా నిర్మించడం కంటే చదవడానికే కొనసాగినవారు.

FAQ

AI agent నిర్మించడానికి machine learning తెలుసుకోవాలా?

లేదు. Agent నిర్మించడం అంటే API ద్వారా model ను పిలిచి, దాని tool అభ్యర్థనలను నిజమైన functions కు అనుసంధానించడం. ఇది సాధారణ application programming. మీరు training, gradients లేదా datasets ను నేరుగా ఉపయోగించరు. మీ agent పనిచేస్తుందా లేదా అనేది tools కోసం schema design, error handling మరియు Linux permissions వంటి నైపుణ్యాలపై ఆధారపడి ఉంటుంది. మీరు తర్వాత model ను fine tune చేయాలనుకుంటేనే machine learning సిద్ధాంతం అవసరమవుతుంది. అది వేరే అవసరాలతో కూడిన వేరే పని.

LangChain లేదా CrewAI వంటి framework తో ప్రారంభించాలా?

మొదట ఒక raw loop రాయండి. ఆ తర్వాత framework ను ఉపయోగించండి. Stage 2లోని ముప్పై lines ను framework ఒక configuration object తో భర్తీ చేస్తుంది. అది భర్తీ చేసినది మీకు తెలిసిన తర్వాత సౌకర్యంగా ఉంటుంది. అంతకు ముందు అది గందరగోళంగా అనిపించవచ్చు. మీ agent సరిగ్గా పనిచేయనప్పుడు message list మరియు tool results ను నేరుగా పరిశీలించాలి. వాటిని మీరు ఎప్పుడూ చూడకపోతే ఈ పని చాలా కష్టంగా ఉంటుంది. మీరు స్వయంగా ఒక loop రాసిన తర్వాత framework mechanism ను దాచకుండా మీ సమయాన్ని ఆదా చేస్తుంది.

AI agents నేర్చుకోవడానికి ఎంత ఖర్చవుతుంది?

చాలామంది ఊహించినదానికంటే తక్కువ ఖర్చవుతుంది, మీరు ఖర్చుకు పరిమితి విధిస్తే. ఈ ఆరు stages లోని ప్రతిదానికి hosted API key మరియు చిన్న VPS సరిపోతాయి. అసలు ప్రమాదం hourly rate కాదు. మీరు నిద్రిస్తున్నప్పుడు ప్రతి iteration కు billing చేసే unbounded loop అసలు ప్రమాదం. మొదటి రోజే మీ API account పై hard spend limit పెట్టండి. మీరు రాసే ప్రతి loop కు iteration cap జోడించండి. సాధారణ steps కోసం తక్కువ ఖర్చైన model ను ఉపయోగించండి. Model ను local గా నడిపితే token ఖర్చు ఉండదు. అయితే దాని స్థానంలో hardware అవసరం ఏర్పడుతుంది.

AI agent మరియు chatbot మధ్య తేడా ఏమిటి?

Chatbot ఒకసారి సమాధానం ఇస్తుంది. Agent ఒక cycle ను పునరావృతం చేస్తుంది: model ఒక tool ను అడుగుతుంది, మీ code దాన్ని నడుపుతుంది, result తిరిగి పంపబడుతుంది, తర్వాత ఏమి చేయాలో model నిర్ణయిస్తుంది. ఈ పునరావృతం వల్ల agent అనేక steps తో కూడిన task ను పూర్తి చేయగలదు. Chatbot లకు అవసరం లేని boundaries agents కు అవసరం కావడానికి కూడా ఇదే కారణం. Chatbot ఇచ్చిన తప్పు సమాధానం ఒక తప్పు paragraph మాత్రమే. Agent ఇచ్చిన తప్పు సమాధానం ఒక తప్పు paragraph తో పాటు, దాని ఆధారంగా agent చేసిన చర్య కూడా కావచ్చు.