VPS-இல் சொந்தமாக AI agent உருவாக்குவது எப்படி?

ஒரு AI agent என்பது உண்மையில் என்ன

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

செயல்முறை (action) என்பது மிக முக்கியமான பகுதி. ஒரு language model தானாகவே வெறும் text-ஐ மட்டுமே உருவாக்கும். அதனால் ஒரு file-ஐப் படிக்கவோ, API-ஐ அழைக்கவோ அல்லது ஒரு command-ஐ இயக்கவோ முடியாது. ஒரு agent, அந்த model-க்கு அது பயன்படுத்தக்கூடிய கருவிகளின் (tools) தொகுப்பையும், அவற்றை எவ்வாறு கேட்பது என்பதற்கான வழியையும் வழங்குகிறது. model இணையத்தில் தேடவோ அல்லது ஒரு file-ஐ எழுதவோ விரும்பும்போது, அது அந்த வேலையைத் தானே செய்யாது. அது ஒரு structured request-ஐ வெளியிடும், உங்கள் code அந்த tool-ஐ இயக்கும், அதன் பதில் அடுத்த turn-இல் model படிக்கும் விஷயமாகத் திரும்பக் கிடைக்கும். modeljudgement-ஐ வழங்குகிறது; உங்கள் server கைகளை வழங்குகிறது.

ஒவ்வொரு பணிக்கும் agent தேவையில்லை, எனவே இயல்பாகவே ஒரு agent-ஐப் பயன்படுத்துவது ஒரு பொதுவான தவறு. படிநிலைகள் (steps) முன்கூட்டியே தெரிந்திருந்தால், ஒரு சாதாரண script எளிமையானது, வேகமானது மற்றும் நம்பகமானது. "ஒவ்வொரு மணி நேரத்திற்கும் இந்த page-ஐப் பெற்று எனக்கு விலையை email செய்" என்பது ஒரு scheduled job, அது agent அல்ல. பாதை முன்கூட்டியே தீர்மானிக்கப்படாதபோது, model தான் கண்டறியும் விஷயங்களைப் பார்த்து அடுத்து என்ன செய்ய வேண்டும் என்று தீர்மானிக்க வேண்டியிருக்கும் போது மட்டும் ஒரு agent-ஐ உருவாக்குங்கள். ஒரு agent-இன் செலவு அதன் கணிக்க முடியாத தன்மை (unpredictability) ஆகும், எனவே அதன் flexibility பயனுள்ளதாக இருக்கும்போது மட்டும் அதைப் பயன்படுத்துங்கள்.

Tools: ஒரு agent எவ்வாறு செயல்படுகிறது

ஒரு tool என்பது நீங்கள் model-இடம் ஒப்படைக்கும் எந்தவொரு திறமையாகும், அதை எப்போது பயன்படுத்த வேண்டும் என்பதைத் தீர்மானிக்கும் வகையில் அது நன்கு விவரிக்கப்பட்டிருக்க வேண்டும். ஒரு file-ஐப் படித்தல், shell command-ஐ இயக்குதல், database-ஐ query செய்தல், ஒரு message-ஐ அனுப்புதல்: இவை ஒவ்வொன்றும் ஒரு பெயர், ஒரு சிறிய விளக்கம் மற்றும் உள்ளீடுகளின் (inputs) பட்டியலைக் கொண்ட ஒரு tool ஆகும். நீங்கள் tools-களை வரையறுக்கிறீர்கள்; model எப்போது அவற்றை அழைக்க வேண்டும் என்று தீர்மானிக்கிறது.

நீங்கள் எந்த model-ஐப் பயன்படுத்தினாலும், இதன் செயல்முறை எல்லா இடங்களிலும் ஒன்றுதான். model ஒரு structured request-ஐத் திருப்பித் தரும், அதில் ஒரு tool-ன் பெயரும் அதன் inputs-களும் இருக்கும். உங்கள் code அந்த request-ஐக் கண்டு, அதற்குப் பொருத்தமான function-ஐ இயக்கி, அதன் முடிவை அடுத்த turn-இல் திருப்பி அனுப்பும். model அந்த முடிவைப் படித்து, மற்றொரு tool-ஐ அழைக்கலாம் அல்லது தனது இறுதிப் பதிலைத் தரலாம். Function calling என்பது ஒவ்வொரு agent-இன் பின்னணியில் உள்ள plumbing ஆகும், அதை இயக்கும் loop சில வரிகள் கொண்ட சாதாரண code மட்டுமே.

இங்குதான் உங்கள் கட்டுப்பாடும் (control) உள்ளது. model ஒரு command-ஐ இயக்கக் கேட்கலாம், ஆனால் உங்கள் code அதை இயக்கத் தீர்மானிக்கும் வரை எதுவும் இயங்காது. அந்த இடைவெளியில்தான் ஆபத்தான செயல்களுக்கான approval prompts, ஒரு tool எவற்றையெல்லாம் தொடலாம் என்பதற்கான வரம்புகள் மற்றும் agent செய்த அனைத்தின் log ஆகியவற்றைப் நீங்கள் வைக்க வேண்டும். நீங்கள் ஒரு agent-க்கு வழங்கும் tools மற்றும் நீங்கள் வைக்கும் சோதனைகளைப் பொறுத்தே அதன் பாதுகாப்பு அமையும்.

MCP: கருவிகளை இணைப்பதற்கான ஒரு நிலையான வழி

ஒவ்வொரு service-க்கும் தனித்தனியாக integration எழுதுவது விரைவாக அலுப்படையச் செய்யும். Model Context Protocol அல்லது MCP என்பது இதற்குத் தீர்வாக அமையும் ஒரு open standard ஆகும். உங்கள் files, database மற்றும் issue tracker ஆகியவற்றிற்காகப் புதிய tool-ஐக் குறியீடாக எழுதுவதற்குப் பதிலாக, ஏற்கனவே அந்த விஷயங்களை tools-களாக வெளிப்படுத்தும் ஒரு MCP server-ஐ agent-இடம் இணைக்கலாம். agent ஒரு protocol-இல் பேசுகிறது; server உண்மையான system-உடன் பேசுவதற்கான வேலையைச் செய்கிறது.

இதன் பலன் மறுபயன்பாடு (reuse) ஆகும். நீங்கள் பயன்படுத்தும் ஒரு service-க்காக மற்றவர் எழுதிய MCP server, புதிய integration code இல்லாமலேயே உங்கள் agent-க்குக் கிடைக்கும், மேலும் நீங்கள் எழுதும் ஒரு server, அந்த protocol-இல் பேசும் எந்த agent-ஆலும் பயன்படுத்தப்படலாம். ஒரு VPS-இல் இது முக்கியமானது, ஏனெனில் நீங்கள் MCP servers-களை agent-இன் பக்கத்தில் தனித்தனி சிறிய services-களாக இயக்கலாம், ஒவ்வொன்றும் அதற்குத் தேவையான அணுகலை மட்டும் கொண்டிருக்கும். running MCP servers on a VPS என்பதில் நான் setup முறையை விளக்கியுள்ளேன்.

Memory மற்றும் retrieval

ஒரு language model-க்கு அழைப்புகளுக்கு இடையில் (between calls) சொந்தமாக நினைவாற்றல் (memory) கிடையாது. தற்போதைய பணி பற்றிய அனைத்தும் ஒவ்வொரு turn-இலும் அதற்கு வழங்கப்பட வேண்டும். ஒரு சிறிய பணிக்கு இது போதுமானது, ஏனெனில் முழு உரையாடலும் ஒரு request-இல் அடங்கிவிடும். நீண்ட பணிகளுக்கு நீங்கள் நினைவாற்றலை நீங்களே நிர்வகிக்க வேண்டும், அதற்குத் தெரிந்த இரண்டு முறைகள் உள்ளன.

முதல் முறை scratchpad ஆகும். நீங்கள் agent-க்கு அது படிக்கவும் எழுதவும்க்கூடிய ஒரு file-ஐக் கொடுத்து, அது கற்றுக்கொண்டவற்றைச் சேகரிக்கச் சொல்லலாம். அடுத்த turn அல்லது அடுத்த session-இல், அது அந்த file-ஐ மீண்டும் படித்து, விட்ட இடத்திலிருந்தே தொடங்கும். இது ஒரு சாதாரண ஆவணமாகச் செயல்படும் memory ஆகும், ஏனெனில் agent அந்த file-ஐ மற்றொரு tool-ஆகக் கருதுகிறது.

இரண்டாவது முறை retrieval ஆகும். ஒரு request-இல் அடங்காத பெரிய ஆவணத் தொகுப்பிலிருந்து agent-க்குத் தகவல் தேவைப்படும்போது, அந்த ஆவணங்களைத் தேடக்கூடிய வடிவில் சேமித்து, தேவைப்படும்போது மட்டும் தொடர்புடைய பகுதிகளை model-இன் பார்வையில் கொண்டு வர வேண்டும். இந்த முறை retrieval-augmented generation அல்லது RAG என்று அழைக்கப்படுகிறது. agent ஒரு கேள்வியைக் கேட்கிறது, உங்கள் code பொருந்தக்கூடிய சில பகுதிகளைக் கண்டறிகிறது, மேலும் அவை மட்டுமே model-க்குச் செல்கின்றன. இந்த store உங்கள் server-இல் இருப்பதால், உங்கள் தனிப்பட்ட ஆவணங்கள் அங்கிருந்து வெளியேறாது.

பல agents, ஒரு coordinator

பல tools கொண்ட ஒரு agent பெரும்பாலான பணிகளுக்குப் போதுமானது. ஒரு பணி பெரியதாகவோ அல்லது இயல்பாகப் பல பகுதிகளாகப் பிரிந்து கிடப்பதோ இருந்தால், ஒரு coordinator agent உதவியாக இருக்கும்: இது specialised sub-agents-களுக்குப் பணிகளைப் பிரித்துக் கொடுக்கும். coordinator இலக்கைச் சிறு துண்டுகளாகப் பிரித்து, அந்தந்தப் பணிகளுக்காக உருவாக்கப்பட்ட sub-agent-களிடம் ஒப்படைத்து, முடிவுகளை ஒருங்கிணைக்கும்.

இதன் பயன் கவனம் (focus) ஆகும். ஒரு குறுகிய வேலையையும் சிறிய tool set-ஐயும் கொண்ட sub-agent, அனைத்தையும் கையாள முயலும் ஒரு பொதுவான agent-ஐ விடச் சிறந்த முடிவுகளை எடுக்கும், மேலும் தனித்தனிப் பகுதிகள் ஒரே நேரத்தில் இயங்க முடியும். இதற்கான செலவு coordination ஆகும், இது உண்மையானது, எனவே ஒரு பணிக்குத் தேவைப்படும் வரை ஒரு single agent-ஐயே வைத்திருங்கள். எளிமையாகத் தொடங்குங்கள், ஒரு agent கடினமாகச் செயல்படும்போது மட்டும் மற்ற agent-களைச் சேர்க்கவும்.

Self-hosted அல்லது hosted: உங்கள் agent-ஐ எந்த model இயக்கும்

model என்பது ஒரு agent-இல் நீங்கள் நீங்களே இயக்க வேண்டிய தேவை இல்லாத ஒரே ஒரு பகுதி ஆகும், அது எங்கு அமைகிறது என்பதைத் தேர்ந்தெடுப்பதே நீங்கள் எடுக்க வேண்டிய மிகப்பெரிய முடிவாகும். API மூலம் அணுகப்படும் ஒரு hosted model, எந்தச் செயல்பாடும் இன்றி உங்களுக்கு மிகச் சிறந்த reasoning-ஐ வழங்கும்: நீங்கள் text-ஐ அனுப்புகிறீர்கள், பதிலாக text-ஐப் பெறுகிறீர்கள். ஒரு self-hosted model உங்கள் சொந்த server-இல் இயங்கும், இது ஒவ்வொரு request-ஐயும் தனிப்பட்டதாக வைத்திருக்கும், token-க்குக் கட்டணம் செலுத்துவதற்குப் பதிலாக நிலையான விலையைக் கொண்டிருக்கும், மேலும் மற்றவர்கள் online-இல் இருக்க வேண்டும் என்ற தேவையையும் இது ஏற்படுத்தாது. இதில் திறன் (capability) மற்றும் முயற்சி (effort) ஆகியவற்றுக்கு இடையேயான சமநிலை உள்ளது. சிறந்த hosted models, நீங்கள் நீங்களாகவே இயக்கக்கூடியதை விட மேம்பட்டவை, மேலும் நீங்களே இயக்குவது என்பது அதற்குத் தேவையான நினைவாற்றலை (memory) வழங்குவதைக் குறிக்கும்.

கடைசிப் புள்ளி ஒரு நடைமுறைச் சிக்கலாகும். ஒரு model உங்கள் server-இன் memory-இல் அடங்க வேண்டும், மேலும் நீங்கள் ஒரு GPU பயன்படுத்தினால், அதன் video memory-இல் அடங்க வேண்டும். hardware-க்குத் தேவையானதை விடப் பெரிய model ஏற்ற wouldn't load. ஒரு self-hosted agent-ஐத் திட்டமிடுவதற்கு முன், நீங்கள் விரும்பும் model உங்களிடம் உள்ள machine-இல் அடங்குமா என்று சரிபார்க்கவும்:

எண்கள் பொருந்தவில்லை என்றால், உங்களிடம் மூன்று வழிகள் உள்ளன: சிறிய model-ஐத் தேர்ந்தெடுங்கள், அதைச் சுருக்க அதிகப்படியான quantization-ஐப் பயன்படுத்துங்கள், அல்லது reasoning-களுக்கு hosted API-ஐப் பயன்படுத்தி, உங்கள் tools மற்றும் தரவுகளை மட்டும் server-இல் வைத்திருங்கள். பல self-hosted agents Ollama on a VPS மூலம் உள்ளூர் model-இல் தொடங்கி, கடினமான படிகளுக்கு hosted API-ஐப் பயன்படுத்துகின்றன.

Server என்பது ஆபத்தான பகுதி

shell commands-களை இயக்கக்கூடிய மற்றும் file-களை எழுதக்கூடிய ஒரு agent மிகவும் சக்தி வாய்ந்தது, அதனால்தான் அது ஆபத்தானது. model-இன்judgement சிறந்தது ஆனால் முழுமையானது அல்ல, ஒரு தவறான instruction, ஒரு bug, அல்லது ஒருத் தீய உள்ளீடு (hostile input) ஒரு பயனுள்ள agent-ஐத் தவறான விஷயங்களை அழிக்கும் அல்லது ரகசியங்களை கசியவிடும் ஒன்றாக மாற்றலாம். பாதுகாப்புப் பணிகள் விருப்பத்தேர்வு அல்ல, ஒரு server-இல் அதுவே மிக முக்கியமான பகுதியாகும்.

சில பழக்கவழக்கங்கள் பெரும்பாலான பாதுகாப்பைத் தரும். agent-ஐ ஒரு பிரத்யேக unprivileged user-ஆக இயக்கவும், root-ஆக ஒருபோதும் இயக்க வேண்டாம், இதனால் தவறு ஏற்பட்டால் அதன் பாதிப்பு வரையறுக்கப்பட்டதாக இருக்கும்; இதே தத்துவம் running services as an unprivileged user என்பதில் உள்ளது. அதன் API keys போன்ற ரகசியங்களை code-இல் இருந்து தள்ளி, அந்த user-ஆல் மட்டுமே படிக்கக்கூடிய வகையில் வைக்கவும். system-ஐத் தொடும் tools-களை sandbox செய்யவும், இதனால் agent அதற்குத் தேவையானதை மட்டும் அணுக முடியும். ஒரு உண்மையான self-hosted agent-ஐப் பாதுகாப்பாக மாற்றுவதற்கான உதாரணத்திற்கு, running OpenClaw safely on a VPS பார்க்கவும். நீங்கள் அறிவாற்றலுக்கு hosted model-ஐப் பயன்படுத்த விரும்பினால், building an agent with Claude on a VPS என்ற வழிகாட்டி அதே கருத்துக்களைக் கொண்டு ஒரு குறிப்பிட்ட model-ஐப் பயன்படுத்துகிறது.

ஒரு உதாரணத்திற்கு, building an OpenClaw-style personal agent இந்தத் துண்டுகளைப் பயன்படுத்துகிறது, மேலும் நீங்கள் ஏற்கனவே உருவாக்கப்பட்ட ஒன்றைப் பயன்படுத்த விரும்பினால், self-hosting Hermes Agent on a VPS அல்லது running Agent Zero on your own server மூலம் தொடங்கலாம், மேலும் the best self-hosted AI agents in 2026 என்பதில் நாங்கள் கவனிக்கும் அனைத்துத் தயார்நிலை விருப்பங்களையும் ஒப்பிட்டுப் பார்க்கலாம்.

FAQ

An AI agent மற்றும் chatbot ஆகியவற்றிற்கு இடையேயான வேறுபாடு என்ன?

ஒரு chatbot ஒரு செய்திகளுக்குப் பதிலளித்து நின்றுவிடும். ஒரு agent ஒரு loop-ஐ இயக்குகிறது: model ஒரு action-ஐத் தீர்மானிக்கிறது, உங்கள் code அதைச் செய்கிறது, அதன் முடிவு மீண்டும் model-க்குச் செல்கிறது, மற்றும் பணி முடியும் வரை அது மீண்டும் மீண்டும் நடக்கிறது. வித்தியாசம் என்னவென்றால், ஒரு agent வெறும் text-ஐ மட்டும் உருவாக்குவதற்குப் பதிலாக, files-களைப் படிக்க, commands-களை இயக்க அல்லது services-களை query செய்ய tools-களைப் பயன்படுத்தி, அதன் turn-களுக்கு இடையில் உண்மையான செயல்களைச் செய்கிறது.

VPS-இல் an AI agent-ஐ இயக்க எனக்கு GPU தேவையா?

நீங்கள் model-ஐ self-host செய்தால் மட்டுமே தேவைப்படும். agent loop, tools மற்றும் memory ஆகியவை சாதாரண code ஆகும், அவை GPU இல்லாத சாதாரண VPS-இல் நன்றாக இயங்கும். நீங்கள் language model-ஐ உங்கள் சொந்த hardware-இல் இயக்க விரும்பினால் GPU முக்கியமானது, ஏனெனில் model நினைவகத்தில் (memory) அடங்க வேண்டும். நீங்கள் API மூலம் hosted model-ஐப் பயன்படுத்தினால், கடினமான கணக்கீடுகள் வேறு இடத்தில் நடக்கும், எனவே ஒரு சாதாரண VPS போதுமானது.

MCP என்றால் என்ன, ஒரு agent-ஐ உருவாக்க எனக்கு அது தேவையா?

MCP (Model Context Protocol) என்பது ஒரு agent-ஐ tools மற்றும் தரவு மூலங்களுடன் இணைப்பதற்கான ஒரு open standard ஆகும். நீங்கள் ஒவ்வொரு tool-ஐயும் கைமுறையாக எழுத முடியும் என்பதால், இது உங்களுக்குக் கண்டிப்பாகத் தேவையில்லை. ஆனால் பொதுவான services-களுக்கு ஏற்கனவே உள்ள servers-களை மறுபயன்பாடு செய்யவும், உங்கள் சொந்த system-களை எந்தவொரு agent-ஆலும் பயன்படுத்தும் வகையில் ஒருமுறை மட்டும் வெளிப்படுத்தவும் MCP உங்களுக்கு உதவுகிறது. ஒருங்கிணைப்புகள் (integrations) அதிகரிக்கும் போது இது ஒரு வசதியாக அமையும்.

எனது server-இன் அணுகலை ஒரு AI agent-இடம் ஒப்படைப்பது பாதுகாப்பானதா?

நீங்கள் அதைத் தடுத்தால் (contain) அது பாதுகாப்பானதுதான். commands-களை இயக்கும் ஒரு agent, அது இயங்கும் கணக்கின் (account) பாதுகாப்பு மற்றும் நீங்கள் அனுமதிக்கும் tools-களைப் பொறுத்தே பாதுகாப்பானது. அதை ஒரு unprivileged user-ஆக இயக்கவும், அதன் ரகசியங்களை அணுக முடியாத தூரத்தில் வைக்கவும், filesystem-ஐத் தொடும் tools-களை sandbox செய்யவும், மற்றும் மாற்ற முடியாத செயல்களுக்கு அனுமதி (approval) கோரவும். agent-ஐ புத்திசாலித்தனமாகச் செயல்படும் ஒரு நம்பகமற்ற code-ஆகக் கருதி, பணிக்குத் தேவையானதை மட்டும் அதற்கு வழங்கவும்.