Ollama vs llama.cpp sa CPU-only VPS: Alin ang tama?
Alamin ang layer na kailangan mo: Ollama para sa daemon at API, o llama.cpp para sa kontrol sa GGUF, quantisation, RAM, context size, at threads sa VPS.
Ollama kumpara sa llama.cpp: aling layer ang gusto mong patakbuhin?
Hindi magkatunggali ang Ollama at llama.cpp sa paraang ipinahihiwatig ng tanong. Ang llama.cpp ang inference engine: naglo-load ito ng model file at ginagawang tokens ang prompt. Ang Ollama naman ay model manager, background daemon, at HTTP API na nakapatong sa engine na iyon. Nakalista pa rin sa README ng Ollama ang llama.cpp bilang inference backend nito (sinuri noong 27 October 2026). Kaya ang tunay na tanong ay kung aling layer ang gusto mong patakbuhin sa VPS mo, hindi kung alin ang mas mabilis.
Patakbuhin ang Ollama kung gusto mo ng service na kumukuha ng mga model ayon sa pangalan at patuloy na gumagana nang hindi kailangang bantayan. Patakbuhin nang direkta ang llama.cpp kapag maliit ang box at kailangan mong piliin ang eksaktong model file, eksaktong context size, at eksaktong thread count, dahil sa maliit na VPS, memory ang kinakain ng bawat setting na iyon at limitado ang available mo.
Ano talaga ang bawat proyekto
Ang llama.cpp ay isang C at C++ implementation ng transformer inference na nakabatay sa ggml library. Nagbabasa ito ng mga GGUF file. Ang GGUF (GGML universal file format) ay isang single-file container na naglalaman ng weights, tokeniser, at metadata na kailangan ng engine para patakbuhin ang model. May magkakahiwalay na binary ang proyekto para sa magkakaibang gawain. Ang llama-server ay isang HTTP server, ang llama-cli ay isang interactive prompt, at ang llama-bench ay sumusukat sa throughput. Gumagamit na ngayon ang proyekto ng semantic-versioned releases (MAJOR.MINOR.PATCH), at ang v0.7.0, na inilabas noong 15 October 2026, ang pinakabago noong 27 October 2026. Patuloy ding lumalabas ang mga nightly tag na may build number kasabay ng mga ito, ilang beses bawat araw, at ang pinakabago noong 27 October 2026 ay b11913.
Ang Ollama ay isang Go program. Isang background daemon, na sinisimulan gamit ang ollama serve, ang naglo-load ng mga model at sumasagot sa mga HTTP request. Isang command line client naman ang kumokonekta sa daemon na iyon. Sa likod ng dalawang ito ay may registry sa ollama.com na naglalaman ng mga prepacked model. Gumagamit ang Ollama ng semantic versions. Inilabas ang v0.32.5 noong 27 July 2026, at inilabas ang v0.40.12 noong 27 October 2026 sa 00:07 UTC. Kinukuha ng ollama pull ang isang GGUF kasama ang prompt template at isang set ng default parameter, pagkatapos ay iniimbak ito sa /usr/share/ollama/.ollama/models sa Linux. Nasa root disk ang mga file na ito at umaabot sa ilang gigabyte ang bawat isa. Kaya sa isang VPS na may 25 GB na root volume, mahalagang malaman kung ano ang iniiwan ng pull at kung paano ilipat sa ibang lokasyon ang directory ng model bago mapuno ng ikatlong download ang disk.
Iyon ang buong pagkakaiba ng packaging ng mga ito. Ang Ollama ang pumipili para sa iyo ng quantisation, template, at context length, at binibigyan ka nito ng isang pangalan na kailangan mong tandaan. Inilalantad naman ng llama.cpp ang mga pagpipiliang ito bilang mga flag, na may awtomatikong default para sa mga setting na hindi mo itinakda.
Axis 1: kontrol sa modelo at quantisation
Ang quantisation ay nag-iimbak ng weights gamit ang mas kaunting bits kaysa sa 16 o 32 bits ng orihinal na modelo. Karaniwan, ang mga GGUF build ay may average na humigit-kumulang 4, 5, o 8 bits bawat weight. Hindi pare-pareho ang precision sa buong file. Sa source ng quantiser ng llama.cpp, na binasa noong 27 October 2026, ang isang Q4_K_M build ay naglalagay sa karamihan ng tensors sa 4-bit. Ngunit ang output layer, pati ang attention value at feed-forward down tensors sa humigit-kumulang kalahati ng mga layer, ay sa 6-bit Q6_K inilalagay. Hindi naman kino-quantise ang maliliit na tensor gaya ng norms. Dahil dito, nagkakasya sa RAM ng karaniwang VPS ang isang modelong may 8 billion parameters. Madaling basahin ang GGUF naming kapag alam mo ang pattern: ang Q4_K_M ay nangangahulugang 4-bit K-quant na medium ang laki. Kapag mas mataas ang numero, mas mataas ang precision na pinapanatili at mas malaki ang memory na ginagamit.
Ang datos sa likod ng tsart na ito
[
{
"label": "Q2_K",
"file_size_gib": 2.96
},
{
"label": "Q3_K_M",
"file_size_gib": 3.74
},
{
"label": "Q4_K_M",
"file_size_gib": 4.58
},
{
"label": "Q5_K_M",
"file_size_gib": 5.34
},
{
"label": "Q6_K",
"file_size_gib": 6.14
},
{
"label": "Q8_0",
"file_size_gib": 7.95
}
]Iyan ang mga inilathalang file size sa bartowski/Meta-Llama-3.1-8B-Instruct-GGUF repository sa Hugging Face, na binasa noong 2 August 2026 at kinonvert mula bytes tungo sa GiB. May 6 build ng isang modelo, at ang pinakamaliit ay 2.96 GiB kumpara sa 7.95 GiB para sa pinakamalaki. Ang karaniwang default na Q4_K_M ay 4.58 GiB. Sa isang 4 GiB VPS, ang pagpiling ito ang nagtatakda kung maglo-load ba ang modelo. Kalahati lamang ng desisyong ito ang size. Ang row na kaya mong gamitin ay hindi awtomatikong angkop na piliin, at ang aktuwal na epekto ng Q4, Q8 at fp16 sa kalidad ng sagot ang magsasabi kung may mapapansin kang pakinabang sa dagdag na gigabytes.
Sa llama.cpp, tinutukoy mo ang file, kaya ikaw mismo ang pumipili ng row.
llama-server -m ~/models/Meta-Llama-3.1-8B-Instruct-Q4_K_M.gguf \
-c 4096 -t 4 --host 127.0.0.1 --port 8080Ang -c ay ang context size sa tokens, ang -t ay ang bilang ng threads, at tinutukoy ng -ngl kung ilang layer ang ililipat sa GPU (0 sa CPU-only na machine). May mga default ang mga setting na hindi itinakda, at naka-enable bilang default ang --fit upang i-adjust ang mga argument na hindi itinakda para magkasya sa memory ng device.
Sa Ollama, kasama sa tag na hina-hatak mo ang quantisation, at ipinapakita ng ollama ls kung ano talaga ang nasa disk. Kapag walang build na gusto mo sa registry, ikaw mismo ang mag-import ng GGUF. Gumawa ng Modelfile:
FROM ./Meta-Llama-3.1-8B-Instruct-Q4_K_M.gguf
PARAMETER num_ctx 4096Pagkatapos, i-build ito at suriin ang resulta:
ollama create llama31-q4 -f ./Modelfile
ollama lsAng context length ang setting na madalas nagdudulot ng problema. Pinipili ng Ollama ang default nito batay sa available na VRAM, at napupunta ang machine na walang GPU sa pinakamaliit na bucket: 4096 tokens. Kapag pinadalhan mo ito ng dokumentong may 20,000 tokens, ibinabawas ang sobrang tokens bago pa man ito makita ng modelo. Dahil dito, maaaring maging kumpiyansa ngunit mali ang sagot tungkol sa file na kalahati lamang nitong nabasa. Itaas ito gamit ang OLLAMA_CONTEXT_LENGTH sa daemon, o gamit ang PARAMETER num_ctx sa isang Modelfile. Kung isang job lamang ang nangangailangan ng mas malaking window, maaaring itakda ang num_ctx bawat request sa halip na para sa buong server, kaya hindi nadaragdagan ang cache ng lahat ng iba pang pinapagawa sa daemon. Wala ring default na sapat pagkatiwalaan ang llama.cpp. Itakda nang tahasan ang -c at tiyaking alam mo kung ano ang itinakda mo.
Ang memory arithmetic na hindi ipinapakita sa iyo
Hindi lamang ang model file ang buong resource cost. Ang KV cache (key/value cache) ay naglalaman ng isang entry bawat layer para sa bawat token ng context, at lumalaki ito habang humahaba ang conversation.
Kuwentahin natin ito para sa Llama 3.1 8B. May 32 layer, 8 key/value head, at head dimension na 128 ang model. Ang bawat token ay nag-iimbak ng key at value na tig-2 byte sa f16, kaya 2 x 8 x 128 x 2 = 4096 byte bawat layer. Sa 32 layer, katumbas ito ng 128 KiB bawat token. Kaya ang 4096 token na context ay kumokonsumo ng 512 MiB, at ang 32,768 token na context ay kumokonsumo ng 4 GiB.
Kaya ang Q4_K_M 8B model sa 4k context ay nangangailangan ng humigit-kumulang 4.58 GiB para sa weights, dagdag ang humigit-kumulang 0.5 GiB para sa cache at ang runtime mismo. Hindi ito kasya sa 4 GiB na RAM. Kasya ito sa 8 GiB, na may natitirang puwang para sa iba pang gawain. Kung itataas mo ang context sa 32k sa parehong 8 GiB na machine, uubusin ng cache lamang ang headroom. I-monitor ito habang tumatakbo gamit ang free -h habang naka-load ang model, at huwag magtiwala sa estimate na hindi mo sinukat. Kung nagso-size ka para sa model na higit na malaki sa 8B, ipinapakita ng parehong arithmetic sa isang 27B model sa CPU-only VPS kung ano talaga ang kayang hawakan ng bawat tier mula 8 hanggang 64 GB.
Pinapalala ito ng Ollama. Naka-default sa 1 ang OLLAMA_NUM_PARALLEL, at ang memory na kailangan ng isang model ay lumalaki ayon sa bilang na iyon na minultiply sa context length. Kapag sabay mong tinaasan ang dalawang ito, tahimik na hihingi ang daemon ng ilang ulit ng RAM na inaasahan mo. Itinatakda rin ng parehong arithmetic ang limitasyon mo sa sabay-sabay na users, dahil kailangan ng bawat concurrent request ng sariling bahagi ng KV cache. Ito ang dahilan kung bakit ang server na maayos para sa isang tao ay bumabagal kapag lima na ang gumagamit.
Axis 2: ang daemon na kailangan mong i-operate
Ang Ollama install script ay nagsusulat ng systemd unit, gumagawa ng ollama system user, at nag-e-enable ng service. May lifecycle management ka nang hindi kailangang isulat ang mga ito. Sa systemd dumadaan ang configuration:
sudo systemctl edit ollama[Service]
Environment="OLLAMA_CONTEXT_LENGTH=8192"
Environment="OLLAMA_KEEP_ALIVE=30m"sudo systemctl daemon-reload
sudo systemctl restart ollama
journalctl -e -u ollamaMas mahalaga ang OLLAMA_KEEP_ALIVE sa isang CPU VPS kaysa sa ibang environment. Bilang default, nananatili sa memory ang mga model sa loob ng 5 minuto at pagkatapos ay inaalis ang mga ito. Kailangang i-load muli ng susunod na request ang buong file bago ito makasagot. Kung nasa page cache pa ng kernel ang file, mabilis ito. Gayunman, spare RAM lamang ang nagpapanatili rito. Kapag nailabas ito ng ibang workload, babalik ang file mula sa disk. Dahil dito, ang 4.58 GiB reload ay maaaring magpabago sa dalawang segundong reply tungo sa tatlumpung segundo sa mabagal na storage. Inaayos ng mahabang keep-alive ang latency, pero permanenteng kumokonsumo ito ng RAM. Parehong may tunay na cost ang mga ito. Piliin ang mas kaunting nakaaapekto sa iyo. Kung gusto mong manatiling resident ang model, sapat ang ilang linya sa pag-set ng keep_alive para manatili ito sa mga idle period at reboot at hindi mo na kailangang manual na i-warm up ang model tuwing nagre-restart ang server.
Walang daemon at service user ang llama.cpp, kaya ikaw ang kailangang mag-set up ng mga ito. Mula sa llama.cpp directory na iyong pinag-build-an, i-install ang binary at mga library nito sa /usr/local, gumawa ng llama user, at bigyan ito ng kopya ng model:
sudo cmake --install build
sudo ldconfig
sudo useradd --system --no-create-home --shell /usr/sbin/nologin llama
sudo install -d -o llama -g llama /srv/models
sudo install -o llama -g llama -m 644 ~/models/Meta-Llama-3.1-8B-Instruct-Q4_K_M.gguf /srv/models/model-Q4_K_M.ggufKung release archive ang ginamit mo sa halip na mag-build, ituro ang ExecStart sa llama-server na nasa loob nito, dahil magkatabi sa archive ang mga library at ang binary. Pagkatapos, isulat ang unit bilang /etc/systemd/system/llama-server.service:
[Unit]
Description=llama.cpp server
After=network-online.target
[Service]
ExecStart=/usr/local/bin/llama-server -m /srv/models/model-Q4_K_M.gguf -c 4096 -t 4 --host 127.0.0.1 --port 8080
Restart=always
RestartSec=3
User=llama
[Install]
WantedBy=multi-user.targetI-enable ito gamit ang sudo systemctl enable --now llama-server. Hawak ng process ang model sa buong lifetime nito. Bilang default, walang model na inaalis kapag idle. Gayunman, kapag idinagdag ang --sleep-idle-seconds, awtomatikong maaalis at mailo-load muli ang model nang hindi pinipigilan ang service. Kung bago sa iyo ang pagsusulat ng units, kapareho ito ng pattern sa pagpapatakbo ng sarili mong mga service sa ilalim ng systemd sa isang VPS.
Axis 3: ang API na gagamitin ng iyong app
Mas lumiit na nang malaki ang pagkakaiba sa axis na ito. Pareho nang gumagamit ang dalawang proyekto ng OpenAI chat format, kaya gumagana ang karamihan ng client library sa alinman sa mga ito matapos palitan lamang ang base URL.
Nakikinig ang Ollama sa 127.0.0.1:11434. Ang OpenAI-compatible route nito ay http://localhost:11434/v1/chat/completions, at mayroon din itong native API sa /api/chat. May dokumentado ring Anthropic-compatible route. Wala sa mga route na ito ang nagpapahintulot sa model na magsagawa ng lookup nang mag-isa, kaya kung kailangan ng app mo ng mga sagot na mas bago kaysa sa training data ng model, magplano para sa pagkonekta ng web search sa pamamagitan ng Ollama API, Open WebUI, o maikling tool loop.
curl -X POST http://localhost:11434/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{"model": "llama31-q4", "messages": [{"role": "user", "content": "Say this is a test"}]}'Kapag sinimulan gamit ang mga flag sa itaas, nakikinig ang llama-server sa 127.0.0.1:8080. Kapag hindi ito binigyan ng ibang setting, gumagamit ito ngayon bilang default ng port 9931 (sinuri noong 27 October 2026), kaya panatilihin ang --port sa command line kung 8080 ang inaasahan ng iyong app. Ibinibigay nito ang /v1/chat/completions, /v1/completions at /v1/embeddings, pati ang sarili nitong /completion endpoint at built-in web UI. May operational route din itong hindi ibinibigay ng Ollama: /health para sa readiness probe, /props para sa settings ng naka-load na model, /slots para sa kasalukuyang ginagawa ng bawat request slot, at /metrics sa Prometheus format kapag idinagdag mo ang --metrics, dahil naka-off ang endpoint na iyon bilang default. Kung plano mong i-monitor ang serbisyong ito, malamang na ito ang pagkakaibang magpapasya sa iyong pagpili.
Walang awtomatikong nag-e-enable ng authentication ang alinmang server. Pareho silang gumagamit bilang default ng loopback, at may mabuting dahilan iyon. I-access ang mga ito sa pamamagitan ng SSH tunnel o mula sa likod ng reverse proxy, at huwag kailanman buksan sa internet ang 11434 o 8080.
Ano ang kayang gawin ng CPU-only VPS, nang makatotohanan
Mabagal magpatakbo ng maliliit na modelo ang CPU-only VPS. Iyan ang tapat na buod, at ang mahalagang malaman ay kung saan ang limitasyon. Magsukat muna bago bumuo ng anumang disenyo batay rito:
llama-bench -m ~/models/Meta-Llama-3.1-8B-Instruct-Q4_K_M.gguf -p 512 -n 128Ang column na pp ay ang bilis ng pagproseso ng prompt, at ang column na tg ay ang bilis ng pagbuo ng token. Pareho itong sinusukat sa tokens per second. Sa shared vCPU plan, karaniwang nasa mababang single digits ang tg ng 8B model sa Q4_K_M. Ang prompt processing ang pangunahing nagpapabagal: pinoproseso muna ang buong prompt bago lumabas ang unang output token, kaya ang mahabang system prompt ay nagdaragdag ng paghihintay sa bawat request. Ang haba ng reply ang bahagi ng paggamit na makokontrol mo, dahil sa bilis na tatlong tokens bawat segundo, ang model na gumagawa ng 600 tokens na mahaba ang sagot ay nagpapanatiling abala sa server nang 200 segundo, o mahigit tatlong minuto para sa generation lamang. Kaya ang paglilimita sa output gamit ang num_predict ang pinakamurang paraan upang maiwasang maging timeout ang isang sobrang mahabang sagot.
Magagamit sa CPU ang 1B hanggang 4B model para sa classification, extraction, maiikling summary, o routing. Dumarating ang mga reply sa loob ng ilang segundo, at kasya ang memory requirement sa karaniwang plan. Para sa aktuwal na halimbawa sa ganitong laki sa halip na range ng laki, ipinapakita ng Nemotron 3.5 Lightning na dina-download at sinusukat sa VPS ang eksaktong tag, ang aktuwal na RAM na hinihingi nito, at ang bilis na napapanatili nito nang walang GPU. Hindi praktikal sa CPU ang interactive chat na kasabay ng bilis ng pagbabasa, coding assistant, pagproseso ng mahahabang dokumento, o anumang agent loop na sunod-sunod na gumagawa ng maraming call. Ang loop na gumagawa ng labindalawang call na tig-apat na segundo ay umaabot ng isang minuto bago makagawa ng anuman. Kung coding assistant ang orihinal na plano, inilalatag ng pagkonekta ng agent sa model na ikaw mismo ang nagho-host kung aling mga gawain ang tunay na mahusay gawin ng maliit na local model at alin ang kailangang manatili sa hosted API.
May dalawang opsiyon kapag hindi gumagana ang mga numero. Kung concurrency ang problema, ibig sabihin ay maraming user ang sabay-sabay na gumagamit ng iisang model, nagbabago ang engine choice. Saklaw ito ng paghahambing ng Ollama at vLLM para sa concurrent serving. Kung raw speed ang problema, ang sagot ay VPS na may nakakabit na GPU, kung saan nagsisimulang maging makabuluhan ang -ngl. Bago gawin ang alinman sa mga ito, kumuha muna ng baseline para sa mismong hardware, dahil nakaaapekto ang disk at memory bandwidth sa load time tulad din ng CPU. Sulit ang isang oras para sa repeatable VPS benchmark.
Mag-install ng llama.cpp gamit ang naka-pin na build
Dahil lingguhan ang paglabas ng mga bagong build ng dalawang proyekto, itala ang bersyong na-deploy mo. Ini-install ng upstream one-liner ang kasalukuyang build:
curl -LsSf https://llama.app/install.sh | sh
llama serve -hf ggml-org/Qwen3.5-0.8B-GGUFPara mag-pin ng partikular na build, gamitin sa halip ang prebuilt tarball mula sa releases page. Naglalabas na rin ngayon ang proyekto ng semantic-versioned releases: ang v0.7.0 ang pinakabago noong 27 October 2026, at itinuturo ng release page nito ang nightly b11669 para sa mga binary. Sumunod ang v0.8.0 noong 28 October 2026, at itinuturo ng release page nito ang nightly b11960 para sa mga binary. Ginagamit ng mga command sa ibaba ang b10224, ang kasalukuyang tag noong 2 August 2026; palitan ito ng tag na nasubukan mo:
curl -LO https://github.com/ggml-org/llama.cpp/releases/download/b10224/llama-b10224-bin-ubuntu-x64.tar.gz
tar xf llama-b10224-bin-ubuntu-x64.tar.gz
find . -type f -name 'llama-server'O i-build ang parehong tag mula sa source:
sudo apt update && sudo apt install -y build-essential cmake git libssl-dev
git clone https://github.com/ggml-org/llama.cpp
cd llama.cpp
git checkout b10224
cmake -B build
cmake --build build --config Release -j $(nproc)Ang libssl-dev ang dokumentadong dependency para sa mga HTTPS feature. Tumatagal nang ilang minuto ang pag-compile at nangangailangan ito ng mas maraming RAM kaysa sa iniaalok ng pinakamaliliit na plan, kaya mag-build sa mas malaking machine at kopyahin ang mga binary kung maubusan ng sapat na resource ang maliit na machine.
Mag-install ng Ollama gamit ang naka-pin na version
curl -fsSL https://ollama.com/install.sh | OLLAMA_VERSION=0.32.5 sh
ollama -vBinabasa ng script ang OLLAMA_VERSION, kaya maaari mong gamitin ang isang release na alam mong stable sa halip na tanggapin ang anumang inilabas ngayong umaga. Na-publish ang v0.32.5 noong 27 July 2026. May manual na paraan din kung ayaw mong mag-pipe ng script papunta sa shell:
sudo rm -rf /usr/lib/ollama
curl -fsSL https://ollama.com/download/ollama-linux-amd64.tar.zst | sudo tar x -C /usr
ollama -vHindi gumagawa ang manual na paraan ng systemd unit o service user, kaya ikaw ang kailangang magdagdag ng mga ito. Sinasaklaw ng buong walkthrough sa Ollama sa isang VPS ang pag-set up ng service na ito nang sunod-sunod.
Mga failure mode at mga string na makikita mo
Tumangging i-load ni Ollama ang model. Sinusuri muna ng mas lumang Ollama releases ang size bago mag-load, at nagbabalik ang ollama run ng linyang ganito:
Error: model requires more system memory (5.6 GiB) than is available (3.2 GiB)Hindi na kasama sa kasalukuyang Ollama source ang mensaheng iyon (sinuri noong 27 October 2026). Ipinapasa na ngayon ni Ollama ang loading sa llama-server, kaya lumilitaw na lang bilang runner failure ang model na hindi kasya, na may mga error na nagsisimula sa ganito:
llama-server reported out-of-memory during startup
llama-server process has terminatedPareho ang ayos sa alinmang kaso. Bumaba ng isang quantisation row, bawasan ang context length, o pumili ng mas maliit na model.
Hindi nagfa-fail ang llama.cpp; napakabagal lang nito. Bilang default, mina-memory-map ng llama.cpp ang GGUF, kaya nagsisimula pa rin ang file na mas malaki kaysa RAM. Pagkatapos, paulit-ulit na nagpa-page in at out ang kernel ng weights mula sa disk sa bawat token, kaya bumabagal ang generation sa ilang segundo bawat token at nananatili sa 100 percent ang paggamit ng disk. Ipasa ang --load-mode none upang i-disable ang memory mapping. Pinalitan ng option na iyon ang --no-mmap, na nakadokumento bilang deprecated sa pinned b10224 build at wala na sa mga kasalukuyang build (sinuri noong 29 October 2026). Kapag kumilos ang kernel, ipinapakita ng dmesg ang dahilan:
Out of memory: Killed process 1234 (llama-server)Hindi talaga naglo-load ang model file. Kapag ang GGUF ay ginawa para sa model family na mas bago kaysa sa engine mo, magbibigay ito ng error na nagsasaad ng architecture na hindi nito kilala, kung saan ang <arch> ay ang pangalang naka-store sa metadata ng file:
llama_model_load: error loading model: unknown model architecture: '<arch>'Ang solusyon ay engine upgrade, hindi ibang file. Ito ang kapalit ng pag-pin, at ito ang dahilan kung bakit dapat mong itala ang build number. Kailangan mong malaman kung mula saang build ka mag-a-upgrade.
Sumasagot ang API nang lokal pero hindi mula sa app mo. Nagbi-bind si Ollama sa 127.0.0.1:11434, kaya connection refused ang makukuha ng ibang host. Itakda ang OLLAMA_HOST=0.0.0.0:11434 sa pamamagitan ng systemctl edit ollama kung ang port ay nasa likod lamang ng firewall o private network, dahil walang authentication sa harap ng API.
Napakabagal ng unang reply pagkatapos ng pause. Nangyari ang 5 minute idle unload, at nilo-load muli ang model, mula sa disk kung hindi ito napanatili ng page cache. Ipinapakita ng ollama ps na walang naka-load bago ang request, na nagpapatunay nito. Itaas ang OLLAMA_KEEP_ALIVE.
Kaya alin ang dapat mong patakbuhin?
Patakbuhin ang Ollama kapag gusto mong ito na ang mag-manage ng mga model para sa iyo at magbigay ng OpenAI-shaped endpoint nang walang dagdag na configuration. Ito ang tamang default para sa unang deployment at para sa mga sitwasyong madalas magbago ang model na ginagamit.
Patakbuhin nang direkta ang llama.cpp kapag sapat na limitado ang memory kaya kailangan mong ikaw mismo ang pumili ng quantisation row, kapag kailangan mo ang /health, /slots at /metrics para sa monitoring, o kapag kailangan mo ng flag na hindi inilalantad ng Ollama. Ito ang praktikal na pagpili sa isang VPS kung halos kasya lamang ang model, dahil ang mga setting na nagpapakasya rito ay siya ring mga setting na pinipili ng Ollama para sa iyo.
Normal lang na patakbuhin ang dalawa. Gamitin ang Ollama para sa mga eksperimento at ang llama.cpp para sa iisang model na inilagay mo sa production at ayaw mong awtomatikong mapalitan.
FAQ
Ang Ollama ba ay wrapper lamang para sa llama.cpp?
Malapit, pero may aktuwal na ginagawa ang wrapper. Nakalista sa README ng Ollama ang llama.cpp bilang inference backend nito (sinuri noong 27 October 2026). Bukod dito, nagdaragdag ang Ollama ng model registry, prompt template na nagko-convert ng chat messages sa isang prompt, set ng default sampling parameters, daemon na nag-a-unload ng mga idle model, at HTTP API. Kapag ikinumpara mo ang tokens per second gamit ang magkakaparehong setting, pareho lamang na engine ang ikinukumpara mo sa sarili nito. Ang aktuwal mong pinipili ay ang management layer.
Alin ang mas mabilis sa CPU-only VPS?
Pareho silang gumagamit ng iisang engine, kaya kung pareho ang model file, quantisation, context size, at thread count, magkalapit ang resulta. Ang mga pagkakaibang karaniwang iniuulat ay kadalasang nagmumula sa magkaibang default, lalo na sa context length at thread count, hindi sa engine. Sukatin ito gamit ang llama-bench -m <file> -p 512 -n 128 at ikumpara ang column na tg sa sarili mong server bago maniwala sa anumang published figure.
Magagamit ko ba ang sarili kong GGUF file sa Ollama?
Oo. Ilagay ang file sa server, gumawa ng Modelfile na ang unang linya ay FROM ./your-model.gguf, magdagdag ng anumang PARAMETER lines na kailangan mo gaya ng num_ctx, at pagkatapos ay patakbuhin ang ollama create your-name -f ./Modelfile. Ililista ito ng ollama ls kasabay ng anumang model na kinuha mo mula sa registry. Ganito ginagamit ang quantisation na hindi available sa registry.
Gaano karaming RAM ang kailangan para sa 8B model?
Isama sa budget ang file size, KV cache, at runtime. Ang Q4_K_M build ng Llama 3.1 8B ay humigit-kumulang 4.58 GiB sa disk, at nagdaragdag ang 4096-token context ng humigit-kumulang 512 MiB na cache, kaya sapat na ang 8 GiB ng RAM at hindi sapat ang 4 GiB. Lumalaki ang cache kasabay ng context: ang parehong model sa 32,768-token context ay nangangailangan mismo ng humigit-kumulang 4 GiB na cache. Sa Ollama, tandaan na lumalaki rin ang requirement kasabay ng OLLAMA_NUM_PARALLEL.