SSD Nodes Learn Hosting plans →
تعلیمی Matt Connorتحریر: Matt Connor · اپ ڈیٹ شدہ 2026-11-04

VPS پر Ollama یا llama.cpp: CPU کے لیے کیا بہتر ہے؟

llama.cpp اصل inference engine ہے، جبکہ Ollama اس کے اوپر layer ہے۔ CPU-only VPS پر RAM، quantisation اور context size کے حساب سے درست انتخاب کریں۔

Ollama بمقابلہ llama.cpp: آپ کون سی layer چلانا چاہتے ہیں؟

Ollama اور llama.cpp اس مفہوم میں حریف نہیں ہیں جو سوال میں ظاہر کیا گیا ہے۔ llama.cpp inference engine ہے: یہ model file لوڈ کرتا ہے اور prompt کو tokens میں تبدیل کرتا ہے۔ Ollama ایک model manager، background daemon اور HTTP API ہے جو اسی engine کے اوپر کام کرتا ہے۔ Ollama کی README اب بھی llama.cpp کو اپنا inference backend بتاتی ہے (27 October 2026 کو جانچا گیا)۔ اس لیے اصل سوال یہ نہیں کہ کون سا زیادہ تیز ہے، بلکہ یہ ہے کہ آپ اپنے VPS پر کون سی layer چلانا چاہتے ہیں۔

اگر آپ ایسی service چاہتے ہیں جو نام کے ذریعے models حاصل کرے اور مسلسل نگرانی کے بغیر کام کرتی رہے تو Ollama چلائیں۔ اگر سرور محدود وسائل رکھتا ہو اور آپ کو exact model file، exact context size اور exact thread count منتخب کرنا ہو تو llama.cpp براہِ راست چلائیں، کیونکہ چھوٹے VPS پر ان میں سے ہر setting ایسی memory استعمال کرتی ہے جو آپ کے پاس دستیاب نہیں۔

ہر project دراصل کیا ہے

llama.cpp، ggml library پر مبنی transformer inference کی C اور C++ implementation ہے۔ یہ GGUF files پڑھتا ہے۔ GGUF (GGML universal file format) ایک single-file container ہے جس میں model چلانے کے لیے درکار weights، tokeniser اور metadata شامل ہوتے ہیں۔ یہ project مختلف کاموں کے لیے الگ binaries فراہم کرتا ہے۔ llama-server ایک HTTP server ہے، llama-cli interactive prompt ہے، اور llama-bench throughput ناپتا ہے۔ project اب semantic-versioned releases (MAJOR.MINOR.PATCH) جاری کرتا ہے، اور 15 October 2026 کو published v0.7.0، 27 October 2026 کو latest release تھا۔ Build-numbered nightly tags بھی ان کے ساتھ جاری ہوتے رہتے ہیں، دن میں کئی بار، اور 27 October 2026 کو تازہ ترین tag b11913 تھا۔

Ollama ایک Go program ہے۔ ollama serve سے شروع ہونے والا background daemon models load کرتا ہے اور HTTP requests کا جواب دیتا ہے، جبکہ command line client اس daemon سے رابطہ کرتا ہے۔ دونوں کے پیچھے ollama.com پر ایک registry ہے جس میں پہلے سے pack کیے گئے models موجود ہیں۔ Ollama semantic versions استعمال کرتا ہے۔ v0.32.5، 27 July 2026 کو جاری ہوا، جبکہ v0.40.12، 27 October 2026 کو 00:07 UTC پر release ہوا۔ ollama pull ایک GGUF کے ساتھ prompt template اور default parameters کا ایک set fetch کرتا ہے، پھر Linux پر اسے /usr/share/ollama/.ollama/models کے تحت store کرتا ہے۔ یہ files root disk پر موجود ہوتی ہیں اور ہر file کئی gigabytes تک ہو سکتی ہے، اس لیے 25 GB root volume والے VPS پر تیسرے download سے پہلے یہ جاننا مفید ہے کہ pull کے بعد کیا باقی رہتا ہے اور model directory کو دوسری جگہ کیسے منتقل کیا جائے۔

یہ packaging ہی بنیادی فرق ہے۔ Ollama آپ کے لیے quantisation، template اور context length طے کرتا ہے اور یاد رکھنے کے لیے ایک ہی نام فراہم کرتا ہے۔ llama.cpp ان choices کو flags کے طور پر ظاہر کرتا ہے اور ان settings کے لیے automatic defaults استعمال کرتا ہے جنہیں آپ unset چھوڑ دیتے ہیں۔

محور 1: model اور quantisation کا کنٹرول

Quantisation اصل model کے 16 یا 32 bits کے مقابلے میں weights کو کم bits میں محفوظ کرتی ہے۔ عام 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، attention value tensors اور تقریباً نصف layers کے feed-forward down tensors کو 6-bit Q6_K میں رکھتا ہے۔ norms جیسے چھوٹے tensors کو بالکل quantise نہیں کیا جاتا۔ اسی وجہ سے 8 billion parameters والا model عام VPS کی RAM میں fit ہو جاتا ہے۔ GGUF naming کا pattern سمجھ آنے کے بعد اسے پڑھنا آسان ہے: Q4_K_M کا مطلب 4-bit K-quant، medium size ہے۔ زیادہ بڑا number زیادہ precision برقرار رکھتا ہے اور زیادہ memory استعمال کرتا ہے۔

چارٹMeta-Llama-3.1-8B-Instruct GGUF file size by quantisation (GiB)
اس چارٹ کے پیچھے کا ڈیٹا
[
  {
    "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 میں Hugging Face پر شائع شدہ file sizes ہیں۔ انہیں 2 August 2026 کو پڑھا گیا اور bytes سے GiB میں تبدیل کیا گیا۔ ایک model کے 6 builds ہیں، اور سب سے چھوٹا build 2.96 GiB کا ہے، جبکہ سب سے بڑا 7.95 GiB کا ہے۔ عام default، Q4_K_M، 4.58 GiB کا ہے۔ 4 GiB VPS پر یہی ایک انتخاب طے کرتا ہے کہ model 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-only machine پر اس کی قدر 0 ہوتی ہے۔ Unset settings کے defaults ہوتے ہیں، اور --fit default طور پر enabled ہے تاکہ unset arguments کو device memory کے مطابق adjust کیا جا سکے۔

Ollama میں quantisation اس tag کے ساتھ شامل ہوتی ہے جسے آپ pull کرتے ہیں، اور ollama ls دکھاتا ہے کہ disk پر حقیقتاً کیا موجود ہے۔ جب registry میں مطلوبہ build موجود نہ ہو تو GGUF خود import کریں۔ ایک Modelfile لکھیں:

FROM ./Meta-Llama-3.1-8B-Instruct-Q4_K_M.gguf
PARAMETER num_ctx 4096

پھر اسے build کریں اور نتیجہ check کریں:

ollama create llama31-q4 -f ./Modelfile
ollama ls

Context length وہ setting ہے جس میں لوگ اکثر غلطی کرتے ہیں۔ Ollama دستیاب VRAM سے اپنا default منتخب کرتا ہے، اور GPU کے بغیر machine سب سے چھوٹے bucket میں آتی ہے: 4096 tokens۔ اگر اسے 20,000 tokens کی document بھیجی جائے تو اضافی tokens model کے دیکھنے سے پہلے ہی drop ہو جاتے ہیں۔ نتیجتاً model ایسی file کے بارے میں پُراعتماد مگر غلط answer دے سکتا ہے جسے اس نے صرف آدھا پڑھا ہو۔ اسے daemon پر OLLAMA_CONTEXT_LENGTH کے ذریعے، یا Modelfile میں PARAMETER num_ctx کے ذریعے بڑھائیں۔ اگر صرف ایک job کو بڑی window درکار ہو تو num_ctx کو پورے server کے بجائے ہر request کے لیے الگ set کیا جا سکتا ہے۔ اس طرح اضافی cache ان تمام کاموں پر لاگو نہیں ہوتی جو daemon سے لیے جاتے ہیں۔ llama.cpp میں بھی کسی default پر بھروسا نہیں کرنا چاہیے۔ -c کو واضح طور پر set کریں اور معلوم رکھیں کہ آپ نے کیا set کیا ہے۔

وہ memory arithmetic جو عموماً کوئی نہیں دکھاتا

Model file پوری لاگت نہیں ہوتی۔ KV cache (key/value cache) ہر layer میں context کے ہر token کے لیے ایک entry رکھتا ہے، اور conversation بڑھنے کے ساتھ یہ بھی بڑھتا جاتا ہے۔

Llama 3.1 8B کے لیے حساب کریں۔ Model میں 32 layers، 8 key/value heads اور head dimension 128 ہے۔ 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 درکار ہوتے ہیں، جبکہ 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 میں کام کرنے کے لیے کچھ گنجائش کے ساتھ چل جاتا ہے۔ اسی 8 GiB box پر context کو 32k تک بڑھائیں تو صرف cache ہی دستیاب گنجائش ختم کر دیتا ہے۔ Model load ہونے کے دوران free -h سے memory کا استعمال براہِ راست monitor کریں، اور ایسے estimate پر اعتماد نہ کریں جس کی پیمائش نہ کی گئی ہو۔ اگر آپ 8B سے کہیں بڑے model کے لیے sizing کر رہے ہیں تو CPU-only VPS پر 27B model کے لیے یہی حساب دکھاتا ہے کہ 8 سے 64 GB تک ہر tier میں حقیقتاً کتنا data آ سکتا ہے۔

Ollama اس اثر کو مزید بڑھا دیتا ہے۔ OLLAMA_NUM_PARALLEL کی default value 1 ہے، اور model کو درکار memory اس number اور context length کے حاصل ضرب کے ساتھ بڑھتی ہے۔ دونوں کو ایک ساتھ بڑھانے پر daemon خاموشی سے آپ کی توقع سے کئی گنا زیادہ RAM طلب کرتا ہے۔ یہی حساب simultaneous users کی حد بھی متعین کرتا ہے، کیونکہ ہر concurrent request کو KV cache کا اپنا حصہ درکار ہوتا ہے؛ یہی وجہ ہے کہ ایک شخص کے لیے ٹھیک چلنے والا server پانچ افراد پر رک جاتا ہے۔

محور 2: وہ daemon جسے آپ کو چلانا ہے

Ollama کی install script ایک systemd unit لکھتی ہے، ایک ollama system user بناتی ہے، اور service کو enable کرتی ہے۔ آپ کو خود یہ سب لکھے بغیر lifecycle management مل جاتی ہے۔ 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 ollama

OLLAMA_KEEP_ALIVE CPU VPS پر دوسری جگہوں کی نسبت زیادہ اہم ہے۔ Models default طور پر 5 منٹ تک memory میں رہتے ہیں، پھر unload ہو جاتے ہیں۔ اگلی request کا جواب دینے سے پہلے پوری file دوبارہ load کرنا پڑتی ہے۔ اگر kernel اب بھی file کو اپنے page cache میں رکھتا ہو تو یہ عمل تیز ہوتا ہے، لیکن اسے وہاں صرف اضافی RAM ہی برقرار رکھتی ہے۔ جب دوسرے کام اسے cache سے نکال دیتے ہیں تو file دوبارہ disk سے آتی ہے۔ اس طرح سست storage پر 4.58 GiB کی reload، دو سیکنڈ کے جواب کو تیس سیکنڈ کا جواب بنا دیتی ہے۔ طویل keep-alive latency کا مسئلہ حل کرتا ہے، لیکن RAM مستقل طور پر مختص رہتی ہے۔ دونوں کے حقیقی اخراجات ہیں۔ جو کم نقصان دہ ہو، اسے منتخب کریں۔ اگر آپ چاہتے ہیں کہ model ہر وقت memory میں موجود رہے، تو keep_alive کو اس طرح set کرنا کہ وہ idle periods اور reboots کے بعد بھی برقرار رہے چند lines کا کام ہے اور ہر بار server restart ہونے پر model کو دستی طور پر گرم کرنے کی ضرورت ختم ہو جاتی ہے۔

llama.cpp آپ کو daemon یا service user فراہم نہیں کرتا، اس لیے دونوں خود set up کرنے ہوں گے۔ جس llama.cpp directory میں آپ نے build کیا تھا، وہاں سے 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.gguf

اگر آپ نے build کرنے کے بجائے release archive استعمال کیا تھا، تو ExecStart کو اس کے اندر موجود llama-server کی طرف point کریں، کیونکہ 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.target

اسے sudo systemctl enable --now llama-server کے ذریعے enable کریں۔ اس کے بعد process اپنی پوری lifetime کے دوران model کو memory میں رکھتا ہے۔ Default طور پر idle ہونے پر کچھ unload نہیں ہوتا، لیکن --sleep-idle-seconds شامل کرنے سے service روکے بغیر automatic unloading اور reloading فعال ہو جاتی ہے۔ اگر units لکھنا آپ کے لیے نیا کام ہے، تو یہ VPS پر اپنی services کو systemd کے تحت چلانے جیسا ہی pattern ہے۔

محور 3: آپ کی ایپ کس API سے رابطہ کرے گی

یہ محور اب کافی محدود ہو گیا ہے۔ دونوں پروجیکٹس OpenAI chat format استعمال کرتے ہیں، اس لیے base URL تبدیل کرنے کے بعد زیادہ تر client libraries دونوں میں سے کسی ایک کے ساتھ کام کرتی ہیں۔

Ollama 127.0.0.1:11434 پر درخواستیں سنتا ہے۔ اس کا OpenAI-compatible route http://localhost:11434/v1/chat/completions ہے، جبکہ ساتھ ہی یہ native API بھی /api/chat پر دستیاب رکھتا ہے۔ Anthropic-compatible route بھی دستاویزی طور پر موجود ہے۔ ان میں سے کوئی بھی route ماڈل کو خود کسی چیز کی تلاش کی اجازت نہیں دیتا۔ اس لیے اگر آپ کی ایپ کو ماڈل کے training data سے زیادہ تازہ جوابات درکار ہوں تو Ollama's 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 پر listening کرتا ہے۔ اگر اسے خود چھوڑ دیا جائے تو اب یہ port 9931 پر default ہوتا ہے (27 October 2026 کو جانچا گیا)۔ اس لیے اگر آپ کی ایپ کو 8080 درکار ہو تو command line میں --port برقرار رکھیں۔ یہ /v1/chat/completions، /v1/completions اور /v1/embeddings فراہم کرتا ہے، نیز اپنا /completion endpoint اور built-in web UI بھی دیتا ہے۔ یہ ایسی operational routes بھی فراہم کرتا ہے جو Ollama میں موجود نہیں ہیں: readiness probe کے لیے /health، loaded model کی settings کے لیے /props، ہر request slot کی موجودہ کارروائی کے لیے /slots، اور Prometheus format میں metrics کے لیے /metrics۔ آخری endpoint کو فعال کرنے کے لیے --metrics شامل کرنا ضروری ہے، کیونکہ یہ default طور پر بند ہوتا ہے۔ اگر آپ اس service کی monitoring کرنا چاہتے ہیں تو غالباً یہی فرق فیصلہ کن ہوگا۔

کوئی بھی server آپ کے لیے authentication خود فعال نہیں کرتا۔ دونوں کا loopback پر default ہونا ایک مناسب حفاظتی انتظام ہے۔ ان تک SSH tunnel کے ذریعے یا reverse proxy کے پیچھے سے رسائی دیں، اور 11434 یا 8080 کو کبھی internet پر کھلا نہ چھوڑیں۔

CPU-only VPS ایمانداری سے کیا کر سکتا ہے

CPU-only VPS چھوٹے models کو سست رفتاری سے چلا سکتا ہے۔ یہی ایماندارانہ خلاصہ ہے، اور مفید بات یہ جاننا ہے کہ اس کی حد کہاں ہے۔ اس کے گرد کوئی بھی design بنانے سے پہلے پیمائش کریں:

llama-bench -m ~/models/Meta-Llama-3.1-8B-Instruct-Q4_K_M.gguf -p 512 -n 128

pp column prompt processing speed ہے، جبکہ tg column token generation speed ہے۔ دونوں کی پیمائش tokens per second میں ہوتی ہے۔ shared vCPU plan پر 8B model عموماً Q4_K_M کے ساتھ tg کے لیے کم single digits تک پہنچتا ہے۔ اصل مسئلہ prompt processing ہے: پہلا output token ظاہر ہونے سے پہلے پورا prompt process ہوتا ہے، اس لیے طویل system prompt ہر request کے ساتھ اضافی انتظار پیدا کرتا ہے۔ Reply length وہ حصہ ہے جسے آپ واقعی قابو کر سکتے ہیں، کیونکہ تین tokens per second کی رفتار پر 600 tokens پر مشتمل طویل جواب server کو 200 seconds، یعنی صرف generation کے لیے تین minutes سے زیادہ، مصروف رکھتا ہے۔ اس لیے num_predict کے ذریعے output محدود کرنا ایک جواب کو timeout بننے سے روکنے کا سب سے سستا طریقہ ہے۔

CPU پر یہ کام قابلِ استعمال ہیں: classification، extraction، مختصر summaries یا routing کے لیے 1B سے 4B model۔ Replies seconds میں آ جاتے ہیں اور memory عام plan میں سما جاتی ہے۔ اس size range کے بجائے اسی size کی ایک عملی مثال کے لیے VPS پر Nemotron 3.5 Lightning حاصل کر کے اس کی پیمائش exact tag، درکار RAM اور GPU کے بغیر برقرار رہنے والی speed بتاتی ہے۔ CPU پر یہ کام قابلِ استعمال نہیں ہیں: reading speed پر interactive chat، coding assistants، طویل documents پر کام، یا ایسا agent loop جو سلسلہ وار کئی calls کرے۔ اگر loop بارہ calls کرے اور ہر call میں چار seconds لگیں تو کسی بھی output سے پہلے ایک minute گزر جاتا ہے۔ اگر coding assistant پہلے ہی منصوبے میں شامل تھا تو agent کو اپنے host کیے ہوئے model کی طرف بھیجنا واضح کرتا ہے کہ چھوٹا local model کن کاموں میں حقیقتاً بہتر ہے اور کن کاموں کے لیے hosted API استعمال کرنا ہوگا۔

جب numbers کام نہ کریں تو دو راستے ہیں۔ اگر مسئلہ 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 کو مخصوص کریں

دونوں projects ہر ہفتے نئی تبدیلیاں جاری کرتے ہیں، اس لیے deploy کیے گئے version کو درج کریں۔ upstream one-liner موجودہ build انسٹال کرتا ہے:

curl -LsSf https://llama.app/install.sh | sh
llama serve -hf ggml-org/Qwen3.5-0.8B-GGUF

کسی مخصوص build کو pin کرنے کے لیے اس کے بجائے releases page سے prebuilt tarball لیں۔ اب project 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 b10224 استعمال کرتی ہیں، جو 2 August 2026 کو current tag تھا؛ اسے اپنے آزمودہ 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)

libssl-dev HTTPS features کے لیے documented dependency ہے۔ compile میں کئی منٹ لگتے ہیں اور اس کے لیے smallest plans میں دستیاب RAM سے زیادہ RAM درکار ہوتی ہے، اس لیے بڑی machine پر build کریں اور اگر چھوٹی machine میں RAM کم پڑ جائے تو binaries copy کر دیں۔

Ollama کو ایک مخصوص version پر نصب کریں

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 کو جاری کیا گیا تھا۔ اگر آپ 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 -v

manual طریقہ systemd unit یا service user نہیں بناتا، اس لیے یہ دونوں آپ کو خود شامل کرنے ہوں گے۔ VPS پر Ollama کی مکمل رہنمائی میں service setup کا مرحلہ بہ مرحلہ طریقہ بیان کیا گیا ہے۔

خرابی کی صورتیں اور آپ کو نظر آنے والے strings

Ollama ماڈل load کرنے سے انکار کرتا ہے۔ پرانے Ollama releases ماڈل load کرنے سے پہلے اس کا سائز چیک کرتے تھے، اور ollama run اس نوعیت کی ایک سطر واپس کرتا تھا:

Error: model requires more system memory (5.6 GiB) than is available (3.2 GiB)

موجودہ Ollama source میں یہ message اب شامل نہیں ہے (27 October 2026 کو چیک کیا گیا)۔ اب Ollama loading کا کام llama-server کو سونپتا ہے۔ اس لیے جو model دستیاب memory میں fit نہ ہو، وہ runner failure کے طور پر ظاہر ہوتا ہے، اور error عموماً اس طرح شروع ہوتا ہے:

llama-server reported out-of-memory during startup
llama-server process has terminated

دونوں صورتوں میں حل ایک ہی ہے۔ ایک quantisation row نیچے جائیں، context length کم کریں، یا چھوٹا model منتخب کریں۔

llama.cpp ناکام نہیں ہوتا، بلکہ انتہائی سست ہو جاتا ہے۔ llama.cpp بطور default GGUF کو memory-map کرتا ہے، اس لیے RAM سے بڑی file بھی start ہو جاتی ہے۔ اس کے بعد kernel ہر token پر weights کو disk سے بار بار load اور unload کرتا ہے۔ نتیجتاً generation میں ہر token کو کئی seconds لگتے ہیں اور disk usage 100 percent تک پہنچ جاتی ہے۔ Memory mapping غیر فعال کرنے کے لیے --load-mode none دیں۔ اس option نے --no-mmap کی جگہ لی ہے۔ pinned b10224 build میں --no-mmap کو deprecated درج کیا گیا ہے، اور موجودہ builds میں یہ option موجود نہیں ہے (29 October 2026 کو چیک کیا گیا)۔ جب kernel مداخلت کرتا ہے تو dmesg وجہ دکھاتا ہے:

Out of memory: Killed process 1234 (llama-server)

Model file بالکل load نہیں ہوتی۔ اگر GGUF ایسی model family کے لیے بنائی گئی ہو جو آپ کے engine سے نئی ہے، تو engine اس architecture کا نام دے کر error ظاہر کرتا ہے جسے وہ نہیں جانتا۔ یہاں <arch> file کے metadata میں محفوظ نام ہے:

llama_model_load: error loading model: unknown model architecture: '<arch>'

حل engine کو upgrade کرنا ہے، کوئی دوسری file استعمال کرنا نہیں۔ یہی pinned version استعمال کرنے کی قیمت ہے، اور اسی لیے build number لکھ کر رکھنا ضروری ہے۔ آپ کو معلوم ہونا چاہیے کہ upgrade سے پہلے کون سا build چل رہا تھا۔

API مقامی طور پر جواب دیتی ہے، لیکن آپ کی app سے جواب نہیں دیتی۔ Ollama 127.0.0.1:11434 پر bind ہوتا ہے، اس لیے دوسرے host سے connection refused ملتا ہے۔ OLLAMA_HOST=0.0.0.0:11434 کو systemctl edit ollama کے ذریعے صرف اس وقت set کریں جب port firewall یا private network کے پیچھے ہو، کیونکہ API کے سامنے authentication موجود نہیں ہے۔

وقفے کے بعد پہلا reply بہت سست آتا ہے۔ 5 minute کے idle ہونے کے بعد model unload ہو گیا ہے، اور اب اسے دوبارہ load کیا جا رہا ہے۔ اگر page cache نے اسے محفوظ نہ رکھا ہو تو یہ disk سے load ہوگا۔ Request سے فوراً پہلے ollama ps چلانے پر کچھ بھی loaded نہیں دکھے گا، جس سے یہ تصدیق ہو جاتی ہے۔ OLLAMA_KEEP_ALIVE کی قدر بڑھائیں۔

تو آپ کو کون سا چلانا چاہیے؟

جب آپ چاہتے ہوں کہ models آپ کے لیے manage ہوں اور بغیر کسی اضافی کام کے OpenAI طرز کا endpoint دستیاب ہو، تو Ollama چلائیں۔ پہلی deployment کے لیے یہ موزوں default ہے، اور ان تمام صورتوں میں بھی جب model کا انتخاب بار بار تبدیل ہونا ہو۔

جب memory اتنی محدود ہو کہ آپ کو quantisation row خود منتخب کرنا پڑے، monitoring کے لیے /health، /slots اور /metrics درکار ہوں، یا آپ کو ایسا flag چاہیے جو Ollama ظاہر نہیں کرتا، تو llama.cpp براہِ راست چلائیں۔ VPS پر یہ زیادہ موزوں انتخاب ہے جہاں model بمشکل fit ہوتا ہو، کیونکہ اسے fit کرنے والی settings وہی ہیں جنہیں Ollama آپ کی طرف سے منتخب کرتا ہے۔

دونوں کو چلانا معمول کی بات ہے۔ experiments کے لیے Ollama، اور اس ایک model کے لیے llama.cpp جسے آپ production میں deploy کرتے ہیں اور کبھی تبدیل نہیں کرنا چاہتے۔

FAQ

کیا Ollama صرف llama.cpp کے گرد ایک wrapper ہے؟

قریب قریب، لیکن یہ wrapper حقیقی کام بھی کرتا ہے۔ Ollama کی README میں llama.cpp کو اس کا inference backend بتایا گیا ہے (27 October 2026 کو جانچا گیا)۔ Ollama اس کے اوپر model registry، ایسا prompt template جو chat messages کو prompt میں تبدیل کرتا ہے، default sampling parameters کا ایک مجموعہ، idle unloading کے ساتھ daemon، اور HTTP API فراہم کرتا ہے۔ یکساں settings پر tokens per second کا موازنہ کرتے وقت آپ اسی engine کا خود سے موازنہ کر رہے ہوتے ہیں۔ اصل انتخاب management layer کا ہوتا ہے۔

صرف CPU والے VPS پر کون تیز ہے؟

دونوں ایک ہی engine استعمال کرتے ہیں، اس لیے ایک ہی model file، quantisation، context size اور thread count پر نتائج ایک دوسرے کے قریب ہوتے ہیں۔ لوگ جن اختلافات کی اطلاع دیتے ہیں، وہ عموماً مختلف defaults، خاص طور پر context length اور thread count، کی وجہ سے ہوتے ہیں، نہ کہ engine کی وجہ سے۔ اسے llama-bench -m <file> -p 512 -n 128 سے ناپیں اور شائع شدہ کسی بھی figure پر یقین کرنے سے پہلے اپنے box پر tg column کا موازنہ کریں۔

کیا میں اپنی GGUF file Ollama کے ساتھ استعمال کر سکتا ہوں؟

ہاں۔ file کو server پر رکھیں، ایک Modelfile لکھیں جس کی پہلی line FROM ./your-model.gguf ہو، اپنی ضرورت کے مطابق PARAMETER lines شامل کریں، مثلاً num_ctx، پھر ollama create your-name -f ./Modelfile چلائیں۔ ollama ls اسے registry سے pull کی گئی دیگر files کے ساتھ list کرے گا۔ اس طرح آپ ایسی quantisation استعمال کر سکتے ہیں جو registry میں موجود نہیں ہے۔

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 کے ساتھ یہ بھی یاد رکھیں کہ requirement OLLAMA_NUM_PARALLEL کے ساتھ بڑھتی ہے۔

کیا یہ مضمون مفید تھا؟