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

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

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

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

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

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

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

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

இதுவே முழுமையான பட்டியல். உங்களுக்கு machine learning கோட்பாடுகள் தேவையில்லை, நீங்கள் ஒரு model-ஐப் பயிற்றுவித்திருக்க வேண்டிய அவசியமும் இல்லை. 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 தொடர்பான stack trace அல்லது file mode-ஐப் பார்த்தவுடன் நீங்கள் terminal-ஐ மூடிவிடுபவர் என்றால், முதலில் ஒரு வார இறுதியில் Linux-ன் அடிப்படை விஷயங்களைக் கற்றுக்கொள்ளுங்கள். இது பிற்காலத்தில் உங்களுக்கு ஒரு மாத கால உழைப்பை மிச்சப்படுத்தும்.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

பயிற்சி: உங்கள் நிலை 2 agent-ஐ எடுத்துக்கொள்ளுங்கள், அதற்கு நான்கு அல்லது ஐந்து படிகள் தேவைப்படும் ஒரு பணியைக் கொடுங்கள், மேலும் ஒரு கடினமான iteration வரம்பைச் (cap) சேர்க்கவும். பிறகு அந்த வரம்பை நீக்கிவிட்டு, வரம்பற்ற சுழற்சி (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 செலவு கட்டுப்பாடு என்பதில் உள்ளன.

உங்கள் agent நீங்கள் எழுதிய script-க்கு பதிலாக ஒரு harness-க்குள் இயங்கினால், இதில் சில பகுதிகள் code-ஐ விட configuration சார்ந்தவை. நிறுவ வேண்டிய DeepSeek Harness plugins என்பதில் பட்ஜெட் வரம்புகள், tool அனுமதி விதிகள் மற்றும் injection scanning போன்றவை குறித்து விளக்கப்பட்டுள்ளன.

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

Prompt injection-ம் இதில் அடங்கும். உங்கள் agent ஒரு web page, issue tracker அல்லது inbox-ஐ வாசித்தால், அந்த உரையை எழுதியவர் உங்கள் agent-க்கு கட்டளைகளையும் எழுதுகிறார் என்று அர்த்தம். Web search பொதுவாக இந்த ஆபத்தை முதலில் ஏற்படுத்தும் கருவியாகும். உங்கள் சொந்த SearXNG instance-ஐ agent-டன் இணைத்தல் என்பதில் அதன் இணைப்பு மற்றும் அது உருவாக்கும் injection surface குறித்து விளக்கப்பட்டுள்ளது. இதற்கான பாதுகாப்பு ஒரு புத்திசாலித்தனமான system prompt அல்ல. அது ஒரு எல்லை (boundary) மட்டுமே; ஏனெனில் ஒரு repository-ஐ நீக்க அதிகாரம் இல்லாத agent-ஐ, அதை நீக்கும்படி யாராலும் தூண்ட முடியாது.

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

ஆறு வெவ்வேறு பாடத்திட்டங்களைச் சோதிப்பதற்குப் பதிலாக, ஏதேனும் ஒன்றை மட்டும் தேர்ந்தெடுத்து முழுமையாக முடிக்கவும். Microsoft ai-agents-for-beginners களஞ்சியம் (repository) மிகவும் முழுமையான இலவச பாடத்திட்டமாகும். இது பதினெட்டு பாடங்களைக் கொண்ட ஒரு படிப்பாகும், ஜூலை 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 தீர்மானிக்கும். அந்தத் தொடர்ச்சியான செயல்பாட்டால்தான் ஒரு agent பல படிகளைக் கொண்ட ஒரு பணியை முடிக்க முடிகிறது; இதனால்தான் chatbot-களுக்குத் தேவையில்லாத எல்லைகள் (boundaries) agent-களுக்குத் தேவைப்படுகின்றன. chatbot-ல் வரும் தவறான பதில் ஒரு மோசமான பத்தி (paragraph) மட்டுமே. agent-ல் வரும் தவறான பதில் ஒரு மோசமான பத்தி மற்றும் அது செய்த பிற விளைவுகளையும் உள்ளடக்கியது.