Ollama model in geheugen houden: zo stelt u dit in
Ollama ontlaadt modellen na vijf minuten inactiviteit. Voorkom vertraging bij nieuwe verzoeken door de OLLAMA_KEEP_ALIVE variabele permanent in te stellen via een systemd override.
Waarom ontlaadt Ollama het model na enkele minuten?
Ollama houdt een model vijf minuten na het laatste verzoek in het geheugen en geeft het daarna vrij. Het volgende verzoek moet de gewichten opnieuw in het RAM of VRAM laden, waardoor er een vertraging optreedt voordat het eerste token verschijnt. Dit is de reden waarom een chat-UI of een coding agent snel aanvoelt, een tijdje stil blijft, en bij het volgende bericht weer traag reageert. Er is niets defect. De inactiviteitstimer is verlopen.
De timer wordt keep_alive genoemd. Deze is per model en wordt telkens opnieuw gestart wanneer een verzoek is voltooid. Een model dat momenteel een verzoek beantwoordt, wordt nooit ontladen, omdat de server alleen een model zonder actief verzoek laat verlopen. Sinds oktober 2026 is de standaardwaarde vijf minuten en deze is van toepassing op elk model dat deze server laadt.
Er zijn twee plaatsen om de inactiviteitstimer in te stellen: het veld keep_alive bij het individuele verzoek, of OLLAMA_KEEP_ALIVE als de standaardinstelling voor de server. Een systemd drop-in zorgt ervoor dat de standaardinstelling van de server behouden blijft na een herstart. Deze handleiding gaat ervan uit dat Ollama al als service draait. Als dat niet het geval is, begin dan met Ollama installeren op een VPS en keer daarna terug.
Welke modellen zijn momenteel geladen en wanneer verlopen ze?
ollama psNAME ID SIZE PROCESSOR CONTEXT UNTIL
qwen3:8b 500a1f067a9f 6.6 GB 100% GPU 4096 4 minutes from nowEen lege uitvoer betekent dat er niets is geladen, waardoor het volgende verzoek het model eerst moet laden. PROCESSOR geeft aan waar de gewichten zijn opgeslagen. 100% GPU en 100% CPU zijn de duidelijke gevallen. Een splitsing zoals 25%/75% CPU/GPU betekent dat slechts een deel van het model zich in VRAM bevindt, waardoor de rest op de processor draait en de generatie trager verloopt. Meestal komt dit doordat het model niet in het geheugen paste, maar een num_gpu-instelling die beperkt hoeveel lagen naar de GPU gaan, produceert hetzelfde type splitsing.
UNTIL is het aftelmoment en toont een relatieve tijd zoals 4 minutes from now. Het toont Forever wanneer het model is geladen met een negatieve keep_alive. Het toont Stopping... na het verlopen, ook wanneer actieve verzoeken het ontladen vertragen.
De kolomset is tussen releases gewijzigd, dus lees de header in plaats van velden te tellen in een script. Ollama v0.40.5, gecontroleerd op 2026-10-30, print ook een RUNNER-kolom tussen CONTEXT en UNTIL, waarin de runner wordt benoemd die het model bedient, waardoor uw header mogelijk één kolom breder is dan het bovenstaande voorbeeld. Vraag voor automatisering de API:
curl -s http://localhost:11434/api/psElk item bevat expires_at, een absolute tijdsaanduiding zoals 2026-08-09T14:38:31.83753Z, en size_vram, het deel van dat model dat in het GPU-geheugen staat. Een size_vram van 0 betekent dat het model op de CPU draait.
Wat de herlaadactie daadwerkelijk kost
Gok hier niet naar. Ollama rapporteert de laadtijd in elk antwoord, als load_duration, in nanoseconden.
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}'Wacht tot ollama ps het model niet meer vermeldt na ollama stop voordat u de twee API-aanroepen uitvoert. De eerste aanroep laadt het model, dus de load_duration is groot. Deel door 1000000000 om dit in seconden af te lezen. De tweede aanroep wordt uitgevoerd terwijl het model in het geheugen staat en rapporteert een veel kleiner getal. Het verschil tussen die twee cijfers is wat elke gebruiker betaalt zodra de timer is verlopen, en dit is de enige reden om keep_alive te wijzigen. Na een unload bevat de page cache van de kernel vaak nog het modelbestand; op een systeem met voldoende RAM kan een herlaadactie dus sneller zijn dan de eerste keer laden na een boot. Wanneer die cache is vrijgegeven, komen de gewichten vanaf de schijf. Als u dus de modeldirectory naar een tweede volume heeft verplaatst, bepaalt de snelheid van dat volume de ondergrens voor elke koude start. Voor de generatiesnelheid aan weerszijden van die pauze, zie hoe u tokens per seconde op uw eigen systeem meet.
Houd een Ollama-model in het geheugen na een verzoek
Verstuur keep_alive bij het verzoek. Dit is van toepassing op dat model vanaf het moment dat het verzoek is voltooid.
curl -s http://localhost:11434/api/chat -d '{
"model": "qwen3:8b",
"messages": [{"role": "user", "content": "hello"}],
"keep_alive": "30m"
}'Er worden vier waardevormen geaccepteerd:
- een tijdsduur-string:
"30m","24h","90s" - een getal, gelezen als seconden:
3600 - een negatieve waarde,
-1of"-1m", wat betekent dat er geen idle-timeout is 0, wat betekent dat het model wordt ontladen zodra er geen actieve verzoeken meer zijn
Een waarde bij het verzoek overschrijft de standaardinstelling van de server, in beide richtingen. Dat is belangrijker dan het lijkt: een client die zijn eigen keep_alive meestuurt, wint het van alles wat u op de server heeft geconfigureerd.
U kunt een model ook laden zonder iets te genereren. Verstuur alleen de modelnaam. De server laadt het model en geeft een leeg antwoord terug met "done": true.
curl -s http://localhost:11434/api/generate -d '{"model": "qwen3:8b", "keep_alive": "30m"}'Dit is het commando om uit te voeren na een herstart, of na het ophalen van een nieuw model, zodat het eerste echte gebruikersverzoek niet hoeft te wachten op het laden. De CLI doet hetzelfde met een flag:
ollama run --keepalive 30m qwen3:8b "hello"Houd het standaard geladen met OLLAMA_KEEP_ALIVE
De server leest OLLAMA_KEEP_ALIVE bij het opstarten en gebruikt deze voor elk model dat geen eigen waarde heeft. Het accepteert dezelfde vormen als het verzoekveld, dus 30m, 3600 en -1 werken allemaal.
Het knelpunt is in welke omgeving dit moet staan. Het uitvoeren van export OLLAMA_KEEP_ALIVE=30m in uw SSH-sessie heeft geen effect, omdat de pakketinstallatie de server uitvoert als een systemd-service onder een eigen gebruiker met een eigen omgeving. Uw inlog-shell en die service komen elkaar nooit tegen. Dit is de meest voorkomende reden waarom de instelling genegeerd lijkt te worden.
Zorg dat de instelling een herstart overleeft met een systemd drop-in
sudo systemctl edit ollama.serviceDe editor wordt geopend met twee commentaarmarkeringen. Typ ertussen: systemd negeert alles wat u onder de tweede markering schrijft.
[Service]
Environment="OLLAMA_KEEP_ALIVE=30m"Bij het opslaan wordt /etc/systemd/system/ollama.service.d/override.conf geschreven. Dit is een drop-in en geen bewerking van de meegeleverde unit. Een Ollama-pakketupgrade die ollama.service vervangt, laat uw instelling daarom ongemoeid. Als drop-ins en unitbestanden nieuw voor u zijn, behandelt de handleiding voor systemd-services en timers de werking ervan.
sudo systemctl daemon-reload
sudo systemctl restart ollama
systemctl show ollama --property=EnvironmentMet de laatste opdracht wordt de omgeving afgedrukt waarin de service daadwerkelijk wordt uitgevoerd. Als OLLAMA_KEEP_ALIVE=30m op die regel ontbreekt, is de drop-in niet toegepast. De oorzaak is vrijwel altijd een ontbrekende koptekst [Service] of regels die onder de markering zijn ingevoerd. Bij de herstart worden alle geladen modellen verwijderd. Het volgende verzoek laadt het model daarom opnieuw. Warm het model op met de preload-aanroep hierboven. De drop-in bewaart de instelling na een reboot, maar niet het model. De service start ollama serve zonder geladen model. Voer daarom na elke boot dezelfde preload-aanroep uit.
Wat het kost om een model resident te houden
De kolom SIZE in ollama ps bevat geheugen dat gedurende het hele inactieve venster is gereserveerd, en niet alleen tijdens een verzoek. Een 8B-model met 4-bit-kwantisatie gebruikt ongeveer 5 tot 6 GB. Bij een 27B-model ligt dat anders. De geheugencalculatie voor het uitvoeren daarvan op een VPS zonder GPU is het waard om vooraf uit te werken voordat u besluit het model resident te houden. Stel keep_alive in op -1 om het verlopen tijdens inactiviteit uit te schakelen. Latere verzoeken voor hetzelfde model kunnen dan de time-out vervangen of een nieuwe lading afdwingen wanneer de runneropties veranderen. Op een kleine VPS gaat dit rechtstreeks ten koste van uw database, webapplicatie en buildtaken.
Controleer de werkelijke waarden in plaats van op een schatting te vertrouwen. Voer dit uit terwijl een model is geladen en daarna opnieuw na ollama stop:
free -hDe kolom available bevat het geheugen dat de kernel nog aan een nieuw proces kan toewijzen. Op een NVIDIA-GPU-systeem toont nvidia-smi hetzelfde voor VRAM. Als het systeem zonder geheugen komt te zitten, beëindigt de kernel een proces om geheugen vrij te maken:
sudo dmesg -T | grep -i "out of memory"Een regel met ollama betekent dat de modelserver het slachtoffer was. Een regel met uw database betekent dat het model won en dat een ander belangrijk proces werd beëindigd. Beide uitkomsten zijn het gevolg van dezelfde keuze: een lange keep-alive-periode op een systeem zonder capaciteitsreserve.
Twee kostenposten worden hier gemakkelijk over het hoofd gezien. Een grotere contextlengte reserveert een grotere KV-cache (key-value-cache, de aandachtstoestand per token die het model tijdens het genereren bewaart). Deze cache maakt deel uit van de residentiegrootte. De omvang ervan volgt uit num_ctx. Als u het contextvenster vergroot, neemt dus ook het geheugen toe dat een resident model gedurende de hele inactieve periode vasthoudt, en niet alleen tijdens het beantwoorden. OLLAMA_NUM_PARALLEL boven 1 reserveert deze cache eenmaal per parallelle slot wanneer het model die paralleliteit ondersteunt. Ollama v0.40.16 stelt paralleliteit voor modellen zonder completion-mogelijkheid in op 1, waaronder embeddingmodellen. De scheduler behandelt mllama of qwen3next niet langer afzonderlijk. Als u meerdere gebruikers met één model wilt bedienen, dimensioneer het geheugen dan voor de slots en niet alleen voor de gewichten.
Een redelijk standaardadvies: één model op een systeem met capaciteitsreserve kan -1 gebruiken. Op een gedeeld systeem gebruikt u een venster dat de intervallen tussen uw verzoeken afdekt, zoals 30m, zodat het geheugen vrijkomt wanneer u stopt met werken.
Een model onmiddellijk ontladen
ollama stop qwen3:8bHet commando geeft geen uitvoer na het aanvragen van de verwijdering; het ontladen wacht tot actieve verzoeken zijn voltooid, waardoor het commando kan terugkeren voordat het geheugen is vrijgegeven. Het geeft ook geen uitvoer voor een model dat u wel hebt opgehaald, maar dat momenteel niet is geladen. Het commando controleert nooit wat er in het geheugen aanwezig is: het verstuurt het ontlaadverzoek en de server antwoordt met succes, ongeacht of er iets in het geheugen stond. De foutmelding couldn't find model "qwen3:8b" to stop verschijnt alleen wanneer er geen model met die naam op deze server is geïnstalleerd, wat meestal duidt op een typefout in de naam of tag. Een stille ollama stop is dus geen bewijs dat er daadwerkelijk geheugen is vrijgemaakt. ollama ps is dat wel. De API-vorm is een verzoek zonder prompt en met keep_alive ingesteld op 0:
curl -s http://localhost:11434/api/chat -d '{"model": "qwen3:8b", "messages": [], "keep_alive": 0}'Het antwoord bevat "done_reason": "unload". Gebruik dit in plaats van de service te herstarten. systemctl restart ollama maakt het geheugen ook vrij, maar verwijdert elk ander geladen model en beëindigt elk lopend verzoek.
Meerdere modellen op één server draaien
OLLAMA_MAX_LOADED_MODELS beperkt het aantal modellen dat tegelijkertijd geladen blijft. Sinds oktober 2026 is de standaardwaarde drie per GPU, of drie op een systeem zonder GPU. De limiet telt het aantal modellen, terwijl het geheugen de werkelijke beperking vormt. Een tweede groot model kan dus worden geweigerd lang voordat u de limiet van drie bereikt.
Wanneer een nieuw model wordt aangevraagd en er is onvoldoende geheugen beschikbaar, of de limiet is bereikt, ontlaadt de scheduler een van de actieve modellen om ruimte te maken. De scheduler geeft de voorkeur aan een model zonder actieve aanvraag. Het systeem verwijdert ook een model waarvan de timer nog niet is verlopen, inclusief een model dat is geladen met -1, al probeert het eerst modellen met kortere vensters. Een negatieve keep_alive betekent dus geen inactiviteits-timeout. Het systeem zet de gewichten niet vast tegenover de aanvraag van een ander model.
Deze beslissingen zijn zichtbaar in het servicelogboek; de limietoverschrijding wordt alleen op debug-niveau gelogd. Voeg een tweede Environment="OLLAMA_DEBUG=1"-regel toe aan hetzelfde drop-in-bestand, herstart de service en observeer:
sudo journalctl -u ollama -fLees de reden die wordt vermeld naast de aanvraag die het ontladen heeft geactiveerd. max runners achieved, unloading one to make room betekent dat de OLLAMA_MAX_LOADED_MODELS-limiet is bereikt. Dit kan gebeuren zelfs als beide modellen in het geheugen zouden passen; verhoog in dat geval de limiet als free -h aantoont dat er nog ruimte is. Een regel die aangeeft dat het nieuwe model naar verwachting het beschikbare geheugen zal overschrijden, gevolgd door een verwijdering, betekent dat de fit-controle van de scheduler het gelijktijdig laden heeft afgewezen vanwege de geheugenmarge. De oplossing is om minder modellen op deze server te draaien, of een lang venster in te stellen voor het model dat snel moet reageren en 0 voor het model dat u zelden aanroept.
Richtlijnen die langer meegaan dan de volgende release
Ollama brengt vaak updates uit en de standaardinstellingen wijzigen regelmatig. Controleer daarom de build die u op dat moment gebruikt in plaats van versienummers uit uw hoofd te leren:
ollama --version
ollama serve --helpollama serve --help somt de omgevingsvariabelen op die de betreffende build daadwerkelijk inleest, waaronder OLLAMA_KEEP_ALIVE. Twee regels zijn door de verschillende releases heen consistent gebleven en vormen een betrouwbare basis. Een waarde in het verzoek overschrijft de standaardinstelling van de server. En ollama ps is de enige bron van waarheid over wat er geladen is, ongeacht wat er in een configuratiebestand staat.
Als een editor of een agent uw server aanstuurt, controleer dan wat die client verstuurt voordat u de server de schuld geeft. Een coding agent koppelen aan uw eigen Ollama-server beschrijft waar deze verzoekinstellingen zich bevinden.
FAQ
Waarom ontlaadt Ollama mijn model na 5 minuten?
Vijf minuten is de standaardwaarde voor keep_alive, de inactiviteitstimer die Ollama start zodra een verzoek is voltooid. Wanneer deze verloopt, geeft de server de gewichten vrij, waardoor het volgende verzoek deze opnieuw moet laden; die herlaadtijd is de pauze die u ervaart. Verhoog deze waarde voor één verzoek door "keep_alive": "30m" in de JSON-body mee te sturen, of voor de gehele server met de omgevingsvariabele OLLAMA_KEEP_ALIVE.
Hoe houd ik een Ollama-model permanent in het geheugen geladen?
Gebruik een negatieve waarde: "keep_alive": -1 bij het verzoek, of OLLAMA_KEEP_ALIVE=-1 voor de server. ollama ps toont vervolgens Forever in de kolom UNTIL. Dit verwijdert de inactiviteitstimer en niets anders. Als er een ander model wordt opgevraagd en het geheugen is beperkt, zal de scheduler dit model alsnog ontladen om ruimte te maken. Latere verzoeken voor hetzelfde model kunnen de time-out overschrijven of een herlaadactie triggeren wanneer de runner-opties wijzigen. Een herstart of reboot wist het geheugen eveneens, dus laad het model daarna opnieuw in.
Waarom wordt OLLAMA_KEEP_ALIVE genegeerd?
Controleer waar u de variabele heeft ingesteld. Voer systemctl show ollama --property=Environment uit; als de variabele niet in die uitvoer staat, heeft de server deze nooit gezien, omdat een variabele die in uw shell is geëxporteerd niet wordt doorgegeven aan een systemd-service. Stel deze in via sudo systemctl edit ollama.service, en voer daarna sudo systemctl daemon-reload en sudo systemctl restart ollama uit. De andere oorzaak is een client die een eigen keep_alive meestuurt bij het verzoek, wat de standaardwaarde van de server overschrijft.
Hoe maak ik het geheugen vrij zonder Ollama te herstarten?
ollama stop qwen3:8b verzoekt om het verlopen van dat specifieke model, terwijl de server en alle andere geladen modellen actief blijven. Actieve verzoeken moeten zijn voltooid voordat het model wordt ontladen. Stuur via de API een verzoek zonder prompt en met "keep_alive": 0; het antwoord bevat vervolgens "done_reason": "unload". Controleer dit met ollama ps, dat het model niet meer zou moeten tonen zodra het ontladen is voltooid.