Ollama विरुद्ध vLLM: कोणता LLM server वापरावा?
Ollama एका वापरकर्त्यासाठी सुविधा देते आणि CPU वरही चालते. vLLM GPU throughput साठी आहे. workload नुसार निवड करा आणि दोन्हींसाठी अचूक commands पहा.
Ollama विरुद्ध vLLM, एका परिच्छेदात
Ollama हे server जोडलेले model manager आहे: ते quantized weights डाउनलोड करून load करते आणि 127.0.0.1:11434 वर उत्तर देते; मशीनमध्ये CPU शिवाय दुसरे काही नसेल, तरी ते CPU वर चालते. vLLM हे throughput engine आहे: ते एकाच वेळी चालणाऱ्या अनेक requests द्वारे GPU चा पूर्ण उपयोग करून घेते. GPU नसलेल्या मशीनवर vLLM हे योग्य साधन नाही. निर्णय इतकाच आहे. स्थानिक assistant शी संवाद साधणाऱ्या एका व्यक्तीचे काम Ollama साठी योग्य आहे. एखाद्या team ला सेवा देणारे application vLLM साठी योग्य आहे.
दोन्ही OpenAI-compatible HTTP API वापरतात. त्यामुळे base URL बदलून client code एका साधनातून दुसऱ्यावर हलवता येतो. फरक API मध्ये नाही. पहिली request अजून tokens generate करत असताना दुसरी request आल्यावर काय घडते, हा मुख्य फरक आहे.
Ollama नेमके काय आहे
Ollama हा सुविधा स्तर आहे. एका install command मधून तो model registry (ollama pull llama3.1:8b), weights साठी local store, chat prompt, systemd service आणि HTTP API उपलब्ध करून देतो. त्यातून उपलब्ध होणाऱ्या बहुतेक models या GGUF files असतात आणि त्या सहसा 4-bit quantized असतात. त्यामुळे 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) समर्थित architectures आपोआप MLX वर चालतात.
याचा GGUF runner llama.cpp वर आधारित आहे. llama.cpp ही C++ inference library आहे. सामान्य hardware वर GGUF quantization व्यवहार्य करण्याचे काम तिने केले. October 2026 पर्यंत Ollama दोन engines समर्थित करते: llama.cpp आणि MLX. Linux builds मध्ये CUDA सह MLX inference देखील समर्थित आहे. Development guide मध्ये cmake -B build . -DOLLAMA_MLX_BACKENDS=cuda_v13 वापरून हा backend सक्षम केला जातो. त्यासाठी CUDA 13+ आणि cuDNN 9+ prerequisites आहेत. त्यामुळे Ollama आणि llama.cpp यांची तुलना करताना प्रत्यक्षात ergonomics layer आणि तो ज्या घटकाभोवती wrapper देतो त्या घटकाची तुलना केली जाते.
या रचनेचे लक्ष्य एक user आहे. October 2026 पर्यंत OLLAMA_NUM_PARALLEL चे default मूल्य 1 आहे. याचा अर्थ एक model एका वेळी एक request process करतो आणि इतर सर्व requests default ने 512 entries असलेल्या queue मध्ये प्रतीक्षा करतात (OLLAMA_MAX_QUEUE). तुम्ही parallel setting वाढवू शकता. मात्र त्यासाठी लागणाऱ्या संसाधनांची किंमत खालील section मध्ये स्पष्ट केली आहे. तुम्ही Ollama यापूर्वी चालवले नसेल, तर VPS वर Ollama host करणे आणि port 11434 बंद ठेवणे येथून सुरुवात करा, कारण local API साठी authentication आवश्यक नाही.
vLLM प्रत्यक्षात काय आहे
vLLM हा केवळ inference server आहे. तो model library व्यवस्थापित करत नाही, तर चालू server साठी `vllm chat` client पुरवतो आणि request आली तेव्हा तुमच्यासाठी model pull करणार नाही. सुरू करताना तुम्ही Hugging Face repository चे नाव देता. vLLM तो एकच model load करतो आणि तुम्ही process थांबवेपर्यंत तो serve करतो.
या मर्यादित व्याप्तीच्या बदल्यात तुम्हाला throughput मिळतो. हे काम दोन mechanisms करतात. PagedAttention KV cache (key-value cache; प्रत्येक active request साठी model जतन करत असलेली प्रत्येक token ची attention state) fixed-size blocks मध्ये साठवते. ही पद्धत operating system memory page करण्यासारखी आहे. आता request साठी worst case नुसार आकाराचे एक मोठे सलग reservation आवश्यक राहत नाही. त्यामुळे पूर्वी reserved पण न वापरलेली memory अधिक concurrent requests साठी उपलब्ध होते. Continuous batching मुळे नवीन request सध्या चालू असलेला batch पूर्ण होण्याची वाट न पाहता पुढील decoding step मध्ये चालू batch मध्ये सामील होऊ शकते. Sequence पूर्ण झाल्यावर ती त्वरित batch मधून बाहेर पडते आणि तिची जागा पुन्हा भरली जाते.
व्यावहारिक परिणाम असा आहे: एका GPU वर concurrent users ची संख्या एकवरून तीस केली, तर एकूण tokens per second मोठ्या प्रमाणात वाढतात; मात्र प्रत्येक user चा वेग अपेक्षेपेक्षा खूपच कमी घटतो. Ollama च्या default वर्तनात, users ची संख्या एकवरून तीस केली, तर फक्त एकोणतीस जणांना प्रतीक्षा करावी लागते.
Continuous batching हाच मुख्य फरक
कल्पना करा की समान hardware असलेल्या प्रत्येक server वर एकाच वेळी पाच requests येतात.
Ollama च्या default settings मध्ये पहिली request पूर्ण होईपर्यंत तीच चालते. त्यानंतर दुसरी, आणि पुढे त्याच क्रमाने. पाचव्या caller ला चार पूर्ण generations पूर्ण होईपर्यंत प्रतीक्षा करावी लागते. एकूण throughput साधारणपणे एका generation च्या वेगाइतपतच राहतो, कारण processor एकावेळी फक्त एका sequence वर काम करत असतो.
vLLM सर्व पाच sequences एकाच forward pass मध्ये decode करतो. पाच sequences साठी एक token generate करण्याचा खर्च एका sequence साठी एक token generate करण्यापेक्षा फारसा जास्त नसतो. याचे कारण म्हणजे महागडा भाग model weights memory मधून वाचणे हा आहे आणि हा read संपूर्ण batch मध्ये share केला जातो. CPU inference slow करणारा memory-bandwidth चा हाच परिणाम येथेही लागू होतो: arithmetic साठी नव्हे, तर weights हलवण्यासाठी किंमत मोजावी लागते.
तुम्ही OLLAMA_NUM_PARALLEL=4 सेट करून यातील काही फायदा मिळवू शकता. मात्र यासाठी memory लागते. प्रत्येक parallel slot ला स्वतःचा KV cache आवश्यक असतो. Ollama context allocation विभागण्याऐवजी त्याचा गुणाकार करतो: त्याच्या FAQ नुसार आवश्यक RAM OLLAMA_NUM_PARALLEL गुणिले OLLAMA_CONTEXT_LENGTH प्रमाणात वाढते. त्यामुळे 8192 tokens साठी configured केलेल्या model विरुद्ध चार parallel requests असतील, तर प्रत्येक request साठी 8192 tokens राखले जातात; परंतु box मध्ये एकूण 32768 tokens इतका cache ठेवावा लागतो. हा 8192 आकडा निश्चित नसून एक configuration choice आहे. त्यामुळे num_ctx वाढवून त्यासाठी लागणारी RAM मोजणे हीच चार slots मावतील की नाही हे ठरवणारी पायरी आहे. vLLM चा paged cache प्रत्येक slot साठी पूर्ण window सुरुवातीपासून reserve करण्याची गरज टाळतो, कारण request प्रत्यक्षात वाढत जाईल तसे blocks allocate केले जातात. कोणत्याही परिस्थितीत, एक box एकावेळी किती लोकांना सेवा देऊ शकतो याची कमाल मर्यादा KV cache size, prefill cost आणि queue depth यांवर ठरते. म्हणूनच एका व्यक्तीसाठी योग्य वाटणारा server पाच जणांवर crawl करतो.
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."ही install script एक ollama system user तयार करते, binary install करते आणि 127.0.0.1:11434 शी जोडलेली ollama.service नोंदणी करते. --verbose ने छापलेली eval rate ओळ त्या मशीनवरील प्रत्यक्ष tokens per second दर्शवते. प्रकाशित केलेल्या कोणत्याही आकडेवारीपेक्षा या मूल्यावर विश्वास ठेवा. एका prompt मधील एक मोजमाप हे क्षमता दर्शवणारे अंतिम मूल्य नसून सुरुवातीचा संदर्भ आहे. त्यामुळे विविध concurrency स्तरांवर tokens per second मोजणे यामुळे तुमच्या अपेक्षित load वर मशीन स्थिर राहते का आणि प्रति token खर्च करण्यापेक्षा GPU भाड्याने घेणे फायदेशीर ठरते का हे समजते.
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 psollama ps मधून कोणती configuration load झाली आहे ते दिसते आणि त्यातील PROCESSOR column वास्तविक स्थिती दर्शवतो. 100% CPU म्हणजे GPU वापरले जात नाही. Ollama slow असल्याच्या बहुतेक अहवालांचे हेच वास्तविक कारण असते. या drop-in मधील OLLAMA_KEEP_ALIVE=30m line शांत असलेल्या मशीनवरही तितकीच महत्त्वाची आहे. कारण request न आल्यास default पाच मिनिटांनंतर model unload करते. requests दरम्यान model resident ठेवणे यामुळे अर्ध्या तासापर्यंतच्या विश्रांतीनंतर आलेल्या पहिल्या prompt ला पूर्ण load time पुन्हा द्यावा लागत नाही. तुमचा idle कालावधी यापेक्षा मोठा असल्यास अधिक मोठी value सेट करा.
vLLM सह स्थापित करून सेवा द्या
vLLM च्या GPU builds साठी Linux आवश्यक आहे. Apple Silicon वरील macOS मध्ये CPU-only support उपलब्ध आहे आणि 0.32.0 release मध्ये prebuilt wheel दिले आहे. त्या Mac वर GPU acceleration vLLM-Metal मार्फत मिळते. vLLM-Metal हा MLX वर आधारित, community-maintained स्वतंत्र plugin आहे. Python बाबत, सध्याचे release (0.32.0, October 2026) 3.11 ते 3.14 आवृत्त्या स्वीकारते. Install guide मध्येही हीच range दिली आहे. Python 3.10 ला 0.32.0 मध्ये support मधून काढले आहे. त्यामुळे खाली वापरलेले 3.12 हे सुरक्षित पर्याय आहे. ते स्वतंत्र virtual environment मध्ये install करा, कारण यामुळे विशिष्ट PyTorch build install होते:
uv venv --python 3.12 --seed
source .venv/bin/activate
uv pip install vllm --torch-backend=auto
vllm download-kernelsOctober 2026 पर्यंत vLLM च्या NVIDIA install guide मध्ये शेवटची ओळ दिली आहे. ती FlashInfer चे precompiled kernels install करते. हे kernels उपलब्ध नसतील, तर vLLM startup वेळी kernels download करून compile करते. Guide नुसार Hopper आणि त्यानंतरच्या GPU वर यासाठी काही मिनिटे अधिक लागू शकतात. प्रत्येक vLLM upgrade नंतर ही command पुन्हा चालवा, कारण kernels जुळत नसतील तर FlashInfer import होण्यास नकार देते.
यानंतर model serve करा. येथे दिलेले नाव हे short tag नसून Hugging Face repository id आहे:
vllm serve Qwen/Qwen2.5-1.5B-Instructपहिल्यांदा startup होण्यास वेळ लागतो. सुरुवातीला weights download होतात आणि त्यानंतर किती KV cache blocks बसतील हे ठरवण्यासाठी GPU profiling केले जाते. सेवा port 8000 वर listening करते. Client code लिहिण्यापूर्वी ती तपासा:
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?"}]}'या मशीनवर Docker आधीपासून असल्यास, official image मुळे CUDA dependency चे काम टाळता येते:
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 वाढवणे हा आणखी एक पर्याय आहे. विशेषतः tensor-parallel inference दरम्यान PyTorch processes मधून tensors पाठवण्यासाठी shared memory वापरते.
Production मध्ये सर्वाधिक महत्त्वाचे flags म्हणजे --max-model-len (तुम्ही स्वीकारण्यास तयार असलेली आणि त्यासाठी खर्च करावयाची context window), --gpu-memory-utilization (vLLM ला GPU card मधील वापरता येणारा भाग; October 2026 पर्यंत default 0.92), एकाच model चे अनेक GPU वर विभाजन करण्यासाठी --tensor-parallel-size, आणि --api-key.
vLLM वर Authentication साठी एक flag आहे, पण Ollama च्या local API वर ते उपलब्ध नाही
vLLM ला token दिल्यास ते bearer token अनिवार्य करते:
vllm serve Qwen/Qwen2.5-1.5B-Instruct --api-key token-abc123हेच मूल्य VLLM_API_KEY environment variable मधूनही देता येते. हा token नसलेली /v1 कडे केलेली request 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 चारही prefixes तपासतो. Guide आणि help text दोन्ही सांगतात की इतर endpoints authenticate केले जात नाहीत. विशेषतः /invocations endpoint यामध्ये येतो; तो /v1 प्रमाणेच inference उपलब्ध करून देतो. त्यामुळे port 8000 public interface वर publish न करण्याचे हे पुरेसे कारण आहे. vLLM च्या security guide नुसार rate limiting ची जबाबदारी त्याच्या पुढे असलेल्या reverse proxy कडे सोपवली जाते. तसेच plain HTTP वर पाठवलेला token transit दरम्यान वाचता येतो. तरीही या flag मुळे server कडे request करणाऱ्या caller ची ओळख पटवण्याची संकल्पना उपलब्ध होते.
Ollama च्या local API साठी authentication आवश्यक नाही. Cloud models, model publishing आणि private model downloads साठी sign-in आवश्यक आहे; ollama.com वरील direct API access साठी API key आवश्यक आहे. 11434 पर्यंत पोहोचू शकणारी कोणतीही process models चालवू, pull करू किंवा delete करू शकते. ते loopback वरच ठेवा आणि तुम्ही स्वतः host केलेल्या WireGuard VPN द्वारे, किंवा TLS (transport layer security) terminate करणाऱ्या authentication असलेल्या reverse proxy मार्फत त्याचा access घ्या.
हार्डवेअर: प्रत्येकाला काय आवश्यक आहे
Ollama CPU वर चालते. 4-bit quantized model साठी प्रत्येक billion parameters मागे साधारण अर्धा gigabyte RAM लागतो. त्याशिवाय runtime overhead साठी सुमारे एक gigabyte आणि context साठी अतिरिक्त memory लागते. त्यामुळे 3B model साठी सुमारे 4 GB मोकळी memory, तर 8B model साठी सुमारे 8 GB मोकळी memory आवश्यक असते. Shared vCPU वरचा वेग single digit ते low double digit tokens per second इतका असतो. हे memory bandwidth मुळे होते; configuration चुकीची असल्यामुळे नाही. कोणताही flag ते दुरुस्त करू शकत नाही. अंदाजे नियमाऐवजी एखाद्या विशिष्ट release वर हे गणित प्रत्यक्ष पाहायचे असल्यास, VPS वर Nemotron 3.5 Lightning चालवणे यामध्ये pull करायचा अचूक tag, model load झाल्यानंतर वापरली जाणारी RAM आणि CPU-only वापर पुरेसा जलद आहे का हे स्पष्ट केले आहे.
vLLM साठी GPU गृहीत धरला जातो. त्याच्या default path मध्ये unquantized weights 16-bit precision मध्ये serve केले जातात. त्यासाठी प्रत्येक billion parameters मागे साधारण 2 GB लागतात. त्यामुळे 8B model साठी weights पुरतेच सुमारे 16 GB video memory लागते. vLLM साठी आवश्यक असलेला concurrency देणारा KV cache याव्यतिरिक्त लागतो. 24 GB card वर त्यासाठी वापरण्याजोगी cache उरते. 16 GB card वर ती उरत नाही. त्यामुळे लहान model निवडा, --quantization द्या (quantized checkpoint सह किंवा load वेळी full-precision weights quantize करण्यासाठी), किंवा --cpu-offload-gb वापरून weights चा काही भाग system RAM मध्ये ठेवा. या पद्धतीत precision कायम राहते, पण वेग कमी असतो, कारण प्रत्येक forward pass वेळी हे weights GPU कडे पाठवावे लागतात. CPU backend उपलब्ध आहे आणि त्यासाठी स्वतंत्र wheels आहेत. मात्र त्यामुळे vLLM चालवण्यामागील मुख्य कारणच नाहीसे होते.
म्हणून बहुतेक वेळा hardware चा प्रश्नच software चा निर्णय ठरवतो. GPU नसेल, तर Ollama वापरा. भाड्याने घेतलेल्या GPU चा utilisation requests serialise होत असल्यामुळे 5 percent असेल, तर vLLM वापरा.
तुमच्या workload साठी कोणता पर्याय
- एका व्यक्तीसाठी, CPU VPS वर drafting आणि summarising करण्यासाठी: Ollama. त्याचा वेग स्वीकारार्ह आहे आणि यापेक्षा सोपे काहीही नाही.
- coding assistant किंवा तुमची साधने local model शी जोडणारा MCP server, जो फक्त तुम्ही वापरता: Ollama. प्रत्यक्ष workload मध्ये concurrency एकच आहे.
- या आठवड्यात पाच models ची तुलना करण्यासाठी: Ollama. tagged models pull आणि delete करणे हे त्याचेच बलस्थान आहे, तर vLLM मध्ये प्रत्येक model साठी process restart आवश्यक असतो.
- internal app, chat product किंवा प्रत्यक्ष users असलेली retrieval pipeline: vLLM. येथे batching मुळे GPU bill योग्य ठरतो.
- रात्रभर एक लाख documents चे scoring करणारे batch job: उच्च
--max-num-seqsसह vLLM. येथे throughput हेच महत्त्वाचे metric आहे; प्रत्येक document साठीची latency महत्त्वाची नाही. - एकाच वेळी अनेक self-hosted AI agents model ला requests पाठवणारे agent platform: vLLM, कारण agent traffic स्वभावतः bursty आणि parallel असतो.
चुकांच्या पद्धती आणि दिसणारे संदेश
vLLM KV cache त्रुटीसह सुरू होण्यास नकार देतो. संदेशात दोन्ही संख्या दिलेल्या असतात:
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.वजन load केल्यानंतर उपलब्ध असलेल्या memory पेक्षा model ने घोषित केलेली context window मोठी आहे. ती --max-model-len 8192 वापरून कमी करा किंवा card दुसरे काही वापरत नसल्यास --gpu-memory-utilization वाढवा.
Generation दरम्यान Ollama Killed दाखवतो. Linux out-of-memory killer ने process थांबवला, कारण model ला या box मध्ये उपलब्ध RAM पेक्षा जास्त RAM आवश्यक होती. sudo dmesg | grep -i oom वापरून याची खात्री करा. उपाय म्हणजे लहान किंवा अधिक quantized model वापरणे; ही setting बदलण्याची समस्या नाही.
एकट्याने चालवल्यावर Ollama योग्य उत्तरे देतो, पण load असताना थांबल्यासारखा वाटतो. कुठेही error दिसत नाही. अधिक callers असताना requests ला अधिक वेळ लागतो, कारण OLLAMA_NUM_PARALLEL=1 त्यांना एकामागोमाग एक process करते. एक caller model ने थांबण्याचा निर्णय घेईपर्यंत एकमेव slot धरून ठेवतो. त्यामुळे लांब उत्तरे queue अधिक मोठी करतात आणि त्यामागील सर्व callers अडकतात. म्हणून num_predict वापरून reply ची कमाल लांबी ठरवणे प्रत्येक 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 गरजेनुसार pull करते; vLLM तसे करत नाही. Request body मधील model field तुम्ही launch केलेल्या repository id शी जुळले पाहिजे किंवा तुम्ही value set केली असल्यास --served-model-name शी जुळले पाहिजे. curl http://localhost:8000/v1/models वापरून अचूक string तपासा.
दोन्ही चालवणे हा व्यवहार्य पर्याय आहे
हे परस्परविरोधी पर्याय नाहीत. एक सामान्य रचना अशी असते: अॅप्लिकेशनला सेवा देण्यासाठी GPU instance वर vLLM चालवणे आणि त्याच्याजवळील सामान्य VPS वर स्थानिक scripts, cron jobs आणि नवीन model releases तपासण्यासाठी Ollama चालवणे. दोन्ही endpoints OpenAI-compatible आहेत. त्यामुळे एकच client library आणि base-URL बदल पुरेसा असतो. येथे कोणतेही engine निवडण्यापेक्षा खर्च नियंत्रण अधिक महत्त्वाचे आहे, कारण निष्क्रिय GPU साठीही व्यस्त GPU इतकाच billing होतो. तसेच agent आणि inference costs अंदाजे व नियंत्रणात ठेवणे ही server निवडण्यापेक्षा वेगळी शिस्त आहे.
FAQ
vLLM हे Ollama पेक्षा जलद आहे का?
समान GPU वर एका विनंतीसाठी हा फरक मर्यादित असतो, कारण दोन्ही समान गणिती प्रक्रिया करतात. अनेक समांतर विनंत्यांसाठी vLLM लक्षणीयरीत्या पुढे असते, कारण continuous batching प्रत्येक सक्रिय sequence चे decoding एकाच forward pass मध्ये करते, तर Ollama ची default पद्धत त्या एकामागोमाग एक चालवते. केवळ CPU असलेल्या मशीनवर दोन्हीकडे inference साठी समर्थित मार्ग आहेत; vLLM स्वतंत्र CPU wheels वापरते.
vLLM GPU शिवाय चालू शकते का?
होय, तिच्या CPU backend द्वारे. Standard wheels NVIDIA किंवा AMD GPU साठी असतात. तसेच, batched requests मुळे accelerator सतत व्यस्त ठेवणे हे vLLM चे मुख्य उद्दिष्ट आहे; 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 देखील वितरित करते. हा engine Apple Silicon वर safetensors-आधारित models चालवतो आणि Linux वर CUDA builds समर्थित करतो. त्यामुळे अंतर्गत अंमलबजावणी नेहमी समान असेलच असे नाही.
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 मूल्य 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 साठी Qwen/Qwen2.5-1.5B-Instruct सारखा पूर्ण repository id वापरला जातो.