Kaya bang i-run ng vLLM ang GGUF? Oo — GPU lang

Noong isang linggo may nagtanong kung bakit bumibigo ang GGUF file niya sa vLLM sa isang makina na walang GPU, samantalang ang same file ay smooth na tumatakbo sa Ollama. Maikling sagot muna, bago ang lahat: oo, kayang i-run ng vLLM ang GGUF — sa pamamagitan ng opisyal na plugin, GPU lang. Ang plugin ay vllm-gguf-plugin, ang syntax ay repo:quant_type; kapag sinubukan mo sa CPU, lumabas ka na sa table ng suportadong hardware. Ang lahat ng nasa ibaba ay galing sa vLLM documentation at sa record ng vllm-project/vllm repo (92,000+ stars mula pa noong February 2023) — galing sa docs, hindi sa test rig ko.

Paano mag-serve ng GGUF model gamit ang vLLM?

Dalawang hakbang: i-install ang plugin, tapos ituro sa vLLM ang model. Ang GGUF support ay hindi na nakatira sa core ng vLLM — nakasaad sa docs na “nag-migrate na ito sa vllm-gguf-plugin”, kaya hindi sapat ang puro pip install vllm:

uv pip install vllm-gguf-plugin

# Direkta mula sa Hugging Face, sa repo_id:quant_type format:
vllm serve unsloth/Qwen3-0.6B-GGUF:Q4_K_M 
  --tokenizer Qwen/Qwen3-0.6B

# O lokal na file na na-download mo na:
vllm serve ./Qwen3-0.6B-Q4_K_M.gguf 
  --tokenizer Qwen/Qwen3-0.6B

Hindi dekorasyon ang --tokenizer flag. Inirerekomenda ng opisyal na docs ang tokenizer ng base model dahil ang tokenizer conversion mula GGUF ay “matagal at hindi stable, lalo na sa mga model na may malaking vocabulary”. Laktawan ito at palit ka ng one-line flag sa mahaba at moody na startup.

Dalawang GPU, iisang model: dagdagan ng --tensor-parallel-size 2 para hatiin ang same GGUF sa dalawang card — gumagana ang tensor parallelism sa GGUF gaya ng sa ibang format.

Bakit tinatanggihan ng vLLM ang GGUF sa CPU?

Dito nagkakagulat. Ang reputasyon ng GGUF ay CPU muna — ito ang format kung saan nagtayo ng pangalan ang llama.cpp, sa mga laptop at Raspberry Pi. Pero sa loob ng vLLM, baliktad ang sitwasyon. Ganito ang marka ng GGUF sa opisyal na hardware compatibility table:

Hardware	GGUF sa vLLM
NVIDIA Volta / Turing / Ampere / Ada / Hopper	suportado
AMD GPU	suportado
Intel GPU	hindi suportado
x86 CPU	hindi suportado
Arm CPU	hindi suportado

Pinagmulan: vLLM quantization docs. Ang dahilan ay arkitektura: ang GGUF path ng vLLM ay nagde-dequantize ng blocks papunta sa GPU kernels na dinisenyo para sa batch serving. Walang CPU kernel sa likod — kasi ang vLLM ay serving engine, hindi laruan para sa laptop. Walang GPU ang makina, walang flag na sasagip — gamitin ang llama.cpp.

Ano ang nababagsak: ang honest na listahan ng limits

May babala ang same docs page na worth i-quote nang literal: “Ang GGUF support sa vLLM ay highly experimental at under-optimized.” Nang konkreto:

• Mas makipot ang quant coverage kaysa llama.cpp. Yung mga K-quant na dinadownload ng lahat (Q4_K_M at pamilya) gumagana; ang mga exotic scheme, hindi palagi. Ang llama.cpp pa rin ang reference implementation ng format.
• Naiiwan ang architecture support. Ang bagong model families ay dumadaan muna sa llama.cpp; sunod lang ang plugin.
• Walang lazy loading na para mmap. Nagmi-map sa memory ang llama.cpp; nilo-load ng vLLM na parang kahit anong checkpoint.
• Memory footprint feature muna ang pangunahin. Iniframe ng docs ang GGUF bilang paraan para bumaba ang VRAM usage, hindi bilang taya sa throughput.

Walang itinatago sa mga ito. Nasa unang talata lahat ng opisyal na GGUF page — mas honest pa kaysa sa ibinibigay ng karamihan ng experimental features.

GGUF: vLLM o llama.cpp — sino ang panalo?

Magkaibang tools na parehong binabasa ang same file:

	vLLM + GGUF	llama.cpp
CPU inference	hindi	oo, first-class
Sabay-sabay na users	continuous batching, para rito talaga ginawa	limitado
Quant coverage	subset, experimental	ang reference
Setup	vLLM + plugin	isang binary
Pinakaangkop sa	isang GPU, maraming user	isang user, kahit anong hardware

Kung nagse-serve ka ng model sa team mula sa isang GPU lang, ang vLLM + GGUF ay para i-reuse mo ang same Q4_K_M files na hinihingi ng buong local-LLM mundo — mas maraming pagpipilian sa GGUF quantization guide namin. Para sa buong engine comparison, tingnan ang llama.cpp vs Ollama at paano mag-run ng GGUF models locally.

One-line rule: same file, magkasalungat na instinct — ang llama.cpp, ang GGUF ay ang format mismo; ang vLLM, isa lang siyang option.