Ollama మోడల్‌ను మెమరీలో శాశ్వతంగా ఉంచడం ఎలా?

Ollama కొన్ని నిమిషాల తర్వాత మోడల్‌ను ఎందుకు అన్‌లోడ్ చేస్తుంది?

చివరి అభ్యర్థన (request) అందిన తర్వాత ఐదు నిమిషాల పాటు Ollama మోడల్‌ను మెమరీలో ఉంచుతుంది, ఆపై దానిని తొలగిస్తుంది. తదుపరి అభ్యర్థన వచ్చినప్పుడు, అది మళ్ళీ డిస్క్ నుండి వెయిట్స్‌ను (weights) చదివి RAM లేదా VRAM లోకి మ్యాప్ చేయాల్సి ఉంటుంది, కాబట్టి మొదటి టోకెన్ వచ్చేలోపు కొంత సమయం పడుతుంది. అందుకే చాట్ UI లేదా కోడింగ్ ఏజెంట్ మొదట వేగంగా పనిచేసి, కొంతసేపు నిశ్శబ్దంగా ఉండి, ఆపై తదుపరి సందేశం వద్ద నెమ్మదిగా అనిపిస్తుంది. ఇందులో ఏదీ పాడవ్వలేదు. ఐడిల్ టైమర్ (idle timer) ముగిసింది.

ఈ టైమర్‌ను keep_alive అని పిలుస్తారు. ఇది ప్రతి మోడల్‌కు విడిగా ఉంటుంది మరియు ప్రతి అభ్యర్థన పూర్తయినప్పుడల్లా ఇది మళ్ళీ మొదటి నుండి మొదలవుతుంది. ప్రస్తుతం ఒక అభ్యర్థనకు సమాధానమిస్తున్న మోడల్ ఎప్పటికీ అన్‌లోడ్ అవ్వదు, ఎందుకంటే ఎటువంటి క్రియాశీల అభ్యర్థన లేని మోడల్‌ను మాత్రమే సర్వర్ తొలగిస్తుంది. ఆగస్టు 2026 నాటికి, డిఫాల్ట్ సమయం ఐదు నిమిషాలు మరియు ఇది ఈ సర్వర్ లోడ్ చేసే ప్రతి మోడల్‌కు వర్తిస్తుంది.

keep_alive ను సెట్ చేయడానికి రెండు మార్గాలు ఉన్నాయి: వ్యక్తిగత అభ్యర్థనపై, లేదా సర్వర్ డిఫాల్ట్‌గా. సర్వర్ డిఫాల్ట్ సెట్టింగ్ రీస్టార్ట్ తర్వాత కూడా అలాగే ఉండాలంటే systemd drop-in ఫైల్‌ను ఉపయోగించాలి. Ollama ఇప్పటికే ఒక సర్వీస్‌గా నడుస్తోందని ఈ గైడ్ భావిస్తోంది. ఒకవేళ అలా లేకపోతే, ముందుగా VPSలో Ollamaను ఇన్‌స్టాల్ చేయడం తో ప్రారంభించి, ఆపై తిరిగి రండి.

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

ollama ps

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

అవుట్‌పుట్ ఖాళీగా ఉంటే ఏ మోడల్ లోడ్ కాలేదని అర్థం, కాబట్టి తదుపరి అభ్యర్థన కోసం పూర్తి లోడింగ్ సమయం పడుతుంది. PROCESSOR కమాండ్ వెయిట్స్ (weights) ఎక్కడ ఉన్నాయో తెలియజేస్తుంది. 100% GPU మరియు 100% CPU స్పష్టమైన సందర్భాలు. 25%/75% CPU/GPU వంటి విభజన ఉంటే, మోడల్ VRAMలో సరిపోలేదని అర్థం, కాబట్టి దానిలో కొంత భాగం ప్రాసెసర్‌పై నడుస్తుంది మరియు జనరేషన్ నెమ్మదిగా ఉంటుంది.

UNTIL అనేది కౌంట్‌డౌన్, ఇది 4 minutes from now వంటి సాపేక్ష సమయాన్ని చూపిస్తుంది. మోడల్‌ను నెగటివ్ keep_alive తో లోడ్ చేసినప్పుడు ఇది Forever అని చూపిస్తుంది. సర్వర్ అన్‌లోడ్ అవుతున్న తక్కువ సమయంలో ఇది Stopping... అని చూపిస్తుంది.

రిలీజ్‌ల మధ్య కాలమ్ సెట్ మారింది, కాబట్టి స్క్రిప్ట్‌లలో ఫీల్డ్‌లను లెక్కించే బదులు హెడర్‌ను చదవండి. ఏదైనా ఆటోమేటెడ్ పనుల కోసం, APIని అడగండి:

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

ప్రతి ఎంట్రీలో expires_at, 2026-08-09T14:38:31.83753Z వంటి సంపూర్ణ టైమ్‌స్టాంప్ మరియు ఆ మోడల్‌లో GPU మెమరీలో ఉన్న భాగాన్ని సూచించే size_vram ఉంటాయి. size_vram విలువ 0 ఉంటే, ఆ మోడల్ CPUపై నడుస్తోందని అర్థం.

Reload వల్ల కలిగే అసలు వ్యయం

దీని గురించి ఊహించవద్దు. Ollama ప్రతి ప్రతిస్పందనలో లోడ్ సమయాన్ని load_duration గా, నానోసెకన్లలో తెలియజేస్తుంది.

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}'

మొదటి కాల్ మోడల్‌ను లోడ్ చేస్తుంది, కాబట్టి దాని load_duration ఎక్కువగా ఉంటుంది. దీన్ని సెకన్లలో చదవడానికి 1000000000 తో భాగించండి. మోడల్ మెమరీలో ఉన్నప్పుడు రెండవ కాల్ రన్ అవుతుంది మరియు చాలా తక్కువ సంఖ్యను చూపుతుంది. ఆ రెండు గణాంకాల మధ్య ఉన్న వ్యత్యాసమే టైమర్ ముగిసిన తర్వాత ప్రతి వినియోగదారుడు చెల్లించే మూల్యం, మరియు keep_alive ని మార్చడానికి ఇదే ప్రధాన కారణం. ఆ విరామానికి ఇరువైపులా ఉన్న జనరేషన్ వేగం కోసం, మీ సొంత సిస్టమ్‌లో టోకెన్ల వేగాన్ని ఎలా కొలవాలి చూడండి.

ఒక అభ్యర్థనపై Ollama మోడల్‌ను మెమరీలో ఉంచడం

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

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

నాలుగు రకాల విలువలు ఆమోదించబడతాయి:

• సమయ వ్యవధి స్ట్రింగ్: "30m", "24h", "90s"
• సాధారణ సంఖ్య, సెకన్లుగా పరిగణించబడుతుంది: 3600
• ప్రతికూల విలువ, -1 లేదా "-1m", అంటే idle timeout ఏదీ ఉండదు
• 0, అంటే ఈ అభ్యర్థన పూర్తయిన వెంటనే అన్‌లోడ్ చేయబడుతుంది

అభ్యర్థనపై ఉన్న విలువ సర్వర్ డిఫాల్ట్ విలువను అధిగమిస్తుంది. ఇది వినడానికి సాధారణంగా అనిపించినా, చాలా ముఖ్యమైనది: క్లయింట్ తన స్వంత keep_alive ను పంపినప్పుడు, సర్వర్‌లో మీరు కాన్ఫిగర్ చేసిన దేనికైనా అదే ప్రాధాన్యత ఉంటుంది.

మీరు ఏమీ జనరేట్ చేయకుండానే మోడల్‌ను లోడ్ చేయవచ్చు. కేవలం మోడల్ పేరును మాత్రమే పంపండి. సర్వర్ దానిని లోడ్ చేసి, "done": true తో ఖాళీ ప్రతిస్పందనను తిరిగి ఇస్తుంది.

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

రీబూట్ తర్వాత లేదా కొత్త మోడల్‌ను పుల్ చేసిన తర్వాత, మొదటి వినియోగదారు అభ్యర్థన లోడ్ సమయాన్ని వేచి చూడకుండా ఉండటానికి ఇది అమలు చేయాల్సిన కమాండ్. CLI కూడా ఒక ఫ్లాగ్‌తో ఇదే పనిని చేస్తుంది:

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

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

సర్వర్ ప్రారంభమైనప్పుడు OLLAMA_KEEP_ALIVE ని చదువుతుంది మరియు దాని స్వంత విలువ లేని ప్రతి మోడల్ కోసం దీనిని ఉపయోగిస్తుంది. ఇది అభ్యర్థన ఫీల్డ్ మాదిరిగానే పనిచేస్తుంది, కాబట్టి 30m, 3600 మరియు -1 అన్నీ పనిచేస్తాయి.

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

systemd drop-in ఉపయోగించి రీస్టార్ట్ తర్వాత కూడా సేవను కొనసాగేలా చేయడం

sudo systemctl edit ollama.service

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

[Service]
Environment="OLLAMA_KEEP_ALIVE=30m"

సేవ్ చేయడం ద్వారా /etc/systemd/system/ollama.service.d/override.conf వ్రాయబడుతుంది. ఇది షిప్ చేయబడిన యూనిట్‌ను ఎడిట్ చేయడానికి బదులుగా ఒక drop-in, కాబట్టి ollama.service ని భర్తీ చేసే Ollama ప్యాకేజీ అప్‌గ్రేడ్ మీ సెట్టింగ్‌ను అలాగే ఉంచుతుంది. మీకు drop-ins మరియు unit files కొత్త అయితే, systemd service and timer guide వీటి పనితీరును వివరిస్తుంది.

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

చివరి కమాండ్ సేవ నిజంగా రన్ అయ్యే environment ను ప్రింట్ చేస్తుంది. ఆ లైన్‌లో OLLAMA_KEEP_ALIVE=30m లేకపోతే, drop-in అమలు కాలేదని అర్థం. దీనికి కారణం దాదాపు ఎప్పుడూ [Service] హెడర్ లేకపోవడం లేదా మార్కర్ కింద లైన్లు టైప్ చేయడం అయి ఉంటుంది. రీస్టార్ట్ చేసినప్పుడు లోడ్ అయిన అన్ని మోడల్స్ తొలగించబడతాయి, కాబట్టి తదుపరి అభ్యర్థన cold load అవుతుంది. పైన పేర్కొన్న preload కాల్‌తో దాన్ని warm up చేయండి.

మోడల్‌ను మెమరీలో ఉంచడం వల్ల కలిగే వ్యయం

ollama psలోని SIZE కాలమ్ అనేది కేవలం అభ్యర్థన (request) సమయంలోనే కాకుండా, మొత్తం ఐడిల్ విండో (idle window) అంతా ఆక్రమించి ఉండే మెమరీని సూచిస్తుంది. 4-bit క్వాంటైజేషన్ కలిగిన 8B మోడల్ సుమారు 5 నుండి 6 GB మెమరీని తీసుకుంటుంది. 27B మోడల్ విషయం వేరు, కాబట్టి CPU-మాత్రమే ఉన్న VPSలో దీనిని రన్ చేయడానికి అవసరమైన మెమరీ గణనలను మీరు మోడల్‌ను శాశ్వతంగా మెమరీలో ఉంచాలని నిర్ణయించుకునే ముందే లెక్కించడం మంచిది. keep_aliveను -1కి సెట్ చేశారంటే, ఆ సర్వర్‌లో మిగిలిన అన్నింటికంటే మోడల్‌కే ప్రాధాన్యత ఇస్తున్నారని అర్థం. తక్కువ సామర్థ్యం ఉన్న VPSలో, ఇది మీ డేటాబేస్, వెబ్ యాప్ మరియు బిల్డ్ జాబ్‌లకు నేరుగా పోటీనిస్తుంది.

అంచనాలను నమ్మే బదులు వాస్తవ గణాంకాలను గమనించండి. మోడల్ లోడ్ అయినప్పుడు ఒకసారి, ఆ తర్వాత ollama stop అమలు చేసిన తర్వాత మరొకసారి ఈ కింది కమాండ్‌ను రన్ చేయండి:

free -h

available కాలమ్ అనేది కొత్త ప్రాసెస్‌కు కెర్నల్ కేటాయించగల మెమరీని సూచిస్తుంది. NVIDIA GPU ఉన్న సర్వర్‌లో, nvidia-smi ఇదే విషయాన్ని VRAM పరంగా చూపిస్తుంది. సర్వర్‌లో మెమరీ అయిపోతే, మెమరీని తిరిగి పొందడానికి కెర్నల్ ఏదో ఒక ప్రాసెస్‌ను నిలిపివేస్తుంది (kill చేస్తుంది):

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

ollama అని ఉన్న లైన్ కనిపిస్తే, మోడల్ సర్వర్ ఆ చర్యకు గురైందని అర్థం. మీ డేటాబేస్ పేరు కనిపిస్తే, మోడల్ గెలిచి, మీకు ముఖ్యమైన సర్వీస్ ఆగిపోయిందని అర్థం. ఈ రెండు ఫలితాలు ఒకే నిర్ణయం వల్ల వస్తాయి: తగినంత ఖాళీ లేని సర్వర్‌లో ఎక్కువ సేపు కీప్-అలైవ్ (keep-alive) విండోను ఉంచడం.

ఇక్కడ రెండు ఖర్చులను గమనించడం సులభం. ఎక్కువ కాంటెక్స్ట్ లెంగ్త్ (context length) ఉంటే, అది పెద్ద KV cache (కీ వాల్యూ క్యాష్, అంటే మోడల్ జనరేట్ చేసేటప్పుడు ప్రతి టోకెన్ కోసం ఉంచే అటెన్షన్ స్టేట్)ను రిజర్వ్ చేస్తుంది, ఈ క్యాష్ కూడా రెసిడెంట్ సైజులో భాగమే. OLLAMA_NUM_PARALLEL విలువ 1 కంటే ఎక్కువ ఉంటే, ప్రతి పారలల్ స్లాట్‌కు ఆ క్యాష్ రిజర్వ్ అవుతుంది. మీరు ఒకే మోడల్ ద్వారా పలువురికి సేవలు అందించాలని ప్లాన్ చేస్తుంటే, కేవలం వెయిట్స్ (weights) కోసం మాత్రమే కాకుండా, స్లాట్‌ల కోసం కూడా మెమరీని లెక్కించండి.

ఒక సరైన డిఫాల్ట్: తగినంత ఖాళీ ఉన్న సర్వర్‌లో ఒక మోడల్ -1 మెమరీని ఉపయోగించవచ్చు. షేర్డ్ సర్వర్ అయితే, మీ అభ్యర్థనల మధ్య విరామాలను కవర్ చేసేలా 30m వంటి విండోను ఉపయోగించడం మంచిది, తద్వారా మీరు పని ఆపినప్పుడు మెమరీ తిరిగి అందుబాటులోకి వస్తుంది.

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

ollama stop qwen3:8b

ఇది ఎటువంటి అవుట్‌పుట్ ఇవ్వకుండా తిరిగి వస్తుంది, మరియు మోడల్ ollama ps నుండి తొలగించబడుతుంది. లోడ్ కాని పేరును ఇస్తే couldn't find model "qwen3:8b" to stop వస్తుంది. API ఫారమ్ అనేది ప్రాంప్ట్ లేని అభ్యర్థన మరియు keep_alive ను 0 కి సెట్ చేస్తుంది:

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

ఈ ప్రత్యుత్తరం "done_reason": "unload" ను కలిగి ఉంటుంది. సర్వీస్‌ను రీస్టార్ట్ చేయడానికి బదులుగా దీనిని ఉపయోగించండి. systemctl restart ollama కూడా మెమరీని ఖాళీ చేస్తుంది, కానీ ఇది లోడ్ అయిన మిగిలిన అన్ని మోడళ్లను తొలగిస్తుంది మరియు నడుస్తున్న ఏ అభ్యర్థననైనా నిలిపివేస్తుంది.

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

OLLAMA_MAX_LOADED_MODELS ఒకే సమయంలో ఎన్ని మోడళ్లు లోడ్ అయి ఉండాలో పరిమితిని విధిస్తుంది. ఆగస్టు 2026 నాటికి, డిఫాల్ట్ పరిమితి ప్రతి GPUకి మూడు, లేదా CPU-మాత్రమే ఉన్న సర్వర్‌కు మూడుగా ఉంది. ఈ పరిమితి మోడళ్ల సంఖ్యను లెక్కిస్తుంది, కానీ వాస్తవ పరిమితి మెమరీపై ఆధారపడి ఉంటుంది. కాబట్టి, మూడు మోడళ్ల పరిమితికి చేరుకోకముందే, రెండవ పెద్ద మోడల్‌కు మెమరీ సరిపోక తిరస్కరించబడవచ్చు.

కొత్త మోడల్ కోసం అభ్యర్థన వచ్చినప్పుడు తగినంత మెమరీ లేకపోతే, షెడ్యూలర్ అందుబాటులో ఉన్న మోడళ్లలో ఒకదానిని తొలగించి స్థలాన్ని ఖాళీ చేస్తుంది. ఎటువంటి యాక్టివ్ అభ్యర్థనలు లేని మోడల్‌కు ఇది ప్రాధాన్యత ఇస్తుంది. టైమర్ ముగియని మోడల్‌ను కూడా ఇది తొలగించగలదు, ఇందులో -1 తో లోడ్ చేసిన మోడళ్లు కూడా ఉంటాయి. కాబట్టి, keep_alive విలువ నెగటివ్‌గా ఉంటే, idle timeout ఉండదని అర్థం. ఇది ఇతర మోడల్ అభ్యర్థనల నుండి వెయిట్స్‌ను (weights) రక్షించదు.

ఈ నిర్ణయం డీబగ్ స్థాయిలో లాగ్ చేయబడుతుంది. అదే డ్రాప్-ఇన్ ఫైల్‌కు రెండవ Environment="OLLAMA_DEBUG=1" లైన్‌ను జోడించి, రీస్టార్ట్ చేసి, ఇలా గమనించండి:

sudo journalctl -u ollama -f

స్థలాన్ని ఖాళీ చేయడానికి ఒక రన్నర్‌ను అన్‌లోడ్ చేసినట్లు వచ్చే లైన్, దానికి కారణమైన అభ్యర్థన పక్కనే కనిపిస్తుంది. ఈ రెండు మోడళ్లు ఈ మెషీన్‌పై కలిసి సరిపోవని ఇది మీకు తెలియజేస్తుంది. దీనికి పరిష్కారం ఏమిటంటే, ఈ బాక్స్‌పై తక్కువ మోడళ్లను ఉంచడం, లేదా వేగంగా స్పందించాల్సిన మోడల్ కోసం ఎక్కువ సమయం కేటాయించడం మరియు అరుదుగా ఉపయోగించే మోడల్ కోసం 0 ను సెట్ చేయడం.

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

Ollama తరచుగా కొత్త వెర్షన్లను విడుదల చేస్తుంది మరియు దాని డిఫాల్ట్ సెట్టింగ్‌లు మారుతుంటాయి. కాబట్టి, సంఖ్యలను గుర్తుంచుకోవడం కంటే, మీ ముందున్న build ను తనిఖీ చేయడం ఉత్తమం:

ollama --version
ollama serve --help

ollama serve --help ఆ build వాస్తవానికి చదివే environment variables జాబితాను చూపుతుంది, అందులో OLLAMA_KEEP_ALIVE కూడా ఉంటుంది. రెండు నియమాలు అన్ని releases లోనూ స్థిరంగా ఉన్నాయి, వాటిపై మీరు ఆధారపడవచ్చు. అభ్యర్థన (request) లోని విలువ సర్వర్ డిఫాల్ట్ విలువ కంటే ప్రాధాన్యత కలిగి ఉంటుంది. అలాగే, కాన్ఫిగరేషన్ ఫైల్‌లో ఏమున్నా సరే, ollama ps లో ఉన్నదే లోడ్ అయిన అసలైన విలువ.

ఒకవేళ ఏదైనా ఎడిటర్ లేదా ఏజెంట్ మీ సర్వర్‌ను నడుపుతుంటే, సర్వర్‌ను నిందించే ముందు ఆ క్లయింట్ ఏమి పంపుతుందో తనిఖీ చేయండి. మీ స్వంత Ollama సర్వర్‌కు కోడింగ్ ఏజెంట్‌ను అనుసంధానించడం అనే విభాగం ఆ అభ్యర్థన సెట్టింగ్‌లు ఎక్కడ ఉంటాయో వివరిస్తుంది.

FAQ

Ollama నా మోడల్‌ను 5 నిమిషాల తర్వాత ఎందుకు అన్‌లోడ్ చేస్తుంది?

5 నిమిషాలు అనేది డిఫాల్ట్ keep_alive, ఇది ఒక అభ్యర్థన పూర్తయిన తర్వాత Ollama ప్రారంభించే idle timer. ఇది ముగిసినప్పుడు సర్వర్ weights ను తొలగిస్తుంది, కాబట్టి తదుపరి అభ్యర్థన వాటిని డిస్క్ నుండి మళ్లీ లోడ్ చేస్తుంది, ఆ రీలోడ్ వల్లనే మీరు ఆ ఆలస్యాన్ని గమనిస్తారు. ఒక అభ్యర్థన కోసం దీన్ని పెంచాలంటే JSON బాడీలో "keep_alive": "30m" పంపండి, లేదా మొత్తం సర్వర్ కోసం అయితే OLLAMA_KEEP_ALIVE environment variable ఉపయోగించండి.

Ollama మోడల్‌ను మెమరీలో శాశ్వతంగా ఎలా ఉంచాలి?

ఋణాత్మక విలువను (negative value) ఉపయోగించండి: అభ్యర్థనలో "keep_alive": -1, లేదా సర్వర్ కోసం OLLAMA_KEEP_ALIVE=-1. అప్పుడు ollama ps కమాండ్ UNTIL కాలమ్‌లో Forever అని చూపిస్తుంది. ఇది idle timer ను తొలగిస్తుంది, అంతకు మించి ఏమీ చేయదు. ఒకవేళ మరొక మోడల్ అభ్యర్థించబడి, మెమరీ తక్కువగా ఉంటే, షెడ్యూలర్ స్థలం కోసం దీన్ని అన్‌లోడ్ చేస్తుంది.

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

మీరు దీన్ని ఎక్కడ సెట్ చేశారో తనిఖీ చేయండి. systemctl show ollama --property=Environment రన్ చేయండి, ఒకవేళ ఆ వేరియబుల్ అవుట్‌పుట్‌లో లేకపోతే సర్వర్ దాన్ని గుర్తించలేదని అర్థం, ఎందుకంటే మీ షెల్‌లో ఎక్స్‌పోర్ట్ చేసిన వేరియబుల్ systemd సర్వీస్‌కు చేరదు. దీన్ని sudo systemctl edit ollama.service తో సెట్ చేసి, ఆపై sudo systemctl daemon-reload మరియు sudo systemctl restart ollama రన్ చేయండి. మరొక కారణం ఏమిటంటే, క్లయింట్ తన సొంత keep_alive ను అభ్యర్థనలో పంపడం, ఇది సర్వర్ డిఫాల్ట్‌ను ఓవర్‌రైడ్ చేస్తుంది.

Ollama ను రీస్టార్ట్ చేయకుండా మెమరీని ఎలా ఖాళీ చేయాలి?

ollama stop qwen3:8b ఆ నిర్దిష్ట మోడల్‌ను వెంటనే అన్‌లోడ్ చేస్తుంది మరియు సర్వర్‌ను, లోడ్ అయి ఉన్న ఇతర మోడళ్లను అలాగే ఉంచుతుంది. API ద్వారా, ప్రాంప్ట్ లేకుండా "keep_alive": 0 తో ఒక అభ్యర్థన పంపండి, అప్పుడు సమాధానం "done_reason": "unload" తో వస్తుంది. ollama ps తో నిర్ధారించుకోండి, అది ఆ మోడల్‌ను ఇకపై చూపించకూడదు.