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

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

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

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

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

దశ 1 ప్రారంభానికి నిజంగా అవసరమైనవి

నిజమైన prerequisite జాబితా చిన్నదే. చాలా 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 అవసరం అవుతుంది. అది వేరే skill. తరువాత మీరు VPSలో Ollamaను host చేసి LLMను self-host చేయడం ద్వారా దాన్ని నేర్చుకోవచ్చు.

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

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

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

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

Chatbot ఒక reply తర్వాత ఆగిపోతుంది. Model tools అడగడం ఆపే వరకు agent అదే exchange ను మళ్లీ మళ్లీ కొనసాగిస్తుంది. మొత్తం తేడా ఇదే. అందుకే 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) ను చేర్చి values ఎలా మారుతున్నాయో గమనించండి.

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

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

దశ 3: agent వద్ద ఇప్పటికే లేని tools

మీ run_command tool పనిచేస్తుంది. కానీ నిజమైన agent కు వ్యవస్థ వెలుపల ఉన్న వనరులను చేరుకునే tools అవసరం: ticket system, database, repository. ప్రతి service, ప్రతి agent కోసం ప్రత్యేక wrapper రాయడం పెద్ద స్థాయిలో నిర్వహించడం సాధ్యం కాదు.

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

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

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

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

దశ 4: memory, ఇది ఎక్కువగా files గురించే

ఇక్కడ beginners సాధారణంగా vector database ను ఎంచుకుంటారు. కనీసం ఇప్పుడైనా అలా చేయవద్దు.

ఒక agent calls మధ్య memory ని కలిగి ఉండదు. ప్రతి సారి మొత్తం conversation ను మళ్లీ పంపాలి. అందుకే short session కంటే long session లో ప్రతి turn కు ఎక్కువ ఖర్చవుతుంది. కాబట్టి memory ను రెండు సమస్యలుగా విభజించాలి. మొదటిది, ప్రస్తుతం context window లో ఏమి సరిపోతుంది అనేది. దీన్ని summarising, పాత tool output ను trim చేయడం, అలాగే prompt లో మారని prefix ను cache చేయడం ద్వారా నిర్వహించవచ్చు. దీనివల్ల ఆ prefix కోసం అయ్యే ఖర్చులో కొంత భాగమే చెల్లించాలి. రెండవది, restart తర్వాత కూడా ఏమి మిగులుతుంది అనేది. అది storage.

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

దశ 5: loop అనేది product

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

Unattended agent ను ఒంటరిగా వదిలేయడం సురక్షితమా కాదా అనేది నాలుగు ప్రశ్నలు నిర్ణయిస్తాయి. ఏది దాన్ని trigger చేస్తుంది, తద్వారా అది కారణం లేకుండా run అవదు? అది ఏ boundary లో పనిచేస్తుంది, తద్వారా పొరపాటు ప్రభావం పరిమితంగా ఉంటుంది? ఫలితాన్ని ఎలా verify చేస్తారు, ఎందుకంటే తన పనిని తానే grade చేసుకునే agent ఎల్లప్పుడూ pass అవుతుంది. ఏ budget దాన్ని ఆపుతుంది—tokens లోనా, wall clock time లోనా? ఈ నాలుగింటినీ ఉద్దేశపూర్వకంగా design చేయడమే loop engineering మరియు ఆ నిర్వచనం పరిధిలో వివరించిన discipline.

ఈ exercise చేయండి: మీ stage 2 agent ను తీసుకుని, నాలుగు లేదా ఐదు steps అవసరమైన task ఇవ్వండి. ఆపై hard iteration cap జోడించండి. తరువాత ఆ cap ను తొలగించి, unbounded loop మీ token bill ను ఎలా పెంచుతుందో గమనించండి. దీన్ని ఒకసారి చిన్న budget పై చేయండి. అప్పుడు పెద్ద budget పై అనుకోకుండా చేయరు.

దశ 6: భద్రత, secrets మరియు ఖర్చు

ఈ దశ ఐచ్ఛికం కాదు. ఇది చివర్లో ఉండటానికి కారణం, పనిచేసే వ్యవస్థను నిర్మించే వరకు ప్రమాదం పూర్తిగా అర్థం కాకపోవడమే.

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 ఖర్చు నియంత్రణ లో ఉన్నాయి.

ఖర్చుకు ఒక స్పష్టమైన సంఖ్యను పరిశీలించాలి. July 2026 నాటికి, Claude Opus 5 ప్రతి million input tokens కు $5 మరియు ప్రతి million output tokens కు $25 వసూలు చేస్తుంది. పెరుగుతున్న conversation ను agent ప్రతి సారి మళ్లీ పంపితే, ఒకే task లో కొన్ని hundred thousand tokens వినియోగం కావచ్చు. Prompt caching మరియు సాధారణ దశలకు చిన్న model ఉపయోగించడం, prompt లో చేసే ఏ చిన్న మార్పుకన్నా ఈ లెక్కను ఎక్కువగా మార్చగలవు.

Prompt injection కూడా ఇక్కడే పరిగణించాలి. మీ agent web page, issue tracker లేదా inbox ను చదివితే, ఆ text ను రాసిన వ్యక్తి మీ agent కు instructions కూడా రాస్తున్నట్టే. Web search సాధారణంగా ఈ దారిని మొదట తెరిచే tool. మీ స్వంత SearXNG instance వైపు agent ను మళ్లించడం లో wiring మరియు దాని వల్ల ఏర్పడే injection surface రెండింటినీ పక్కపక్కనే చూపిస్తుంది. దీనికి పరిష్కారం మరింత clever system prompt కాదు. సరిహద్దే పరిష్కారం. Repository ను delete చేయలేని agent ను, దాన్ని delete చేయమని ఎవరూ ఒప్పించలేరు.

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

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

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

ఇది ఎంత సమయం పడుతుంది?

ఇప్పటికే programming తెలిసిన వారికి stages 1 మరియు 2 పూర్తి చేయడానికి ఒక సాయంత్రం సరిపోతుంది. Stage 3 కు ఒక వారాంతం పడుతుంది. ఇందులో ఎక్కువ సమయం protocol పై కాకుండా tools వివరణలపై వెచ్చించాలి. Stages 4 మరియు 5 కు వాస్తవ వినియోగంలో కొన్ని వారాలు పడతాయి. ఎందుకంటే మీ agent ఏమి మర్చిపోతుందో, అది మర్చిపోతున్నప్పుడు monitor చేసినప్పుడే మీరు తెలుసుకుంటారు. Stage 6 పూర్తిగా ముగియదు. మీరు అందించే ప్రతి కొత్త capability దాన్ని మళ్లీ తెరుస్తుంది.

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

FAQ

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

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

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

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

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

మీరు ఖర్చుకు పరిమితి విధిస్తే, చాలామంది ఊహించేదానికంటే తక్కువ ఖర్చవుతుంది. ఈ ఆరు దశలకు hosted API key మరియు చిన్న VPS సరిపోతాయి. అసలు ప్రమాదం hourly rate కాదు. మీరు నిద్రిస్తున్నప్పుడు ప్రతి iteration కు billing జరిగే, పరిమితి లేని loop అసలు ప్రమాదం. మొదటి రోజే మీ API account లో గరిష్ఠ ఖర్చు పరిమితిని సెట్ చేయండి. మీరు రాసే ప్రతి loop కు iteration cap జోడించండి. సాధారణ దశలకు చౌకైన model ఉపయోగించండి. Model ను locally నడిపితే token ఖర్చు ఉండదు. అయితే దానికి తగిన hardware అవసరం అవుతుంది.

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

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