Paano gumawa ng AI agent sa sariling VPS

Ano ba talaga ang isang AI agent

Ang AI agent ay isang loop na nakabalot sa isang language model. Binabasa ng model ang sitwasyon, nagdedesisyon para sa isang action, isinasagawa ng iyong code ang action na iyon, bumabalik ang result sa model, at uulit ang loop hanggang matapos ang task. Iyan ang buong konsepto. Ang isang simpleng chatbot ay sumasagot nang isang beses at humihinto. Ang isang agent ay patuloy na gumagalaw, gumagawa ng mga totoong action sa pagitan ng mga turn nito, hanggang maabot ang goal na ibinigay mo.

Ang action ang pinakaimportanteng bahagi. Sa sarili nito, ang language model ay naglalabas lamang ng text. Hindi ito makakapagbasa ng file, makakatawag ng API, o makakapag-run ng command. Ang isang agent ay nagbibigay sa model ng set ng mga tools na maaari nitong gamitin, at isang paraan para hingin ang mga ito. Kapag gustong mag-search ng model sa web o magsulat ng file, hindi nito ginagawa ang trabaho nang direkta. Naglalabas ito ng structured request, tatakbo ang iyong code para gamitin ang tool, at ang sagot ay babalik bilang susunod na babasahin ng model. Ang model ang nagbibigay ng judgement; ang iyong server ang nagbibigay ng mga kamay.

Hindi lahat ng task ay nangangailangan ng agent, at ang paggamit nito agad ay isang karaniwang pagkakamali. Kung alam na ang mga steps nang maaga, ang isang simpleng script ay mas simple, mas mabilis, at mas reliable. Ang "i-fetch ang page na ito bawat oras at i-email sa akin ang presyo" ay isang scheduled job, hindi isang agent. Gumawa ng agent kapag ang path ay hindi fixed nang maaga, o kapag kailangang suriin ng model ang kanyang nahanap para magdesisyon kung ano ang susunod na gagawin. Ang cost ng isang agent ay ang pagiging unpredictable, kaya gamitin lamang ito kung ang flexibility ay sulit sa halaga.

Tools: kung paano kumikilos ang isang agent

Ang tool ay anumang kakayahan na ibinibigay mo sa model, na may sapat na deskripsyon para malaman nito kung kailan ito gagamitin. Magbasa ng file, mag-run ng shell command, mag-query ng database, magpadala ng message: bawat isa ay isang tool na may pangalan, maikling deskripsyon, at listahan ng mga inputs. Ikaw ang nagtatakda ng mga tools; ang model ang nagdedesisyon kung kailan tatawagin ang mga ito.

Ang mekanismo ay pareho kahit anong model ang gamit mo. Ang model ay nagbabalik ng structured request na nagsasaad ng pangalan ng tool at ang mga inputs nito. Makikita ng iyong code ang request na iyon, tatakbo ang katumbas na function, at ibabalik ang result sa susunod na turn. Babasahin ng model ang result at tatawag alinman sa isa pang tool o isusulat ang final answer nito. Ang function calling ang plumbing sa ilalim ng bawat agent, at ang loop na nagpapatakbo nito ay ilang linya lamang ng ordinaryong code.

Dito rin matatagpuan ang iyong control. Maaaring humiling ang model na mag-run ng command, pero walang tatakbo hangga't hindi pinipili ng iyong code na i-run ito. Sa gap na iyon inilalagay ang mga approval prompt para sa mga mapanganib na action, mga limitasyon sa kung ano ang maaaring galawin ng isang tool, at isang log ng lahat ng ginawa ng agent. Ang isang agent ay kasing-safe lamang ng mga tools na ibinigay mo at ng mga check na inilagay mo sa harap ng mga ito.

MCP: isang standard na paraan para ikonekta ang mga tools

Ang pagsusulat ng bagong integration para sa bawat serbisyo nang manu-mano ay nakakapagod. Ang Model Context Protocol, o MCP, ay isang open standard na solusyon dito. 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 sa mga bagay na iyon bilang mga tools. Ang agent ay gumagamit ng isang protocol; ang server ang gumagawa ng trabaho ng pakikipag-usap sa totoong system.

Ang benepisyo ay ang reuse. Ang isang MCP server na isinulat ng iba para sa serbisyong ginagamit mo ay magiging available sa iyong agent nang walang bagong integration code, at ang server na isinulat mo ay magagamit ng kahit anong agent na gumagamit ng protocol. Mahalaga ito sa isang VPS, dahil maaari kang magpatakbo ng mga MCP server bilang sarili nilang maliliit na services sa tabi ng agent, bawat isa ay mayroon lamang access na kailangan nito. Ipinapaliwanag ko ang setup sa running MCP servers on a VPS.

Memory at retrieval

Ang isang language model ay walang sariling memory sa pagitan ng mga call. Ang lahat ng alam nito tungkol sa kasalukuyang task ay dapat ibigay dito sa bawat turn. Para sa mga maikling trabaho ay ayos na ito, dahil ang buong conversation ay kasya sa isang request. Para sa anumang mas mahaba, kailangan mong i-manage ang memory nang manu-mano, at may dalawang pattern na dapat malaman.

Ang una ay isang scratchpad. Bibigyan mo ang agent ng isang file na maaari nitong basahin at isulat, at sasabihan itong i-record ang lahat ng natutunan nito habang tumatagal. Sa susunod na turn, o sa susunod na session, babasahin nito muli ang file at itutuloy kung saan ito huminto. Ito ay memory bilang isang simpleng dokumento, at gumagana ito dahil itinuturing ng agent ang file bilang isa pang tool.

Ang ikalawa ay retrieval. Kapag kailangan ng agent ng kaalaman mula sa isang malaking koleksyon ng mga dokumento na hindi kasya sa isang request, i-store ang mga dokumentong iyon sa isang searchable na anyo at kunin lamang ang mga relevant na bahagi para sa view ng model kapag kailangan na ang mga ito. Ang pattern na ito ay tinatawag na retrieval-augmented generation, o RAG. Magtatanong ang agent, hahanapin ng iyong code ang mga tugmang passage, at ang mga iyon lamang ang ipadadala sa model. Ang store ay nasa iyong server, kaya ang iyong mga private documents ay hindi lalabas dito.

Maraming agent, isang coordinator

Ang isang agent na may maraming tools ay sapat na para sa karamihan ng mga task. Kapag ang isang trabaho ay malaki o natural na nahahati sa mga bahagi, mas mainam ang ibang anyo: isang coordinator agent na nagdedelegasyon sa mga specialized sub-agents. Hinahati ng coordinator ang goal sa mga bahagi, ibinibigay ang bawat bahagi sa isang sub-agent na ginawa para sa ganoong uri ng trabaho, at pinagsasama ang mga resulta.

Ang pakinabang ay ang focus. Ang isang sub-agent na may limitadong trabaho at maliit na tool set ay nakakagawa ng mas mabuting desisyon kaysa sa isang generalist na gumagawa ng lahat, at ang mga independent na bahagi ay maaaring tumakbo nang sabay-sabay. Ang cost ay coordination, na totoo, kaya manatili muna sa isang agent hangga't hindi malinaw na kailangan ng task ang higit pa. Magsimula nang simple, at magdagdag lamang ng mga agent kapag ang isa ay halatang nahihirapan na.

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

Ang model ang tanging bahagi ng isang agent na hindi mo kailangang i-run nang manu-mano, at ang pagpili kung saan ito nakalagay ang pinakamalaking desisyon na gagawin mo. Ang isang hosted model, na ina-access via API, ay nagbibigay ng pinakamalakas na reasoning nang walang kailangang i-operate: magpapadala ka ng text, at makakatanggap ka ng text pabalik. Ang isang self-hosted model ay tumatakbo sa sarili mong server, na nagpapanatili sa bawat request na private, may fixed na presyo sa halip na fee per token, at hindi umaasa sa availability ng iba. Ang trade-off ay capability at effort. Ang pinakamahusay na mga hosted models ay mas advanced kaysa sa kaya mong i-run nang manu-mano, at ang pagpapatakbo ng sarili mong model ay nangangailangan ng sapat na memory para dito.

Ang huling puntong iyon ang praktikal na hadlang. Ang isang model ay dapat kasya sa memory ng iyong server, at kung gagamit ka ng GPU, sa video memory nito. Ang model na masyadong malaki para sa hardware ay hindi maglo-load. Bago ka magplano ng self-hosted agent, i-check kung ang model na gusto mo ay kasya sa machine na mayroon ka:

Kung hindi kasya ang mga numero, mayroon kang tatlong opsyon: pumili ng mas maliit na model, gumamit ng mas aggressive na quantization para paliitin ito, o gumamit ng hosted API para sa reasoning at panatilihin lamang ang iyong mga tools at data sa server. Maraming self-hosted agents ang nagsisimula sa isang local model gamit ang Ollama on a VPS at gumagamit ng hosted API para sa pinakamahihirap na steps.

Ang server ang mapanganib na bahagi

Ang isang agent na kayang mag-run ng shell commands at magsulat ng files ay makapangyarihan, at iyan mismo ang dahilan kung bakit ito mapanganib. Ang judgement ng model ay maganda pero hindi perpekto, at ang isang maling instruction, bug, o hostile input ay maaaring magpalit sa isang helpful agent tungo sa isang agent na nagbubura ng maling bagay o naglalabas ng sikreto. Ang security work ay hindi optional, at sa isang server, ito ang bahaging pinakaimportante.

Ang ilang gawi ang nagbibigay ng proteksyon. I-run ang agent bilang isang dedicated unprivileged user, huwag kailanman bilang root, para ang pagkakamali ay may limitasyon; ang parehong reasoning ay nasa running services as an unprivileged user. Panatilihing malayo sa code ang mga sikreto nito, gaya ng mga API keys, at dapat ay nababasa lamang ito ng user na iyon. At i-sandbox ang mga tools na humahawak sa system, para ang agent ay makakaabot lamang sa kung ano ang talagang kailangan nito. Para sa isang halimbawa ng pag-harden ng isang totoong self-hosted agent, tingnan ang running OpenClaw safely on a VPS. Kung mas gusto mong gumamit ng hosted model para sa intelligence, ang companion guide sa building an agent with Claude on a VPS ay gumagamit ng parehong mga ideya gamit ang isang specific na model.

Para sa isang halimbawa, ang building an OpenClaw-style personal agent ay gumagamit ng mga bahaging ito, at kung mas gusto mong magpatakbo ng tapos na produkto, magsimula sa self-hosting Hermes Agent on a VPS o running Agent Zero on your own server, at ang the best self-hosted AI agents in 2026 ay nagkukumpara sa lahat ng ready-made option na aming tinatalakay.

FAQ

Ano ang pagkakaiba ng AI agent at chatbot?

Ang chatbot ay sumasagot sa isang message at humihinto. Ang agent ay nagpapatakbo ng isang loop: nagdedesisyon ang model para sa isang action, isinasagawa ito ng iyong code, bumabalik ang result sa model, at inuulit ito hanggang matapos ang task. Ang pagkakaiba ay gumagawa ang agent ng mga totoong action sa pagitan ng mga turn nito, tinatawag ang mga tools para magbasa ng files, mag-run ng commands, o mag-query ng mga services, sa halip na maglabas lamang ng text.

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

Kung mag-se-self-host ka ng model. Ang agent loop, ang mga tools, at ang memory ay ordinaryong code na tumatakbo nang maayos sa isang normal na VPS na walang GPU. Mahalaga ang GPU kapag gusto mong i-run ang language model sa sarili mong hardware, dahil kailangang kasya ang model sa memory. Kung gagamit ka ng hosted model via API, ang mabigat na computation ay nangyayari sa ibang lugar at sapat na ang isang modest na VPS.

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

Ang MCP, ang Model Context Protocol, ay isang open standard para ikonekta ang isang agent sa mga tools at data sources. Hindi mo ito strictly na kailangan, dahil maaari mong isulat ang bawat tool nang manu-mano. Ang MCP ay nagpapabilis sa trabaho sa pamamagitan ng pagpapahintulot na muling gamitin ang mga existing na servers para sa mga karaniwang serbisyo at pag-expose sa iyong sariling mga system nang isang beses para magamit ng kahit anong agent. Ito ay isang convenience na nagiging sulit habang lumalaki ang bilang ng mga integration.

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

Maaari ito, kung ililimitahan mo ito. Ang isang agent na nagpapatakbo ng mga command ay kasing-safe lamang ng account na pinapatakbo nito at ng mga tools na pinapayagan mo. I-run ito bilang isang unprivileged user, panatilihing malayo ang mga sikreto nito, i-sandbox ang mga tools na humahadlang sa filesystem, at mangailangan ng approval para sa mga action na mahirap i-undo. Ituring ang agent bilang isang untrusted code na matalino, at ibigay lamang ang kailangan ng task.