SSD Nodes Learn Hosting plans →
Mga Gabay Matt ConnorNi Matt Connor

Ollama vs vLLM: Alin ang Tamang LLM Server?

Ollama para sa isang user at puwedeng CPU; vLLM para sa mataas na throughput sa GPU. Tingnan ang tamang workload at commands para sa bawat isa.

Ollama kumpara sa vLLM, sa isang talata

Ang Ollama ay isang model manager na may kasamang server: dina-download nito ang quantized weights, nilo-load ang mga ito, at sumasagot sa 127.0.0.1:11434, gamit ang CPU kung iyon lang ang mayroon ang machine. Ang vLLM ay isang throughput engine: pinananatili nitong abala ang GPU sa maraming request na sabay-sabay na tumatakbo, kaya maling tool ito sa machine na walang GPU. Iyon ang buong batayan ng pagpili. Ang isang tao na nakikipag-usap sa isang local assistant ay isang Ollama job. Ang application na nagsisilbi sa isang team ay isang vLLM job.

Pareho silang gumagamit ng OpenAI-compatible HTTP API, kaya maililipat ang client code sa pagitan ng mga ito sa pamamagitan ng pagpapalit ng base URL. Hindi ang API ang pinagkaiba. Ang pinagkaiba ay ang nangyayari kapag may dumating na second request habang nagge-generate pa ng tokens ang unang request.

Ano talaga ang Ollama

Ang Ollama ay isang convenience layer. Nagbibigay ito ng model registry (ollama pull llama3.1:8b), lokal na imbakan ng weights, chat prompt, systemd service, at HTTP API sa pamamagitan ng isang install command. Karamihan sa mga modelong sini-serve nito ay mga GGUF file na karaniwang naka-4-bit quantized. Dahil dito, humigit-kumulang 5 GB lang sa disk ang kailangan ng 7B o 8B model sa halip na 16 GB. Binabawasan ng quantization ang memory na kailangan para sa CPU inference. Sa Apple Silicon Mac, maaari rin itong magpatakbo ng mga modelong nakabatay sa safetensors sa pamamagitan ng MLX engine. Simula v0.40.0 (September 2026), awtomatikong tumatakbo sa MLX ang mga sinusuportahang architecture.

Ang GGUF runner nito ay nakabatay sa llama.cpp, ang C++ inference library na nagpa-practical sa GGUF quantization sa karaniwang hardware. Noong October 2026, sinusuportahan ng Ollama ang dalawang engine: llama.cpp at MLX. Sinusuportahan din ng Linux builds ang MLX inference gamit ang CUDA. Ino-on ng development guide ang backend na iyon gamit ang cmake -B build . -DOLLAMA_MLX_BACKENDS=cuda_v13, at kailangan ang CUDA 13+ at cuDNN 9+ bilang prerequisites. Kaya kapag ikinukumpara ng mga tao ang Ollama sa llama.cpp, kadalasan ay ikinukumpara nila ang isang ergonomics layer sa mismong tool na binabalot nito.

Ang target na disenyo nito ay isang user. Noong October 2026, ang default para sa OLLAMA_NUM_PARALLEL ay 1. Ibig sabihin, isang request lang ang pinoproseso ng isang model sa bawat pagkakataon, at naghihintay sa queue ang lahat ng iba pa. May default na 512 entry ang queue (OLLAMA_MAX_QUEUE). Maaari mong taasan ang parallel setting, at ipinapaliwanag ng susunod na section ang kapalit nito sa resources. Kung hindi mo pa nagagamit ang Ollama, magsimula sa pagho-host ng Ollama sa isang VPS at pagpapanatiling sarado ng port 11434, dahil walang authentication ang lokal na API.

Ano talaga ang vLLM

Ang vLLM ay inference server lamang. Hindi ito namamahala ng model library, nagbibigay ito ng vllm chat client para sa tumatakbong server, at hindi ito kukuha ng model sa oras ng request. Tinutukoy mo ang isang Hugging Face repository sa pagsisimula, nilo-load nito ang model na iyon, at sine-serve ito hanggang ihinto mo ang process.

Ang kapalit ng limitasyong ito ay mataas na throughput. Dalawang mekanismo ang gumagawa nito. Iniimbak ng PagedAttention ang KV cache (key-value cache, ang per-token na attention state na pinananatili ng model para sa bawat aktibong request) sa mga block na may takdang laki, gaya ng pagpa-page ng memory ng operating system. Hindi na kailangan ng request ng isang malaking contiguous reservation na nakabatay sa worst case, kaya nagiging available para sa mas maraming concurrent request ang memory na dati ay naka-reserve ngunit hindi ginagamit. Hinahayaan ng continuous batching na sumali ang bagong request sa kasalukuyang batch sa susunod na decoding step, sa halip na maghintay na matapos ang kasalukuyang batch. Agad na inaalis sa batch ang natapos na sequence at pinapalitan ang slot nito.

Ang praktikal na resulta: sa iisang GPU, kapag tumaas mula sa isang concurrent user hanggang tatlumpu, malaki ang itinaas ng kabuuang tokens per second, samantalang mas kaunti kaysa inaasahan ang ibinababa ng speed bawat user. Sa default ng Ollama, kapag tumaas mula sa isang user hanggang tatlumpu, dalawampu't siyam na tao lang ang naghihintay.

Continuous batching ang pangunahing pagkakaiba

Isipin ang limang request na sabay-sabay na dumarating sa bawat server na may magkakaparehong hardware.

Sa default settings, tinatapos muna ng Ollama ang unang request bago nito simulan ang ikalawa, at ganoon din ang kasunod. Hihintayin ng ikalimang caller ang apat na buong generation. Humigit-kumulang kapantay lang ng bilis ng isang generation ang kabuuang throughput, dahil isang sequence lang ang pinoproseso ng processor sa bawat sandali.

Dine-decode ng vLLM ang lahat ng lima sa iisang forward pass. Halos hindi mas mahal ang pag-generate ng isang token para sa limang sequence kaysa sa pag-generate ng isang token para sa isang sequence, dahil ang magastos na bahagi ay ang pagbasa ng model weights mula sa memory, at pinagsasaluhan ng buong batch ang read na iyon. Ito rin ang memory-bandwidth na dahilan kung bakit mabagal ang CPU inference: binabayaran mo ang paglipat ng weights, hindi ang arithmetic.

Maitatakda mo ang OLLAMA_NUM_PARALLEL=4 at makukuha ang ilan sa benepisyong ito. Memory ang kapalit. Kailangan ng bawat parallel slot ng sarili nitong KV cache, at pinaparami ng Ollama ang context allocation sa halip na hatiin ito: ayon sa FAQ nito, ang kinakailangang RAM ay uma-scale ng OLLAMA_NUM_PARALLEL beses sa OLLAMA_CONTEXT_LENGTH. Kaya ang apat na parallel request laban sa model na naka-configure para sa 8192 token ay may tig-8192 token pa rin, pero kailangang maglaman ang server ng cache para sa kabuuang 32768 token. Ang 8192 na iyon ay isa ring configuration choice, hindi awtomatikong value, kaya ang pagtataas ng num_ctx at paglalaan ng RAM para rito ang nagtatakda kung magkakasya ba ang apat na slot. Ang paged cache ng vLLM ang pumipigil sa pagreserba agad ng buong window para sa bawat slot, dahil naglalaan ito ng mga block sa request habang aktuwal na lumalaki ang request. Sa alinmang paraan, nakadepende sa laki ng KV cache, prefill cost, at queue depth ang maximum na bilang ng taong kayang pagsilbihan ng isang server nang sabay-sabay. Ito ang dahilan kung bakit maayos ang server para sa isang tao pero bumabagal nang husto kapag lima na.

Mag-install at mag-serve gamit ang 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."

Gumagawa ang install script ng ollama system user, ini-install ang binary, at nirerehistro ang ollama.service na naka-bind sa 127.0.0.1:11434. Ang eval rate line na ipinapakita ng --verbose ang aktuwal na tokens per second sa server na iyon. Mas dapat itong pagkatiwalaan kaysa sa anumang published figure. Ang isang reading mula sa isang prompt ay panimulang punto lamang, hindi sukatan ng capacity. Kaya ang pagsukat ng tokens per second sa iba’t ibang concurrency ang nagpapakita kung kakayanin ng server ang inaasahan mong load at kung mas matipid ang pag-rent ng GPU kaysa pagbabayad kada token.

Para pataasin ang concurrency, gumamit ng systemd drop-in upang hindi mabura ng upgrade ang pagbabago:

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

Ipinapakita ng ollama ps kung ano ang naka-load, at sinasabi ng PROCESSOR column nito ang aktuwal na kalagayan. Ibig sabihin ng 100% CPU ay walang GPU na ginagamit. Ito ang tapat na paliwanag sa karamihan ng mga ulat na mabagal ang Ollama. Mahalaga rin ang OLLAMA_KEEP_ALIVE=30m line sa drop-in kahit tahimik ang server, dahil ina-unload ng default ang model makalipas ang limang minuto na walang request. Ang pagpapanatiling resident ng model sa pagitan ng mga request ang pumipigil na muling bayaran ng unang prompt pagkatapos ng hanggang kalahating oras na walang activity ang buong load time. Kung mas mahaba rito ang mga panahon ng kawalan ng activity, magtakda ng mas mahabang value.

Mag-install at mag-serve gamit ang vLLM

Kailangan ng Linux ng GPU builds ng vLLM. Sa macOS gamit ang Apple Silicon, CPU-only support lamang ang available gamit ang prebuilt wheel sa release na 0.32.0. Ang GPU acceleration sa mga Mac na iyon ay galing sa vLLM-Metal, isang hiwalay na plugin na pinapanatili ng komunidad at binuo sa MLX. Para sa Python, tinatanggap ng kasalukuyang release (0.32.0, October 2026) ang 3.11 hanggang 3.14. Pareho rin ang range na nakalista sa install guide. Inalis ang suporta para sa Python 3.10 sa 0.32.0, kaya ang 3.12 na ginagamit sa ibaba ang ligtas na piliin. I-install ito sa sarili nitong virtual environment dahil nag-i-install ito ng partikular na PyTorch build:

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

Ang huling linya ay nasa NVIDIA install guide ng vLLM noong October 2026. Ini-install nito ang mga precompiled kernel ng FlashInfer. Kung wala ang mga ito, dina-download at kino-compile ng vLLM ang mga kernel sa pagsisimula. Ayon sa guide, maaari itong magdagdag ng ilang minuto sa Hopper at mas bagong GPU. Patakbuhin itong muli pagkatapos ng bawat upgrade ng vLLM dahil tumatangging mag-import ang FlashInfer kapag hindi tugma ang mga kernel.

Pagkatapos, mag-serve ng isang model. Ang pangalan ay isang Hugging Face repository id, hindi isang maikling tag:

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

Mabagal ang unang pagsisimula dahil dina-download muna nito ang weights at pagkatapos ay bina-profile ang GPU upang matukoy kung ilang KV cache block ang kasya. Nakikinig ito sa port 8000. Suriin muna ito bago magsulat ng 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?"}]}'

Kung naka-install na ang Docker sa server, iniiwasan ng official image ang pag-asikaso sa 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

Binibigyan ng --ipc=host ang container ng access sa shared memory ng host. Isa pang option ang pagtaas ng --shm-size. Ginagamit ng PyTorch ang shared memory upang magpasa ng tensors sa pagitan ng mga proseso, lalo na para sa tensor-parallel inference.

Ang pinakamahahalagang flag sa production ay ang --max-model-len, ang context window na handa mong bayaran; ang --gpu-memory-utilization, ang fraction ng GPU card na maaaring gamitin ng vLLM, na 0.92 bilang default noong October 2026; ang --tensor-parallel-size para hatiin ang isang model sa ilang GPU; at ang --api-key.

Ang authentication ay isang flag sa vLLM at wala sa local API ng Ollama

Nagpapatupad ang vLLM ng bearer token kapag binigyan mo ito ng isa:

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

Maaari ring manggaling ang parehong value sa VLLM_API_KEY environment variable. Ang request sa /v1 na walang token ay nagbabalik ng HTTP 401. Gayunman, hindi saklaw ng key ang buong server. Ayon sa security guide ng vLLM at sa authentication code sa source ng 0.32.0, inilalapat lamang ito sa mga endpoint sa ilalim ng /v1, /v2, /inference, at /cohere path prefixes. Sa vllm serve page, ang --api-key help text ay unang tatlo lamang ang inililista, ngunit sinusuri ng code ang lahat ng apat. Parehong sinasabi ng guide at help text na hindi authenticated ang iba pang endpoint, lalo na ang /invocations, na naglalantad ng parehong inference gaya ng /v1. Sapat na itong dahilan upang huwag i-publish ang port 8000 sa public interface. Iniiwan din ng security guide ng vLLM ang rate limiting sa reverse proxy na nasa harap nito. Bukod dito, mababasa habang ipinapadala ang token sa plain HTTP. Gayunman, ipinapakita ng flag na may konsepto ang server ng caller.

Walang kinakailangang authentication ang local API ng Ollama. Kailangan ng sign-in para sa cloud models, pag-publish ng models, at pag-download ng private models. Kailangan naman ng API key para sa direktang API access sa ollama.com. Maaaring mag-run, mag-pull, o mag-delete ng models ang anumang process na makakaabot sa 11434. Panatilihin ito sa loopback at i-access sa pamamagitan ng sarili mong WireGuard VPN, o sa pamamagitan ng authenticating reverse proxy na nagte-terminate ng TLS (transport layer security).

Hardware: ano ang kailangan ng bawat isa

Tumatakbo ang Ollama sa CPU. Ang 4-bit quantized model ay nangangailangan ng humigit-kumulang kalahating gigabyte ng RAM para sa bawat bilyong parameter, bukod pa sa humigit-kumulang isang gigabyte na runtime overhead at karagdagang memory para sa context. Kaya nangangailangan ang 3B model ng humigit-kumulang 4 GB na libreng memory, habang ang 8B model ay nangangailangan ng humigit-kumulang 8 GB. Ang bilis sa shared vCPU ay nasa single digit hanggang mababang double digit na tokens bawat segundo. Limitasyon ito ng memory bandwidth, hindi maling configuration, kaya walang flag na makapaglulutas nito. Para makita ang aktuwal na resulta sa isang partikular na release sa halip na umasa sa pangkalahatang tantiya, itinatakda ng pagpapatakbo ng Nemotron 3.5 Lightning sa isang VPS ang eksaktong tag na ida-download, ang RAM na ginagamit nito kapag loaded na, at kung sapat ang bilis ng CPU-only setup para maging praktikal.

Ipinapalagay ng vLLM na may GPU. Ang default nitong path ay naghahatid ng unquantized weights sa 16-bit precision, na humigit-kumulang 2 GB para sa bawat bilyong parameter. Dahil dito, nangangailangan ang 8B model ng humigit-kumulang 16 GB ng video memory para sa weights lamang, bago pa isama ang KV cache na nagbibigay ng concurrency na dahilan kung bakit mo ini-install ang vLLM. Sa 24 GB na card, may sapat na natitirang espasyo para sa isang praktikal na cache. Sa 16 GB na card, wala, kaya kailangan mong pumili ng mas maliit na model, gumamit ng --quantization (kasama ang quantized checkpoint, o para i-quantize ang full-precision weights habang nilo-load), o ilipat ang bahagi ng weights sa system RAM gamit ang --cpu-offload-gb. Nananatili ang precision ng weights sa huling opsyon, pero mas mabagal ito dahil inililipat ang mga weight na iyon sa GPU sa bawat forward pass. May CPU backend, na gumagamit ng sarili nitong hiwalay na wheels, pero inaalis nito ang pangunahing dahilan para gamitin ang vLLM.

Kaya kadalasan, sinasagot ng hardware question ang software question. Kung walang GPU, gamitin ang Ollama. Kung ang rented GPU ay nasa 5 percent utilisation dahil serialized ang mga request, gamitin ang vLLM.

Alin ang angkop para sa iyong workload

  • Isang user, isang CPU VPS, para sa pagbuo ng draft at pagbubuod: Ollama. Katanggap-tanggap ang bilis, at wala nang mas simple rito.
  • Isang coding assistant, o isang MCP server na nag-uugnay ng iyong mga tool sa isang local model, na ikaw lamang ang gumagamit: Ollama. Ang concurrency na one ay ang aktuwal na workload.
  • Naghahambing ng limang model ngayong linggo: Ollama. Eksaktong ito ang mahusay nitong gawin—mag-pull at mag-delete ng mga tagged model—samantalang kailangan ng vLLM ng process restart para sa bawat model.
  • Isang internal app, chat product, o retrieval pipeline na may aktuwal na mga user: vLLM. Dito sulit ang GPU bill dahil sa batching.
  • Isang batch job na nagso-score ng isang daang libong dokumento magdamag: vLLM, na may mataas na --max-num-seqs. Throughput lamang ang mahalagang metric, at hindi mahalaga ang latency ng bawat dokumento.
  • Isang agent platform kung saan sabay-sabay na kumokonekta sa model ang ilang self-hosted AI agent: vLLM, dahil likas na bursty at parallel ang traffic ng mga agent.

Mga failure mode at mga string na makikita mo

Tumangging magsimula ang vLLM dahil sa error sa KV cache. Parehong numero ang binabanggit sa mensahe:

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.

Mas malaki ang context window na idineklara ng model kaysa sa memory na natira matapos i-load ang weights. Bawasan ito gamit ang --max-model-len 8192, o dagdagan ang --gpu-memory-utilization kung walang ibang gumagamit sa card.

Nagpi-print ang Ollama ng Killed habang ginagawa ang output. Itinigil ng Linux out-of-memory killer ang proseso dahil mas maraming RAM ang kailangan ng model kaysa sa mayroon ang server. Kumpirmahin ito gamit ang sudo dmesg | grep -i oom. Ang solusyon ay gumamit ng mas maliit o mas heavily quantized na model, hindi magbago ng setting.

Maayos sumagot ang Ollama kapag mag-isa, pero bumabagal kapag may load. Walang lumalabas na error kahit saan. Mas tumatagal lang ang mga request kapag mas maraming caller, dahil sine-serialize ng OLLAMA_NUM_PARALLEL=1 ang mga ito. Lalong lumalala ang pila kapag mahahaba ang sagot, dahil hinaharangan ng isang caller na gumagamit sa nag-iisang slot ang lahat ng kasunod hanggang magpasya ang model na huminto. Kaya ang paglilimita sa reply gamit ang num_predict ay nagtatakda ng maximum na tagal na maaaring gamitin ng isang turn sa server. Taasan ang parallel setting at tanggapin ang karagdagang RAM na kailangan ng context ng bawat slot, o ilipat ang workload sa vLLM.

Nagbabalik ang vLLM ng 401 sa bawat /v1 call. Sinimulan mo ito gamit ang --api-key, pero walang ipinapadalang Authorization header ang client. Karamihan sa mga OpenAI client library ay ipinapasa bilang key ang anumang value na ibinigay mo, kaya doon ito itakda sa halip na alisin ang flag.

Sinasabi ng vLLM na hindi nahanap ang model. Nagda-download ang Ollama kapag kailangan, pero hindi ito ginagawa ng vLLM. Dapat tumugma ang model field sa request body sa repository id na ginamit mo sa pag-launch, o sa value ng --served-model-name kung nagtakda ka nito. Kumpirmahin ang eksaktong string gamit ang curl http://localhost:8000/v1/models.

Parehong patakbuhin ay isang makatuwirang sagot

Hindi kailangang pumili ng isa lamang. Karaniwang setup ang vLLM sa isang GPU instance para maghatid ng application, habang nasa ordinaryong VPS ang Ollama para sa mga lokal na script, cron job, at pagsubok ng mga bagong model release. OpenAI-compatible ang parehong endpoint, kaya sapat na ang isang client library at pagpapalit ng base URL para magamit ang mga ito. Mas mahalaga rito ang cost control kaysa sa alinmang engine, dahil pareho ang singil sa idle na GPU at sa busy na GPU. Hiwalay na disiplina ang pagpapanatiling predictable ng gastos sa agent at inference kumpara sa pagpili ng server.

FAQ

Mas mabilis ba ang vLLM kaysa sa Ollama?

Para sa isang request sa parehong GPU, maliit lamang ang agwat dahil pareho silang nagsasagawa ng parehong arithmetic. Para sa maraming sabay-sabay na request, mas mabilis nang malaki ang vLLM dahil dine-decode ng continuous batching ang bawat aktibong sequence sa isang forward pass, samantalang isa-isang pinapatakbo ng default na Ollama ang mga ito. Sa CPU-only na machine, parehong may suportadong inference path, at gumagamit ang vLLM ng hiwalay na CPU wheels.

Maaari bang tumakbo ang vLLM nang walang GPU?

Oo, gamit ang CPU backend nito. Ang standard wheels ay nakatuon sa NVIDIA o AMD GPUs, at nawawala sa CPU ang dahilan kung bakit ginagamit ang vLLM: ang panatilihing puno ang accelerator sa pamamagitan ng batched requests. May CPU backend ito, na may hiwalay na wheels para sa x86 at Arm. Para sa aktuwal na CPU inference, gamitin nang direkta ang Ollama o llama.cpp.

Ano ang pagkakaiba ng Ollama at llama.cpp?

Ang llama.cpp ang inference library, at ang GGUF ang quantized weight format nito. Ginagamit ito ng Ollama para sa GGUF inference at nagdaragdag ito ng model registry, tagged downloads, model management, at systemd unit. May MLX engine din ang Ollama na nagpapatakbo ng mga model na nakabatay sa safetensors sa Apple Silicon at sumusuporta sa CUDA builds sa Linux, kaya hindi palaging magkapareho ang mga ito sa ilalim.

Gaano kalaking GPU memory ang kailangan ng vLLM para sa isang 8B model?

Sa 16-bit precision, humigit-kumulang 16 GB ang kailangan ng weights lamang, o mga 2 GB bawat bilyong parameter, at kailangan pa ng espasyo para sa KV cache. Komportable ang isang 24 GB card. Sa 16 GB card, kailangan ng quantized model, mas maliit na model, o --cpu-offload-gb upang mailipat ang bahagi ng weights sa system RAM kapalit ng mas mababang speed. Sinasabi ng vLLM na bahagi ng card na itinakda ng --gpu-memory-utilization ang gagamitin nito; ang default nito ay 0.92 noong October 2026.

Kailangan ko bang baguhin ang application code para lumipat sa pagitan ng mga ito?

Karaniwan, base URL, API key, at model name lamang ang kailangang baguhin. Ibinibigay ng Ollama ang OpenAI-compatible surface nito sa http://127.0.0.1:11434/v1 at hindi nito pinapansin ang key, samantalang ibinibigay ng vLLM ang http://localhost:8000/v1 at ipinapatupad nito ang key sa mga /v1 route nito kung may itinakda ka. Magkaiba ang anyo ng mga model name: llama3.1:8b para sa Ollama at full repository id gaya ng Qwen/Qwen2.5-1.5B-Instruct para sa vLLM.

Nakatulong ba ang artikulong ito?