Paano Gumawa ng AI Agent sa Sarili Mong VPS

Ano talaga ang isang AI agent

Ang AI agent ay isang loop na nakapalibot sa isang language model. Binabasa ng model ang sitwasyon, pumipili ng isang action, isinasagawa ng code mo ang action na iyon, ibinabalik sa model ang resulta, at inuulit ang loop hanggang matapos ang task. Iyon ang buong ideya. Isang beses lang sumasagot ang plain chatbot at pagkatapos ay tumitigil. Patuloy ang agent sa pagkuha ng mga aktuwal na action sa pagitan ng mga turn nito hanggang maabot nito ang goal na ibinigay mo. Sapat na maliit ang loop para ikaw mismo ang sumulat nito sa loob ng isang hapon. Dito nagsisimula ang sunod-sunod na paraan ng pag-aaral ng mga agent mula sa simula, bago magdagdag ng tools, memory, at safety.

Ang action ang pinakamahalagang bahagi. Sa sarili nito, text lamang ang ginagawa ng language model. Hindi ito makakabasa ng file, makakatawag ng API, o makakapagpatakbo ng command. Binibigyan ng agent ang model ng set ng tools na pinapayagan nitong gamitin, pati ng paraan para hilingin ang mga ito. Kapag gusto ng model na maghanap sa web o magsulat ng file, hindi nito ginagawa mismo ang trabaho. Naglalabas ito ng structured request, pinapatakbo ng code mo ang tool, at bumabalik ang sagot bilang susunod na binabasa ng model. Ang model ang nagbibigay ng judgement; ang server mo ang nagbibigay ng kakayahang magsagawa ng mga action.

Hindi lahat ng task ay nangangailangan ng agent, at karaniwang pagkakamali ang awtomatikong paggamit nito. Kung alam na nang maaga ang mga hakbang, mas simple, mas mabilis, at mas maaasahan ang plain script. Ang “Kunin ang page na ito bawat oras at i-email sa akin ang presyo” ay isang scheduled job, hindi isang agent. Bumuo ng agent kapag hindi pa nakatakda nang maaga ang daloy, at kailangang tingnan ng model ang mga nahanap nito at magpasya kung ano ang susunod na gagawin. Ang kapalit ng agent ay unpredictability, kaya gamitin lamang ito kapag sulit ang flexibility.

Mga tool: kung paano kumikilos ang isang agent

Ang tool ay anumang capability na ibinibigay mo sa model at inilalarawan nang sapat para malaman nito kung kailan ito gagamitin. Magbasa ng file, magpatakbo ng shell command, mag-query ng database, o magpadala ng message: bawat isa ay tool na may pangalan, maikling paglalarawan, at listahan ng mga input. Ikaw ang nagde-define ng mga tool; ang model ang nagpapasya kung kailan tatawag sa mga ito. Karaniwang web search ang unang tool na sulit idagdag. Kung nagpapatakbo ka na ng sarili mong SearXNG instance, maaari mo itong gawing search backend ng agent sa halip na magbayad para sa commercial search API.

Pareho ang mekanismo saanman, anuman ang model na ginagamit mo. Nagbabalik ang model ng structured request na tumutukoy sa isang tool at naglalagay ng mga input nito. Nakikita ng code mo ang request na iyon, pinapatakbo ang katugmang function, at ipinapadala ang resulta sa susunod na turn. Binabasa ng model ang resulta at maaaring tumawag sa isa pang tool o isulat ang final answer nito. Ang function calling ang plumbing sa ilalim ng bawat agent, at ilang linya lamang ng ordinaryong code ang loop na nagpapatakbo nito.

Dito rin nakasalalay ang control mo. Maaaring humiling ang model na magpatakbo ng command, pero walang tatakbo hangga't hindi ito pinipili ng code mo. Sa pagitan na ito mo inilalagay ang approval prompt para sa mga mapanganib na action, ang mga limitasyon sa maaaring galawin ng tool, at ang log ng lahat ng ginawa ng agent. Kasing-ligtas lamang ang agent ng mga tool na ibinibigay mo rito at ng mga check na inilalagay mo bago gamitin ang mga iyon.

MCP: standard na paraan para ikonekta ang mga tool

Mabilis nakasasawa ang manu-manong paggawa ng bagong integration para sa bawat service. Ang Model Context Protocol, o MCP, ay isang open standard na lumulutas sa problemang ito. Sa halip na mag-code ng bagong tool para sa iyong mga file, database, at issue tracker, ituro ang agent sa isang MCP server na nag-e-expose na ng mga iyon bilang mga tool. Isang protocol ang ginagamit ng agent; ang server ang nakikipag-ugnayan sa aktuwal na system.

Ang pakinabang nito ay reuse. Ang MCP server na ginawa ng ibang tao para sa service na ginagamit mo ay nagiging available sa iyong agent nang walang bagong integration code, at magagamit ng anumang agent na gumagamit ng protocol ang server na ginawa mo. May ilang self-hosted app na ngayon na may sarili nilang MCP server: ang openGym, isang workout tracker ay nag-e-expose ng read-only MCP server, kaya masasagot ng agent ang mga tanong tungkol sa training history mo nang hindi ito makapagbabago ng anuman. Sa isang VPS, mahalaga ito dahil maaari mong patakbuhin ang mga MCP server bilang magkakahiwalay na maliliit na service sa tabi ng agent, at bigyan ang bawat isa ng access na kailangan lamang nito. Kapag ang mga system sa likod ng mga server na iyon ay nasa network na hindi nakikita ng VPS, gaya ng database sa bahay o opisina, ang pag-advertise ng network na iyon sa iyong tailnet gamit ang subnet router ay nagbibigay-daan sa agent na maabot ang mga ito gamit ang mga private address nang hindi inilalantad ang anuman sa public internet. Tinalakay ko ang setup sa pagpapatakbo ng mga MCP server sa isang VPS.

Memory at retrieval

Walang sariling memory ang isang language model sa pagitan ng mga call. Kailangang ibigay sa model sa bawat turn ang lahat ng kailangan nito para sa kasalukuyang task. Para sa maikling task, sapat ito dahil kasya ang buong conversation sa isang request. Depende sa context window kung gaano karaming content ang magkakasya. Ang self-hosted model na sine-serve ng Ollama ay may maliit na default context window na tahimik na nagtatanggal sa pinakamatatandang turn. Kaya sulit na itakda ang num_ctx ayon sa traffic na nililikha ng loop mo bago mo sisihin ang agent sa pagkalimot. Para sa mas mahahabang task, ikaw mismo ang kailangang mag-manage ng memory. May dalawang pattern na mahalagang malaman.

Ang una ay scratchpad. Bibigyan mo ang agent ng file na maaari nitong basahin at sulatan. Sasabihan mo rin itong itala ang mga natututuhan nito habang nagpapatuloy. Sa susunod na turn o susunod na session, babasahin nitong muli ang file at ipagpapatuloy ang ginawa nito. Memory ito bilang plain document. Gumagana ito dahil itinuturing ng agent ang file bilang isa pang tool.

Ang ikalawa ay retrieval. Kapag nangangailangan ang agent ng kaalaman mula sa maraming dokumento na hindi kailanman magkakasya sa isang request, ise-save mo ang mga dokumentong iyon sa isang searchable na format. Pagkatapos, kinukuha mo lamang ang mga nauugnay na bahagi at ipinapakita ang mga ito sa model kapag kailangan. Ang pattern na ito ay tinatawag na retrieval-augmented generation, o RAG. Nagtatanong ang agent, hinahanap ng code mo ang ilang tumutugmang passage, at ang mga iyon lamang ang ipinapadala sa model. Nasa server mo ang store, kaya hindi umaalis dito ang iyong mga pribadong dokumento.

Maraming agent, isang coordinator

Para sa karamihan ng task, sapat na ang isang agent na maraming tool. Kapag malaki ang job o natural itong nahahati sa ilang bahagi, mas angkop ang ibang setup: isang coordinator agent na nagde-delegate sa mga specialized sub-agent. Hinahati ng coordinator ang goal sa mga bahagi, ipinapasa ang bawat bahagi sa sub-agent na binuo para sa ganoong uri ng trabaho, at pinagsasama ang mga resulta. Kailangan ng delegation ng channel sa pagitan ng mga bahagi. Ang pinakasimpleng bersyon nito ay nasa server mo na: maaaring magpadalhan ng mensahe ang dalawang Claude Code session sa iisang VPS. Murang paraan ito para makita kung paano gumagana ang handoff bago ka gumawa ng sarili mong coordination machinery.

Ang pakinabang ay focus. Mas mahusay magpasya ang sub-agent na may limitadong trabaho at maliit na tool set kaysa sa isang generalist na sabay-sabay na humahawak sa lahat. Maaari ring tumakbo nang sabay ang mga independent na bahagi. May tunay na dagdag na coordination cost, kaya manatili muna sa isang agent hanggang malinaw na kailangan ng task ang higit pa. Magsimula sa simple, at magdagdag lamang ng mga agent kapag malinaw na nahihirapan na ang isang agent.

Self-hosted o hosted: aling modelo ang magpapatakbo sa iyong agent

Ang modelo ang isang bahagi ng agent na hindi mo kailangang patakbuhin mismo, at ang pagpili kung saan ito tatakbo ang pinakamalaking desisyong gagawin mo. Ang hosted model na ina-access sa pamamagitan ng API ay nagbibigay ng pinakamalakas na reasoning nang wala kang kailangang i-operate: magpapadala ka ng text at makakatanggap ka ng text. Ang self-hosted model ay tumatakbo sa sarili mong server. Pinananatili nitong private ang bawat request, may fixed cost sa halip na bayad sa bawat token, at hindi kailanman nakadepende sa availability ng ibang provider. Ang kapalit nito ay capability at effort. Mas mahusay ang mga pinakamahusay na hosted model kaysa sa mga model na kaya mong patakbuhin mismo, at ang pagpapatakbo ng sarili mong modelo ay nangangahulugang kailangan mong maglaan ng sapat na memory para magkasya ito.

Iyon ang praktikal na limitasyon. Kailangang magkasya ang modelo sa memory ng server mo. Kung gumagamit ka ng GPU, kailangan din itong magkasya sa video memory nito. Hindi maglo-load ang modelong masyadong malaki para sa hardware. Bago ka magplano ng self-hosted agent, tingnan kung kasya sa machine mo ang modelong gusto mong gamitin:

Kung hindi kasya ang mga value, mayroon kang 3 opsyon: pumili ng mas maliit na modelo, gumamit ng mas agresibong quantization para lumiit ito, o gumamit ng hosted API para sa reasoning at panatilihin lamang sa server ang iyong tools at data. Maraming self-hosted agent ang nagsisimula sa local model sa pamamagitan ng Ollama sa isang VPS at gumagamit ng hosted API bilang fallback para sa pinakamahihirap na hakbang.

Ang server ang mapanganib na bahagi

Makapangyarihan ang agent na maaaring magpatakbo ng shell commands at magsulat ng files. Iyon mismo ang dahilan kung bakit ito mapanganib. Maganda ang judgment ng model, pero hindi ito perpekto. Maaaring maging agent na nagde-delete ng maling bagay o naglalabas ng secret ang isang maling instruction, bug, o hostile input. Hindi optional ang security work. Sa server, ito ang pinakamahalagang bahagi.

Malaking bahagi ng resulta ang ilang simpleng gawain. Patakbuhin ang agent bilang dedicated unprivileged user, hindi kailanman bilang root, upang may limitasyon ang magiging epekto ng pagkakamali; kapareho nito ang paliwanag sa pagpapatakbo ng mga serbisyo bilang unprivileged user. Itago ang mga secret nito, gaya ng API keys, sa labas ng code at gawing mababasa lamang ng user na iyon. I-sandbox din ang mga tool na humahawak sa system upang maabot lamang ng agent ang tunay nitong kailangan. Kung ayaw mong isulat nang mano-mano ang bawat check, saklaw ng mga DeepSeek Harness plugin na sulit i-install ang parehong mga pangangailangan bilang mga handa nang bahagi: mga panuntunan sa tool permission, pag-scan para sa prompt injection, at limitasyon sa maaaring gastusin ng agent bago ito huminto. Para sa kumpletong halimbawa ng pag-hardening ng isang aktuwal na self-hosted agent, tingnan ang ligtas na pagpapatakbo ng OpenClaw sa isang VPS. Kung mas gusto mong gumamit ng hosted model para sa intelligence, ginagamit ng kasamang gabay sa pagbuo ng agent gamit ang Claude sa isang VPS ang parehong mga ideya at inilalagay sa likod ng mga ito ang isang partikular na model.

Para sa kumpletong halimbawa, inilalapat ng pagbuo ng personal agent na gaya ng OpenClaw ang mga bahaging ito. Kung mas gusto mong magpatakbo ng tapos nang agent, magsimula sa pag-self-host ng Hermes Agent sa isang VPS o pagpapatakbo ng Agent Zero sa sarili mong server. Inihahambing naman ng pinakamahuhusay na self-hosted AI agent sa 2026 ang lahat ng handa nang opsyong saklaw namin, nang magkatabi.

FAQ

Ano ang pagkakaiba ng AI agent at chatbot?

Sinasagot ng chatbot ang isang mensahe at humihinto. Tumatakbo ang agent sa isang loop: nagpapasya ang model sa isang action, isinasagawa ito ng iyong code, ibinabalik ang resulta sa model, at inuulit ito hanggang matapos ang task. Ang kaibahan ay nagsasagawa ang agent ng mga aktuwal na action sa pagitan ng mga turn nito. Tumatawag ito ng mga tool para magbasa ng files, magpatakbo ng commands, o mag-query ng services, sa halip na text lamang ang gawin.

Kailangan ko ba ng GPU para magpatakbo ng AI agent sa isang VPS?

Kailangan lamang kung ikaw mismo ang nagho-host ng model. Ang agent loop, mga tool, at memory ay karaniwang code na maayos na tumatakbo sa isang normal na VPS kahit walang GPU. Mahalaga ang GPU kapag gusto mong patakbuhin ang language model sa sarili mong hardware, dahil kailangang magkasya ang model sa memory. Kung gumagamit ka ng hosted model sa pamamagitan ng API, sa ibang lugar ginagawa ang mabigat na computation kaya sapat na ang isang modest na VPS.

Ano ang MCP at kailangan ko ba ito para bumuo ng agent?

Ang MCP, o Model Context Protocol, ay isang open standard para ikonekta ang agent sa mga tool at data source. Hindi ito mahigpit na kailangan dahil maaari mong isulat nang mano-mano ang bawat tool. Binabawasan ng MCP ang gawaing ito sa pamamagitan ng pagpapagamit muli ng mga umiiral na server para sa mga karaniwang serbisyo, at sa pag-expose ng sarili mong systems nang isang beses para magamit ng anumang agent. Isa itong convenience na mas nagiging kapaki-pakinabang habang dumarami ang integrations.

Ligtas ba na bigyan ng access sa server ko ang isang AI agent?

Maaari itong maging ligtas kung iko-contain mo ito. Ang agent na nagpapatakbo ng commands ay kasing-ligtas lamang ng account na ginagamit nito at ng mga tool na pinapayagan mo. Patakbuhin ito bilang unprivileged user, ilayo rito ang mga secret nito, i-sandbox ang mga tool na humahawak sa filesystem, at humingi ng approval para sa mga action na mahirap i-undo. Ituring ang agent bilang untrusted code na may kakayahang umunawa, at ibigay lamang dito ang kailangan ng task.