SSD Nodes Learn Hosting plans →
Mga Gabay Matt ConnorNi Matt Connor · Na-update 2026-11-16

Paano Panatilihing Loaded ang Ollama Model sa Memory

Pagkalipas ng 5 minutong idle, nire-release ni Ollama ang model at mabagal ang susunod na request. Itakda ang OLLAMA_KEEP_ALIVE sa systemd override at mag-preload.

Bakit ina-unload ni Ollama ang model pagkalipas ng ilang minuto?

Pinananatiling naka-load ni Ollama sa memory ang isang model nang limang minuto matapos ang huling request, saka ito nire-release. Kailangang i-load muli ng susunod na request ang weights sa RAM o VRAM, kaya may paghihintay bago lumabas ang unang token. Kaya mabilis ang pakiramdam ng isang chat UI o coding agent, biglang tumitigil nang ilang sandali, at muling bumabagal sa susunod na message. Walang sira. Nag-expire ang idle timer.

Ang tawag sa timer ay keep_alive. Bawat model ay may sarili nito, at nagre-restart ito sa tuwing natatapos ang isang request. Hindi kailanman ina-unload ang model na kasalukuyang sumasagot sa request, dahil nag-e-expire lamang ang server ng model na walang aktibong request. Noong October 2026, limang minuto ang default, at nalalapat ito sa bawat model na nilo-load ng server na ito.

May dalawang lugar kung saan maaaring itakda ang idle timeout: ang field na keep_alive sa indibidwal na request, o ang OLLAMA_KEEP_ALIVE bilang default ng server. Ang systemd drop-in ang nagpapanatili ng default ng server pagkatapos ng restart. Ipinapalagay ng gabay na ito na tumatakbo na si Ollama bilang isang service. Kung hindi pa ito tumatakbo, magsimula sa pag-install ng Ollama sa isang VPS at bumalik dito.

Anong mga model ang kasalukuyang naka-load, at kailan mag-e-expire ang mga ito?

ollama ps
NAME        ID              SIZE      PROCESSOR    CONTEXT    UNTIL
qwen3:8b    500a1f067a9f    6.6 GB    100% GPU     4096       4 minutes from now

Ang walang laman na output ay nangangahulugang walang naka-load, kaya kailangang i-load muna ang model bago maproseso ang susunod na request. Ipinapakita ng PROCESSOR kung saan inilagay ang weights. Malinaw na kaso ang 100% GPU at 100% CPU. Ang split na gaya ng 25%/75% CPU/GPU ay nangangahulugang bahagi lamang ng model ang nasa VRAM, kaya sa processor tumatakbo ang natitira at mas mabagal ang generation. Karaniwan itong nangyayari dahil hindi kasya ang model, ngunit nagdudulot din ng kaparehong split ang setting na num_gpu kapag nililimitahan nito kung ilang layer ang ilalagay sa GPU.

Ang UNTIL ang countdown, at nagpi-print ito ng relative time gaya ng 4 minutes from now. Nagpi-print ito ng Forever kapag na-load ang model gamit ang negatibong keep_alive. Nagpi-print ito ng Stopping... pagkatapos ng expiration, kabilang na habang inaantala ng mga aktibong request ang pag-unload.

Nagbago ang set ng mga column sa pagitan ng mga release, kaya basahin ang header sa halip na bilangin ang mga field sa isang script. Ang Ollama v0.40.5, na sinuri noong 2026-10-30, ay nagpi-print din ng RUNNER column sa pagitan ng CONTEXT at UNTIL. Tinutukoy nito ang runner na nagsisilbi sa model, kaya maaaring mas malapad ng isang column ang header mo kaysa sa nasa halimbawa sa itaas. Para sa anumang automated na proseso, itanong ito sa API:

curl -s http://localhost:11434/api/ps

May expires_at ang bawat entry, isang absolute timestamp gaya ng 2026-08-09T14:38:31.83753Z, at size_vram, na tumutukoy sa bahaging iyon ng model na nasa GPU memory. Ang size_vram na 0 ay nangangahulugang tumatakbo ang model sa CPU.

Ang aktuwal na gastos ng reload

Huwag itong hulaan. Iniuulat ng Ollama ang oras ng pag-load sa bawat response bilang load_duration, na nasa nanoseconds.

sudo apt install -y jq
ollama stop qwen3:8b
curl -s http://localhost:11434/api/generate -d '{"model": "qwen3:8b", "prompt": "hi", "stream": false}' | jq '{load_duration, total_duration}'
curl -s http://localhost:11434/api/generate -d '{"model": "qwen3:8b", "prompt": "hi", "stream": false}' | jq '{load_duration, total_duration}'

Hintaying hindi na ilista ng ollama ps ang model pagkatapos ng ollama stop bago patakbuhin ang dalawang API call. Nilo-load ng unang call ang model, kaya malaki ang load_duration nito. Hatiin ito sa 1000000000 upang mabasa bilang seconds. Tumatakbo ang pangalawang call habang nasa memorya pa ang model, kaya mas maliit ang iniuulat nitong value. Ang agwat ng dalawang value na ito ang binabayaran ng bawat user kapag nag-expire na ang timer, at ito ang buong dahilan kung bakit kailangang baguhin ang keep_alive. Pagkatapos ng unload, madalas na nasa page cache pa rin ng kernel ang model file. Kaya sa server na may ekstrang RAM, maaaring mas mabilis ang reload kaysa sa unang load pagkatapos ng boot. Kapag na-reclaim na ang cache, mula sa disk kukunin ang weights. Kung inilipat mo ang model directory sa pangalawang volume, ang bilis ng volume na iyon ang nagtatakda ng pinakamababang oras sa bawat cold load. Para sa generation speed bago at pagkatapos ng pause na iyon, tingnan ang paraan ng pagsukat ng tokens per second sa sarili mong server.

Panatilihing naka-load sa memory ang Ollama model sa isang request

Ipadala ang keep_alive kasama ng request. Nalalapat ito sa model mula sa oras na matapos ang request.

curl -s http://localhost:11434/api/chat -d '{
  "model": "qwen3:8b",
  "messages": [{"role": "user", "content": "hello"}],
  "keep_alive": "30m"
}'

Apat na anyo ng value ang tinatanggap:

  • duration string: "30m", "24h", "90s"
  • plain number na binabasa bilang mga segundo: 3600
  • negative value, -1 o "-1m", na nangangahulugang walang idle timeout
  • 0, na nangangahulugang i-unload ang model kapag wala na itong aktibong request

Ino-override ng value sa request ang server default sa alinmang direksiyon. Mahalaga ito: mananaig ang sariling keep_alive ng client sa anumang na-configure mo sa server.

Maaari ka ring mag-load ng model nang hindi nagge-generate ng anuman. Ipadala lamang ang pangalan ng model. Ilo-load ito ng server at magbabalik ng walang laman na response na may "done": true.

curl -s http://localhost:11434/api/generate -d '{"model": "qwen3:8b", "keep_alive": "30m"}'

Ito ang command na dapat patakbuhin pagkatapos ng reboot o pagkatapos mag-pull ng bagong model, upang hindi maghintay sa pag-load ang unang aktuwal na request ng user. Pareho rin ang ginagawa ng CLI gamit ang flag:

ollama run --keepalive 30m qwen3:8b "hello"

Panatilihin itong naka-load bilang default gamit ang OLLAMA_KEEP_ALIVE

Binabasa ng server ang OLLAMA_KEEP_ALIVE sa startup at ginagamit ito para sa bawat model na walang sariling value. Pareho ang format nito sa request field, kaya gumagana ang 30m, 3600, at -1.

Ang mahalaga ay kung saang environment ito dapat ilagay. Walang epekto ang pagpapatakbo ng export OLLAMA_KEEP_ALIVE=30m sa iyong SSH session, dahil pinapatakbo ng packaged install ang server bilang systemd service sa ilalim ng sarili nitong user at environment. Hindi nagkakaroon ng ugnayan ang iyong login shell at ang service na iyon. Ito ang pinakakaraniwang dahilan kung bakit mukhang hindi gumagana ang setting.

Panatilihin itong gumana kahit mag-restart gamit ang systemd drop-in

sudo systemctl edit ollama.service

Bubukas ang editor na may dalawang comment marker. I-type ang setting sa pagitan ng mga ito: itinatapon ng systemd ang anumang isusulat mo sa ibaba ng pangalawang marker.

[Service]
Environment="OLLAMA_KEEP_ALIVE=30m"

Isinusulat ng pag-save ang /etc/systemd/system/ollama.service.d/override.conf. Drop-in ito at hindi pagbabago sa shipped unit, kaya mananatiling hindi nagbabago ang setting mo kapag pinalitan ng Ollama package upgrade ang ollama.service. Kung bago sa iyo ang drop-in at unit file, ipinapaliwanag ng systemd service at timer guide ang mga mekanismo nito.

sudo systemctl daemon-reload
sudo systemctl restart ollama
systemctl show ollama --property=Environment

Ipinapakita ng huling command ang environment na aktuwal na gagamitin ng service. Kung wala ang OLLAMA_KEEP_ALIVE=30m sa linyang iyon, hindi nailapat ang drop-in. Halos palaging sanhi nito ang nawawalang [Service] header o mga linyang nai-type sa ibaba ng marker. Inaalis ng restart ang lahat ng naka-load na model, kaya cold load ang susunod na request. I-warm up ito gamit ang preload call sa itaas. Pinananatili ng drop-in ang setting pagkatapos ng reboot, hindi ang model: nagsisimula ang service nang ollama serve na walang naka-load, kaya patakbuhin ang parehong preload call pagkatapos ng bawat boot.

Magkano ang gastos ng pagpapanatiling naka-resident ng model

Ang SIZE column sa ollama ps ay memory na ginagamit sa buong idle window, hindi lamang habang may request. Karaniwang kumokonsumo ang isang 8B model na may 4-bit quantisation ng humigit-kumulang 5 hanggang 6 GB. Ibang usapan ang 27B model, at sulit munang suriin ang memory arithmetic para magpatakbo nito sa CPU-only VPS bago magpasya na panatilihin itong resident. Itakda ang keep_alive sa -1 upang i-disable ang idle expiration; maaaring palitan ng mga susunod na request para sa parehong model ang timeout nito o puwersahin ang reload kapag nagbago ang runner options. Sa maliit na VPS, direktang kapalit nito ang memory na magagamit ng database, web app, at build jobs mo.

Subaybayan ang aktuwal na mga value sa halip na umasa sa estimate. Patakbuhin ito habang naka-load ang model, at ulitin pagkatapos ng ollama stop:

free -h

Ang available column ay ang memory na maaari pang ilaan ng kernel sa isang bagong process. Sa NVIDIA GPU box, ipinapakita ng nvidia-smi ang parehong sitwasyon sa VRAM. Kapag naubusan ng memory ang box, magki-kill ang kernel ng isang process upang makabawi:

sudo dmesg -T | grep -i "out of memory"

Kapag ollama ang nakalagay sa isang line, ang model server ang naging biktima. Kapag database mo ang nakalagay, nanalo ang model at may mahalagang process na nawala. Parehong resulta ito ng iisang desisyon: mahabang keep-alive window sa box na walang sapat na headroom.

May dalawang cost dito na madaling hindi mapansin. Ang mas mahabang context length ay nagrereserba ng mas malaking KV cache (key value cache, ang per-token attention state na pinananatili ng model habang nagge-generate), at bahagi ng resident size ang cache na ito. Ang laki nito ay nakadepende sa num_ctx, kaya ang pagtaas ng context window ay nagpapalaki sa memory na hawak ng resident model sa buong idle period, hindi lamang habang sumasagot ito. Ang OLLAMA_NUM_PARALLEL na lampas sa 1 ay nagrereserba ng cache nang isang beses para sa bawat parallel slot kapag sinusuportahan ng model ang parallelism na iyon. Pinipilit ng Ollama v0.40.16 na maging 1 ang parallelism para sa mga model na walang completion capability, kabilang ang embedding models; hindi na hiwalay na tinatrato ng scheduler nito ang mllama o qwen3next. Kung plano mong mag-serve ng ilang user gamit ang iisang model, i-size ang memory para sa mga slot, hindi lamang para sa weights.

Makatuwirang default: ang isang model sa box na may sapat na headroom ay maaaring gumamit ng -1. Ang shared box ay dapat gumamit ng window na sumasaklaw sa pagitan ng mga request mo, gaya ng 30m, upang bumalik ang memory kapag tumigil ka sa pagtatrabaho.

Agad na i-unload ang isang model

ollama stop qwen3:8b

Wala itong inilalabas na output matapos humiling ng expiration. Naghihintay ang unloading na matapos ang mga aktibong request, kaya maaaring bumalik ang command bago ma-release ang memory. Wala rin itong inilalabas na output para sa model na na-pull mo na ngunit hindi kasalukuyang naka-load. Hindi kailanman sinusuri ng command kung ano ang nasa memory: ipinapadala nito ang unload request, at nagbabalik ang server ng success kahit walang anumang model sa memory. Lumalabas lamang ang error na couldn't find model "qwen3:8b" to stop kapag walang naka-install na model na may ganoong pangalan sa server na ito. Karaniwan itong nangangahulugan na may typo sa pangalan o tag. Kaya hindi patunay ang tahimik na ollama stop na may na-release na memory. ollama ps ang patunay. Ang API form ay isang request na walang prompt at nakatakda ang keep_alive sa 0:

curl -s http://localhost:11434/api/chat -d '{"model": "qwen3:8b", "messages": [], "keep_alive": 0}'

Nasa reply ang "done_reason": "unload". Gamitin ito sa halip na i-restart ang service. Nagre-release din ng memory ang systemctl restart ollama, ngunit ibinababa nito ang lahat ng iba pang naka-load na model at tinatapos ang anumang kasalukuyang request.

Higit sa isang model sa iisang server

Tinutukoy ng OLLAMA_MAX_LOADED_MODELS kung ilang model ang maaaring manatiling naka-load nang sabay-sabay. Noong October 2026, ang default ay tatlo bawat GPU, o tatlo sa CPU-only na server. Binibilang ng limit na ito ang mga model, pero memory ang tunay na limitasyon. Kaya maaaring hindi mapaglaanan ng puwang ang ikalawang malaking model bago pa umabot sa tatlo.

Kapag may hiniling na bagong model at walang sapat na memory para rito, o naabot na ang limit, inaalis ng scheduler ang isa sa mga kasalukuyang naka-load na model upang magkaroon ng puwang. Mas pinipili nito ang model na walang aktibong request. Maaari nitong alisin ang model kahit hindi pa nag-expire ang timer nito, kabilang ang model na na-load gamit ang -1, pero inuuna nitong subukan ang mga model na may mas maikling window. Kaya ang negatibong keep_alive ay nangangahulugang walang idle timeout. Hindi nito pinipirmi ang weights upang pigilan ang request para sa ibang model.

Makikita ang mga desisyong ito sa service log. Ang kaso kung saan naabot ang limit ay itinatala lamang sa debug level. Magdagdag ng ikalawang Environment="OLLAMA_DEBUG=1" line sa parehong drop-in, mag-restart, at mag-monitor:

sudo journalctl -u ollama -f

Basahin ang dahilan na nakalagay sa tabi ng request na nag-trigger sa pag-unload. Ibig sabihin ng max runners achieved, unloading one to make room ay naabot ang OLLAMA_MAX_LOADED_MODELS cap. Maaari itong mangyari kahit magkasya ang dalawang model, kaya taasan ang cap kung ipinapakita ng free -h na may sapat pang headroom. Kung sinasabi ng isang line na inaasahang lalampas sa available memory ang bagong model, at kasunod nito ay may eviction, nangangahulugan itong tinanggihan ng fit check ng scheduler ang sabay na pag-load sa mga model dahil sa memory headroom. Ang solusyon ay gumamit ng mas kaunting model sa server na ito, o magtakda ng mahabang window para sa model na kailangang mabilis sumagot at 0 para sa model na bihira mong tawagin.

Mga gabay na mananatiling kapaki-pakinabang lampas sa susunod na release

Madalas mag-release ang Ollama at nagbabago ang mga default nito, kaya suriin ang build na nasa harap mo sa halip na isaulo ang mga numero:

ollama --version
ollama serve --help

Inililista ng ollama serve --help ang mga environment variable na aktuwal na binabasa ng build na iyon, kabilang ang OLLAMA_KEEP_ALIVE. May dalawang panuntunang nanatiling pareho sa iba’t ibang release at ligtas gawing batayan. Mas nangingibabaw ang value sa request kaysa sa default ng server. At ang ollama ps ang nagsasabi kung ano ang aktuwal na naka-load, anuman ang nakasaad na dapat i-load sa config file.

Kung editor o agent ang kumokontrol sa server mo, tingnan muna kung ano ang ipinapadala ng client bago sisihin ang server. Saklaw ng Pagtutok ng coding agent sa sarili mong Ollama server kung saan matatagpuan ang mga setting na iyon ng request.

FAQ

Bakit ina-unload ng Ollama ang model ko pagkalipas ng 5 minuto?

Ang 5 minuto ang default na keep_alive, ang idle timer na sinisimulan ng Ollama kapag natapos ang isang request. Kapag nag-expire ito, inaalis ng server ang weights, kaya kailangang i-load muli ang mga ito sa susunod na request. Ang reload na ito ang nagdudulot ng pause na nararanasan mo. Dagdagan ito para sa isang request sa pamamagitan ng pagpapadala ng "keep_alive": "30m" sa JSON body, o para sa buong server gamit ang OLLAMA_KEEP_ALIVE environment variable.

Paano ko mapananatiling naka-load sa memory ang isang Ollama model?

Gumamit ng negatibong value: "keep_alive": -1 sa request, o OLLAMA_KEEP_ALIVE=-1 para sa server. Ipinapakita ng ollama ps ang Forever sa column na UNTIL. Inaalis nito ang idle timer at wala nang iba. Kung may ibang model na hiningi at kapos ang memory, ia-unload pa rin ito ng scheduler upang maglaan ng espasyo. Maaari ring palitan ng mga susunod na request para sa parehong model ang timeout nito o mag-trigger ng reload kapag nagbago ang runner options. Nililinis din ito ng restart o reboot, kaya i-preload muli ang model pagkatapos nito.

Bakit hindi pinapansin ang OLLAMA_KEEP_ALIVE?

Tingnan kung saan mo ito itinakda. Patakbuhin ang systemctl show ollama --property=Environment. Kung wala ang variable sa output na iyon, hindi ito nakita ng server dahil hindi umaabot sa systemd service ang variable na na-export sa shell mo. Itakda ito gamit ang sudo systemctl edit ollama.service, pagkatapos ay patakbuhin ang sudo systemctl daemon-reload at sudo systemctl restart ollama. Ang isa pang sanhi ay client na nagpapadala ng sarili nitong keep_alive sa request, na nag-o-override sa server default.

Paano ko palalayain ang memory nang hindi nire-restart ang Ollama?

Humihiling ang ollama stop qwen3:8b na i-expire ang isang model at iniiwang tumatakbo ang server at lahat ng iba pang naka-load na model. Kailangang matapos muna ang mga aktibong request bago ito i-unload. Sa API, magpadala ng request na walang prompt at may "keep_alive": 0. Ang tugon ay may "done_reason": "unload". Kumpirmahin gamit ang ollama ps. Hindi na dapat nito ilista ang model kapag natapos ang unloading.

Nakatulong ba ang artikulong ito?