SSD Nodes Learn Hosting plans →
تعلیمی Matt Connorتحریر: Matt Connor

Ollama یا vLLM: LLM server کے لیے کیا چنیں؟

Ollama ایک صارف کے لیے CPU پر بھی چلتا ہے، جبکہ vLLM GPU throughput کے لیے ہے۔ 7B یا 8B model تقریباً 5 GB لیتا ہے، اور دونوں OpenAI-compatible API دیتے ہیں۔

Ollama بمقابلہ vLLM، ایک پیراگراف میں

Ollama ایک model manager ہے جس کے ساتھ server منسلک ہوتا ہے: یہ quantized weights download اور load کرتا ہے، پھر 127.0.0.1:11434 پر جواب دیتا ہے؛ اگر سسٹم میں صرف CPU موجود ہو تو اسی پر کام کرتا ہے۔ vLLM ایک throughput engine ہے: یہ بیک وقت چلنے والی متعدد requests کے ذریعے GPU کو مسلسل مصروف رکھتا ہے، اس لیے ایسے machine پر یہ درست انتخاب نہیں جس میں GPU موجود نہ ہو۔ فیصلہ اتنا ہی ہے۔ کسی مقامی assistant سے بات کرنے والا ایک فرد Ollama کا استعمال کرتا ہے۔ کسی team کو service فراہم کرنے والی application کے لیے vLLM موزوں ہے۔

دونوں OpenAI-compatible HTTP API استعمال کرتے ہیں، اس لیے base URL تبدیل کرکے client code کو ایک سے دوسرے پر منتقل کیا جا سکتا ہے۔ فرق API میں نہیں ہے۔ فرق اس وقت ظاہر ہوتا ہے جب پہلی request ابھی tokens generate کر رہی ہو اور دوسری request آ جائے۔

Ollama دراصل کیا ہے

Ollama سہولت فراہم کرنے والی ایک layer ہے۔ ایک ہی install command سے یہ آپ کو model registry (ollama pull llama3.1:8b)، weights کا local store، chat prompt، systemd service اور HTTP API فراہم کرتا ہے۔ اس کے فراہم کردہ زیادہ تر models GGUF files ہوتے ہیں، جنہیں عموماً 4-bit quantization کے ساتھ تیار کیا جاتا ہے۔ اسی لیے 7B یا 8B model disk پر 16 GB کے بجائے تقریباً 5 GB جگہ لیتا ہے۔ Quantization سے CPU inference کے لیے درکار memory کم ہو جاتی ہے۔ Apple Silicon Macs پر یہ MLX engine کے ذریعے safetensors-based models بھی چلا سکتا ہے۔ v0.40.0 (September 2026) سے supported architectures خودکار طور پر MLX پر چلتے ہیں۔

اس کا GGUF runner llama.cpp پر مبنی ہے۔ llama.cpp وہ C++ inference library ہے جس نے عام hardware پر GGUF quantization کو عملی بنایا۔ October 2026 تک Ollama دو engines، llama.cpp اور MLX، کو support کرتا ہے۔ Linux builds میں CUDA کے ساتھ MLX inference بھی supported ہے۔ Development guide میں اس backend کو cmake -B build . -DOLLAMA_MLX_BACKENDS=cuda_v13 کے ذریعے enable کیا جاتا ہے۔ اس کے لیے CUDA 13+ اور cuDNN 9+ درکار ہیں۔ لہٰذا جب لوگ Ollama کا موازنہ llama.cpp سے کرتے ہیں تو وہ زیادہ تر ایک ergonomics layer کا اس چیز سے موازنہ کر رہے ہوتے ہیں جسے وہ wrap کرتی ہے۔

اس design کا ہدف ایک user ہے۔ October 2026 تک OLLAMA_NUM_PARALLEL کی default value 1 ہے۔ اس کا مطلب ہے کہ ایک model ایک وقت میں ایک request process کرتا ہے اور باقی تمام requests queue میں انتظار کرتی ہیں۔ یہ queue default طور پر 512 entries رکھتی ہے (OLLAMA_MAX_QUEUE)۔ آپ parallel setting بڑھا سکتے ہیں۔ ذیل کا section بتاتا ہے کہ اس کی کیا لاگت ہوتی ہے۔ اگر آپ نے پہلے Ollama نہیں چلایا تو VPS پر Ollama host کرنا اور port 11434 کو بند رکھنا سے شروع کریں، کیونکہ local API میں authentication درکار نہیں ہوتی۔

vLLM حقیقت میں کیا ہے

vLLM صرف inference server ہے، اس کے علاوہ کچھ نہیں۔ یہ model library کا انتظام نہیں کرتا، running server کے لیے vllm chat client فراہم کرتا ہے، اور request کے وقت آپ کے لیے model download نہیں کرے گا۔ آپ launch کے وقت Hugging Face repository کا نام دیتے ہیں، یہ وہی ایک model load کرتا ہے، اور process روکنے تک اسے serve کرتا رہتا ہے۔

اس محدود دائرۂ کار کے بدلے آپ کو زیادہ throughput ملتا ہے۔ یہ کام دو mechanisms انجام دیتے ہیں۔ PagedAttention، KV cache (key-value cache، یعنی وہ فی-token attention state جسے model ہر active request کے لیے محفوظ رکھتا ہے) کو fixed-size blocks میں store کرتا ہے، بالکل اسی طرح جیسے operating system memory کو pages میں تقسیم کرتا ہے۔ اب request کو worst-case کے مطابق ایک بڑی contiguous reservation درکار نہیں ہوتی، اس لیے وہ memory جو پہلے reserved مگر unused رہتی تھی، مزید concurrent requests کے لیے دستیاب ہو جاتی ہے۔ Continuous batching نئے request کو current batch مکمل ہونے کا انتظار کرانے کے بجائے اگلے decoding step پر running batch میں شامل ہونے دیتا ہے۔ مکمل ہونے والا sequence فوراً batch سے نکل جاتا ہے اور اس کی جگہ دوبارہ بھر دی جاتی ہے۔

عملی نتیجہ یہ ہے: ایک GPU پر ایک concurrent user سے تیس users تک جانے سے total tokens per second میں نمایاں اضافہ ہوتا ہے، جبکہ ہر user کی speed آپ کی توقع کے مقابلے میں بہت کم کم ہوتی ہے۔ Ollama کے default behavior میں ایک user سے تیس users تک جانے کا مطلب صرف یہ ہے کہ انتیس افراد انتظار کرتے ہیں۔

مسلسل batching ہی پورا فرق پیدا کرتی ہے

فرض کریں کہ یکساں hardware والے ہر server پر بیک وقت پانچ requests آ رہی ہیں۔

Ollama کی default settings میں پہلے request کو مکمل کیا جاتا ہے، پھر دوسرے کو، اور اسی طرح آگے۔ پانچواں caller چار مکمل generations کا انتظار کرتا ہے۔ مجموعی throughput تقریباً ایک generation کی رفتار کے برابر رہتا ہے، کیونکہ processor ہر وقت صرف ایک sequence پر کام کر رہا ہوتا ہے۔

vLLM ایک ہی forward pass میں پانچوں کو decode کرتا ہے۔ پانچ sequences کے لیے ایک token generate کرنے کی لاگت، ایک sequence کے لیے ایک token generate کرنے سے بمشکل زیادہ ہوتی ہے، کیونکہ مہنگا مرحلہ model weights کو memory سے پڑھنا ہے، اور یہ read پورے batch میں shared ہوتی ہے۔ یہی memory-bandwidth حقیقت CPU inference کو سست بناتی ہے: لاگت weights منتقل کرنے کی ہوتی ہے، arithmetic کی نہیں۔

آپ OLLAMA_NUM_PARALLEL=4 set کر کے اس کا کچھ فائدہ حاصل کر سکتے ہیں۔ اس کی قیمت memory ہے۔ ہر parallel slot کو اپنا KV cache درکار ہوتا ہے، اور Ollama context allocation کو تقسیم کرنے کے بجائے اسے multiply کرتا ہے: اس کے FAQ کے مطابق مطلوبہ RAM OLLAMA_NUM_PARALLEL گنا OLLAMA_CONTEXT_LENGTH کے حساب سے بڑھتی ہے۔ چنانچہ 8192 tokens کے لیے configured model کے خلاف چار parallel requests میں ہر request کے لیے 8192 tokens برقرار رہتے ہیں، لیکن box کو مجموعی طور پر 32768 tokens کے cache کی گنجائش رکھنی پڑتی ہے۔ یہ 8192 بھی کوئی مقررہ قدر نہیں بلکہ ایک انتخاب ہے، اس لیے num_ctx بڑھانا اور اس کے لیے درکار RAM کا تعین کرنا وہ مرحلہ ہے جو طے کرتا ہے کہ چار slots بالکل fit ہوں گے یا نہیں۔ vLLM کا paged cache ہر slot کے لیے ابتدا ہی میں پوری window reserve کرنے سے بچاتا ہے، کیونکہ blocks request کے بڑھنے کے ساتھ مختص کیے جاتے ہیں۔ بہرحال، ایک box بیک وقت کتنے لوگوں کو serve کر سکتا ہے، اس کی حد KV cache size، prefill cost اور queue depth سے طے ہوتی ہے، اور یہی وجہ ہے کہ ایک شخص کے لیے مناسب محسوس ہونے والا server پانچ لوگوں پر سست پڑ جاتا ہے۔

Ollama کے ساتھ انسٹال اور سروس فراہم کریں

curl -fsSL https://ollama.com/install.sh | sh
ollama pull llama3.1:8b
ollama run --verbose llama3.1:8b "Write two sentences about Linux."

انسٹالیشن اسکرپٹ ایک ollama system user بناتا ہے، binary انسٹال کرتا ہے، اور 127.0.0.1:11434 سے bound ollama.service رجسٹر کرتا ہے۔ --verbose کی طرف سے دکھائی جانے والی eval rate لائن اس مشین پر آپ کی حقیقی tokens per second کارکردگی ہے۔ اسے شائع شدہ کسی بھی عدد پر ترجیح دیں۔ ایک prompt سے حاصل ہونے والی ایک reading صرف ابتدائی نقطۂ آغاز ہے، capacity number نہیں۔ اس لیے مختلف concurrency پر tokens per second کی پیمائش ہی بتاتی ہے کہ مشین آپ کی متوقع load برداشت کر سکتی ہے یا نہیں، اور یہ بھی کہ GPU کرائے پر لینا فی token ادائیگی سے بہتر ہے یا نہیں۔

concurrency بڑھانے کے لیے systemd drop-in استعمال کریں تاکہ upgrade اس تبدیلی کو overwrite نہ کرے:

sudo systemctl edit ollama.service
[Service]
Environment="OLLAMA_NUM_PARALLEL=4"
Environment="OLLAMA_KEEP_ALIVE=30m"
sudo systemctl restart ollama
ollama ps

ollama ps بتاتا ہے کہ کیا load ہوا ہے، اور اس کا PROCESSOR column اصل صورت حال دکھاتا ہے۔ 100% CPU کا مطلب ہے کہ کوئی GPU استعمال نہیں ہو رہا۔ Ollama کے سست ہونے کی زیادہ تر reports کی یہی حقیقی وجہ ہوتی ہے۔ اس drop-in میں OLLAMA_KEEP_ALIVE=30m لائن ایک خاموش مشین پر بھی اتنی ہی اہم ہے، کیونکہ default کسی request کے بغیر پانچ منٹ بعد model کو unload کر دیتا ہے۔ requests کے درمیان model کو resident رکھنا اس بات کو روکتا ہے کہ آدھے گھنٹے تک خاموشی کے بعد آنے والے پہلے prompt کو دوبارہ مکمل load time ادا کرنا پڑے۔ اگر آپ کی خاموشی اس سے زیادہ طویل رہتی ہے تو زیادہ طویل value مقرر کریں۔

vLLM کے ساتھ انسٹال اور سروس فراہم کریں

vLLM کی GPU builds کے لیے Linux درکار ہے۔ Apple Silicon والے macOS پر CPU-only support موجود ہے، جس کے لیے 0.32.0 release میں prebuilt wheel شامل ہے۔ ان Macs پر GPU acceleration، vLLM-Metal کے ذریعے حاصل ہوتی ہے، جو MLX پر مبنی الگ community-maintained plugin ہے۔ Python کے لیے موجودہ release (0.32.0، October 2026) 3.11 سے 3.14 تک کے versions قبول کرتی ہے، اور install guide بھی یہی range درج کرتی ہے۔ Python 3.10 کو 0.32.0 میں ختم کر دیا گیا، اس لیے نیچے استعمال ہونے والا 3.12 محفوظ انتخاب ہے۔ اسے اپنی الگ virtual environment میں انسٹال کریں، کیونکہ یہ مخصوص PyTorch build شامل کرتا ہے:

uv venv --python 3.12 --seed
source .venv/bin/activate
uv pip install vllm --torch-backend=auto
vllm download-kernels

October 2026 تک vLLM کی NVIDIA install guide میں آخری سطر شامل ہے۔ یہ FlashInfer کے precompiled kernels انسٹال کرتی ہے۔ ان کے بغیر vLLM startup کے وقت kernels download اور compile کرتا ہے۔ Guide کے مطابق Hopper اور اس کے بعد کے نئے GPUs پر اس میں کئی منٹ لگ سکتے ہیں۔ ہر vLLM upgrade کے بعد اسے دوبارہ چلائیں، کیونکہ kernels مطابقت نہ رکھنے کی صورت میں FlashInfer import نہیں ہوتا۔

اب model کو serve کریں۔ نام Hugging Face repository id ہے، مختصر tag نہیں:

vllm serve Qwen/Qwen2.5-1.5B-Instruct

پہلی بار startup سست ہوتا ہے، کیونکہ پہلے weights download ہوتے ہیں اور پھر vLLM یہ طے کرنے کے لیے GPU کا profiling کرتا ہے کہ کتنے KV cache blocks دستیاب ہوں گے۔ یہ port 8000 پر listening کرتا ہے۔ کوئی client code لکھنے سے پہلے اسے check کریں:

curl http://localhost:8000/v1/models
curl http://localhost:8000/v1/chat/completions \
    -H "Content-Type: application/json" \
    -d '{"model": "Qwen/Qwen2.5-1.5B-Instruct", "messages": [{"role": "user", "content": "Who won the world series in 2020?"}]}'

اگر اس machine پر Docker پہلے سے موجود ہے تو official image، CUDA dependencies کی configuration کا کام ختم کر دیتی ہے:

docker run --runtime nvidia --gpus all \
    -v ~/.cache/huggingface:/root/.cache/huggingface \
    --env "HF_TOKEN=$HF_TOKEN" \
    -p 8000:8000 \
    --ipc=host \
    vllm/vllm-openai:latest \
    --model Qwen/Qwen3-0.6B

--ipc=host container کو host shared memory تک رسائی دیتا ہے؛ --shm-size بڑھانا بھی ایک متبادل ہے۔ PyTorch processes کے درمیان tensors منتقل کرنے کے لیے shared memory استعمال کرتا ہے، خاص طور پر tensor-parallel inference میں۔

Production میں سب سے اہم flags --max-model-len ہیں، یعنی وہ context window جس کی لاگت آپ برداشت کرنے کے لیے تیار ہیں؛ --gpu-memory-utilization، یعنی card کے memory کا وہ fraction جسے vLLM استعمال کر سکتا ہے، جو October 2026 تک default طور پر 0.92 ہے؛ --tensor-parallel-size، جو ایک model کو متعدد GPUs پر تقسیم کرتا ہے؛ اور --api-key۔

vLLM میں تصدیق ایک flag ہے، جبکہ Ollama کی local API میں یہ موجود نہیں

vLLM میں bearer token فراہم کرنے پر یہ token نافذ ہو جاتا ہے:

vllm serve Qwen/Qwen2.5-1.5B-Instruct --api-key token-abc123

یہی value VLLM_API_KEY environment variable سے بھی حاصل کی جا سکتی ہے۔ /v1 کو بھیجی گئی ایسی request جس میں یہ token موجود نہ ہو، HTTP 401 واپس کرتی ہے۔ تاہم یہ key پورے server پر لاگو نہیں ہوتی۔ vLLM کی security guide اور 0.32.0 source میں موجود authentication code اسے صرف /v1، /v2، /inference، اور /cohere path prefixes کے تحت آنے والے endpoints پر لاگو کرتے ہیں۔ vllm serve صفحے پر --api-key کی help text میں صرف پہلے تین prefixes درج ہیں، لیکن code چاروں کو check کرتا ہے۔ Guide اور help text دونوں بتاتے ہیں کہ دیگر endpoints authenticated نہیں ہیں۔ ان میں خاص طور پر /invocations شامل ہے، جو وہی inference فراہم کرتا ہے جو /v1 فراہم کرتا ہے۔ یہی وجہ کافی ہے کہ port 8000 کو public interface پر publish نہ کیا جائے۔ vLLM کی security guide rate limiting کی ذمہ داری بھی اس کے سامنے موجود reverse proxy پر چھوڑتی ہے۔ plain HTTP پر بھیجا گیا token دورانِ ترسیل پڑھا جا سکتا ہے، لیکن یہ flag کم از کم یہ ظاہر کرتا ہے کہ server کے پاس caller کا تصور موجود ہے۔

Ollama کی local API کے لیے authentication درکار نہیں ہوتی۔ Cloud models، model publishing، اور private model downloads کے لیے sign-in ضروری ہے؛ ollama.com تک براہِ راست API access کے لیے API key درکار ہوتی ہے۔ 11434 تک رسائی رکھنے والا کوئی بھی process models کو run، pull، یا delete کر سکتا ہے۔ اسے loopback پر رکھیں اور اپنے زیرِ انتظام WireGuard VPN کے ذریعے، یا TLS (transport layer security) terminate کرنے والے ایسے authenticating reverse proxy کے ذریعے access کریں۔

Hardware: ہر ایک کو کیا درکار ہے

Ollama CPU پر چلتا ہے۔ 4-bit quantized model کے لیے فی billion parameters تقریباً آدھا gigabyte RAM درکار ہوتا ہے۔ اس کے علاوہ runtime overhead کے لیے تقریباً 1 gigabyte اور context کے لیے مزید RAM درکار ہوتی ہے۔ اس لیے 3B model کے لیے تقریباً 4 GB خالی RAM، جبکہ 8B model کے لیے تقریباً 8 GB درکار ہوتی ہے۔ مشترکہ vCPU پر رفتار single digit سے low double digit tokens per second تک ہوتی ہے۔ یہ memory bandwidth کا مسئلہ ہے، misconfiguration کا نہیں، اور کوئی flag اسے درست نہیں کر سکتا۔ عمومی اندازے کے بجائے کسی مخصوص release پر یہ حساب دیکھنے کے لیے VPS پر Nemotron 3.5 Lightning چلانا استعمال کریں۔ اس سے pull کرنے کے لیے درست tag، load ہونے کے بعد استعمال ہونے والی RAM، اور یہ معلوم ہو جاتا ہے کہ CPU-only استعمال کے لیے رفتار قابل قبول ہے یا نہیں۔

vLLM میں GPU فرض کیا جاتا ہے۔ اس کا default path 16-bit precision میں unquantized weights فراہم کرتا ہے۔ اس کے لیے فی billion parameters تقریباً 2 GB درکار ہوتے ہیں۔ چنانچہ 8B model کو صرف weights کے لیے تقریباً 16 GB video memory درکار ہوتی ہے۔ اس میں KV cache شامل نہیں ہے، جو vLLM چلانے سے حاصل ہونے والی concurrency فراہم کرتا ہے۔ 24 GB card پر اس کے لیے قابل استعمال cache باقی رہتی ہے۔ 16 GB card پر ایسا نہیں ہوتا۔ اس صورت میں یا تو چھوٹا model منتخب کریں، --quantization دیں، جس کے لیے quantized checkpoint درکار ہوتا ہے یا load time پر full-precision weights کو quantize کیا جاتا ہے، یا --cpu-offload-gb کے ذریعے weights کا کچھ حصہ system RAM میں منتقل کریں۔ اس صورت میں precision برقرار رہتی ہے، لیکن رفتار کم ہو جاتی ہے، کیونکہ ہر forward pass پر یہ weights GPU کو منتقل ہوتے ہیں۔ CPU backend بھی موجود ہے اور اس کے لیے الگ wheels درکار ہوتے ہیں، لیکن اس سے vLLM چلانے کی بنیادی وجہ ختم ہو جاتی ہے۔

اس لیے اکثر hardware کا سوال ہی software کا جواب دے دیتا ہے۔ GPU نہ ہو تو Ollama استعمال کریں۔ اگر کرائے کا GPU صرف 5 percent utilisation پر ہو کیونکہ requests ایک کے بعد ایک process ہو رہی ہوں، تو vLLM استعمال کریں۔

آپ کے workload کے لیے کون سا انتخاب کریں

  • ایک شخص، CPU VPS، اور مسودہ نویسی یا خلاصہ تیار کرنا: Ollama۔ رفتار قابل قبول ہے اور اس سے زیادہ آسان کوئی انتخاب نہیں۔
  • coding assistant، یا آپ کے tools کو مقامی model سے جوڑنے والا MCP server، جسے صرف آپ استعمال کرتے ہیں: Ollama۔ اصل workload میں concurrency ایک ہی ہے۔
  • اس ہفتے پانچ models کا موازنہ کرنا: Ollama۔ tagged models کو pull اور delete کرنا اسی کام کے لیے موزوں ہے، جبکہ vLLM میں ہر model کے لیے process restart درکار ہوتا ہے۔
  • ایک داخلی app، chat product، یا حقیقی users والی retrieval pipeline: vLLM۔ اسی صورت میں batching کا فائدہ GPU bill کو جواز فراہم کرتا ہے۔
  • رات بھر میں ایک لاکھ documents کی scoring کرنے والا batch job: vLLM، زیادہ --max-num-seqs کے ساتھ۔ صرف throughput اہم ہے، جبکہ ہر document کی latency اہم نہیں۔
  • ایسا agent platform جس پر متعدد self-hosted AI agents بیک وقت model تک پہنچتے ہوں: vLLM، کیونکہ agent traffic فطری طور پر bursty اور parallel ہوتا ہے۔

خرابی کی صورتیں اور وہ strings جو آپ دیکھیں گے

vLLM، KV cache error کے ساتھ شروع ہونے سے انکار کرتا ہے۔ پیغام دونوں numbers دکھاتا ہے:

ValueError: To serve at least one request with the model's max seq len (32768), (4.00 GiB KV cache is needed, which is larger than the available KV cache memory (1.00 GiB). Based on the available memory, the estimated maximum model length is 8192. Try increasing `gpu_memory_utilization` (which also controls CPU memory on the CPU backend) or decreasing `max_model_len` when initializing the engine. See https://docs.vllm.ai/en/latest/configuration/conserving_memory/ for more details.

Model، weights load ہونے کے بعد دستیاب memory سے بڑی context window declare کرتا ہے۔ اسے --max-model-len 8192 کے ذریعے کم کریں، یا اگر card پر کوئی اور چیز memory استعمال نہیں کر رہی تو --gpu-memory-utilization بڑھا دیں۔

Ollama generation کے دوران Killed دکھاتا ہے۔ Linux کا out-of-memory killer نے process روک دیا، کیونکہ model کو machine میں موجود RAM سے زیادہ memory درکار تھی۔ sudo dmesg | grep -i oom کے ذریعے تصدیق کریں۔ حل کم سائز یا زیادہ quantized model استعمال کرنا ہے، کوئی setting تبدیل کرنا نہیں۔

Ollama اکیلے درست جواب دیتا ہے، لیکن load کے تحت رک جاتا ہے۔ کہیں بھی کوئی error ظاہر نہیں ہوتا۔ Callers کی تعداد بڑھنے کے ساتھ requests زیادہ وقت لیتی ہیں، کیونکہ OLLAMA_NUM_PARALLEL=1 انہیں serialise کر رہا ہے۔ طویل جوابات queue کو مزید خراب کرتے ہیں، کیونکہ ایک caller واحد slot کو اس وقت تک روکے رکھتا ہے جب تک model رکنے کا فیصلہ نہ کرے، اور اس کے پیچھے موجود تمام requests رک جاتی ہیں۔ اس لیے num_predict کے ذریعے جواب کی حد مقرر کرنا ہر turn کے server پر قبضہ رکھنے کے دورانیے کی زیادہ سے زیادہ حد مقرر کرتا ہے۔ Parallel setting بڑھائیں اور ہر slot کے context کے لیے درکار اضافی RAM قبول کریں، یا workload کو vLLM پر منتقل کریں۔

vLLM ہر /v1 call پر 401 واپس کرتا ہے۔ آپ نے اسے --api-key کے ساتھ شروع کیا، لیکن client کوئی Authorization header نہیں بھیج رہا۔ زیادہ تر OpenAI client libraries، key کے طور پر وہی value بھیجتی ہیں جو آپ انہیں دیتے ہیں۔ اس لیے flag ہٹانے کے بجائے key وہیں set کریں۔

vLLM کہتا ہے کہ model نہیں ملا۔ Ollama ضرورت کے وقت model pull کرتا ہے، vLLM ایسا نہیں کرتا۔ Request body میں model field کا match اس repository id سے ہونا چاہیے جس کے ساتھ آپ نے اسے launch کیا تھا، یا --served-model-name کی value سے، اگر آپ نے وہ set کی ہے۔ curl http://localhost:8000/v1/models کے ذریعے exact string کی تصدیق کریں۔

دونوں کو چلانا ایک معقول حل ہے

یہ ایک دوسرے کے متبادل نہیں ہیں۔ عام ترتیب یہ ہوتی ہے کہ GPU instance پر vLLM application کو سروس فراہم کرتا ہے، جبکہ عام VPS پر Ollama مقامی scripts، cron jobs اور نئے model releases آزمانے کے لیے چلتا ہے۔ دونوں endpoints OpenAI-compatible ہیں، اس لیے ایک ہی client library اور base-URL تبدیل کرنا کافی ہوتا ہے۔ یہاں کسی ایک engine کے انتخاب سے زیادہ cost control اہم ہے، کیونکہ idle GPU بھی مصروف GPU جتنا ہی بل وصول کرتا ہے، اور agent اور inference کے اخراجات کو قابل پیش گوئی رکھنا server منتخب کرنے سے الگ انتظامی کام ہے۔

FAQ

کیا vLLM، Ollama سے زیادہ تیز ہے؟

اسی GPU پر ایک درخواست کے لیے فرق معمولی ہوتا ہے، کیونکہ دونوں ایک ہی حساب انجام دیتے ہیں۔ متعدد بیک وقت درخواستوں کے لیے vLLM بہت آگے ہے، کیونکہ continuous batching ہر فعال sequence کو ایک ہی forward pass میں decode کرتی ہے، جبکہ Ollama کی default ترتیب انہیں ایک کے بعد ایک چلاتی ہے۔ صرف CPU والی مشین پر دونوں کے supported inference paths موجود ہیں، جبکہ vLLM الگ CPU wheels استعمال کرتا ہے۔

کیا vLLM، GPU کے بغیر چل سکتا ہے؟

ہاں، اس کے CPU backend کے ذریعے۔ standard wheels کا ہدف NVIDIA یا AMD GPUs ہیں، اور vLLM کے وجود کی بنیادی وجہ، یعنی batched requests کے ذریعے accelerator کو مسلسل مصروف رکھنا، CPU پر ختم ہو جاتی ہے۔ CPU backend موجود ہے، جس کے لیے x86 اور Arm کے الگ wheels ہیں۔ حقیقی CPU inference کے لیے Ollama یا llama.cpp براہِ راست استعمال کریں۔

Ollama اور llama.cpp میں کیا فرق ہے؟

llama.cpp inference library ہے، جبکہ GGUF اس کا quantized weight format ہے۔ Ollama، GGUF inference کے لیے اسے استعمال کرتا ہے اور اس کے ساتھ model registry، tagged downloads، model management اور systemd unit فراہم کرتا ہے۔ Ollama ایک MLX engine بھی فراہم کرتا ہے، جو Apple Silicon پر safetensors-based models چلاتا ہے، اور Linux پر CUDA builds کو support کرتا ہے؛ اس لیے دونوں کے اندرونی اجزا ہمیشہ یکساں نہیں ہوتے۔

8B model کے لیے vLLM کو کتنی GPU memory درکار ہوتی ہے؟

16-bit precision پر صرف weights کے لیے تقریباً 16 GB درکار ہوتے ہیں، یعنی تقریباً ہر billion parameters کے لیے 2 GB، اور اس کے علاوہ KV cache کے لیے بھی جگہ درکار ہوتی ہے۔ 24 GB card مناسب ہے۔ 16 GB card کے لیے quantized model، چھوٹا model، یا --cpu-offload-gb درکار ہوتا ہے تاکہ weights کا کچھ حصہ system RAM میں منتقل کیا جا سکے، جس سے speed کم ہو جاتی ہے۔ vLLM card کی memory کا وہ حصہ استعمال کرتا ہے جو --gpu-memory-utilization سے مقرر ہوتا ہے؛ October 2026 تک اس کی default value 0.92 ہے۔

کیا ان کے درمیان تبدیل ہونے کے لیے application code تبدیل کرنا ضروری ہے؟

عام طور پر صرف base URL، API key اور model name تبدیل کرنے ہوتے ہیں۔ Ollama اپنی OpenAI-compatible surface کو http://127.0.0.1:11434/v1 پر فراہم کرتا ہے اور key کو نظرانداز کرتا ہے، جبکہ vLLM http://localhost:8000/v1 فراہم کرتا ہے اور اگر آپ key مقرر کریں تو اپنے /v1 routes پر اسے لازم قرار دیتا ہے۔ Model names کی ساخت مختلف ہوتی ہے: Ollama کے لیے llama3.1:8b، جبکہ vLLM کے لیے مکمل repository id، جیسے Qwen/Qwen2.5-1.5B-Instruct۔

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