Ollama మోడల్‌ను మెమరీలో ఎప్పటికీ ఎలా ఉంచాలి

Ollama కొన్ని నిమిషాల తర్వాత model ను ఎందుకు unload చేస్తుంది?

చివరి request తర్వాత Ollama ఒక model ను memory లో ఐదు నిమిషాలు loaded గా ఉంచి, తరువాత దాన్ని విడుదల చేస్తుంది. తదుపరి request సమయంలో weights ను disk నుంచి మళ్లీ చదివి RAM లేదా VRAM లో map చేయాలి. అందువల్ల మొదటి token రావడానికి ముందు కొంతసేపు ఆగుతుంది. అందుకే chat UI లేదా coding agent వేగంగా పనిచేసి, కొంతసేపు నిశ్శబ్దంగా ఉండి, తదుపరి message సమయంలో మళ్లీ నెమ్మదిగా అనిపిస్తుంది. ఏదీ పాడవలేదు. idle timer గడువు ముగిసింది.

ఈ timer ను keep_alive అంటారు. ఇది ప్రతి model కు విడిగా ఉంటుంది. ప్రతి request పూర్తయినప్పుడు ఇది మళ్లీ ప్రారంభమవుతుంది. ప్రస్తుతం request కు సమాధానం ఇస్తున్న model ఎప్పుడూ unload కాదు. active request లేని model కు మాత్రమే server గడువు ముగించగలదు. August 2026 నాటికి default విలువ ఐదు నిమిషాలు. ఈ server load చేసే ప్రతి model కు ఇది వర్తిస్తుంది.

keep_alive ను రెండు చోట్ల సెట్ చేయవచ్చు: individual request లో లేదా server default గా. Restart తర్వాత కూడా server default అమలులో ఉండేలా చేయడానికి systemd drop-in ఉపయోగించాలి. ఈ guide లో Ollama ఇప్పటికే service గా నడుస్తోందని భావిస్తున్నాం. అలా లేకపోతే VPSలో Ollamaను install చేయడంతో ప్రారంభించి, తరువాత ఇక్కడికి తిరిగి రండి.

ప్రస్తుతం ఏ models మెమరీలో ఉన్నాయి, అవి ఎప్పుడు expire అవుతాయి?

ollama ps

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

ఖాళీ output అంటే ఏదీ load కాలేదని అర్థం. అందువల్ల తదుపరి request కు పూర్తి load సమయం పడుతుంది. PROCESSOR ద్వారా weights ఎక్కడ ఉన్నాయో తెలుస్తుంది. 100% GPU మరియు 100% CPU స్పష్టమైన సందర్భాలు. 25%/75% CPU/GPU వంటి split అంటే model పూర్తిగా VRAM లో సరిపోలలేదని అర్థం. అందువల్ల దాని కొంత భాగం processor పై నడుస్తుంది మరియు generation నెమ్మదిగా ఉంటుంది.

UNTIL countdown ను చూపిస్తుంది. ఇది 4 minutes from now వంటి relative time ను print చేస్తుంది. model ను negative keep_alive తో load చేసినప్పుడు Forever ను print చేస్తుంది. server unload చేస్తున్న స్వల్ప వ్యవధిలో Stopping... ను print చేస్తుంది.

Releases మధ్య column set మారింది. అందువల్ల script లో fields లెక్కించకుండా header ను చదవండి. Automated పనుల కోసం API ను అడగండి:

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

ప్రతి entry లో expires_at, 2026-08-09T14:38:31.83753Z వంటి absolute timestamp, అలాగే size_vram ఉంటాయి. size_vram అంటే ఆ model లో GPU memory లో ఉన్న భాగం. size_vram విలువ 0 అయితే model CPU పై నడుస్తోందని అర్థం.

రిలీజ్ చేయడానికి వాస్తవంగా ఎంత సమయం పడుతుంది

దీనిని ఊహించవద్దు. Ollama ప్రతి response లో load time ను load_duration రూపంలో 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}'

మొదటి call model ను load చేస్తుంది. అందువల్ల దాని load_duration విలువ ఎక్కువగా ఉంటుంది. దానిని seconds గా చదవడానికి 1000000000 తో భాగించండి. రెండవ call model memory లో ఉన్న సమయంలో నడుస్తుంది. అందువల్ల అది చాలా తక్కువ సంఖ్యను చూపిస్తుంది. ఆ రెండు విలువల మధ్య తేడానే timer గడిచిన తర్వాత ప్రతి user భరించాల్సిన సమయం. keep_alive ను మార్చడానికి ఇదే ప్రధాన కారణం. ఆ తేడాలో ఎక్కువ భాగం disk read సమయం. కాబట్టి మీరు model directory ను రెండవ volume కు తరలించి ఉంటే, ప్రతి cold load కు కనీస సమయాన్ని ఆ volume వేగమే నిర్ణయిస్తుంది. ఆ విరామానికి ముందు మరియు తర్వాత generation speed తెలుసుకోవడానికి మీ స్వంత box లో tokens per second ను ఎలా కొలవాలో చూడండి.

ఒక అభ్యర్థనలో Ollama model ను memoryలో లోడ్‌గానే ఉంచడం

అభ్యర్థనతో పాటు keep_alive పంపండి. అభ్యర్థన పూర్తయిన క్షణం నుంచి అది ఆ model కు వర్తిస్తుంది.

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

నాలుగు value రూపాలు అంగీకరించబడతాయి:

• duration string: "30m", "24h", "90s"
• seconds గా పరిగణించే plain number: 3600
• idle timeout అసలు ఉండకూడదని సూచించే negative value, -1 లేదా "-1m"
• ఈ అభ్యర్థన పూర్తయిన వెంటనే unload చేయాలని సూచించే 0

అభ్యర్థనలోని value server default ను రెండు దిశల్లోనూ override చేస్తుంది. ఇది కనిపించేదానికంటే ముఖ్యమైనది: client తన సొంత keep_alive పంపితే, serverలో మీరు configure చేసిన విలువ కంటే అదే ప్రాధాన్యం పొందుతుంది.

ఏదీ generate చేయకుండా కూడా model ను load చేయవచ్చు. Model name మాత్రమే పంపండి. Server దాన్ని load చేసి, "done": true తో ఖాళీ response ను తిరిగి ఇస్తుంది.

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

Reboot తర్వాత లేదా కొత్త model ను pull చేసిన తర్వాత అమలు చేయాల్సిన command ఇదే. అప్పుడు మొదటి నిజమైన user request కు model load అయ్యే సమయం అదనంగా పట్టదు. CLIలో flag ఉపయోగించి ఇదే పని చేయవచ్చు:

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

OLLAMA_KEEP_ALIVE తో డిఫాల్ట్‌గా లోడ్‌లో ఉంచండి

సర్వర్ ప్రారంభ సమయంలో OLLAMA_KEEP_ALIVE ను చదివి, స్వంత విలువ లేని ప్రతి మోడల్‌కు దానినే ఉపయోగిస్తుంది. ఇది request field వలేనే అదే రూపాలను స్వీకరిస్తుంది. అందువల్ల 30m, 3600 మరియు -1 అన్నీ పనిచేస్తాయి.

అయితే ఈ environment లో అది ఉండాలి అన్నదే ముఖ్యమైన విషయం. మీ SSH session లో export OLLAMA_KEEP_ALIVE=30m ను అమలు చేయడం వల్ల ప్రయోజనం ఉండదు. కారణం, package ద్వారా చేసిన install సర్వర్‌ను ప్రత్యేక user మరియు ప్రత్యేక environment తో systemd serviceగా నడుపుతుంది. మీ login shell మరియు ఆ service environment ఒకదానితో ఒకటి సంబంధం కలిగి ఉండవు. ఈ setting పట్టించుకోబడలేదని అనిపించడానికి ఇదే అత్యంత సాధారణ కారణం.

systemd drop-in తో restart తర్వాత కూడా ఈ అమరికను కొనసాగించండి

sudo systemctl edit ollama.service

ఎడిటర్ రెండు comment markers తో తెరుచుకుంటుంది. వాటి మధ్యలో వ్రాయండి: రెండవ marker కింద మీరు వ్రాసినదాన్ని systemd విస్మరిస్తుంది.

[Service]
Environment="OLLAMA_KEEP_ALIVE=30m"

సేవ్ చేస్తే /etc/systemd/system/ollama.service.d/override.conf వ్రాయబడుతుంది. ఇది shipped unit ను సవరించడం కాదు, drop-in ను సృష్టించడం. అందువల్ల ollama.service ను భర్తీ చేసే Ollama package upgrade వచ్చినా మీ అమరిక అలాగే ఉంటుంది. drop-ins మరియు unit files మీకు కొత్తగా ఉంటే, systemd service మరియు timer guide వాటి విధానాన్ని వివరిస్తుంది.

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

చివరి command సేవ వాస్తవంగా ఏ environment తో నడుస్తుందో చూపిస్తుంది. ఆ output లో OLLAMA_KEEP_ALIVE=30m కనిపించకపోతే drop-in అమలు కాలేదు. దీనికి దాదాపు ఎల్లప్పుడూ కారణం [Service] header లేకపోవడం లేదా marker కింద lines వ్రాయడం. Restart సమయంలో load చేసిన ప్రతి model తొలగిపోతుంది. అందువల్ల తదుపరి request cold load అవుతుంది. పై preload call తో దాన్ని ముందుగానే load చేయండి.

మోడల్‌ను memoryలో నిరంతరం ఉంచడానికి అయ్యే ఖర్చు

ollama ps లోని SIZE column మొత్తం idle window సమయంలో ఉంచే memoryని సూచిస్తుంది. ఇది request వచ్చినప్పుడు మాత్రమే ఉపయోగించే memory కాదు. 4-bit quantisationలో 8B model సాధారణంగా 5 నుంచి 6 GB వరకు memory ఉపయోగిస్తుంది. 27B model విషయంలో పరిస్థితి భిన్నంగా ఉంటుంది. అందువల్ల దాన్ని memoryలో నిరంతరం ఉంచే ముందు CPU-only VPSలో ఒక modelను నడపడానికి అవసరమైన memory లెక్కింపును పరిశీలించడం మంచిది. keep_alive ను -1 కు సెట్ చేస్తే, ఆ boxలోని మిగతా అన్నింటికంటే modelకు శాశ్వతంగా ఎక్కువ ప్రాధాన్యత ఇచ్చినట్టే. చిన్న VPSలో ఇది మీ database, web app, build jobsతో నేరుగా memory కోసం పోటీ పడుతుంది.

ఒక estimateపై ఆధారపడకుండా వాస్తవ సంఖ్యలను పరిశీలించండి. Model load అయి ఉన్నప్పుడు దీన్ని run చేయండి. తరువాత ollama stop తర్వాత మళ్లీ run చేయండి:

free -h

available columnలో kernel కొత్త processకు ఇంకా కేటాయించగల memory కనిపిస్తుంది. NVIDIA GPU boxలో nvidia-smi VRAMలో ఇదే పరిస్థితిని చూపిస్తుంది. Boxలో memory పూర్తిగా అయిపోతే kernel ఒక processను terminate చేసి memoryని తిరిగి పొందుతుంది:

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

ollama పేరున్న line కనిపిస్తే model serverను terminate చేసినట్టు అర్థం. మీ database పేరు ఉన్న line కనిపిస్తే model గెలిచింది, మీకు ముఖ్యమైన మరొక process నష్టపోయింది. ఈ రెండు పరిణామాలకు ఒకే నిర్ణయం కారణం: headroom లేని boxలో చాలా ఎక్కువ keep-alive window ఉంచడం.

ఇక్కడ రెండు ఖర్చులు సులభంగా కనిపించకుండా పోతాయి. ఎక్కువ context length వల్ల పెద్ద KV cache reserve అవుతుంది. KV cache అంటే key value cache; model generate చేస్తున్నప్పుడు ప్రతి tokenకు ఉంచే attention state. ఈ cache resident sizeలో భాగమే. దీని పరిమాణం num_ctx పై ఆధారపడుతుంది. అందువల్ల context windowను పెంచితే, model సమాధానం ఇస్తున్న సమయంలో మాత్రమే కాకుండా, మొత్తం idle periodలో residentగా ఉంచే memory కూడా పెరుగుతుంది. 1 కంటే ఎక్కువగా ఉన్న OLLAMA_NUM_PARALLEL ప్రతి parallel slotకు ఆ cacheను ఒకసారి reserve చేస్తుంది. ఒకే model నుంచి పలువురు ఉపయోగించుకునేలా అందించాలనుకుంటే, weights కోసం మాత్రమే కాకుండా slots కోసం కూడా memoryని లెక్కించండి.

సాధారణంగా సరైన default ఇలా ఉంటుంది: headroom ఉన్న boxలో ఒక model -1 ను ఉపయోగించవచ్చు. Shared boxలో మీ requests మధ్య ఉండే విరామాలను కవర్ చేసే windowను ఉపయోగించాలి. ఉదాహరణకు 30m సరిపోతుంది. మీరు పని ఆపిన తర్వాత memory తిరిగి అందుబాటులోకి వస్తుంది.

మోడల్‌ను వెంటనే unload చేయడం

ollama stop qwen3:8b

దీనికి ఎలాంటి output ఉండదు, మరియు model ollama ps నుంచి తొలగిపోతుంది. Load చేయని పేరుకు couldn't find model "qwen3:8b" to stop వస్తుంది. API రూపంలో prompt ఉండదు, అలాగే keep_alive ను 0 కు set చేయాలి:

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

Replyలో "done_reason": "unload" ఉంటుంది. Serviceను restart చేయడానికి బదులుగా దీన్ని ఉపయోగించండి. systemctl restart ollama కూడా memoryని విడుదల చేస్తుంది, కానీ load చేసిన ఇతర modelలన్నింటినీ తొలగించి, అప్పటివరకు నడుస్తున్న ప్రతి requestను నిలిపివేస్తుంది.

ఒకే సర్వర్‌పై ఒకటి కంటే ఎక్కువ మోడళ్లను నడపడం

OLLAMA_MAX_LOADED_MODELS ఒకేసారి ఎంత మంది మోడళ్లు loaded గా ఉండవచ్చో పరిమితం చేస్తుంది. 2026 August నాటికి, ప్రతి GPUకి default పరిమితి మూడు. CPU-only box కు కూడా ఈ పరిమితి మూడు. ఈ పరిమితి మోడళ్ల సంఖ్యను లెక్కిస్తుంది. అయితే అసలు పరిమితి memory. అందువల్ల మూడు మోడళ్లకు చేరకముందే రెండవ పెద్ద మోడల్‌కు స్థలం లేదని scheduler నిరాకరించవచ్చు.

కొత్త మోడల్‌ను request చేసినప్పుడు దానికి సరిపడ memory లేకపోతే, scheduler స్థలం కల్పించడానికి resident models లో ఒకదాన్ని unload చేస్తుంది. active request లేని మోడల్‌కు ప్రాధాన్యత ఇస్తుంది. timer ఇంకా ముగియని మోడల్‌ను కూడా evict చేస్తుంది. -1 తో loaded చేసిన మోడల్ కూడా ఇందుకు మినహాయింపు కాదు. కాబట్టి ప్రతికూల keep_alive అంటే idle timeout లేదని అర్థం. మరో మోడల్ request చేసినప్పుడు ఆ model weights ను ఇది pin చేయదు.

ఈ నిర్ణయం debug level వద్ద log అవుతుంది. అదే drop-in కు రెండవ Environment="OLLAMA_DEBUG=1" line ను జోడించి, restart చేసి, ఈ log ను monitor చేయండి:

sudo journalctl -u ollama -f

స్థలం కల్పించడానికి runner ను unload చేసినట్లు తెలిపే line, దాన్ని trigger చేసిన request పక్కనే కనిపిస్తే, ఈ రెండు models ఈ machine లో కలిసి సరిపోవని అర్థం. పరిష్కారం ఈ box పై models సంఖ్యను తగ్గించడం. లేదా త్వరగా సమాధానం ఇవ్వాల్సిన మోడల్‌కు ఎక్కువ window ఉంచి, అరుదుగా ఉపయోగించే మోడల్‌కు 0 ఉంచడం.

తదుపరి release కంటే ఎక్కువకాలం ఉపయోగపడే మార్గదర్శకాలు

Ollama తరచుగా కొత్త releases విడుదల చేస్తుంది మరియు దాని default విలువలు మారుతుంటాయి. అందువల్ల సంఖ్యలను కంఠస్థం చేసుకోవడం కంటే, మీ ముందున్న build ను పరిశీలించండి:

ollama --version
ollama serve --help

ollama serve --help ఆ build వాస్తవంగా చదివే environment variables ను జాబితా చేస్తుంది. వాటిలో OLLAMA_KEEP_ALIVE కూడా ఉంది. అన్ని releases లోనూ రెండు నియమాలు స్థిరంగా ఉన్నాయి. వాటి ఆధారంగా configuration రూపొందించవచ్చు. Request లో ఇచ్చిన విలువ server default కంటే ప్రాధాన్యంగా ఉంటుంది. ఏ configuration file ఏమి ఉండాలని చెబుతున్నా, ఏది load అయిందో చెప్పేది ollama ps మాత్రమే.

Editor లేదా agent మీ server ను నియంత్రిస్తే, server ను నిందించే ముందు ఆ client ఏమి పంపుతుందో పరిశీలించండి. మీ స్వంత Ollama server కు coding agent ను సూచించడం అనే విభాగంలో ఆ request settings ఎక్కడ ఉంటాయో వివరించబడింది.

FAQ

Ollama నా model ను 5 నిమిషాల తర్వాత ఎందుకు unload చేస్తుంది?

ఐదు నిమిషాలు default keep_alive. Request పూర్తయినప్పుడు Ollama ప్రారంభించే idle timer ఇదే. ఇది ముగిసినప్పుడు server weights ను memory నుంచి తొలగిస్తుంది. అందువల్ల తదుపరి request సమయంలో అవి disk నుంచి మళ్లీ load అవుతాయి. మీరు అనుభవించే pause దీనివల్లే వస్తుంది. ఒక request కోసం దీన్ని పెంచాలంటే JSON bodyలో "keep_alive": "30m" పంపండి. మొత్తం server కోసం OLLAMA_KEEP_ALIVE environment variable ఉపయోగించండి.

Ollama model ను memoryలో శాశ్వతంగా ఎలా ఉంచాలి?

Negative value ఉపయోగించండి: requestలో "keep_alive": -1 లేదా server కోసం OLLAMA_KEEP_ALIVE=-1. అప్పుడు ollama ps లో UNTIL columnలో Forever కనిపిస్తుంది. దీనివల్ల idle timer మాత్రమే తొలగిపోతుంది. మరే మార్పు జరగదు. మరో modelను request చేసినప్పుడు memory సరిపోకపోతే, స్థలం కల్పించడానికి scheduler ఈ modelను unload చేస్తుంది.

OLLAMA_KEEP_ALIVE ఎందుకు పనిచేయడం లేదు?

మీరు దాన్ని ఎక్కడ set చేశారో పరిశీలించండి. systemctl show ollama --property=Environment అమలు చేయండి. ఆ outputలో variable కనిపించకపోతే server దాన్ని ఎప్పుడూ చూడలేదు. మీ shellలో export చేసిన variable systemd serviceకు చేరదు. sudo systemctl edit ollama.service ఉపయోగించి దాన్ని set చేయండి. తరువాత sudo systemctl daemon-reload మరియు sudo systemctl restart ollama అమలు చేయండి. మరో కారణం ఏమిటంటే, client requestలో తన స్వంత keep_alive పంపి ఉండవచ్చు. ఇది server defaultను override చేస్తుంది.

Ollamaను restart చేయకుండా memoryని ఎలా విడుదల చేయాలి?

ollama stop qwen3:8b ఆ ఒక్క modelను వెంటనే unload చేస్తుంది. Server మరియు ఇప్పటికే loaded అయిన ఇతర models నడుస్తూనే ఉంటాయి. API ద్వారా prompt లేకుండా, "keep_alive": 0తో request పంపండి. Response "done_reason": "unload"తో తిరిగి వస్తుంది. ollama ps ఉపయోగించి నిర్ధారించండి. అందులో ఆ model ఇకపై కనిపించకూడదు.