Ollama dhidi ya llama.cpp kwenye VPS: ipi uchague?
Linganisha Ollama na llama.cpp kwenye VPS ya CPU pekee: elewa tofauti ya injini na safu ya juu, athari ya quantisation kwa RAM, na mipaka yake.
Ollama dhidi ya llama.cpp: unataka kuendesha tabaka gani?
Ollama na llama.cpp si washindani kwa maana inayodokezwa na swali hilo. llama.cpp ni injini ya inference: hupakia faili la model na kubadilisha prompt kuwa tokens. Ollama ni msimamizi wa models, daemon ya chinichini na HTTP API inayotumia injini hiyo. README ya Ollama bado inaorodhesha llama.cpp kama inference backend yake (imekaguliwa 27 October 2026). Kwa hiyo, swali halisi ni ni tabaka gani unalotaka kuendesha kwenye VPS yako, si lipi lina kasi zaidi.
Tumia Ollama unapotaka huduma inayopakua models kwa jina na kuendelea kufanya kazi bila uangalizi wa mara kwa mara. Tumia llama.cpp moja kwa moja wakati seva ina rasilimali chache na unahitaji kuchagua faili mahususi la model, ukubwa mahususi wa context na idadi mahususi ya threads, kwa sababu kwenye VPS yenye rasilimali chache kila moja ya mipangilio hiyo hutumia memory ambayo huna.
Kila mradi ni nini hasa
llama.cpp ni utekelezaji wa C na C++ wa inference ya transformer unaotumia maktaba ya ggml. Husoma faili za GGUF. GGUF (GGML universal file format) ni kontena la faili moja lenye weights, tokeniser na metadata ambazo engine inahitaji ili kuendesha model. Mradi hutoa binary tofauti kwa kazi tofauti. llama-server ni HTTP server, llama-cli ni interactive prompt, na llama-bench hupima throughput. Sasa mradi hutoa releases zenye semantic versioning (MAJOR.MINOR.PATCH), na v0.7.0, iliyochapishwa tarehe 15 October 2026, ndiyo iliyokuwa ya hivi karibuni tarehe 27 October 2026. Tags za nightly zenye build number bado hutolewa pamoja nazo, mara kadhaa kwa siku, na tag mpya zaidi tarehe 27 October 2026 ilikuwa b11913.
Ollama ni programu ya Go. Background daemon, inayoanzishwa kwa ollama serve, hupakia models na kujibu HTTP requests, huku command line client ikiwasiliana na daemon hiyo. Nyuma ya zote mbili kuna registry kwenye ollama.com yenye models zilizofungwa tayari. Ollama hutumia semantic versions. v0.32.5 ilitolewa tarehe 27 July 2026, na v0.40.12 ilitolewa tarehe 27 October 2026 saa 00:07 UTC. ollama pull hupakua GGUF pamoja na prompt template na seti ya default parameters, kisha huihifadhi chini ya /usr/share/ollama/.ollama/models kwenye Linux. Faili hizo hukaa kwenye root disk na kila moja inaweza kuwa na ukubwa wa gigabytes kadhaa. Kwa hiyo, kwenye VPS yenye root volume ya 25 GB, ni muhimu kujua kile ambacho pull huacha na jinsi ya kuhamisha model directory kwingine kabla download ya tatu haijaijaza.
Huo ndio utofauti wote wa packaging hiyo. Ollama hukuamulia quantisation, template na context length, na hukupa jina moja la kukumbuka. llama.cpp huweka chaguo hizo kama flags, ikiwa na default za kiotomatiki kwa settings unazoacha bila kuweka.
Mhimili 1: udhibiti wa modeli na quantisation
Quantisation huhifadhi weights kwa bits chache kuliko bits 16 au 32 za modeli asili, na miundo ya kawaida ya GGUF huwa na wastani wa takriban bits 4, 5 au 8 kwa kila weight. Precision si sawa katika faili lote. Kulingana na source ya quantiser ya llama.cpp (ilisomwa 27 October 2026), build ya Q4_K_M huhifadhi tensors nyingi kwa 4-bit, lakini output layer, pamoja na attention value tensors na feed-forward down tensors katika takriban nusu ya layers, hupewa Q6_K ya 6-bit badala yake. Tensors ndogo kama norms hazifanyiwi quantisation kabisa. Hilo ndilo linalowezesha modeli yenye parameters bilioni 8 kutoshea kwenye RAM ya VPS ya kawaida. Majina ya GGUF huwa rahisi kusoma ukijua muundo wake: Q4_K_M humaanisha K-quant ya 4-bit yenye ukubwa wa kati. Namba kubwa huhifadhi precision zaidi na hutumia memory zaidi.
Data iliyo nyuma ya chati hii
[
{
"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
}
]Hizi ndizo ukubwa wa faili zilizochapishwa katika repository ya bartowski/Meta-Llama-3.1-8B-Instruct-GGUF kwenye Hugging Face, zilizosomwa tarehe 2 August 2026 na kubadilishwa kutoka bytes kuwa GiB. Kuna builds 6 za modeli moja, na ndogo zaidi ina ukubwa wa 2.96 GiB dhidi ya 7.95 GiB ya kubwa zaidi. Chaguo la kawaida la default, Q4_K_M, lina ukubwa wa 4.58 GiB. Kwenye VPS ya 4 GiB, chaguo hilo pekee huamua kama modeli itapakia kabisa. Size ni nusu tu ya uamuzi huo, kwa sababu row unayoweza kumudu si lazima iwe row inayofaa kutumia, na gharama halisi za Q4, Q8 na fp16 katika ubora wa jibu ndizo zinazoonyesha kama gigabytes za ziada zitanunua tofauti utakayoiona.
Ukitumia llama.cpp, unaandika jina la faili, kwa hiyo unachagua row hiyo mwenyewe.
llama-server -m ~/models/Meta-Llama-3.1-8B-Instruct-Q4_K_M.gguf \
-c 4096 -t 4 --host 127.0.0.1 --port 8080-c ni context size kwa tokens, -t ni thread count, na -ngl huweka idadi ya layers zinazohamishwa kwenye GPU (0 kwenye mashine ya CPU pekee). Settings ambazo hazijawekwa hutumia defaults, na --fit huwa imewashwa kwa default ili kurekebisha arguments ambazo hazijawekwa na kuzifanya zitoshee kwenye device memory.
Ukitumia Ollama, quantisation huambatana na tag unayovuta, na ollama ls huonyesha kilicho kwenye disk kwa kweli. Registry isipokuwa na build unayotaka, import GGUF mwenyewe. Andika Modelfile:
FROM ./Meta-Llama-3.1-8B-Instruct-Q4_K_M.gguf
PARAMETER num_ctx 4096Kisha build hiyo na uthibitishe matokeo:
ollama create llama31-q4 -f ./Modelfile
ollama lsContext length ndiyo setting inayowachanganya watu. Ollama huchagua default yake kulingana na VRAM inayopatikana, na mashine isiyo na GPU huingia kwenye bucket ndogo zaidi: tokens 4096. Ukiitumia hati yenye tokens 20,000, tokens za ziada huondolewa kabla modeli haijaona hati hiyo. Kwa hiyo jibu linaweza kuwa na uhakika usio sahihi kuhusu faili ambalo modeli ilisoma nusu tu. Iongeze kwa OLLAMA_CONTEXT_LENGTH kwenye daemon, au kwa PARAMETER num_ctx katika Modelfile. Ikiwa job moja tu inahitaji window kubwa zaidi, num_ctx inaweza kuwekwa kwa kila request badala ya seva nzima, jambo linalozuia cache ya ziada kutumiwa na kila kitu kingine ambacho daemon inaombwa ifanye. llama.cpp pia haina default unayopaswa kuiamini. Weka -c wazi na ujue thamani uliyoweka.
Hesabu ya kumbukumbu ambayo hakuna anayekuonyesha
Faili la model siyo gharama nzima. KV cache (key/value cache) huhifadhi ingizo moja kwa kila layer kwa kila token ya context, na hukua kadiri mazungumzo yanavyoongezeka.
Fanya hesabu kwa Llama 3.1 8B. Model hii ina layers 32, heads 8 za key/value, na dimension ya head ya 128. Kila token huhifadhi key na value kwa baiti 2 kila moja katika f16, hivyo 2 x 8 x 128 x 2 = 4096 baiti kwa kila layer. Katika layers 32, hiyo ni 128 KiB kwa kila token. Kwa hivyo, context ya token 4096 inagharimu 512 MiB, na context ya token 32,768 inagharimu 4 GiB.
Kwa hiyo, model ya Q4_K_M 8B yenye context ya 4k inahitaji takriban 4.58 GiB kwa ajili ya weights, pamoja na takriban 0.5 GiB ya cache, na runtime yenyewe. Haitoshei kwenye 4 GiB ya RAM. Inatoshea kwenye 8 GiB ikiwa na nafasi ya kufanyia kazi. Ukiongeza context hadi 32k kwenye mashine hiyo hiyo ya 8 GiB, cache pekee itamaliza nafasi iliyobaki. Iangalie moja kwa moja ukitumia free -h wakati model inapakizwa, na usiamini makadirio ambayo hukuyapima mwenyewe. Ikiwa unapanga ukubwa kwa ajili ya kitu kikubwa zaidi ya 8B, hesabu hiyo hiyo iliyofafanuliwa kwa model ya 27B kwenye VPS ya CPU pekee inaonyesha kile kila ngazi kuanzia 8 hadi 64 GB kinachoweza kuhifadhi.
Ollama huzidisha hili. OLLAMA_NUM_PARALLEL huwa na thamani ya msingi ya 1, na kumbukumbu inayohitajika na model huongezeka kulingana na namba hiyo mara urefu wa context. Ukiongeza vyote kwa wakati mmoja, daemon huomba kimyakimya RAM mara nyingi zaidi ya ile uliyotarajia. Hesabu hiyo hiyo huweka ukomo wako kwa watumiaji wa wakati mmoja, kwa sababu kila ombi la wakati mmoja linahitaji sehemu yake ya KV cache, jambo ambalo ndilo kwa nini seva inayoonekana kufanya kazi vizuri kwa mtu mmoja hukwama kwa watumiaji watano.
Mhimili 2: daemon unayopaswa kuendesha
Script ya usakinishaji ya Ollama huandika systemd unit, huunda system user wa ollama na kuwezesha service. Unapata usimamizi wa lifecycle bila kuandika sehemu hizo mwenyewe. Configuration hupitia systemd:
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 ollamaOLLAMA_KEEP_ALIVE ina umuhimu zaidi kwenye CPU VPS kuliko mahali pengine popote. Models huhifadhiwa kwenye memory kwa dakika 5 kwa default, kisha huondolewa. Request inayofuata lazima ipakie faili zima tena kabla ya kutoa jibu. Ikiwa kernel bado inashikilia faili kwenye page cache yake, mchakato huo huwa wa haraka, lakini RAM iliyo wazi pekee ndiyo huiweka hapo. Kazi nyingine ikishaiondoa kwenye cache, faili hurudishwa kutoka disk, hivyo reload ya 4.58 GiB inaweza kubadilisha jibu la sekunde 2 kuwa la sekunde 30 kwenye storage polepole. Keep-alive ndefu huondoa latency hiyo, lakini hutumia RAM hiyo kila wakati. Gharama zote mbili ni halisi. Chagua inayokusumbua kidogo. Ukiamua model ibaki resident, kuweka keep_alive ili ibaki wakati wa idle na baada ya reboots kunahitaji mistari michache na hukuepusha kuipasha model kwa mkono kila mara box inapowashwa upya.
llama.cpp haina daemon wala service user, kwa hiyo unapaswa kuviandaa vyote mwenyewe. Kutoka kwenye directory ya llama.cpp uliyotumia kujenga, install binary na libraries zake kwenye /usr/local, create user wa llama, na umpe copy ya 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.ggufIkiwa ulitumia release archive badala ya kujenga, elekeza ExecStart kwenye llama-server iliyo ndani yake, kwa sababu archive huhifadhi libraries zake karibu na binary. Kisha andika unit kama /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.targetIwezeshe kwa sudo systemctl enable --now llama-server. Mchakato huo hushikilia model kwa muda wote wa maisha yake. Kwa default, hakuna kinachoiondoa wakati wa idle, lakini kuongeza --sleep-idle-seconds huwezesha kuiondoa na kuipakia tena kiotomatiki bila kusimamisha service. Ikiwa kuandika units ni jambo jipya kwako, huu ni muundo uleule wa kuendesha services zako mwenyewe chini ya systemd kwenye VPS.
Mhimili 3: API ambayo app yako itawasiliana nayo
Mhimili huu umepungua sana. Miradi yote miwili sasa hutumia format ya mazungumzo ya OpenAI, kwa hiyo client library nyingi hufanya kazi na mojawapo baada ya kubadilisha base URL pekee.
Ollama husikiliza kwenye 127.0.0.1:11434. Route yake inayooana na OpenAI ni http://localhost:11434/v1/chat/completions, na pia ina API yake ya asili kwenye /api/chat. Route inayooana na Anthropic pia imeandikwa kwenye nyaraka. Hakuna route yoyote kati ya hizi inayowezesha model kutafuta taarifa yenyewe. Kwa hiyo, kama app yako inahitaji majibu yaliyo mapya kuliko data ya mafunzo ya model, panga kuunganisha web search kupitia API ya Ollama, Open WebUI au tool loop fupi.
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"}]}'Ikianzishwa kwa flags zilizo hapo juu, llama-server husikiliza kwenye 127.0.0.1:8080. Ikiachwa yenyewe, sasa hutumia port 9931 kwa chaguo-msingi (imehakikiwa 27 October 2026), kwa hiyo weka --port kwenye command line ikiwa app yako inatarajia 8080. Inatoa /v1/chat/completions, /v1/completions na /v1/embeddings, pamoja na endpoint yake ya /completion na web UI iliyojengwa ndani. Pia inatoa routes za uendeshaji ambazo Ollama haina: /health kwa readiness probe, /props kwa settings za model iliyopakiwa, /slots kwa kuonyesha kila request slot inachofanya, na /metrics katika format ya Prometheus baada ya kuongeza --metrics, kwa sababu endpoint hiyo imezimwa kwa chaguo-msingi. Ikiwa unapanga kufuatilia huduma hii, tofauti hiyo huenda ndiyo itakayoamua chaguo lako.
Hakuna server yoyote kati ya hizi inayowasha authentication kwa niaba yako. Zote mbili hutumia loopback kwa chaguo-msingi kwa sababu nzuri. Zifikie kupitia SSH tunnel au ukiwa nyuma ya reverse proxy, na usiwahi kufungua 11434 au 8080 kwa internet.
Uwezo halisi wa VPS inayotumia CPU pekee
VPS inayotumia CPU pekee huendesha mifano midogo (small models) kwa kasi ndogo. Huo ndio muhtasari wa kweli, na sehemu ya maana ni kujua mpaka wa uwezo huo. Pima utendaji kabla ya kubuni chochote kulingana na VPS hiyo:
llama-bench -m ~/models/Meta-Llama-3.1-8B-Instruct-Q4_K_M.gguf -p 512 -n 128Safu ya pp ni kasi ya kuchakata maelekezo (prompt processing) na safu ya tg ni kasi ya kuzalisha token, zote zikiwa katika token kwa sekunde. Kwenye mpango wa vCPU iliyoshirikiwa (shared vCPU), mfano wa 8B katika Q4_K_M kwa kawaida hutoa matokeo ya tarakimu moja ya chini kwa tg. Kuchakata maelekezo ndiko kunakochukua muda mwingi: maelekezo yote huchakatwa kabla ya token ya kwanza ya matokeo kuonekana, kwa hivyo maelekezo marefu ya mfumo (system prompt) huongeza muda wa kusubiri kwa kila ombi. Urefu wa jibu ni nusu ya gharama unayoweza kuidhibiti, kwa sababu kwa kasi ya token tatu kwa sekunde, mfano unaozalisha token 600 utaifanya seva ifanye kazi kwa sekunde 200, yaani zaidi ya dakika tatu za uzalishaji pekee, kwa hivyo kudhibiti matokeo kwa num_predict ndiyo njia rahisi zaidi ya kuzuia jibu refu lisilete timeout.
Inayofaa kwa CPU: mfano wa 1B hadi 4B unaofanya uainishaji, uchimbaji wa data, muhtasari mfupi, au uelekezaji (routing). Majibu hufika ndani ya sekunde chache na kumbukumbu inatosha kwa mpango wa kawaida. Kwa mfano wa kazi katika ukubwa huo badala ya masafa ya ukubwa, Nemotron 3.5 Lightning iliyopakuliwa na kupimwa kwenye VPS inatoa tag kamili, RAM inayohitajika, na kasi inayopatikana bila GPU. Isiyofaa kwa CPU: mazungumzo ya moja kwa moja (interactive chat) kwa kasi ya kusoma, visaidizi vya uandishi wa code, kazi za hati ndefu, au chochote chenye mzunguko wa wakala (agent loop) kinachofanya wito mwingi mfululizo. Mzunguko unaofanya wito kumi na mbili kwa sekunde nne kila mmoja huchukua dakika nzima kabla ya kutoa matokeo yoyote. Ikiwa msaada wa uandishi wa code ndiyo ulikuwa mpango, kuelekeza wakala kwenye mfano unaojiendeshea mwenyewe kunaainisha kazi ambazo mfano mdogo wa ndani unaweza kufanya vizuri na zile zinazopaswa kubaki kwenye API ya nje.
Kuna njia mbili za kutoka ikiwa namba hazikidhi mahitaji. Ikiwa tatizo ni uwezo wa kuhudumia watumiaji wengi kwa wakati mmoja (concurrency), chaguo la injini hubadilika, na ulinganisho wa Ollama dhidi ya vLLM kwa ajili ya huduma ya wakati mmoja unashughulikia hilo. Ikiwa tatizo ni kasi ya msingi, jibu ni VPS yenye GPU iliyounganishwa, ambapo -ngl huanza kuwa na maana. Kabla ya yote, pata kipimo cha msingi cha maunzi yenyewe, kwa sababu bandwidth ya diski na kumbukumbu huathiri muda wa kupakia (load time) kama vile CPU inavyofanya. Benchmark ya VPS inayoweza kurudiwa inastahili saa moja ya kazi.
Sakinisha llama.cpp, ukiweka build maalum
Miradi yote miwili husasishwa kila wiki, kwa hiyo rekodi toleo ulilosambaza. Amri ya mstari mmoja kutoka upstream husakinisha build ya sasa:
curl -LsSf https://llama.app/install.sh | sh
llama serve -hf ggml-org/Qwen3.5-0.8B-GGUFIli kuweka build maalum, tumia tarball iliyotengenezwa tayari kutoka ukurasa wa releases badala yake. Sasa mradi pia huchapisha releases zenye semantic versioning: v0.7.0 lilikuwa toleo la hivi karibuni tarehe 27 October 2026, na ukurasa wake wa release unaelekeza kwenye nightly b11669 kwa binaries. v0.8.0 lilifuata tarehe 28 October 2026, huku ukurasa wake wa release ukielekeza kwenye nightly b11960 kwa binaries. Amri zilizo hapa chini hutumia b10224, ambayo ndiyo tag ya sasa tarehe 2 August 2026; badilisha kwa tag yoyote uliyoijaribu:
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'Au jenga tag hiyo hiyo kutoka kwenye 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)libssl-dev ni dependency iliyoandikwa kwa ajili ya vipengele vya HTTPS. Compilation huchukua dakika kadhaa na huhitaji RAM zaidi kuliko iliyo kwenye plans ndogo zaidi, kwa hiyo jenga kwenye mashine kubwa kisha nakili binaries ikiwa mashine ndogo itaishiwa na rasilimali.
Sakinisha Ollama, ukiwa umefunga toleo maalum
curl -fsSL https://ollama.com/install.sh | OLLAMA_VERSION=0.32.5 sh
ollama -vHati hii inasoma OLLAMA_VERSION, kwa hivyo unaweza kuhifadhi toleo linalofanya kazi vizuri badala ya kuchukua toleo lolote lililotolewa leo asubuhi. v0.32.5 ilichapishwa tarehe 27 Julai 2026. Kuna njia ya mwongozo pia ikiwa hutaki kuingiza hati moja kwa moja kwenye shell:
sudo rm -rf /usr/lib/ollama
curl -fsSL https://ollama.com/download/ollama-linux-amd64.tar.zst | sudo tar x -C /usr
ollama -vNjia ya mwongozo haitengenezi unit ya systemd wala mtumiaji wa huduma (service user), kwa hivyo utaongeza hayo wewe mwenyewe. Mwongozo kamili wa Ollama kwenye VPS unaelezea hatua hizo za usanidi wa huduma kwa kina.
Njia za kushughulikia hitilafu, na mistari utakayoiona
Ollama inakataa kupakia model. Matoleo ya zamani ya Ollama yalithibitisha ukubwa kabla ya kupakia, na ollama run ilirudisha mstari wa aina hii:
Error: model requires more system memory (5.6 GiB) than is available (3.2 GiB)Msimbo wa sasa wa Ollama hauna tena ujumbe huo (ulikaguliwa 27 October 2026). Sasa Ollama hukabidhi upakiaji kwa llama-server, kwa hiyo model isiyotoshea huonekana kama hitilafu ya runner, ikiwa na errors zinazoanza kama hizi:
llama-server reported out-of-memory during startup
llama-server process has terminatedKwa hali zote mbili, suluhisho ni lilelile. Shuka kwenye safu moja ndogo ya quantisation, punguza urefu wa context, au chagua model ndogo.
llama.cpp haipati hitilafu, lakini inakuwa polepole sana. Kwa kawaida llama.cpp hutumia memory mapping kwa GGUF, kwa hiyo faili kubwa kuliko RAM bado huanza. Kisha kernel hubadilisha weights kati ya disk na RAM kwa kila token, na generation hushuka hadi sekunde kadhaa kwa token huku disk ikiwa kwenye matumizi ya 100 percent. Tumia --load-mode none kuzima memory mapping. Chaguo hilo lilibadilisha --no-mmap, ambalo limeandikwa kuwa deprecated katika build ya b10224 iliyowekwa, na halionekani tena katika builds za sasa (ulikaguliwa 29 October 2026). Kernel inapoingilia kati, dmesg huonyesha sababu:
Out of memory: Killed process 1234 (llama-server)Faili ya model haipakii kabisa. GGUF iliyotengenezwa kwa model family iliyo mpya kuliko engine yako itatoa error inayotaja architecture ambayo engine haijui, ambapo <arch> ni jina lililohifadhiwa katika metadata ya faili:
llama_model_load: error loading model: unknown model architecture: '<arch>'Suluhisho ni kusasisha engine, si kutumia faili tofauti. Hii ndiyo gharama ya kubandika toleo, na ndiyo sababu unaandika build number. Unahitaji kujua unatoka kwenye build gani kabla ya kufanya upgrade.
API inajibu ndani ya seva, lakini si kutoka kwenye app yako. Ollama hufunga kwenye 127.0.0.1:11434, kwa hiyo host nyingine hupata connection refused. Weka OLLAMA_HOST=0.0.0.0:11434 kupitia systemctl edit ollama tu wakati port iko nyuma ya firewall au private network, kwa sababu API haina authentication mbele yake.
Jibu la kwanza baada ya kusubiri ni la polepole sana. Unloading baada ya dakika 5 za kutotumika kumetokea, na model inapakiwa tena kutoka kwenye disk ikiwa page cache haikuihifadhi. ollama ps inapoendeshwa kabla tu ya request haionyeshi kitu kilichopakiwa, jambo linalothibitisha hali hiyo. Ongeza OLLAMA_KEEP_ALIVE.
Ni ipi unapaswa kuiendesha?
Endesha Ollama pale unapotaka mifano (models) idhibitiwe kwa ajili yako na uwe na endpoint yenye muundo wa OpenAI bila kufanya kazi ya ziada. Hili ndilo chaguo chaguo-msingi sahihi kwa deployment ya kwanza, na kwa chochote ambapo chaguo la model litaendelea kubadilika.
Endesha llama.cpp moja kwa moja pale kumbukumbu (memory) inapokuwa finyu kiasi kwamba unahitaji kuchagua safu ya quantisation mwenyewe, pale unapotaka /health, /slots na /metrics kwa ajili ya ufuatiliaji, au pale unapohitaji flag ambayo Ollama haitoi. Hili ni chaguo la kweli kwenye VPS ambapo model inatoshea kwa shida, kwa sababu mipangilio inayofanya itoshee ndiyo ile ile ambayo Ollama huchagua kwa niaba yako.
Kuendesha zote mbili ni jambo la kawaida. Ollama kwa ajili ya majaribio, llama.cpp kwa ajili ya model moja unayoiweka kwenye production na hutaki kuona ikibadilika.
FAQ
Je, Ollama ni wrapper tu inayozunguka llama.cpp?
Karibu, lakini wrapper hiyo hufanya kazi halisi. README ya Ollama inaorodhesha llama.cpp kama inference backend yake (ilikaguliwa 27 October 2026). Juu yake, Ollama huongeza model registry, prompt template inayobadilisha ujumbe wa mazungumzo kuwa prompt, seti ya default sampling parameters, daemon yenye idle unloading, na HTTP API. Unapolinganisha tokens per second kwa settings zinazofanana, unalinganisha engine ileile na yenyewe. Chaguo lako halisi ni management layer.
Ni ipi yenye kasi zaidi kwenye VPS inayotumia CPU pekee?
Zinatumia engine ileile, kwa hiyo zikitumia model file, quantisation, context size na thread count zinazofanana, matokeo yao huwa karibu sawa. Tofauti ambazo watu huripoti kwa kawaida hutokana na defaults tofauti, hasa context length na thread count, wala si engine yenyewe. Ipime kwa llama-bench -m <file> -p 512 -n 128 na ulinganishe column ya tg kwenye server yako mwenyewe kabla ya kuamini takwimu yoyote iliyochapishwa.
Je, naweza kutumia faili yangu ya GGUF kwenye Ollama?
Ndiyo. Weka faili kwenye server, andika Modelfile ambayo mstari wake wa kwanza ni FROM ./your-model.gguf, ongeza mistari yoyote ya PARAMETER unayohitaji kama num_ctx, kisha endesha ollama create your-name -f ./Modelfile. ollama ls itaorodhesha faili hiyo pamoja na faili nyingine ulizovuta kutoka kwenye registry. Hivi ndivyo unavyotumia quantisation ambayo haipo kwenye registry.
Ninahitaji RAM kiasi gani kwa model ya 8B?
Panga nafasi ya faili, pamoja na KV cache na runtime. Build ya Q4_K_M ya Llama 3.1 8B ina ukubwa wa takriban 4.58 GiB kwenye disk, na context ya tokens 4096 huongeza cache ya takriban 512 MiB, kwa hiyo RAM ya 8 GiB inatosha vizuri lakini 4 GiB haitoshi. Cache huongezeka kulingana na context: model hiyo hiyo ikiwa na context ya tokens 32,768 inahitaji takriban 4 GiB ya cache peke yake. Kwa Ollama, kumbuka kwamba hitaji hilo pia huongezeka kulingana na OLLAMA_NUM_PARALLEL.