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

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

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

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

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

stage 1కు ముందు వాస్తవంగా అవసరమైనవి

నిజమైన prerequisite జాబితా చిన్నదే. చాలా course పేజీలు సూచించే దానికంటే ఇది ఇంకా చిన్నది.

• మీరు యాభై పంక్తుల script స్థాయిలో Python లేదా TypeScript code ను చదివి రాయగలగాలి.
• 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 అవసరం అవుతుంది. అది వేరే నైపుణ్యం. దాన్ని తరువాత VPSలో LLMను self-host చేయడానికి Ollamaను నిర్వహించడం ద్వారా నేర్చుకోవచ్చు.

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 ను చూడండి. ఇప్పుడు ఖర్చు యొక్క 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 కు మాత్రమే చర్యలు తీసుకునే సామర్థ్యం ఉంటుంది. ఆ మార్పిడి యొక్క మీ వైపు ఉన్న code ను designs ను పోల్చడం ప్రారంభించినప్పుడు ఒక పేరుతో పిలుస్తారు: అది agent harness. స్వంత permissions ఏవీ లేని model చుట్టూ loop, tools మరియు permissions ను చుట్టి ఉంచిన నిర్మాణం అదే.

Chatbot ఒక reply తర్వాత ఆగిపోతుంది. Model tools కోసం అడగడం ఆపే వరకు agent అదే మార్పిడిని పునరావృతం చేస్తుంది. మొత్తం తేడా ఇదే. అందుకే failure modes కూడా భిన్నంగా ఉంటాయి. Chatbot ఒకసారి తప్పు సమాధానం ఇస్తుంది. Agent పై ఎవరైనా గమనించేలోపు తప్పు సమాధానంపై అనేకసార్లు చర్య తీసుకుంటుంది.

దశ 2: లూప్‌ను మీరే ఒకసారి రాయండి

Frameworkతో ప్రారంభించవద్దు. సుమారు ముప్పై lines 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 తో అమలు చేయండి. సరిగ్గా పనిచేసే run లో మీ filesystems మరియు వాటిలోని ఖాళీ స్థలాన్ని పేర్కొనే ఒక paragraph ముద్రించబడుతుంది. దీనికి కారణం model df -h ను అభ్యర్థించడం, మీ code దాన్ని అమలు చేయడం, మరియు రెండో pass ఆ table ను ఒక sentence గా మార్చడం. ఏమీ ముద్రించబడకపోతే, text block వచ్చేలోపే loop ముగిసింది. Loop లో print(response.stop_reason) ను చేర్చి values ఎలా మారుతున్నాయో చూడండి.

ఇప్పుడు ఉద్దేశపూర్వకంగా దాన్ని విఫలమయ్యేలా చేయండి. tool_use_id line ను తొలగించి error ను చదవండి. Matching id లేని tool result ను API తిరస్కరిస్తుంది. అక్కడ beginners చేసే అత్యంత సాధారణ తప్పు ఇదే. రెండు commands అవసరమైన ప్రశ్న అడిగి loop రెండుసార్లు నడుస్తుందో చూడండి. సాధ్యం కాని విషయం అడిగి అది ఆగిపోతుందో లేదా అంతులేకుండా తిరుగుతుందో చూడండి.

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

దశ 3: agent వద్ద ఇప్పటికే లేని సాధనాలు

మీ run_command సాధనం పనిచేస్తుంది. అయితే నిజమైన agent కు వ్యవస్థ వెలుపల ఉన్న సేవలను చేరుకునే సాధనాలు అవసరం: ticket system, database, repository. ప్రతి సేవ కోసం, ప్రతి agent కోసం ప్రత్యేక 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. ఇది security model ను సంక్షిప్తంగా చూపిస్తుంది: boundary ను model కాదు, server నిర్ణయిస్తుంది. Client ను దానికి అనుసంధానిస్తే, మీరు స్వయంగా రాయకుండానే agent కు files చదవడం మరియు రాయడం సాధ్యమవుతుంది. వీటిని service account కింద సరిగ్గా ఎలా అమలు చేయాలి, transport ఎంపికలను ఎలా నిర్ణయించాలి అన్నది AI coding agents కోసం VPSపై MCP servers అమలు చేయడం లో వివరించబడింది. Scratch directory బదులుగా నిజమైన data ను సూచించే రెండవ server కోసం, openGymను self-host చేయడం, workout tracker read-only server ను అందిస్తుంది. అందువల్ల agent కు మార్చగల లేదా తొలగించగల ఏదీ ఇవ్వకుండా, మీ స్వంత training history గురించి ప్రశ్నలు అడగడం అభ్యసించవచ్చు.

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

దశ 4: memory, అంటే ప్రధానంగా files

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

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

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

దశ 5: loop నే product

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

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

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

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

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

Agent ను ప్రత్యేక unprivileged user గా నడపండి. దాన్ని ఎప్పుడూ root గా లేదా మీ స్వంత account గా నడపవద్దు. అప్పుడు దాని వల్ల కలిగే నష్టం ఒక directory కి పరిమితం అవుతుంది, మొత్తం machine కి కాదు. Credentials ను model అందుబాటులోకి రానివ్వవద్దు. Context window లో ఉన్న ఏదైనా విషయం tool call ద్వారా తిరిగి బయటకు పంపబడవచ్చు. దీనికి పరిష్కారం, మీ AI agents లో secrets ను ఉంచకుండా ఉండటం లో వివరించిన విధంగా, helper వెనుక పరిమిత కాలం మాత్రమే పనిచేసే scoped tokens ఉపయోగించడం. ఖర్చుపై కఠినమైన గరిష్ఠ పరిమితి విధించండి. ఎవరూ పర్యవేక్షించని loop ప్రతి iteration కు ఖర్చు నమోదు చేస్తుంది. దాన్ని నియంత్రించే caps మరియు batching గురించి ఎల్లప్పుడూ పనిచేసే VPS పై AI agent ఖర్చు నియంత్రణ లో ఉంది.

మీ agent మీరు స్వయంగా రాసిన script లో కాకుండా harness లో నడుస్తుంటే, ఈ దశలోని కొన్ని అంశాలు code కాకుండా configuration రూపంలో ఉంటాయి. Budget caps, tool permission rules మరియు injection scanning తో సమానమైన అవసరాలను ఇన్‌స్టాల్ చేయదగిన DeepSeek Harness plugins లో చాలావరకు కవర్ చేశారు.

ఖర్చు విషయంలో ఒక నిర్దిష్ట సంఖ్యను చూడాలి. July 2026 నాటికి, Claude Opus 5 ప్రతి million input tokens కు $5, ప్రతి million output tokens కు $25 వసూలు చేస్తుంది. పెరుగుతున్న conversation ను agent మళ్లీ మళ్లీ పంపితే, ఒకే task లో కొన్ని వందల వేల 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 ను పక్కపక్కనే చూడవచ్చు. దీనికి పరిష్కారం మరింత తెలివైన system prompt కాదు. అసలు పరిష్కారం boundary. Repository ను delete చేయలేని agent ను దాన్ని delete చేయమని ఒప్పించలేరు.

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

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

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

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

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

నిరంతరంగా రెండు నెలలు సాయంత్రాలు కేటాయిస్తే, చాలామంది పనిచేసే, పరిమిత పరిధి కలిగిన, ఉపయోగకరమైన 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 theory అవసరం అవుతుంది. అది వేరే prerequisites కలిగిన వేరే పని.

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 ను స్థానికంగా run చేస్తే token bill తొలగిపోతుంది. దాని స్థానంలో hardware requirement వస్తుంది.

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

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