AI agents கற்பது எப்படி: அடிப்படையிலிருந்து தொடங்கும் பாதை

ஆறு நிலைகளில் பாதை

AI agents-ஐ அடிப்படையிலிருந்து கற்க, ஆறு நிலைகளையும் வரிசையாக முடிக்கவும்: கருத்துகள், உங்கள் முதல் loop, tools, memory, loop design மற்றும் safety. ஒவ்வொரு நிலையிலும், நீங்கள் சொந்தமாக உருவாக்க வேண்டிய ஒரு விஷயம் இருக்கும். முன்கூட்டியே அடுத்த நிலைக்குச் செல்வதே பலர் முன்னேறாமல் நிற்பதற்கான பொதுவான காரணம். Framework உங்களுக்கு பார்க்க வேண்டிய பகுதியையே மறைத்துவிடுகிறது.

AI agent என்பது tools-ஐ அழைக்க அனுமதிக்கப்பட்ட language model-ஐச் சுற்றியுள்ள loop ஆகும். இந்த ஒரு வாக்கியமே முழு தலைப்பு. அதன் பிறகு வரும் அனைத்தும் loop-க்குள் சேர்வது என்ன, tools எதைத் தொடலாம், மேலும் loop தவறாகச் செயல்படும் போது அதை எவ்வாறு நிறுத்துவது என்பதற்கான விவரங்களாகும். அந்த loop-ஐ வேறொருவருக்கு விளக்க முடிந்தால், நீங்கள் இந்தக் கருத்தைக் கற்றுள்ளீர்கள். Framework-களின் பெயர்களை மட்டும் சொல்ல முடிந்தால், நீங்கள் இன்னும் கற்றுக்கொள்ளவில்லை.

கீழே உள்ள திட்டம், உருவாக்கிச் செயல்படுவதன் மூலம் நீங்கள் கற்றுக்கொள்வீர்கள் என்ற அடிப்படையில் அமைந்துள்ளது. ஒரு நிலையைப் படிக்கவும், சிறிய விஷயத்தை உருவாக்கவும், அதை நோக்கத்துடன் செயலிழக்கச் செய்யவும், பின்னர் அடுத்த நிலைக்குச் செல்லவும். நீங்கள் படித்ததிலேயே நின்றுவிட்ட நிலை, நீங்கள் முடித்த நிலை அல்ல.

நிலை 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 முக்கியமாகிறது. இதைத் தனித்திறனாக பின்னர் VPS-ல் Ollama-வை host செய்து LLM-ஐ நீங்களே இயக்குவது மூலம் கற்றுக்கொள்ளலாம்.

Shell தொடர்பான பகுதியை மக்கள் குறைத்து மதிப்பிடுகிறார்கள். Permissions, paths, environment variables, மற்றும் அமைதியாக நிறுத்தப்படும் processes ஆகியவற்றால் agents தோல்வியடைகின்றன. PATH அல்லது file mode பற்றிய stack trace தோன்றும்போது நீங்கள் terminal-ஐ மூடிவிடுகிறீர்கள் என்றால், முதலில் Linux அடிப்படைகளைக் கற்றுக்கொள்ள ஒரு வார இறுதியை ஒதுக்குங்கள். அது பின்னர் ஒரு மாத நேரத்தைச் சேமிக்கும்.

நிலை 1: agent என்றால் என்ன, அது என்ன அல்ல

ஒரு API call-இல் தொடங்குங்கள்; loop எதுவும் பயன்படுத்த வேண்டாம். ஒரு prompt-ஐ அனுப்பி, reply-ஐ print செய்து, response-இல் உள்ள token counts-ஐப் பாருங்கள். இதன் மூலம் cost-இன் அலகும் latency-யின் அலகும் உங்களுக்கு புரியும்.

அடுத்து tool use-ஐ கற்றுக்கொள்ளுங்கள். இந்தத் துறையில் உண்மையாகப் புதிதான ஒரே கருத்து இதுதான். ஒரு function-ஐ model-க்கு name, description, மற்றும் அதன் inputs-க்கான JSON (JavaScript object notation) schema ஆக விவரிக்கிறீர்கள். Model எதையும் இயக்காது. அது structured request ஒன்றை அனுப்பும்: இந்த arguments-களுடன் run_command-ஐ call செய்யவும். உங்கள் code அந்த function-ஐ இயக்கி, அதன் output-ஐ message ஆகத் திருப்பி அனுப்பி, model-ஐ மீண்டும்க் கேட்கும். Model என்பது text-ஐப் படித்து text-ஐ எழுதும் planner. உங்கள் code-தான் செயல்பாடுகளைச் செய்யும் பகுதி.

ஒரு chatbot ஒரு reply-க்குப் பிறகு முடிவடையும். Model tools-ஐக் கேட்பதை நிறுத்தும் வரை, ஒரு agent அந்த exchange-ஐத் தொடர்ந்து மீண்டும் செய்கிறது. இந்த repetition-தான் முழு வேறுபாடு. அதனால்தான் failure modes-களும் வேறுபடுகின்றன. Chatbot ஒரு முறை தவறான answer-ஐ வழங்கும். Agent-ன் தவறான answer யாரும் கவனிப்பதற்கு முன் பலமுறை செயல்படுத்தப்படலாம்.

நிலை 2: loop-ஐ நீங்களே ஒருமுறை எழுதுங்கள்

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-ஐ குறிப்பிடும் ஒரு 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 குறித்து ஒரு எச்சரிக்கை. இது shell=True மூலம் model output-ஐ நேரடியாக 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) என்பது industry ஏற்றுக்கொண்ட தீர்வாகும். MCP server, standard transport மூலம் tools-ன் தொகுப்பை வெளிப்படுத்துகிறது. எந்த MCP-aware agent-மும் custom glue இல்லாமல் அவற்றைப் பயன்படுத்தலாம். Reference filesystem server-ஐ இயக்குவதற்கான command இதுதான்:

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

இதற்கு Node நிறுவப்பட்டிருக்க வேண்டும். Directory argument-ல் குறிப்பிடப்படும் path மட்டுமே server அணுகும். இதுவே security model-ன் சுருக்கமான வடிவம்: எல்லையை model அல்ல, server தீர்மானிக்கிறது. Client-ஐ அதனுடன் இணைத்தால், நீங்கள் எழுதாத file reading மற்றும் writing திறன்களை agent பெறும். இவற்றை service account-ன் கீழ், சரியான முறையில் இயக்குவது மற்றும் transport தேர்வுகள் குறித்த விளக்கம் AI coding agents-க்காக VPS-ல் MCP servers-ஐ இயக்குதல் பகுதியில் உள்ளது.

இந்த நிலையின் முக்கியப் பாடம்: tool design-தான் உண்மையான வேலை. தெளிவற்ற விளக்கம் model-ஐ ஊகிக்கச் செய்கிறது. 40000 characters-ஐத் திருப்பி அனுப்பும் tool, context window-ஐப் பாதிக்கும். பொருட்களை delete செய்யக்கூடிய tool, இறுதியில் பொருட்களை delete செய்யும்.

நிலை 4: memory, பெரும்பாலும் files மட்டுமே

இங்கு Beginners பொதுவாக vector database-ஐ பயன்படுத்தத் தொடங்குவார்கள். குறைந்தது இப்போதைக்கு அதைச் செய்ய வேண்டாம்.

ஒரு agent-க்கு calls-களுக்கு இடையில் memory இருக்காது. ஒவ்வொரு முறையும் முழு conversation-ஐ மீண்டும் அனுப்ப வேண்டும். அதனால் நீண்ட session-க்கு, குறுகிய session-ஐவிட ஒவ்வொரு turn-க்கும் அதிகச் செலவாகும். எனவே memory இரண்டு பிரச்சினைகளாகப் பிரிகிறது. முதலாவது, இப்போது context window-க்குள் பொருந்த வேண்டிய தகவல். இதை summarising செய்வதன் மூலம், பழைய tool output-ஐச் சுருக்குவதன் மூலம், மேலும் உங்கள் prompt-இன் நிலையான prefix-ஐ caching செய்வதன் மூலம் நிர்வகிக்கலாம். இதனால் அந்தப் பகுதியுக்கான முழுச் செலவின் ஒரு பகுதியை மட்டுமே செலுத்துவீர்கள். இரண்டாவது, restart-க்குப் பிறகும் நீடிக்க வேண்டியது. அது storage.

இரண்டாவது பிரச்சினைக்கு, agent படித்தும் எழுதியும் செயல்படக்கூடிய ஒரு சாதாரண markdown file, கிட்டத்தட்ட ஒவ்வொரு first project-க்கும் vector database-ஐவிடச் சிறந்தது. அதற்கு ஒரு file கொடுத்து, அதன் format-ஐத் தெரிவியுங்கள். தொடங்குவதற்கு முன் அந்த file-ஐப் படிக்கவும், ஏதேனும் கற்றுக்கொண்டால் அதை update செய்யவும் என்று கூறுங்கள். இதன் மூலம் பெரும்பாலான பயனைப் பெறுவீர்கள். மேலும் அந்த file-ஐத் திறந்து உங்கள் agent என்ன நம்புகிறது என்பதைப் பார்க்கலாம். குறிப்புகள் context window-க்குள் பொருந்தாமல் போகும்போது மட்டும் embeddings மற்றும் retrieval-ஐப் பயன்படுத்தத் தொடங்குங்கள். அதற்கு முன் அவற்றைப் பயன்படுத்த வேண்டாம்.

நிலை 5: loop தான் தயாரிப்பு

இந்நேரத்தில், நீங்கள் கண்காணித்துக்கொண்டிருக்கும்போது செயல்படும் agent-ஐ உருவாக்க முடியும். நிலை 5-ன் நோக்கம், நீங்கள் கண்காணிக்காதபோதும் அது செயல்படுமாறு செய்வதாகும்.

கண்காணிப்பின்றி இயங்கும் agent-ஐ பாதுகாப்பாக விட்டுச் செல்ல முடியுமா என்பதை 4 கேள்விகள் தீர்மானிக்கின்றன. அது எதனால் தொடங்குகிறது, எனவே எந்தத் தூண்டுதலும் இல்லாமல் இயங்காது. அது எந்த வரம்புக்குள் செயல்படுகிறது, எனவே தவறு ஏற்பட்டாலும் அதன் தாக்கம் சிறியதாக இருக்கும். முடிவு எவ்வாறு சரிபார்க்கப்படுகிறது, ஏனெனில் தன் சொந்தப் பணியைத் தானே மதிப்பிடும் agent எப்போதும் தேர்ச்சி பெறும். tokens அல்லது wall clock time அடிப்படையில் அதை நிறுத்தும் budget என்ன. இந்த 4 அம்சங்களையும் திட்டமிட்டு வரையறுப்பதே loop engineering மற்றும் அந்த வரையறை உள்ளடக்கும் அம்சங்கள் எனப்படும் ஒழுங்குமுறையாகும்.

பயிற்சி: உங்கள் stage 2 agent-ஐ எடுத்துக்கொள்ளுங்கள். அதற்கு 4 அல்லது 5 படிகள் தேவைப்படும் task-ஐ வழங்கி, கடுமையான iteration cap-ஐச் சேர்க்கவும். பின்னர் அந்த cap-ஐ நீக்கி, வரம்பற்ற 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-க்கும் கட்டணம் விதிக்கப்படும். இதை கட்டுப்பாட்டில் வைத்திருக்கும் 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 மற்றும் வழக்கமான steps-க்கு சிறிய model-ஐப் பயன்படுத்துதல் ஆகியவை, எந்த prompt மாற்றத்தையும் விட இந்தக் கணக்கீட்டை அதிகமாக மாற்றும்.

Prompt injection-மும் இங்கே கவனிக்க வேண்டியதாகும். உங்கள் agent web page, issue tracker அல்லது inbox-ஐப் படித்தால், அந்த text-ஐ எழுதியவரே உங்கள் agent-க்கான instructions-ஐயும் எழுதுகிறார். இதற்கான defence, இன்னும் புத்திசாலித்தனமான system prompt அல்ல. அது boundary ஆகும். ஏனெனில் repository-ஐ delete செய்ய முடியாத agent-ஐ அதை delete செய்யும்படி பேச வைத்து சம்மதிக்கச் செய்ய முடியாது.

எந்த வழிகாட்டுதலைப் பின்பற்ற வேண்டும்?

ஆறு பாடத்திட்டங்களில் சிறிது சிறிதாகக் கற்றுக்கொள்வதைவிட, ஒரு பாடத்திட்டத்தைத் தேர்ந்தெடுத்து அதை முழுமையாக முடிக்கவும். Microsoft ai-agents-for-beginners repository மிகவும் முழுமையான இலவசப் பாடத்திட்டமாகும். இது 18 பாடங்களைக் கொண்டது. July 2026 நிலவரப்படி இது 70,000 stars-ஐ கடந்துள்ளது. மேலே குறிப்பிடப்பட்ட நிலைகளுடன் இது தெளிவாகப் பொருந்துகிறது. பிரபலமாக இருக்கும் agent repositories பற்றிய தொகுப்புகள், எவை உள்ளன என்பதை அறிய உதவும். ஆனால் அவை பாடத்திட்டமாக அதிகம் பயன்படாது. காரணம், stars அடிப்படையில் வரிசைப்படுத்தப்பட்ட பட்டியல் கற்பிக்கும் வரிசையை அல்ல, பிரபலத்தைக் காட்டுகிறது.

பயிற்சி செய்ய ஒரு உண்மையான project தேவைப்பட்டால், coding agent சிறந்த முதல் இலக்கு. அதன் feedback உடனடியாகக் கிடைக்கும். அதன் tools தெளிவாக இருக்கும். செய்த தவறுகளை எளிதாகத் திருத்தலாம். VPS-ல் coding AI agent-ஐ இயக்குதல் என்ற வழிகாட்டி, இதை தொடக்கம் முதல் முடிவு வரை விளக்குகிறது. புதிதாக உருவாக்குவதற்குப் பதிலாக ஏற்கனவே செயல்படும் systems-ஐ ஆய்வு செய்ய விரும்பினால், சிறந்த self hosted AI agents பற்றிய ஒப்பீடு, ஒரே loop-ஐ பல projects எவ்வாறு வெவ்வேறு முறைகளில் செயல்படுத்துகின்றன என்பதைக் காட்டுகிறது.

இதற்கு எவ்வளவு நேரம் ஆகும்?

ஏற்கனவே programming செய்பவர்களுக்கு, நிலைகள் 1 மற்றும் 2 ஒரு மாலை நேரத்தில் முடியும். நிலை 3க்கு ஒரு வார இறுதி தேவைப்படும். இதில் பெரும்பாலான நேரம் protocol மீது அல்ல, tool descriptions மீது செலவாகும். நிலைகள் 4 மற்றும் 5க்கு உண்மையான பயன்பாட்டில் சில வாரங்கள் தேவைப்படும். ஏனெனில் உங்கள் agent எதை மறக்கிறது என்பதை அது மறப்பதைப் பார்த்தால்தான் கற்றுக்கொள்ள முடியும். நிலை 6 முழுமையாக முடிவதில்லை. நீங்கள் வழங்கும் ஒவ்வொரு புதிய திறனும் அதை மீண்டும் திறக்கும்.

தொடர்ச்சியாக இரண்டு மாதங்கள் மாலை நேரங்களில் செலவிட்டால், பெரும்பாலானவர்கள் செயல்படும், வரையறுக்கப்பட்ட, பயனுள்ள agent ஒன்றை உருவாக்கிவிடலாம். ஒரு ஆண்டு எடுத்துக்கொள்பவர்கள் பொதுவாக உருவாக்குவதற்குப் பதிலாக தொடர்ந்து படித்துக்கொண்டிருந்தவர்களாக இருப்பார்கள்.

FAQ

AI agent உருவாக்க machine learning தெரிந்திருக்க வேண்டுமா?

வேண்டியதில்லை. Agent உருவாக்குவது, API வழியாக ஒரு model-ஐ அழைத்து, அதன் 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-ஐப் பயன்படுத்துங்கள். Stage 2-இல் உள்ள முப்பது lines-ஐ framework ஒரு configuration object-ஆக மாற்றுகிறது. அது எதை மாற்றியுள்ளது என்பதை நீங்கள் அறிந்த பிறகு வசதியாக இருக்கும். அதற்கு முன் அது குழப்பமாக இருக்கலாம். உங்கள் agent எதிர்பாராத வகையில் செயல்பட்டால், message list மற்றும் tool results-ஐ நேரடியாக ஆராய வேண்டியிருக்கும். அவற்றை நீங்கள் ஒருபோதும் பார்த்திருக்கவில்லை என்றால், இந்தப் பணி மிகவும் கடினமாகும். நீங்கள் எழுதிய ஒரு loop-க்குப் பிறகு, framework செயல்முறையை மறைப்பதற்குப் பதிலாக உங்கள் நேரத்தைச் சேமிக்கும்.

AI agents கற்றுக்கொள்ள எவ்வளவு செலவாகும்?

பெரும்பாலானவர்கள் எதிர்பார்ப்பதைவிடக் குறைவு, நீங்கள் செலவுக்கு வரம்பு விதித்தால். Hosted API key மற்றும் சிறிய VPS ஆகியவை இந்த ஆறு stages-க்கும் போதுமானவை. உண்மையான ஆபத்து hourly rate அல்ல. நீங்கள் தூங்கிக்கொண்டிருக்கும்போது, வரம்பில்லாத loop ஒவ்வொரு iteration-க்கும் கட்டணம் வசூலிப்பதே ஆபத்து. முதல் நாளிலேயே உங்கள் API account-இல் கடுமையான spend limit-ஐ அமைக்கவும். நீங்கள் எழுதும் ஒவ்வொரு loop-க்கும் iteration cap-ஐச் சேர்க்கவும். வழக்கமான steps-க்கு மலிவான model-ஐப் பயன்படுத்தவும். Model-ஐ locally இயக்கினால் token bill நீங்கும். அதற்குப் பதிலாக hardware requirement ஏற்படும்.

AI agent மற்றும் chatbot ஆகியவற்றுக்கு என்ன வித்தியாசம்?

Chatbot ஒருமுறை பதிலளிக்கும். Agent ஒரு cycle-ஐ மீண்டும் மீண்டும் இயக்கும்: model ஒரு tool-ஐக் கோரும், உங்கள் code அதை இயக்கும், result மீண்டும் model-க்கு அனுப்பப்படும், பின்னர் அடுத்து என்ன செய்ய வேண்டும் என்பதை model தீர்மானிக்கும். பல steps கொண்ட ஒரு task-ஐ agent முடிக்கச் செய்வது இந்த மீள்சுழற்சிதான். Chatbot-களுக்கு தேவையில்லாத boundaries agents-க்கு தேவைப்படுவதற்கும் இதுவே காரணம். Chatbot வழங்கும் தவறான பதில் ஒரு மோசமான paragraph ஆகும். Agent வழங்கும் தவறான பதில், ஒரு மோசமான paragraph-உடன், அதைப் பற்றி agent செய்த செயலையும் உள்ளடக்கும்.