Ollama pull మరియు run మధ్య తేడాలు ఏమిటి?

ollama pull మరియు ollama run మధ్య తేడాలు

ollama pull ఒక మోడల్‌ను డౌన్‌లోడ్ చేసి ఆగిపోతుంది. ollama run మోడల్ లేకపోతే మాత్రమే డౌన్‌లోడ్ చేసి, ఆపై దానిని మెమరీలోకి లోడ్ చేసి ఇంటరాక్టివ్ చాట్‌ను ప్రారంభిస్తుంది. డౌన్‌లోడ్ ప్రక్రియ రెండింటికీ ఒకటే మరియు ఫైళ్లు ఒకే చోట నిల్వ చేయబడతాయి. run మాత్రమే ఆ తర్వాత కూడా కొనసాగుతుంది.

ఈ ఒక్క తేడానే ఏ కమాండ్‌ను స్క్రిప్ట్‌లో వాడాలి, దేనిని కీబోర్డ్ ద్వారా వాడాలి అనేది నిర్ణయిస్తుంది.

ollama pull gemma4
ollama run gemma4
ollama run gemma4 "Reply with one word: ready"

మొదటి లైన్ మోడల్‌ను తీసుకువచ్చి (fetch) నిష్క్రమిస్తుంది, కాబట్టి ఇది ప్రొవిజనింగ్ మరియు systemd యూనిట్‌లలో వాడటానికి సురక్షితం. రెండవది చాట్ సెషన్‌ను తెరుస్తుంది; నిష్క్రమించడానికి /bye అని టైప్ చేయండి లేదా Ctrl+D నొక్కండి. మూడవది ఒకే ప్రాంప్ట్‌ను పంపి, సమాధానాన్ని ప్రింట్ చేసి నిష్క్రమిస్తుంది; స్క్రిప్ట్‌కు సెషన్ కంటే సమాధానం మాత్రమే అవసరమైనప్పుడు ఈ పద్ధతిని వాడాలి. ఆ మూడవ పద్ధతిలో కూడా సమాధానం ఎంత పొడవు ఉండాలో మోడల్ నిర్ణయిస్తుంది, కాబట్టి ఒక లైన్ ప్రశ్న మూడు పేరాగ్రాఫ్‌ల సమాధానంగా రావచ్చు. num_predict తో సమాధానాన్ని పరిమితం చేయడం ద్వారా స్క్రిప్ట్ చేసిన run అవుట్‌పుట్‌ను అవసరమైన పరిమాణంలో ఉంచుకోవచ్చు. మోడల్ పేర్లు త్వరగా మారుతుంటాయి, కాబట్టి ఇక్కడ ఉన్న gemma4 ను ఒక ప్లేస్‌హోల్డర్‌గా పరిగణించండి: ఇది ఆగస్టు 2026 నాటికి అధికారిక Ollama డాక్యుమెంటేషన్‌లో ఉన్న ఉదాహరణ, లైబ్రరీలోని ఏ ట్యాగ్ అయినా ఇదే విధంగా పనిచేస్తుంది. ఒకవేళ మీరు ఇప్పటికే రియల్ సర్వర్‌పై పరీక్షించిన మోడల్‌ను వాడాలనుకుంటే, VPS పై Nemotron 3.5 Lightning రన్ చేయడం అనే గైడ్‌లో సరైన ట్యాగ్ మరియు దానికి అవసరమైన మెమరీ వివరాలు ఉంటాయి.

మొదటి ollama run ఎందుకు ఆగిపోయినట్లు కనిపిస్తుంది

కొత్త VPSలో మొదటి run కొన్ని నిమిషాల పాటు ఎటువంటి అవుట్‌పుట్ చూపించకుండా ఉండవచ్చు. ఇందులో ఏదీ పాడవ్వలేదు. మోడల్ డిస్క్‌లోకి వచ్చి మెమరీలోకి లోడ్ అయ్యే వరకు చాట్ ప్రాంప్ట్ కనిపించదు, కాబట్టి మీకు ఏమీ చూపించకముందే run మల్టీ-గిగాబైట్ డౌన్‌లోడ్‌ను పూర్తి చేస్తోంది.

రెండు కారణాల వల్ల ఈ పని బయటకు కనిపించదు. Ollama తన ప్రోగ్రెస్ బార్‌ను టెర్మినల్‌లో మాత్రమే చూపిస్తుంది, కాబట్టి షెల్ స్క్రిప్ట్, క్రోన్ జాబ్, CI స్టెప్ లేదా సాధారణ ssh host ollama run ... లోపల ఉన్న run డౌన్‌లోడ్ అవుతున్నప్పుడు ఏమీ ప్రింట్ చేయదు. ఆ తర్వాత, డేటా డౌన్‌లోడ్ అయినప్పటికీ, మొదటి టోకెన్ రావడానికి ముందు ఫైల్‌ను డిస్క్ నుండి RAM లోకి చదవాలి; చిన్న VPSలలో ఈ రీడింగ్ ప్రక్రియ నెమ్మదిగా ఉంటుంది. ఒకవేళ సర్వర్‌లో మోడల్‌కు సరిపడా మెమరీ లేకపోతే, కెర్నల్ స్వాపింగ్ (swapping) మొదలుపెడుతుంది, దీనివల్ల వేచి ఉండే సమయం మరింత పెరుగుతుంది.

ఏమీ జరగడం లేదని ఊహించే బదులు, రెండవ సెషన్ నుండి దీనిని గమనించండి:

df -h /
watch -n5 df -h /

ఫ్రీ స్పేస్ క్రమంగా తగ్గుతుందంటే డౌన్‌లోడ్ ఇంకా జరుగుతోందని అర్థం. కమాండ్ ఇంకా రన్ అవుతున్నప్పటికీ ఫ్రీ స్పేస్ తగ్గడం ఆగిపోయిందంటే, డౌన్‌లోడ్ పూర్తయి మెమరీలోకి లోడ్ అవ్వడం మొదలైందని అర్థం.

అందుకే ముందే మోడల్‌ను పుల్ (pull) చేసుకోవడం మంచిది. ollama run అని టైప్ చేసే వ్యక్తి డౌన్‌లోడ్ కోసం వేచి చూడాల్సిన అవసరం ఉండకూడదు.

ఎవరైనా అడగకముందే మోడల్‌ను pull చేయండి

వ్యక్తి కాని దేనికైనా ఇదే వర్తిస్తుంది: మీ Ollama endpoint కి పాయింట్ చేసిన coding agent సాధారణంగా మల్టీ-గిగాబైట్ డౌన్‌లోడ్ కోసం వేచి ఉండటం కంటే, మొదటి అభ్యర్థనలోనే విఫలమవుతుంది. కొత్త సర్వర్‌లో, సర్వర్‌ను ఇన్‌స్టాల్ చేసే script తో పాటే దీన్ని కూడా pull చేయండి:

curl -fsSL https://ollama.com/install.sh | sh
ollama pull gemma4

మీరు మొదటిసారి సర్వర్‌ను సిద్ధం చేస్తుంటే, the full Ollama on a VPS install సర్వీస్ గురించి మరియు దాన్ని ఎవరు యాక్సెస్ చేయవచ్చో వివరిస్తుంది. ఆ తర్వాత, మీ terminal సెషన్ ముగిసినా ఆగిపోని విధంగా pull ప్రాసెస్‌ను సెటప్ చేయడం మంచిది, ఎందుకంటే డౌన్‌లోడ్ మధ్యలో ఆగిపోతే మోడల్ స్టోర్ అసంపూర్ణంగా మిగిలిపోతుంది.

దీనిని tmux లోపల రన్ చేయండి, లేదా boot సమయంలో రన్ అయ్యేలా systemd కి one-shot unit గా ఇవ్వండి. /etc/systemd/system/ollama-pull.service ను ఇలా రాయండి:

[Unit]
Description=Pre-pull Ollama models
Wants=ollama.service network-online.target
After=ollama.service network-online.target

[Service]
Type=oneshot
RemainAfterExit=yes
ExecStart=/bin/sh -c 'until ollama list >/dev/null 2>&1; do sleep 2; done'
ExecStart=/bin/sh -c 'ollama pull gemma4'

[Install]
WantedBy=multi-user.target

రెండు కమాండ్‌లు ఉద్దేశపూర్వకంగానే /bin/sh -c ద్వారా రన్ అవుతాయి. కేవలం ExecStart= వాడితే absolute path అవసరం, కానీ ఇన్‌స్టాలర్ ఎప్పుడూ binary ని ఒకే డైరెక్టరీలో ఉంచదు, కాబట్టి మీ సర్వర్‌లో command -v ollama మాత్రమే నమ్మదగిన మార్గం. షెల్ ద్వారా వెళ్లడం వల్ల గైడ్ నుండి కాపీ చేసిన path కి బదులుగా సర్వీస్ PATH ఉపయోగించబడుతుంది. మొదటి ExecStart కూడా ముఖ్యమైనది: After=ollama.service అంటే సర్వర్ unit ప్రారంభమైందని అర్థం, కానీ అది సిద్ధంగా ఉందని కాదు, కాబట్టి pull ప్రారంభమయ్యే ముందు ollama list స్పందించే వరకు ఈ loop వేచి ఉంటుంది.

sudo systemctl daemon-reload
sudo systemctl enable --now ollama-pull.service
journalctl -u ollama-pull.service

Journal లో pull ఎటువంటి లోపం లేకుండా పూర్తయినట్లు చూపాలి, ఆపై ollama list మోడల్‌ను చూపాలి. మారుతున్న tag ను తాజాగా ఉంచడానికి, అదే pull కమాండ్‌ను రన్ చేసే systemd timer లేదా weekly cron entry ని జోడించండి. మారిన tag ను మళ్ళీ pull చేసినప్పుడు కొత్త layers డౌన్‌లోడ్ అవుతాయి మరియు పాత వాటికి ఎటువంటి పాయింటర్లు ఉండవు, సర్వర్ తదుపరిసారి ప్రారంభమైనప్పుడు అవి తొలగించబడతాయి.

పుల్ (pull) ప్రక్రియకు అంతరాయం కలిగితే ఏమి జరుగుతుంది

మోడల్‌లోని ప్రతి లేయర్ దాని కంటెంట్ యొక్క హ్యాష్ (hash) ఆధారంగా నిల్వ చేయబడుతుంది. కాబట్టి, అంతరాయం కలిగిన పుల్ ప్రక్రియ వృథా కాదు: అదే ollama pullని మళ్లీ రన్ చేసినప్పుడు, ఇప్పటికే పూర్తయిన లేయర్‌లను సిస్టమ్ గుర్తించి వాటిని దాటవేస్తుంది, తద్వారా ఆగిపోయిన లేయర్ నుండి డౌన్‌లోడ్ కొనసాగుతుంది.

ఒక చర్య ఆ పురోగతిని నాశనం చేస్తుంది. Ollama సర్వర్ ప్రారంభమైనప్పుడు, ఏ మోడల్ మేనిఫెస్టోలోనూ లేని నిల్వ చేయబడిన లేయర్‌లను అది తొలగిస్తుంది; అసంపూర్తిగా ఆగిపోయిన పుల్ వల్ల మిగిలిన లేయర్ కూడా అటువంటిదే. కాబట్టి, మీరు మళ్లీ ప్రయత్నించే ముందు సర్వీస్‌ను రీస్టార్ట్ చేస్తే, మీరు ఇప్పటికే డౌన్‌లోడ్ చేసిన భాగం తొలగించబడుతుంది. ముందుగా పుల్ ప్రక్రియను మళ్లీ ప్రయత్నించండి, ఆ తర్వాత రీస్టార్ట్ చేయండి. ఒకవేళ అసంపూర్తిగా ఉన్న డౌన్‌లోడ్ రీస్టార్ట్ తర్వాత కూడా ఉండాలంటే, సర్వీస్ ఎన్విరాన్‌మెంట్‌లో OLLAMA_NOPRUNE=1ని సెట్ చేయండి, ఆపై దానిని తిరిగి తొలగించండి. ఎందుకంటే, డిస్క్‌లో అనాథ లేయర్‌లు (orphaned layers) పేరుకుపోకుండా ఉండటానికి ఆ స్టార్టప్ క్లీనప్ ప్రక్రియ అవసరం.

ఒకవేళ పుల్ ప్రక్రియ no space left on deviceతో ఆగిపోతే, మళ్లీ ప్రయత్నించే ముందు ఖాళీ స్థలాన్ని సిద్ధం చేయండి. df డిస్క్ నిండిపోయిందని చూపిస్తూ, మోడల్ డైరెక్టరీపై du చేసినప్పుడు ఆ స్థలం ఎక్కడ ఉందో తెలియకపోతే, ఆ స్థలం వేరే చోట వినియోగించబడిందని అర్థం. ఏదైనా తొలగించే ముందు df మరియు du ఎందుకు భిన్నంగా చూపిస్తాయి అనే అంశాన్ని చదవడం మంచిది.

VPSలో Ollama మోడళ్లను ఎక్కడ నిల్వ చేస్తుంది?

ఏదైనా గైడ్‌లో ఉన్న పాత్‌ను నమ్మే బదులు, మీ సర్వర్‌నే అడిగి తెలుసుకోండి. ప్యాకేజీ ఇన్‌స్టాలేషన్ మరియు కంటైనర్ మధ్య ఈ లొకేషన్ మారుతుంది, అలాగే ఎవరైనా OLLAMA_MODELS సెట్ చేస్తే కూడా ఇది మారుతుంది.

systemctl cat ollama.service
getent passwd ollama
sudo find / -xdev -type d -name blobs 2>/dev/null

systemctl cat యూనిట్ ఫైల్‌ను మరియు దానిలోని ప్రతి డ్రాప్-ఇన్ ఫైల్‌ను ప్రింట్ చేస్తుంది, కాబట్టి మీరు సెట్ చేసిన లేదా మీ ఇమేజ్‌లో ఉన్న OLLAMA_MODELS లైన్ అక్కడ కనిపిస్తుంది. అటువంటి లైన్ లేకపోతే, సర్వీస్ ఏ అకౌంట్ ద్వారా రన్ అవుతుందో ఆ అకౌంట్ హోమ్ డైరెక్టరీలోనే స్టోర్ ఉంటుంది, మరియు getent passwd ఆ హోమ్ డైరెక్టరీని ఆరవ కాలన్-సెపరేటెడ్ ఫీల్డ్‌లో చూపిస్తుంది. find ఫైల్‌సిస్టమ్‌లో blobs డైరెక్టరీ కోసం వెతుకుతుంది, ఇక్కడే లేయర్‌లు వాస్తవానికి రాయబడతాయి. మోడళ్లు ఇప్పటికే వేరే మౌంట్‌లో ఉంటే -xdev ని వదిలేయండి.

ఇప్పుడు కొలవండి, మరియు మీ సర్వర్ చూపే విలువలను చదవండి:

ollama list
df -h /
sudo du -sh /the/directory/you/found
sudo du -h -d1 /the/directory/you/found

ఈ స్టోర్‌లో రెండు భాగాలు ఉంటాయి. manifests ప్రతి మోడల్ ట్యాగ్‌కు ఒక చిన్న ఫైల్‌ను కలిగి ఉంటుంది, ఆ ఫైల్ ఆ ట్యాగ్ ఏ లేయర్లతో నిర్మించబడిందో తెలియజేస్తుంది. blobs లేయర్లను కలిగి ఉంటుంది, ప్రతి లేయర్ దాని కంటెంట్ యొక్క హ్యాష్ పేరుతో ఉంటుంది, మరియు దాదాపు మొత్తం సైజు ఇక్కడే ఉంటుంది. లేయర్‌లు వేర్వేరు ట్యాగ్‌ల మధ్య షేర్ చేయబడతాయి కాబట్టి, ఒకే వెయిట్స్‌తో నిర్మించిన రెండు మోడళ్లు ollama list లో వాటి స్వంత సైజును చూపిస్తాయి, కానీ డిస్క్‌లో మాత్రం ఆ స్థలాన్ని ఒక్కసారి మాత్రమే ఆక్రమిస్తాయి. అందువల్ల, డైరెక్టరీ కోసం du నివేదించే దానికంటే, జాబితా చేయబడిన సైజుల మొత్తం ఎక్కువగా ఉండవచ్చు.

మీరు ఇన్‌స్టాల్ చేసే ఇతర వాటి కంటే మోడల్ ఫైళ్లు చిన్న VPS రూట్ ఫైల్‌సిస్టమ్‌ను వేగంగా నింపేస్తాయి, మరియు వాటి సైజును తగ్గించడానికి ఉన్న అతిపెద్ద మార్గం వెయిట్ ఫార్మాట్. q4, q8 మరియు fp16 మధ్య ఎంపిక చేసుకోవడం ద్వారా ప్రతి మోడల్‌కు గిగాబైట్ల స్థలాన్ని ఆదా చేయవచ్చు.

OLLAMA_MODELS ఉపయోగించి మోడళ్లను డేటా వాల్యూమ్‌కు తరలించడం

ఒకవేళ మీ ప్లాన్‌లో రెండవ డిస్క్ లేదా పెద్ద డేటా వాల్యూమ్ అందుబాటులో ఉంటే, root filesystem నిండకముందే స్టోర్‌ను తరలించండి. ముందుగా సర్వర్‌ను ఆపివేయండి, తద్వారా ఇంకా రాయబడుతున్న ఫైల్‌ను మీరు కాపీ చేయకుండా ఉంటారు.

sudo systemctl stop ollama
sudo mkdir -p /mnt/data/ollama-models
sudo rsync -a /the/directory/you/found/ /mnt/data/ollama-models/
sudo chown -R ollama:ollama /mnt/data/ollama-models
sudo systemctl edit ollama.service

systemctl edit ఒక డ్రాప్-ఇన్ ఫైల్‌ను ఎడిటర్‌లో తెరుస్తుంది, దీనివల్ల ప్యాకేజీ యూనిట్ మారకుండా ఉంటుంది మరియు ప్యాకేజీ అప్‌గ్రేడ్ మీ మార్పులను ఓవర్‌రైట్ చేయదు. ఈ రెండు లైన్లను జోడించండి:

[Service]
Environment="OLLAMA_MODELS=/mnt/data/ollama-models"

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

systemctl show మీ కొత్త పాత్‌ను ప్రింట్ చేయాలి, మరియు ollama list తరలింపుకు ముందు చూపిన మోడళ్లనే చూపాలి. జాబితా ఖాళీగా ఉంటే, సర్వర్ కొత్త డైరెక్టరీని చదవలేకపోతోందని అర్థం. ఈ సర్వీస్ ollama యూజర్‌గా రన్ అవుతుంది, కాబట్టి ఆ యూజర్‌కు గమ్యస్థానంలో రీడ్ మరియు రైట్ అనుమతులు ఉండాలి, ఇది పైన ఉన్న chown లైన్ యొక్క పని. కొత్త పాత్‌ను పేర్కొంటూ వచ్చే అనుమతి లోపాల కోసం journalctl -e -u ollama ని తనిఖీ చేయండి. జాబితా సరిగ్గా ఉన్న తర్వాతే పాత కాపీని తొలగించండి, ఎందుకంటే తరలింపు విఫలమై, పాత సోర్స్ తొలగిస్తే, మీరు మళ్లీ అన్నింటినీ డౌన్‌లోడ్ చేయాల్సి వస్తుంది.

మరొక ఎంపిక అసలు పాత్‌ను అలాగే ఉంచి, డేటా వాల్యూమ్‌ను దానిపై మౌంట్ చేయడం:

echo '/mnt/data/ollama-models /the/directory/you/found none bind 0 0' | sudo tee -a /etc/fstab
sudo mount -a
findmnt /the/directory/you/found
df -h /

findmnt మౌంట్‌ను ప్రింట్ చేస్తుందంటే bind లైవ్‌లో ఉందని అర్థం. డిఫాల్ట్ లొకేషన్ కోసం సిస్టమ్‌లోని ఇతర అంశాలు ఎదురుచూస్తున్నప్పుడు bind mount ఉపయోగపడుతుంది. ఇందులో ఒక చిక్కు ఉంది: మీరు కాపీ చేసిన ఫైళ్లు రూట్ డిస్క్‌పై మౌంట్ పాయింట్ కింద అలాగే ఉంటాయి, మౌంట్ వల్ల అవి దాచబడతాయి, కాబట్టి మీరు వాటిని unmount చేసి తొలగించే వరకు స్థలం ఖాళీ అవ్వదు. తర్వాత లాగిన్ అయ్యే వారికి వివరించడానికి ఈ environment variable సులభమైన పద్ధతి.

కంటైనర్ వాటిని ఎక్కడ ఉంచుతుంది

అధికారిక ఇమేజ్ మోడళ్లను మీరు మౌంట్ చేసిన చోట నిల్వ చేస్తుంది, ఏ ollama వినియోగదారునికి చెందిన హోస్ట్ డైరెక్టరీలోనూ కాదు. డాక్యుమెంట్ చేయబడిన run కమాండ్ ఇది:

docker run -d -v ollama:/root/.ollama -p 11434:11434 --name ollama ollama/ollama

ollama కోలన్‌కు ముందు ఉన్నది ఒక named Docker volume, మరియు /root/.ollama అనేది కంటైనర్ లోపల సర్వర్ వ్రాసే మార్గం. కాబట్టి మునుపటి విభాగంలోని మార్గాలకు వ్యతిరేకంగా du రన్ చేస్తే ఏమీ కనిపించదు, ఎందుకంటే అక్కడ ఏమీ లేదు. అసలు స్థానాన్ని మరియు పరిమాణాన్ని ప్రింట్ చేయండి:

docker volume inspect ollama
docker system df -v
docker exec -it ollama ollama list

docker volume inspect నుండి Mountpoint ఫీల్డ్‌ను చదవండి, ఆపై దానికి వ్యతిరేకంగా sudo du -sh రన్ చేయండి. మోడళ్లను డేటా వాల్యూమ్‌లో ఉంచడానికి, named volume స్థానంలో హోస్ట్ డైరెక్టరీని (-v /mnt/data/ollama:/root/.ollama) ఉంచి, కంటైనర్‌ను మళ్లీ సృష్టించండి. కంటైనర్ root గా వ్రాస్తుంది, కాబట్టి ఆ హోస్ట్ డైరెక్టరీకి root యజమాని అవుతుంది. rootless Podman కింద, IDలు మీ వినియోగదారుని subuid పరిధిలోకి మ్యాప్ చేయబడతాయి, కాబట్టి హోస్ట్ యాజమాన్యం భిన్నంగా కనిపిస్తుంది: rootless Podman కింద Ollamaను రన్ చేయడం ఆ మ్యాపింగ్‌ను వివరిస్తుంది.

క్లీనప్ గురించి ఒక హెచ్చరిక. docker volume prune ఏ కంటైనర్ సూచించని ప్రతి వాల్యూమ్‌ను తొలగిస్తుంది. ollama కంటైనర్‌ను దాని వాల్యూమ్ లేకుండా తొలగించినా లేదా మళ్లీ సృష్టించినా, ఆ తర్వాత prune కమాండ్ మీరు డౌన్‌లోడ్ చేసిన ప్రతి మోడల్‌ను తొలగిస్తుంది, వాటిని మళ్లీ డౌన్‌లోడ్ చేయడం తప్ప వేరే మార్గం ఉండదు. మోడళ్లను హోస్ట్ చేసే బాక్స్‌పై prune రన్ చేసే ముందు VPSలో Docker డిస్క్ వినియోగాన్ని ఎలా prune చేయాలి చదవండి.

ollama rm ఉపయోగించి మోడల్‌ను తొలగించండి, rm తో కాదు

ollama list
ollama rm gemma4
ollama list
df -h /

ollama rm ఆ ట్యాగ్ కోసం ఉన్న మానిఫెస్ట్‌ను తొలగిస్తుంది, ఆపై ఏ మానిఫెస్ట్ ద్వారా కూడా సూచించబడని లేయర్లను తొలగిస్తుంది. ఆ ఫైళ్లు అన్‌లింక్ అవ్వగానే డిస్క్ స్పేస్ తిరిగి వస్తుంది, కాబట్టి df వెంటనే అమల్లోకి వస్తుంది. లేయర్లు షేర్ చేయబడతాయి కాబట్టి, ఒకదానితో ఒకటి సంబంధం ఉన్న రెండు ట్యాగ్‌లలో ఒకదాన్ని తొలగిస్తే, దాని పక్కన ollama list చూపిన పరిమాణం కంటే చాలా తక్కువ స్పేస్ ఖాళీ అవ్వవచ్చు. ఇది సరైన ప్రవర్తనే, తొలగింపు విఫలమైనట్లు కాదు.

ఫైళ్లను మాన్యువల్‌గా తొలగిస్తే ఈ జత దెబ్బతింటుంది. rm తో ఒక బ్లబ్‌ను తొలగిస్తే, మానిఫెస్ట్‌లో అది ఇంకా కనిపిస్తుంది, కాబట్టి ollama list ఆ మోడల్‌ను చూపిస్తూనే ఉంటుంది, కానీ ఆ లేయర్ లేకపోవడం వల్ల దాన్ని ఉపయోగించడానికి ప్రయత్నించినప్పుడు విఫలమవుతుంది. మానిఫెస్ట్‌ను మాన్యువల్‌గా తొలగిస్తే, దాని లేయర్లు డిస్క్‌లోనే ఉండిపోతాయి, వాటిని ఏ Ollama కమాండ్ గుర్తించదు, తద్వారా అనవసరంగా స్పేస్ ఆక్రమిస్తాయి. మీరు ఇప్పటికే అలా చేసి ఉంటే, ఆ ట్యాగ్‌పై ollama rm రన్ చేయడం ద్వారా మిగిలిపోయిన ఎంట్రీని తొలగించవచ్చు, మరియు సర్వర్‌ను రీస్టార్ట్ చేయడం ద్వారా దేనితోనూ సంబంధం లేని లేయర్లు తొలగిపోతాయి.

చివరిగా ఒక ముఖ్యమైన తేడా, ఎందుకంటే ఈ రెండింటినీ తరచుగా గందరగోళానికి గురిచేస్తుంటారు. ollama rm డిస్క్‌కు సంబంధించినది. ollama stop gemma4 మెమరీ నుండి మోడల్‌ను అన్‌లోడ్ చేస్తుంది, ఇది డిస్క్ స్పేస్‌ను ఏమాత్రం ఖాళీ చేయదు. డౌన్‌లోడ్ పూర్తయిన తర్వాత ఒక మోడల్ RAM లో ఎంతసేపు ఉండాలనేది వేరే సెట్టింగ్, దీని గురించి ప్రతి అభ్యర్థనకు మళ్లీ లోడ్ చేసే బదులు మోడల్‌ను లోడ్ చేసి ఉంచడం లో వివరించబడింది.

FAQ

ollama pull మరియు ollama run మధ్య తేడా ఏమిటి?

ollama pull ఒక మోడల్‌ను డిస్క్‌లోకి డౌన్‌లోడ్ చేసి నిష్క్రమిస్తుంది. ollama run మోడల్ ఇప్పటికే డిస్క్‌లో ఉందో లేదో తనిఖీ చేస్తుంది, లేకపోతే డౌన్‌లోడ్ చేస్తుంది, మెమరీలోకి లోడ్ చేస్తుంది, ఆపై ఇంటరాక్టివ్ చాట్ సెషన్‌ను ప్రారంభిస్తుంది. రెండూ ఒకే డైరెక్టరీలో ఒకే ఫైళ్లను రాస్తాయి. ప్రొవిజనింగ్ మరియు స్క్రిప్ట్‌లలో pull ని ఉపయోగించండి, మరియు వినియోగదారు కీబోర్డ్ వద్ద ఉన్నప్పుడు run ని ఉపయోగించండి. ollama run <model> "your prompt" ఒక ప్రాంప్ట్‌ను పంపి నిష్క్రమిస్తుంది, ఇది run యొక్క స్క్రిప్ట్ చేయదగిన రూపం.

నా మొదటి ollama run ఎందుకు హ్యాంగ్ అయినట్లు కనిపిస్తుంది?

అది డౌన్‌లోడ్ అవుతోంది. మోడల్ డిస్క్‌లోకి వచ్చి మెమరీలోకి లోడ్ అయ్యే వరకు చాట్ ప్రాంప్ట్ కనిపించదు, మరియు ఒక మోడల్ పరిమాణం కొన్ని గిగాబైట్లు ఉంటుంది. అవుట్‌పుట్ టెర్మినల్ అయినప్పుడు మాత్రమే Ollama ప్రోగ్రెస్ బార్‌ను చూపిస్తుంది, కాబట్టి స్క్రిప్ట్, cron job లేదా ssh host ollama run ... లోని run అది పని చేస్తున్నప్పుడు ఏమీ చూపదు. రెండవ సెషన్‌ను తెరిచి watch -n5 df -h / ని రన్ చేయండి: ఖాళీ స్థలం క్రమంగా తగ్గడం అంటే డౌన్‌లోడ్ జరుగుతోందని అర్థం. మోడల్‌ను ముందుగానే pull చేస్తే ఈ నిరీక్షణ ఉండదు.

Ollama తన మోడళ్లను ఎక్కడ నిల్వ చేస్తుంది?

ఈ స్థానం ఇన్‌స్టాలేషన్‌పై ఆధారపడి ఉంటుంది, కాబట్టి ఊహించడం కంటే ప్రింట్ చేయడం మంచిది. యూనిట్ లేదా డ్రాప్-ఇన్‌లో OLLAMA_MODELS సెట్ చేయబడిందో లేదో చూడటానికి systemctl cat ollama.service ని రన్ చేయండి. ఒకవేళ అది సెట్ చేయకపోతే, సర్వీస్ ఏ ఖాతాలో రన్ అవుతుందో ఆ ఖాతా యొక్క హోమ్ డైరెక్టరీలో నిల్వ ఉంటుంది, దీన్ని getent passwd ollama ప్రింట్ చేస్తుంది. sudo find / -xdev -type d -name blobs 2>/dev/null లేయర్ డైరెక్టరీని నేరుగా గుర్తిస్తుంది. కంటైనర్ ఇమేజ్ కోసం, నిల్వ మౌంట్ చేయబడిన వాల్యూమ్ లోపల ఉంటుంది, మరియు docker volume inspect ollama దాని హోస్ట్ Mountpoint ని ప్రింట్ చేస్తుంది.

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

సర్వీస్‌ను ఆపివేయండి, rsync -a తో స్టోర్‌ను కొత్త స్థానానికి కాపీ చేయండి, sudo chown -R ollama:ollama <directory> తో ఆ డైరెక్టరీని సర్వీస్ ఖాతాకు కేటాయించండి, ఆపై sudo systemctl edit ollama.service ని రన్ చేసి [Service] లైన్ కింద Environment="OLLAMA_MODELS=<directory>" ని జోడించండి. sudo systemctl daemon-reload తో రీలోడ్ చేసి రీస్టార్ట్ చేయండి. systemctl show ollama --property=Environment మరియు ollama list తో నిర్ధారించుకోండి. జాబితా ఖాళీగా ఉంటే, ollama యూజర్‌కు కొత్త డైరెక్టరీని చదివే అనుమతి లేదని అర్థం; journalctl -e -u ollama ఆ పాత్‌ను చూపిస్తుంది.

మోడల్ ఫైళ్లను తొలగిస్తే స్థలం ఖాళీ అవుతుందా?

ఫైళ్లను మాన్యువల్‌గా తొలగిస్తే బైట్లు ఖాళీ అవుతాయి కానీ స్టోర్ అస్థిరంగా మారుతుంది. ఒక బ్లబ్‌ను తొలగిస్తే, ఆ మోడల్ ఇంకా మేనిఫెస్టోలో కనిపిస్తుంది, కాబట్టి అది ollama list లో కనిపిస్తూనే ఉంటుంది మరియు ఉపయోగించినప్పుడు విఫలమవుతుంది. ఒక మేనిఫెస్టోను తొలగిస్తే, దాని లేయర్లు డిస్క్‌లోనే ఉండిపోతాయి, వాటిని సూచించేది ఏదీ ఉండదు. ollama rm <model> ని ఉపయోగించండి, ఇది మేనిఫెస్టోను తొలగించి, ఆపై ఏ ఇతర మోడల్‌కు అవసరం లేని లేయర్లను తొలగిస్తుంది. ఒకవేళ ఫైళ్లను ఇప్పటికే మాన్యువల్‌గా తొలగించినట్లయితే, ఎంట్రీని క్లియర్ చేయడానికి ట్యాగ్‌పై ollama rm ని రన్ చేయండి, ఆపై సర్వర్‌ను రీస్టార్ట్ చేయండి, ఇది ఏ మేనిఫెస్టో సూచించని లేయర్లను తొలగిస్తుంది.