VPS वर Ollama की llama.cpp: CPU साठी योग्य पर्याय
llama.cpp inference engine आणि Ollama त्यावरील manager व API layer आहे. CPU-only VPS वर quantisation मुळे RAM कशी बदलते, कोणता पर्याय कधी निवडावा आणि दोन्ही कधी अपुरे पडतात ते पाहा.
Ollama विरुद्ध llama.cpp: तुम्हाला कोणता स्तर चालवायचा आहे?
Ollama आणि llama.cpp हे प्रश्नात सूचित केल्याप्रमाणे एकमेकांचे प्रतिस्पर्धी नाहीत. llama.cpp हे inference engine आहे: ते model file लोड करते आणि prompt चे tokens मध्ये रूपांतर करते. Ollama हे model manager, background daemon आणि त्या engine वर चालणारे HTTP API आहे. Ollama च्या README मध्ये अजूनही llama.cpp ला त्याचा inference backend म्हणून नमूद केले आहे (27 October 2026 रोजी तपासले). त्यामुळे खरा प्रश्न कोणते अधिक वेगवान आहे हा नसून, तुमच्या VPS वर कोणता स्तर चालवायचा आहे हा आहे.
नावाने models fetch करणारी आणि सतत देखरेखीशिवाय कार्यरत राहणारी service हवी असल्यास Ollama चालवा. VPS ची क्षमता कमी असेल आणि नेमकी model file, नेमका context size तसेच नेमकी thread count निवडायची असेल, तर llama.cpp थेट चालवा. लहान VPS वर यापैकी प्रत्येक setting साठी उपलब्ध नसलेली memory वापरली जाते.
प्रत्येक प्रकल्प नेमका काय आहे
llama.cpp हा ggml library वर आधारित transformer inference ची C आणि C++ अंमलबजावणी आहे. तो GGUF files वाचतो. GGUF (GGML universal file format) हा single-file container आहे. त्यात model चालवण्यासाठी engine ला आवश्यक असलेले weights, tokeniser आणि metadata असतात. हा प्रकल्प वेगवेगळ्या कामांसाठी स्वतंत्र binaries उपलब्ध करून देतो. llama-server हा HTTP server आहे, llama-cli हा interactive prompt आहे आणि llama-bench throughput मोजतो. आता हा प्रकल्प semantic-versioned releases (MAJOR.MINOR.PATCH) प्रकाशित करतो. 15 October 2026 रोजी प्रकाशित झालेली v0.7.0 ही 27 October 2026 रोजीची latest release होती. Build-numbered nightly tags यासोबतच प्रकाशित होत राहतात, दिवसाला अनेक tags येतात आणि 27 October 2026 रोजीचा नवीनतम tag b11913 होता.
Ollama हा Go program आहे. ollama serve ने सुरू केलेला background daemon models load करतो आणि HTTP requests ची उत्तरे देतो. Command line client त्या daemon शी संवाद साधतो. या दोन्हींच्या मागे ollama.com वरील registry आहे. त्यात आधीपासून package केलेले models असतात. Ollama semantic versions वापरतो. v0.32.5 27 July 2026 रोजी प्रकाशित झाले आणि v0.40.12 27 October 2026 रोजी 00:07 UTC वाजता release झाले. ollama pull prompt template आणि default parameters च्या संचासह GGUF fetch करतो आणि Linux वर ते /usr/share/ollama/.ollama/models अंतर्गत साठवतो. या files root disk वर साठवल्या जातात आणि प्रत्येकाचा आकार अनेक gigabytes असतो. त्यामुळे 25 GB root volume असलेल्या VPS वर तिसऱ्या download मुळे disk भरू नये, यासाठी pull नंतर काय साठवले जाते आणि model directory दुसरीकडे कशी हलवायची हे आधी जाणून घेणे उपयुक्त ठरते.
ही packaging मधीलच संपूर्ण भिन्नता आहे. Ollama तुमच्यासाठी quantisation, template आणि context length ठरवतो आणि लक्षात ठेवण्यासाठी एकच name देतो. llama.cpp हीच निवड flags म्हणून उपलब्ध करून देतो आणि तुम्ही unset ठेवलेल्या settings साठी automatic defaults वापरतो.
अक्ष 1: मॉडेल आणि quantisation नियंत्रण
Quantisation मध्ये मूळ मॉडेलमधील 16 किंवा 32 bits पेक्षा कमी bits मध्ये weights साठवले जातात. सामान्य GGUF builds मध्ये प्रत्येक weight साठी सरासरी सुमारे 4, 5 किंवा 8 bits वापरले जातात. संपूर्ण file मध्ये precision एकसमान नसते. llama.cpp च्या quantiser source नुसार (27 October 2026 रोजी पाहिलेले), Q4_K_M build मध्ये बहुतेक tensors 4-bit ठेवले जातात. मात्र output layer तसेच सुमारे निम्म्या layers मधील attention value आणि feed-forward down tensors यांना त्याऐवजी 6-bit Q6_K दिले जाते. norms सारखे छोटे tensors अजिबात quantise केले जात नाहीत. त्यामुळे 8 billion parameters असलेले मॉडेल सामान्य VPS च्या RAM मध्ये बसते. Pattern माहीत असल्यास GGUF naming समजणे सोपे आहे: Q4_K_M म्हणजे 4-bit K-quant, medium size. मोठी संख्या अधिक precision ठेवते आणि अधिक memory वापरते.
या तक्त्यामागील डेटा
[
{
"label": "Q2_K",
"file_size_gib": 2.96
},
{
"label": "Q3_K_M",
"file_size_gib": 3.74
},
{
"label": "Q4_K_M",
"file_size_gib": 4.58
},
{
"label": "Q5_K_M",
"file_size_gib": 5.34
},
{
"label": "Q6_K",
"file_size_gib": 6.14
},
{
"label": "Q8_0",
"file_size_gib": 7.95
}
]ही bartowski/Meta-Llama-3.1-8B-Instruct-GGUF repository मधील प्रकाशित file sizes आहेत. त्या 2 August 2026 रोजी पाहिल्या असून bytes मधून GiB मध्ये रूपांतरित केल्या आहेत. एका मॉडेलच्या 6 builds आहेत. त्यांपैकी सर्वात लहान build 2.96 GiB आहे, तर सर्वात मोठी build 7.95 GiB आहे. सामान्य default, Q4_K_M, 4.58 GiB आहे. 4 GiB VPS वर मॉडेल load होईल की नाही हे एकाच निवडीवर ठरते. मात्र या निर्णयात size हा फक्त अर्धा भाग आहे. परवडणारी row वापरण्यास योग्य असेलच असे नाही. तसेच Q4, Q8 आणि fp16 मुळे answer quality वर प्रत्यक्षात काय परिणाम होतो हेच अतिरिक्त gigabytes मुळे तुम्हाला जाणवेल असा फायदा मिळतो का ते सांगते.
llama.cpp मध्ये तुम्ही file चे नाव देता, त्यामुळे ती row तुम्ही स्वतः निवडता.
llama-server -m ~/models/Meta-Llama-3.1-8B-Instruct-Q4_K_M.gguf \
-c 4096 -t 4 --host 127.0.0.1 --port 8080-c म्हणजे tokens मधील context size, -t म्हणजे thread count आणि -ngl मुळे किती layers GPU वर हलवायचे ते ठरते (केवळ CPU असलेल्या box वर 0). Unset settings साठी defaults वापरले जातात. Device memory मध्ये बसण्यासाठी unset arguments समायोजित करण्यासाठी --fit default ने enabled असते.
Ollama मध्ये तुम्ही pull करत असलेल्या tag सोबत quantisation येते. Disk वर प्रत्यक्षात काय उपलब्ध आहे ते ollama ls दाखवते. Registry मध्ये हवी असलेली build उपलब्ध नसल्यास GGUF स्वतः import करा. एक Modelfile लिहा:
FROM ./Meta-Llama-3.1-8B-Instruct-Q4_K_M.gguf
PARAMETER num_ctx 4096त्यानंतर ते build करा आणि result तपासा:
ollama create llama31-q4 -f ./Modelfile
ollama lsContext length ही वापरकर्त्यांच्या लक्षात येणारी महत्त्वाची setting आहे. उपलब्ध VRAM नुसार Ollama आपले default निवडते. GPU नसलेला box सर्वात लहान bucket मध्ये येतो: 4096 tokens. त्याला 20,000 tokens असलेले document पाठवल्यास मॉडेलला ते दिसण्यापूर्वीच अतिरिक्त tokens काढून टाकले जातात. त्यामुळे मॉडेलने file अर्धीच वाचलेली असूनही answer आत्मविश्वासाने चुकीचा येतो. Daemon वर OLLAMA_CONTEXT_LENGTH किंवा Modelfile मध्ये PARAMETER num_ctx वापरून ही मर्यादा वाढवा. फक्त एका job ला मोठी window आवश्यक असल्यास num_ctx हे server-wide न ठेवता प्रत्येक request साठी सेट करता येते. त्यामुळे daemon कडून चालवल्या जाणाऱ्या इतर कामांसाठी अतिरिक्त cache ठेवावा लागत नाही. llama.cpp च्या default वरही विश्वास ठेवण्यासारखे नाही. -c स्पष्टपणे सेट करा आणि काय सेट केले आहे ते माहीत ठेवा.
तुम्हाला सहसा दाखवले जात नाही असे memory गणित
Model file ही एकूण memory cost नसते. KV cache (key/value cache) मध्ये context मधील प्रत्येक token साठी प्रत्येक layer ची एक entry ठेवली जाते. Conversation वाढत गेल्यावर हा cache वाढत जातो.
Llama 3.1 8B साठी हे गणित पाहू. या model मध्ये 32 layers, 8 key/value heads आणि 128 head dimension आहे. f16 मध्ये प्रत्येक token साठी key आणि value प्रत्येकी 2 bytes साठवले जातात. त्यामुळे 2 x 8 x 128 x 2 = 4096 bytes प्रति layer होतात. 32 layers साठी हे 128 KiB प्रति token होते. 4096 token context साठी 512 MiB memory लागते, तर 32,768 token context साठी 4 GiB लागतात.
म्हणून 4k context असलेल्या Q4_K_M 8B model साठी weights साठी अंदाजे 4.58 GiB, cache साठी सुमारे 0.5 GiB आणि runtime साठी अतिरिक्त memory लागते. हे 4 GiB RAM मध्ये बसत नाही. 8 GiB RAM मध्ये ते चालते आणि कामासाठी काही memory शिल्लक राहते. त्याच 8 GiB मशीनवर context 32k केल्यास cache एकटाच उपलब्ध शिल्लक memory वापरतो. Model load असताना free -h वापरून हे प्रत्यक्ष पाहा. मोजमाप न केलेल्या अंदाजावर विश्वास ठेवू नका. 8B पेक्षा बऱ्याच मोठ्या model साठी sizing करत असल्यास, CPU-only VPS वरील 27B model साठी केलेले हेच गणित 8 ते 64 GB मधील प्रत्येक tier मध्ये प्रत्यक्ष किती memory उपलब्ध राहते ते दाखवते.
Ollama मुळे हा परिणाम आणखी वाढतो. OLLAMA_NUM_PARALLEL चे default मूल्य 1 असते. Model ला लागणारी memory या संख्येच्या आणि context length च्या गुणोत्तरानुसार वाढते. दोन्ही एकाच वेळी वाढवल्यास daemon अपेक्षेपेक्षा कित्येक पट अधिक RAM मागतो. हेच गणित एकाच वेळी वापरता येणाऱ्या users ची कमाल संख्या ठरवते, कारण प्रत्येक concurrent request ला KV cache मधील स्वतंत्र भाग हवा असतो. म्हणूनच एका व्यक्तीसाठी व्यवस्थित चालणारा server पाच users वर अडखळतो.
Axis 2: ऑपरेट करावा लागणारा daemon
Ollama install script systemd unit लिहितो, ollama system user तयार करतो आणि service enable करतो. यापैकी काहीही स्वतः लिहावे लागत नाही. Configuration systemd द्वारे केली जाते:
sudo systemctl edit ollama[Service]
Environment="OLLAMA_CONTEXT_LENGTH=8192"
Environment="OLLAMA_KEEP_ALIVE=30m"sudo systemctl daemon-reload
sudo systemctl restart ollama
journalctl -e -u ollamaOLLAMA_KEEP_ALIVE हे CPU VPS वर इतर कोणत्याही ठिकाणापेक्षा अधिक महत्त्वाचे आहे. Models default स्वरूपात 5 मिनिटे memory मध्ये ठेवले जातात आणि त्यानंतर unload केले जातात. पुढील request चे उत्तर देण्यापूर्वी संपूर्ण file पुन्हा load करावी लागते. Kernel कडे file चा page cache अजूनही असल्यास हे जलद होते. परंतु ती file तेथे ठेवण्यासाठी spare RAM आवश्यक असते. इतर कामामुळे ती page cache मधून बाहेर गेल्यावर file पुन्हा disk वरून load केली जाते. त्यामुळे slow storage वर 4.58 GiB reload मुळे दोन सेकंदांचे उत्तर तीस सेकंदांचे होते. दीर्घ keep-alive मुळे latency टाळता येते, पण RAM कायमस्वरूपी वापरली जाते. दोन्हींची वास्तविक किंमत आहे. ज्याचा त्रास कमी असेल तो पर्याय निवडा. Model memory मध्ये कायम ठेवायचा असल्यास, idle periods आणि reboots नंतरही तो memory मध्ये ठेवण्यासाठी keep_alive सेट करणे यासाठी काहीच ओळी पुरेशा असतात. त्यामुळे प्रत्येक वेळी system restart झाल्यावर model manually warm करण्याची गरज राहत नाही.
llama.cpp daemon किंवा service user देत नाही. त्यामुळे दोन्ही स्वतः सेट करावे लागतात. तुम्ही build केलेल्या llama.cpp directory मधून binary आणि त्याच्या libraries /usr/local मध्ये install करा, llama user तयार करा आणि model ची एक copy त्याला द्या:
sudo cmake --install build
sudo ldconfig
sudo useradd --system --no-create-home --shell /usr/sbin/nologin llama
sudo install -d -o llama -g llama /srv/models
sudo install -o llama -g llama -m 644 ~/models/Meta-Llama-3.1-8B-Instruct-Q4_K_M.gguf /srv/models/model-Q4_K_M.ggufBuild करण्याऐवजी release archive वापरल्यास, ExecStart ला त्यातील llama-server कडे निर्देशित करा. Archive मध्ये libraries binary च्या शेजारी ठेवलेल्या असतात. त्यानंतर unit /etc/systemd/system/llama-server.service म्हणून लिहा:
[Unit]
Description=llama.cpp server
After=network-online.target
[Service]
ExecStart=/usr/local/bin/llama-server -m /srv/models/model-Q4_K_M.gguf -c 4096 -t 4 --host 127.0.0.1 --port 8080
Restart=always
RestartSec=3
User=llama
[Install]
WantedBy=multi-user.targetsudo systemctl enable --now llama-server वापरून ते enable करा. त्यानंतर process च्या संपूर्ण lifetime मध्ये model memory मध्ये ठेवला जातो. Default स्वरूपात idle असताना model unload होत नाही. मात्र --sleep-idle-seconds जोडल्यास service थांबविल्याशिवाय automatic unloading आणि reloading सुरू होते. Unit files लिहिणे नवीन असल्यास, हीच पद्धत VPS वर systemd अंतर्गत स्वतःच्या services चालवण्यासाठी वापरली जाते.
अक्ष 3: तुमचे अॅप ज्या API शी संवाद साधेल
हा अक्ष आता बराच अरुंद झाला आहे. दोन्ही प्रकल्प आता OpenAI chat format मध्ये संवाद साधतात. त्यामुळे base URL बदलल्यानंतर बहुतेक client libraries दोन्हींपैकी कोणत्याही प्रकल्पासोबत कार्य करतात.
Ollama 127.0.0.1:11434 वर requests स्वीकारतो. त्याचा OpenAI-compatible route http://localhost:11434/v1/chat/completions आहे आणि त्यासोबत native API /api/chat वर उपलब्ध ठेवतो. Anthropic-compatible route चेही दस्तऐवजीकरण केलेले आहे. यापैकी कोणताही route model ला स्वतःहून माहिती शोधू देत नाही. त्यामुळे तुमच्या अॅपला model च्या training data पेक्षा नवीन उत्तरे आवश्यक असल्यास, Ollama च्या API, Open WebUI किंवा छोट्या tool loop द्वारे web search जोडण्याचे नियोजन करा.
curl -X POST http://localhost:11434/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{"model": "llama31-q4", "messages": [{"role": "user", "content": "Say this is a test"}]}'वरील flags सह सुरू केल्यावर llama-server 127.0.0.1:8080 वर ऐकते. स्वतंत्रपणे चालवल्यास ते आता default म्हणून port 9931 वापरते (27 October 2026 रोजी तपासले). त्यामुळे तुमचे अॅप 8080 अपेक्षित करत असल्यास command line मध्ये --port ठेवा. ते /v1/chat/completions, /v1/completions आणि /v1/embeddings, तसेच स्वतःचे /completion endpoint आणि built-in web UI उपलब्ध करून देते. Ollama मध्ये नसलेले operational routes देखील ते देते: readiness probe साठी /health, loaded model च्या settings साठी /props, प्रत्येक request slot काय करत आहे हे पाहण्यासाठी /slots, आणि --metrics जोडल्यानंतर Prometheus format मधील /metrics. /metrics endpoint default म्हणून बंद असते. या सेवेचे monitoring करण्याची योजना असल्यास हा फरक निर्णायक ठरू शकतो.
तुमच्यासाठी कोणताही server authentication आपोआप सुरू करत नाही. योग्य कारणांसाठी दोन्ही servers default म्हणून loopback वर bind होतात. SSH tunnel द्वारे किंवा reverse proxy च्या मागून त्यांच्यापर्यंत पोहोचा. 11434 किंवा 8080 इंटरनेटवर कधीही उघडे ठेवू नका.
CPU-only VPS प्रत्यक्षात काय करू शकतो
CPU-only VPS वर छोटी models धीम्या गतीने चालतात. हा प्रामाणिक निष्कर्ष आहे. त्याची मर्यादा नेमकी कुठे आहे हे समजून घेणे अधिक उपयुक्त ठरते. त्याभोवती कोणतीही रचना करण्यापूर्वी मोजमाप करा:
llama-bench -m ~/models/Meta-Llama-3.1-8B-Instruct-Q4_K_M.gguf -p 512 -n 128pp हा स्तंभ prompt processing speed दाखवतो आणि tg हा स्तंभ token generation speed दाखवतो. दोन्ही मोजमापे tokens per second मध्ये आहेत. Shared vCPU plan वर Q4_K_M मधील 8B model साठी tg ची गती साधारणपणे कमी एक-अंकी मूल्यांमध्ये असते. Prompt processing हा अधिक त्रासदायक भाग आहे: पहिला output token दिसण्यापूर्वी संपूर्ण prompt process केला जातो. त्यामुळे मोठा system prompt प्रत्येक request साठी प्रतीक्षा वाढवतो. Reply length हा तुम्ही प्रत्यक्ष नियंत्रित करू शकणारा खर्चाचा भाग आहे. तीन tokens per second या गतीवर 600 tokens चे लांबलचक उत्तर देणाऱ्या model मुळे VPS 200 seconds, म्हणजे generation साठीच तीन minutes पेक्षा जास्त काळ व्यस्त राहतो. त्यामुळे num_predict ने output ची मर्यादा ठरवणे हे एखादे लांबट उत्तर timeout होण्यापासून रोखण्याचा सर्वात स्वस्त मार्ग आहे.
CPU वर वापरण्यास योग्य: classification, extraction, short summaries किंवा routing करणारे 1B ते 4B model. Replies काही seconds मध्ये मिळतात आणि memory सामान्य plan मध्ये बसते. त्या आकारासाठी range ऐवजी प्रत्यक्ष उदाहरण पाहायचे असल्यास, VPS वर Nemotron 3.5 Lightning download करून त्याचे मोजमाप exact tag, प्रत्यक्ष लागणारी RAM आणि GPU शिवाय मिळणारी speed दाखवते. CPU वर वापरण्यास अयोग्य: वाचण्याच्या गतीने interactive chat, coding assistants, long-document work किंवा सलग अनेक calls करणारा agent loop. प्रत्येक call ला चार seconds लागत असल्यास बारा calls च्या loop ला काहीही output देण्यापूर्वी एक minute लागतो. Coding assistant वापरण्याचा उद्देश असल्यास, स्वतः host केलेल्या model कडे agent निर्देशित करणे लहान local model कोणती कामे प्रत्यक्षात चांगली करतो आणि कोणती कामे hosted API वरच ठेवावी लागतात हे स्पष्ट करते.
संख्या योग्य ठरत नसतील, तर दोन पर्याय आहेत. समस्या concurrency ची असेल, म्हणजे अनेक users एकाच वेळी एका model कडे requests पाठवत असतील, तर engine ची निवड बदलते. concurrent serving साठी Ollama आणि vLLM ची तुलना हा भाग स्पष्ट करते. समस्या raw speed ची असेल, तर उत्तर आहे GPU जोडलेला VPS, जिथे -ngl ला प्रत्यक्ष महत्त्व येऊ लागते. यापैकी कोणताही पर्याय निवडण्यापूर्वी hardware साठी baseline मिळवा. Disk आणि memory bandwidth load time वर CPU इतकाच परिणाम करतात. पुन्हा करता येणारा VPS benchmark करण्यासाठी एक तास देणे उपयुक्त ठरते.
llama.cpp स्थापित करा आणि build निश्चित करा
दोन्ही प्रकल्पांच्या आवृत्त्या दर आठवड्याला बदलतात. त्यामुळे तुम्ही deploy केलेली आवृत्ती नोंदवून ठेवा. Upstream one-liner सध्याचा build स्थापित करते:
curl -LsSf https://llama.app/install.sh | sh
llama serve -hf ggml-org/Qwen3.5-0.8B-GGUFविशिष्ट build निश्चित करण्यासाठी releases page वरील prebuilt tarball वापरा. प्रकल्प आता semantic-versioned releases देखील प्रकाशित करतो: 27 October 2026 रोजी v0.7.0 ही नवीनतम आवृत्ती होती आणि तिच्या release page वर binaries साठी nightly b11669 कडे निर्देश होता. 28 October 2026 रोजी v0.8.0 आली आणि तिच्या release page वर binaries साठी nightly b11960 कडे निर्देश होता. खालील commands मध्ये 2 August 2026 रोजीचा सध्याचा tag b10224 वापरला आहे; तुम्ही तपासलेला tag त्याऐवजी द्या:
curl -LO https://github.com/ggml-org/llama.cpp/releases/download/b10224/llama-b10224-bin-ubuntu-x64.tar.gz
tar xf llama-b10224-bin-ubuntu-x64.tar.gz
find . -type f -name 'llama-server'किंवा तोच tag source मधून build करा:
sudo apt update && sudo apt install -y build-essential cmake git libssl-dev
git clone https://github.com/ggml-org/llama.cpp
cd llama.cpp
git checkout b10224
cmake -B build
cmake --build build --config Release -j $(nproc)HTTPS features साठी libssl-dev ही दस्तऐवजीकृत dependency आहे. Compile पूर्ण होण्यासाठी काही मिनिटे लागतात आणि सर्वात लहान plans मध्ये उपलब्ध असलेल्या RAM पेक्षा जास्त RAM आवश्यक असते. त्यामुळे मोठ्या box वर build करा आणि लहान box मध्ये RAM अपुरी पडल्यास binaries कॉपी करा.
Ollama ची ठरावीक आवृत्ती pin करून install करा
curl -fsSL https://ollama.com/install.sh | OLLAMA_VERSION=0.32.5 sh
ollama -vही script OLLAMA_VERSION वाचते. त्यामुळे आज सकाळी release झालेली कोणतीही आवृत्ती घेण्याऐवजी तपासलेली release वापरता येते. v0.32.5 ही 27 July 2026 रोजी release झाली. Script थेट shell मध्ये pipe करायची नसेल, तर manual पद्धतही उपलब्ध आहे:
sudo rm -rf /usr/lib/ollama
curl -fsSL https://ollama.com/download/ollama-linux-amd64.tar.zst | sudo tar x -C /usr
ollama -vManual पद्धतीत systemd unit किंवा service user तयार होत नाही. त्यामुळे ते स्वतः तयार करावे लागतात. VPS वर Ollama सेट करण्याचा संपूर्ण मार्गदर्शक या लेखात service setup ची प्रक्रिया क्रमाने दिली आहे.
अपयशाच्या स्थिती आणि दिसणारे संदेश
Ollama मॉडेल लोड करण्यास नकार देतो. जुन्या Ollama releases मध्ये लोड करण्यापूर्वी आकार तपासला जात असे आणि ollama run खालील स्वरूपाची ओळ परत करत असे:
Error: model requires more system memory (5.6 GiB) than is available (3.2 GiB)सध्याच्या Ollama source मध्ये हा संदेश आता नाही (27 October 2026 रोजी तपासले). Ollama आता loading ची जबाबदारी llama-server कडे सोपवतो. त्यामुळे क्षमतेत न बसणारे मॉडेल runner failure म्हणून दिसते. त्यातील errors साधारणपणे पुढीलप्रमाणे सुरू होतात:
llama-server reported out-of-memory during startup
llama-server process has terminatedदोन्ही परिस्थितींमध्ये उपाय एकच आहे. quantisation table मधील एक ओळ खाली जा, context length कमी करा किंवा लहान मॉडेल निवडा.
llama.cpp अपयशी होत नाही; ते अत्यंत संथ होते. llama.cpp डीफॉल्टनुसार GGUF ला memory-map करते. त्यामुळे RAM पेक्षा मोठी file तरीही सुरू होते. त्यानंतर kernel प्रत्येक token साठी disk मधून weights वारंवार page in आणि page out करते. disk 100 percent वापरात राहतो आणि generation ला प्रत्येक token साठी काही seconds लागतात. memory mapping बंद करण्यासाठी --load-mode none द्या. या option ने --no-mmap ची जागा घेतली आहे. pinned b10224 build मध्ये --no-mmap deprecated म्हणून documented आहे आणि सध्याच्या builds मध्ये तो आता दिसत नाही (29 October 2026 रोजी तपासले). kernel ला हस्तक्षेप करावा लागल्यास dmesg त्याचे कारण दाखवतो:
Out of memory: Killed process 1234 (llama-server)मॉडेल file अजिबात लोड होत नाही. तुमच्या engine पेक्षा नवीन model family साठी तयार केलेले GGUF वापरल्यास, engine ला माहीत नसलेल्या architecture चे नाव देणारा error येतो. <arch> हे file च्या metadata मध्ये साठवलेले नाव आहे:
llama_model_load: error loading model: unknown model architecture: '<arch>'यासाठी वेगळी file नव्हे, तर engine upgrade करणे आवश्यक आहे. pinning ची हीच किंमत आहे. म्हणून build number लिहून ठेवणे महत्त्वाचे आहे. तुम्ही कोणत्या version वरून upgrade करत आहात हे माहीत असणे आवश्यक आहे.
API स्थानिक पातळीवर उत्तर देते, परंतु तुमच्या app मधून उत्तर देत नाही. Ollama 127.0.0.1:11434 वर bind होते. त्यामुळे दुसऱ्या host कडून connection refused मिळतो. पोर्ट firewall किंवा private network च्या मागे असेल तेव्हाच systemctl edit ollama द्वारे OLLAMA_HOST=0.0.0.0:11434 सेट करा, कारण API समोर authentication उपलब्ध नाही.
थांबल्यानंतरचे पहिले उत्तर अत्यंत संथ असते. 5 minute idle unload झालेले असते आणि मॉडेल पुन्हा लोड केले जात असते. page cache ने ते जतन केले नसेल, तर मॉडेल disk मधून लोड होते. request च्या अगोदर चालवलेले ollama ps काहीही loaded नसल्याचे दाखवते, त्यामुळे याची पुष्टी होते. OLLAMA_KEEP_ALIVE चे मूल्य वाढवा.
मग तुम्ही कोणते चालवावे?
मॉडेल्सचे व्यवस्थापन आपोआप व्हावे आणि कोणतेही अतिरिक्त काम न करता OpenAI-सुसंगत endpoint मिळावा असे वाटत असल्यास Ollama चालवा. पहिल्या deployment साठी आणि मॉडेलची निवड वारंवार बदलत राहणार असल्यास हा योग्य default आहे.
मेमरी इतकी मर्यादित असेल की quantisation row स्वतः निवडणे आवश्यक असेल, monitoring साठी /health, /slots आणि /metrics हवे असतील किंवा Ollama उपलब्ध करून देत नसलेला flag आवश्यक असेल, तर llama.cpp थेट चालवा. मॉडेल कसेबसे बसत असलेल्या VPS वर हा अधिक व्यवहार्य पर्याय आहे, कारण मॉडेल बसण्यासाठी आवश्यक असलेल्या settings Ollama तुमच्यावतीने निवडते.
दोन्ही चालवणे सामान्य आहे. प्रयोगांसाठी Ollama वापरा आणि production मध्ये ठेवलेल्या, बदलायचे नसलेल्या एका मॉडेलसाठी llama.cpp वापरा.
FAQ
Ollama हे llama.cpp भोवतीचे फक्त wrapper आहे का?
जवळपास, पण हा wrapper प्रत्यक्ष काम करतो. 27 October 2026 रोजी तपासलेल्या Ollama च्या README मध्ये llama.cpp हे inference backend म्हणून नमूद केले आहे. त्यावर Ollama model registry, chat messages चे prompt मध्ये रूपांतर करणारे prompt template, sampling parameters चे default संच, idle unloading असलेला daemon आणि HTTP API जोडते. समान settings वर प्रति सेकंद tokens ची तुलना केली, तर तुम्ही तोच engine स्वतःशीच तुलना करत असता. प्रत्यक्षात तुमची निवड management layer मधील असते.
केवळ CPU असलेल्या VPS वर कोणते अधिक वेगवान आहे?
दोन्ही समान engine वापरतात. त्यामुळे model file, quantisation, context size आणि thread count समान असल्यास त्यांचे परिणाम जवळपास सारखे असतात. लोकांनी नोंदवलेले फरक सहसा engine मुळे नसतात. ते बहुतेक वेळा वेगवेगळ्या default settings मुळे, विशेषतः context length आणि thread count मुळे असतात. प्रकाशित आकडेवारीवर विश्वास ठेवण्यापूर्वी स्वतःच्या सर्व्हरवर llama-bench -m <file> -p 512 -n 128 वापरून मोजा आणि tg स्तंभाची तुलना करा.
मी माझी स्वतःची GGUF file Ollama सोबत वापरू शकतो का?
होय. ही file सर्व्हरवर ठेवा. पहिली ओळ FROM ./your-model.gguf असलेली Modelfile लिहा. त्यानंतर num_ctx सारख्या आवश्यक PARAMETER ओळी जोडा. मग ollama create your-name -f ./Modelfile चालवा. ollama ls मध्ये registry मधून pull केलेल्या इतर files सोबत ती file दिसेल. Registry मध्ये उपलब्ध नसलेली quantisation वापरण्याची ही पद्धत आहे.
8B model साठी किती RAM आवश्यक आहे?
File size, KV cache आणि runtime यांचा एकत्रित विचार करा. Llama 3.1 8B ची Q4_K_M build disk वर सुमारे 4.58 GiB असते. 4096 token context मुळे आणखी अंदाजे 512 MiB cache लागते. त्यामुळे 8 GiB RAM पुरेशी असते, पण 4 GiB पुरेशी नाही. Cache चे प्रमाण context नुसार वाढते. त्याच model साठी 32,768 token context वापरल्यास केवळ cache साठी सुमारे 4 GiB लागतात. Ollama वापरताना ही आवश्यकता OLLAMA_NUM_PARALLEL नुसारही वाढते.