AI Agents-ஐ அடிப்படையிலிருந்து கற்றுக்கொள்வது எப்படி?

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

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

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

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

நிலை 1-க்கு முன் உங்களுக்குத் தேவையானவை

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

• ஐம்பது வரிகள் கொண்ட Python அல்லது TypeScript script-ஐ உங்களால் எழுதவும் வாசிக்கவும் முடியும்.
• Linux shell-ல் உங்களுக்குப் பரிச்சயம் உண்டு: ஒரு package-ஐ நிறுவுதல், கோப்பைத் திருத்துதல், log-ஐ வாசித்தல் போன்றவை உங்களுக்குத் தெரியும்.
• உங்களிடம் hosted model-க்கான API key உள்ளது, அல்லது local-ஆக model-ஐ இயக்கும் திறன் கொண்ட கணினி உள்ளது.

இதுவே முழுமையான பட்டியல். உங்களுக்கு machine learning கோட்பாடுகள் தேவையில்லை, நீங்கள் எந்த model-ஐயும் train செய்திருக்க வேண்டிய அவசியமில்லை. Agent பணிகளில் gradients அல்லது training data தொடர்பான வேலைகள் எதுவும் இல்லை. நீங்கள் சொந்தமாக model-ஐ இயக்க முடிவு செய்தால் மட்டுமே graphics card தேவைப்படும்; இது ஒரு தனித்திறன், இதை நீங்கள் பிறகு hosting Ollama on a VPS to self host an LLM மூலம் கற்றுக்கொள்ளலாம்.

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

நிலை 1: ஏஜென்ட் (agent) என்றால் என்ன, அது எதல்ல

ஒரே ஒரு API அழைப்பு மற்றும் லூப் (loop) இல்லாத நிலையில் தொடங்கவும். ஒரு prompt-ஐ அனுப்பி, பதிலைப் பெற்று, response-ல் உள்ள token எண்ணிக்கையைப் பார்க்கவும். இப்போது நீங்கள் செலவு மற்றும் latency-ன் அடிப்படை அலகுகளைப் புரிந்துகொள்வீர்கள்.

அதன்பின் tool பயன்பாட்டைக் கற்றுக்கொள்ளுங்கள்; இதுவே இந்தத் துறையில் உள்ள ஒரே உண்மையான புதிய கருத்தாகும். ஒரு function-ன் பெயர், விளக்கம் மற்றும் அதன் உள்ளீடுகளுக்கான JSON (JavaScript object notation) schema ஆகியவற்றை நீங்கள் model-க்கு விவரிக்க வேண்டும். model எதையும் இயக்காது. அதற்குப் பதிலாக, ஒரு கட்டமைக்கப்பட்ட கோரிக்கையை அது அனுப்பும்: இந்த arguments-உடன் run_command-ஐ அழைக்கவும். உங்கள் code அந்த function-ஐ இயக்கி, வெளியீட்டை ஒரு செய்தியாக மீண்டும் அனுப்பி, model-இடம் மீண்டும் கேட்கும். model என்பது உரையை வாசித்து எழுதும் ஒரு திட்டமிடுபவர் (planner). உங்கள் code தான் செயல்களைச் செய்யும் கருவி.

ஒரு chatbot ஒரு பதிலுடன் முடிந்துவிடும். ஒரு ஏஜென்ட், model கருவிகளைக் கேட்பதை நிறுத்தும் வரை அந்தப் பரிமாற்றத்தைத் திரும்பத் திரும்பச் செய்யும். அந்தத் தொடர்ச்சியான செயல்பாடே இதற்கும் அதற்கும் உள்ள வித்தியாசம்; இதனால்தான் இவற்றின் தோல்வி முறைகளும் (failure modes) வேறுபடுகின்றன. ஒரு chatbot ஒருமுறை தவறான பதிலைத் தரும். ஒரு ஏஜென்ட், யாராவது கவனிக்கும் வரை பலமுறை தவறான பதிலின் அடிப்படையில் செயல்படும்.

நிலை 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-ஐக் கேட்டது, உங்கள் நிரல் அதை இயக்கியது, இரண்டாவது சுற்றில் அந்த அட்டவணை ஒரு வாக்கியமாக மாற்றப்பட்டது. வெளியீடு ஏதும் வரவில்லை என்றால், உரைத் தொகுதி வருவதற்கு முன்பே லூப் முடிந்துவிட்டது என்று அர்த்தம். லூப்பிற்குள் print(response.stop_reason)-ஐச் சேர்த்து, மதிப்புகள் மாறுவதைக் கவனியுங்கள்.

இப்போது இதை வேண்டுமென்றே சிதைக்கவும். tool_use_id வரியை நீக்கிவிட்டு வரும் பிழையைப் படியுங்கள். ஏனெனில், பொருந்தக்கூடிய id இல்லாத கருவி முடிவை (tool result) API நிராகரிக்கும்; இது ஆரம்ப நிலையில் இருப்பவர்களுக்கு ஏற்படும் மிக பொதுவான பிழையாகும். இரண்டு கட்டளைகள் தேவைப்படும் ஒரு கேள்வியைக் கேட்டு, லூப் இரண்டு முறை இயங்குவதைக் கவனியுங்கள். சாத்தியமில்லாத ஒன்றைக் கேட்டு, அது முயற்சியைக் கைவிடுகிறதா அல்லது முடிவில்லாமல் சுற்றுகிறதா என்று பாருங்கள்.

இந்த உதாரணத்தைப் பற்றி ஒரு எச்சரிக்கை. இது shell=True மூலம் மாதிரியின் வெளியீட்டை நேரடியாக shell-க்கு அனுப்புகிறது. நீங்கள் மீண்டும் உருவாக்கக்கூடிய (rebuild) ஒரு scratch machine-ல் இது ஏற்றுக்கொள்ளத்தக்கது, ஆனால் மற்ற இடங்களில் இது தவறானது. நிலை 6 இதைச் சரிசெய்கிறது. லூப்பிற்கு அடியில் உள்ள கருத்துகள் VPS-ல் உங்கள் சொந்த AI agent-ஐ உருவாக்குதல் என்பதில் விரிவாக விளக்கப்பட்டுள்ளன.

நிலை 3: ஏஜென்ட்டிடம் ஏற்கனவே இல்லாத கருவிகள்

உங்கள் run_command கருவி வேலை செய்கிறது, ஆனால் ஒரு உண்மையான ஏஜென்ட்டிற்கு கணினிக்கு வெளியே தொடர்பு கொள்ளும் கருவிகள் தேவை: ஒரு டிக்கெட் சிஸ்டம், தரவுத்தளம், அல்லது களஞ்சியம் (repository). ஒவ்வொரு சேவைக்கும், ஒவ்வொரு ஏஜென்ட்டிற்கும் தனித்தனியாக wrapper எழுதுவது அளவிடக்கூடியது (scalable) அல்ல.

Model Context Protocol (MCP) என்பது இதற்குத் தீர்வாகத் தொழில்துறையில் ஏற்றுக்கொள்ளப்பட்டுள்ளது. ஒரு MCP server தரப்படுத்தப்பட்ட போக்குவரத்து (transport) மூலம் கருவிகளை வழங்குகிறது; MCP-ஐ ஆதரிக்கும் எந்தவொரு ஏஜென்ட்டும் கூடுதல் குறியீடுகள் இன்றி இதைப் பயன்படுத்தலாம். கோப்பு முறைமைக்கான (filesystem) reference server-ஐ ஒரு கட்டளை மூலம் இயக்கலாம்:

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

இதற்கு Node நிறுவப்பட்டிருக்க வேண்டும். நீங்கள் குறிப்பிடும் directory மட்டுமே அந்த server அணுகக்கூடிய பாதையாக இருக்கும். இதுவே பாதுகாப்பின் அடிப்படை: ஏஜென்ட் அல்ல, server-தான் எல்லையைத் தீர்மானிக்கிறது. ஒரு client-ஐ இதனுடன் இணைப்பதன் மூலம், நீங்கள் எழுதாத கோப்பு வாசிப்பு மற்றும் எழுதும் திறனை உங்கள் ஏஜென்ட் பெறுகிறது. இவற்றைச் சரியாக, ஒரு service account-ன் கீழ் மற்றும் போக்குவரத்துத் தேர்வுகளுடன் இயக்குவது AI coding ஏஜென்ட்டுகளுக்காக VPS-ல் MCP server-களை இயக்குதல் பகுதியில் விளக்கப்பட்டுள்ளது.

இந்த நிலையின் பாடம் என்னவென்றால், கருவி வடிவமைப்புதான் உண்மையான வேலை. தெளிவற்ற விளக்கம் ஏஜென்ட்டை யூகிக்க வைக்கும். நாற்பதாயிரம் எழுத்துக்களைத் தரும் ஒரு கருவி context window-ஐப் பாதிக்கும். எதையும் நீக்கக்கூடிய ஒரு கருவி, இறுதியில் ஏதோ ஒன்றை நீக்கிவிடும்.

நிலை 4: நினைவகம், இது பெரும்பாலும் கோப்புகளே

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

ஒரு agent-க்கு அழைப்புகளுக்கு இடையே நினைவகம் இருப்பதில்லை. ஒவ்வொரு முறையும் முழு உரையாடலையும் நீங்கள் மீண்டும் அனுப்ப வேண்டும், இதனால்தான் நீண்ட உரையாடல்கள் குறுகிய உரையாடல்களை விட அதிக செலவை ஏற்படுத்துகின்றன. எனவே நினைவகம் இரண்டு சிக்கல்களாகப் பிரிகிறது. முதலாவது, தற்போது context window-க்குள் என்ன அடங்கும் என்பது; இதை நீங்கள் சுருக்கம் செய்வதன் மூலமும், பழைய tool output-ஐ நீக்குவதன் மூலமும், prompt-ன் நிலையான பகுதியை cache செய்வதன் மூலமும் நிர்வகிக்கலாம், இதன் மூலம் நீங்கள் அதற்கான செலவில் ஒரு பகுதியை மட்டுமே செலுத்துவீர்கள். இரண்டாவது, மறுதொடக்கம் (restart) செய்த பிறகும் எஞ்சியிருப்பது; இதுவே சேமிப்பகம் (storage).

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

நிலை 5: சுழற்சியே தயாரிப்பு

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

ஒரு unattended agent-ஐ தனியாக விட்டுவிடுவது பாதுகாப்பானதா என்பதை நான்கு கேள்விகள் தீர்மானிக்கின்றன. அது எதனால் தூண்டப்படுகிறது (trigger), இதனால் தேவையற்ற நேரங்களில் அது இயங்காது. அது எந்த எல்லைக்குள் (boundary) செயல்படுகிறது, இதனால் தவறு நடந்தாலும் பாதிப்பு குறைவாக இருக்கும். அதன் முடிவு எவ்வாறு சரிபார்க்கப்படுகிறது (verification), ஏனெனில் தனது வேலையைத் தானே மதிப்பீடு செய்யும் agent எப்போதும் தேர்ச்சி பெறும். எந்த வரம்பு (budget) அதை நிறுத்துகிறது, அது tokens அல்லது நேரத்தின் அடிப்படையில் இருக்கலாம். இந்த நான்கையும் திட்டமிட்டு வடிவமைப்பதே loop engineering மற்றும் அதன் வரையறை என்பதில் விவரிக்கப்பட்டுள்ள ஒழுக்கமாகும்.

பயிற்சி: உங்கள் நிலை 2 agent-ஐ எடுத்துக்கொண்டு, நான்கு அல்லது ஐந்து படிகள் தேவைப்படும் ஒரு பணியை அதற்கு வழங்கவும். பிறகு, ஒரு கடினமான iteration வரம்பைச் சேர்க்கவும். அதன் பிறகு அந்த வரம்பை நீக்கிவிட்டு, unbounded loop உங்கள் token கட்டணத்தில் என்ன செய்கிறது என்பதைக் கவனியுங்கள். இதை ஒருமுறை சிறிய பட்ஜெட்டில் செய்து பாருங்கள், அப்போதுதான் பெரிய பட்ஜெட்டில் தவறுதலாக இதைச் செய்ய மாட்டீர்கள்.

நிலை 6: பாதுகாப்பு, ரகசியங்கள் மற்றும் செலவு

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

Agent-ஐ root பயனராகவோ அல்லது உங்கள் சொந்த கணக்கிலோ இயக்காமல், அதற்கென பிரத்யேகமான unprivileged user-ஆக இயக்கவும். இதன் மூலம் பாதிப்பு ஒரு முழு இயந்திரத்திற்குப் பதிலாக ஒரு குறிப்பிட்ட directory-க்குள் மட்டுமே கட்டுப்படுத்தப்படும். Credentials-ஐ model-ன் அணுகலுக்கு வெளியே வைக்கவும். ஏனெனில், context window-வில் இருக்கும் எந்தவொரு தகவலும் tool call மூலம் வெளியே கசிய வாய்ப்புள்ளது. இதற்கான தீர்வு, AI agent-களில் ரகசியங்களை பாதுகாத்தல் பகுதியில் விவரிக்கப்பட்டுள்ளபடி, helper மூலம் குறுகிய கால tokens-ஐப் பயன்படுத்துவதாகும். செலவுக்கு ஒரு கடினமான உச்சவரம்பை (hard ceiling) நிர்ணயிக்கவும். ஏனெனில், கவனிக்கப்படாத ஒரு loop, ஒவ்வொரு iteration-க்கும் கட்டணத்தை உயர்த்திக்கொண்டே இருக்கும். இதைச் சீராக வைத்திருக்கத் தேவையான வரம்புகள் மற்றும் batching முறைகள் எப்போதும் இயங்கும் VPS-ல் AI agent செலவு கட்டுப்பாடு பகுதியில் உள்ளன.

செலவு குறித்து ஒரு தெளிவான புள்ளிவிவரம் அவசியம். ஜூலை 2026 நிலவரப்படி, Claude Opus 5 ஒரு மில்லியன் input tokens-க்கு $5 மற்றும் ஒரு மில்லியன் output tokens-க்கு $25 கட்டணம் வசூலிக்கிறது. ஒரு உரையாடல் நீண்டுகொண்டே செல்லும் போது, ஒரு சிறிய task-க்கு கூட சில லட்சம் tokens செலவாகலாம். Prompt-ல் மாற்றங்கள் செய்வதை விட, prompt caching மற்றும் வழக்கமான பணிகளுக்கு சிறிய model-களைப் பயன்படுத்துவது இந்த கணக்கீட்டை பெருமளவு மாற்றும்.

Prompt injection-ம் இதில் அடங்கும். உங்கள் agent ஒரு இணையப்பக்கம், issue tracker அல்லது inbox-ஐ வாசித்தால், அந்த உரையை எழுதியவர் உங்கள் agent-க்கு மறைமுகமாக கட்டளைகளை வழங்குகிறார் என்று அர்த்தம். இதற்கு புத்திசாலித்தனமான system prompt மட்டும் தீர்வல்ல. எல்லைகளை (boundary) வகுப்பதே சரியான பாதுகாப்பு. ஒரு repository-ஐ நீக்க அதிகாரம் இல்லாத agent-ஐ, அதை நீக்கும்படி யாராலும் தூண்ட முடியாது.

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

ஆறு வெவ்வேறு பாடத்திட்டங்களை மேலோட்டமாகப் பார்ப்பதை விட, ஏதேனும் ஒன்றை மட்டும் தேர்ந்தெடுத்து முழுமையாக முடிக்கவும். Microsoft-ன் ai-agents-for-beginners களஞ்சியம் (repository) மிகவும் முழுமையான இலவச பாடத்திட்டமாகும். இது 18 பாடங்களைக் கொண்ட ஒரு படிப்பாகும்; ஜூலை 2026 நிலவரப்படி இது 70,000 நட்சத்திரங்களைப் பெற்றுள்ளது. இது மேலே குறிப்பிடப்பட்ட நிலைகளுடன் சரியாகப் பொருந்துகிறது. பிரபலமாக உள்ள ஏஜென்ட் களஞ்சியங்களின் தொகுப்புகள், என்னென்ன கருவிகள் உள்ளன என்பதை அறிய உதவும், ஆனால் ஒரு பாடத்திட்டமாகப் பயன்படுத்த முடியாது. ஏனெனில், நட்சத்திரங்களின் அடிப்படையில் வரிசைப்படுத்தப்பட்ட பட்டியல், கற்பித்தல் வரிசையை விட பிரபலத்தையே காட்டுகிறது.

பயிற்சி செய்ய ஒரு உண்மையான திட்டம் தேவைப்படும்போது, ஒரு coding agent-ஐ உருவாக்குவதே சிறந்த முதல் இலக்காகும்: இதில் பின்னூட்டம் (feedback) உடனடியாகக் கிடைக்கும், கருவிகள் தெளிவாக இருக்கும், மேலும் தவறுகளைச் சரிசெய்வது எளிது. VPS-ல் ஒரு coding AI agent-ஐ இயக்குதல் என்ற கட்டுரை, ஒரு திட்டத்தை முழுமையாக எவ்வாறு முடிப்பது என்பதை விளக்குகிறது. நீங்களாக உருவாக்குவதை விட, ஏற்கனவே இயங்கும் அமைப்புகளைப் படிக்க விரும்பினால், சிறந்த self hosted AI agents என்ற ஒப்பீடு, பல்வேறு திட்டங்கள் ஒரே சுழற்சியை (loop) எவ்வாறு வித்தியாசமாகச் செயல்படுத்துகின்றன என்பதைக் காட்டுகிறது.

இதற்கு எவ்வளவு காலம் எடுக்கும்?

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

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

FAQ

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

தேவையில்லை. ஒரு agent-ஐ உருவாக்குவது என்பது API மூலம் ஒரு model-ஐ அழைத்து, அதன் tool கோரிக்கைகளை உண்மையான functions-உடன் இணைப்பது மட்டுமே; இது சாதாரண application programming ஆகும். நீங்கள் training, gradients, அல்லது datasets-ஐ தொட வேண்டிய அவசியமில்லை. உங்கள் agent சரியாகச் செயல்படுகிறதா என்பதைத் தீர்மானிக்கும் திறன்கள், tool-களுக்கான schema design, error handling, மற்றும் Linux permissions ஆகியவை மட்டுமே. நீங்கள் ஒரு model-ஐ fine-tune செய்ய முற்பட்டால் மட்டுமே machine learning கோட்பாடு தேவைப்படும்; அது வேறுபட்ட முன்நிபந்தனைகளைக் கொண்ட ஒரு தனிப்பணியாகும்.

LangChain அல்லது CrewAI போன்ற framework-களில் தொடங்க வேண்டுமா?

முதலில் ஒரு raw loop-ஐ நீங்களே எழுதிப் பாருங்கள், அதன் பிறகு framework-க்கு மாறுங்கள். ஒரு framework, stage 2-ல் உள்ள முப்பது வரிகளை ஒரு configuration object-ஆக மாற்றுகிறது. அது எதை மாற்றுகிறது என்று தெரிந்தால் மட்டுமே இது வசதியானது, இல்லையெனில் குழப்பத்தையே தரும். உங்கள் agent தவறாகச் செயல்படும்போது, message list மற்றும் tool results-ஐ நேரடியாக ஆராய வேண்டியிருக்கும்; அவற்றை இதற்கு முன் பார்த்ததில்லை என்றால் இது மிகவும் கடினம். நீங்களாக ஒருமுறை loop-ஐ எழுதிய பிறகு, framework-ஐப் பயன்படுத்துவது உங்கள் நேரத்தை மிச்சப்படுத்தும், அதன் செயல்பாட்டை மறைக்காது.

AI agent-களைக் கற்க எவ்வளவு செலவாகும்?

நீங்கள் செலவைக் கட்டுப்படுத்தினால், பெரும்பாலானோர் எதிர்பார்ப்பதை விடக் குறைவான செலவே ஆகும். ஒரு hosted API key மற்றும் ஒரு சிறிய VPS ஆகியவை இந்த ஆறு நிலைகளுக்கும் போதுமானவை. உண்மையான ஆபத்து மணிநேரக் கட்டணம் அல்ல, நீங்கள் தூங்கும்போது ஒவ்வொரு iteration-க்கும் கட்டணம் வசூலிக்கும் unbounded loop ஆகும். முதல் நாளிலேயே உங்கள் API கணக்கில் ஒரு கடினமான செலவு வரம்பை (hard spend limit) நிர்ணயியுங்கள், நீங்கள் எழுதும் ஒவ்வொரு loop-க்கும் ஒரு iteration cap-ஐச் சேர்க்கவும், மேலும் வழக்கமான பணிகளுக்கு மலிவான model-ஐப் பயன்படுத்தவும். model-ஐ locally இயக்குவது token கட்டணத்தைத் தவிர்க்கும், ஆனால் அதற்குப் பதிலாக வன்பொருள் (hardware) தேவைப்படும்.

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

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