Paano Mag-run ng GGUF Models Locally: Ollama, llama.cpp at vLLM

Nag-download ka ng .gguf file at nagtataka kung paano ito talaga patakbuhin? Pinakamabilis na daan: ollama run hf.co/<repo>:Q4_K_M — hinihila ng Ollama ang GGUF diretso mula sa Hugging Face at sineserve ito. Ang GGUF ang single-file model format na ipinakilala ng llama.cpp at kaya na ng bawat local-LLM tool na kausapin, kaya ang same file ay tumatakbo sa Ollama, llama.cpp, LM Studio, Jan, at (na may mga caveat) vLLM. Saklaw ng guide na ito ang bawat runner na may copy-paste commands, kung paano pumili ng tamang quantisation para sa VRAM mo, at ang mga load errors na talaga namang tatamaan mo.

Ano ang GGUF file?

Ang GGUF (GGML Universal File) ay container format para sa mga quantised na language model. Isang file ang nagbubuhat ng weights, tokenizer at model metadata — walang ibang ida-download, walang config soup. Ang weights sa loob ay quantised: kinompress mula 16-bit floats pababa sa 4-bit (o mas mababa) na integers, kaya ang 9B model na nangangailangan ng ~18 GB sa full precision ay pumapasok sa ~5.5 GB bilang Q4 file at tumatakbo sa gaming GPU o kahit CPU.

Dalawang bagay ang mahalaga sa pangalan ng GGUF file:

1. Ang base model — ang gemma-3-4b-it-GGUF ay fine-tuned na Gemma 3 4B na na-export sa GGUF.
2. Ang quant tag — ang Q4_K_M, Q8_0, IQ4_XS at mga kaibigan nito ang nagsasabi kung gaano ka-aggressive kinompress ang weights. Dagdag sa pagpili sa ibaba.

Kayang mag-run ng GGUF models ang Ollama?

Oo — native format ng Ollama ang GGUF, at mula pa 2024 ay kaya na nitong humakot nang diretso mula sa Hugging Face nang hindi mo man lang hinahawakan ang file:

# Pull a GGUF quant directly from Hugging Face and chat with it
ollama run hf.co/bartowski/gemma-2-9b-it-GGUF:Q4_K_M

# The quant tag after the colon picks the file inside the repo
ollama run hf.co/ggml-org/gemma-3-4b-it-GGUF:Q8_0

May na-download ka nang .gguf file? Itutok mo ang Modelfile dito:

# Modelfile — one line is enough
FROM ./gemma-2-9b-it-Q4_K_M.gguf

ollama create gemma9b -f Modelfile
ollama run gemma9b

Automatic ang pagdedecide ng Ollama sa GPU offload at naglalantad ito ng OpenAI-compatible API sa port 11434, kaya kahit anong nagsasalita ng API na iyan ay pwedeng gumamit ng model. Ang trade-off ay control: ikaw ang hindi pumipili kung ilang layers ang mapupunta sa GPU.

Paano mo i-run ang GGUF file sa llama.cpp?

Sa llama.cpp nagmumula ang GGUF — para dito umiral ang format — kaya pinakamalalim at pinakasariwa ang support dito. Ang llama-server binary ay nagbibigay sa’yo ng chat UI at OpenAI-compatible endpoint nang sabay:

# Download straight from Hugging Face (picks a matching GGUF for your machine)
llama-server -hf ggml-org/gemma-3-4b-it-GGUF --port 8080

# Or run a file you already have, with full GPU offload
llama-server -m ./gemma-2-9b-it-Q4_K_M.gguf -ngl 99 --port 8080

Itinutulak ng -ngl 99 ang 99 layers sa GPU; babaan mo kung mas kaunti ang kaya ng VRAM mo at ang natitira ay mananatili sa CPU. Ang partial-offload dial na iyan ang superpower ng llama.cpp — gumagana nang maayos ang 9B model sa 6 GB card na may 20 sa 48 layers na na-offload, mabagal nga lang. Para sa one-shot prompting sa halip na server, palitan mo ng llama-cli ang llama-server na may same -m flag.

Ang LM Studio ay same engine sa likod ng desktop GUI: i-drop ang .gguf file sa models folder nito (o mag-search ng Hugging Face sa app mismo) at i-click ang load. Para sa tooling choice mismo, saklaw ng Ollama vs LM Studio comparison kung alin ang ilalagay sa ilalim ng models mo.

Aling GGUF quantisation ang ida-download mo?

Default na sagot: Q4_K_M. Community sweet spot ito — sa loob ng isa o dalawang porsyento ng full-precision quality sa humigit kumulang isang kapat ng laki. Ang hagdanan, pinakamalaki hanggang pinakamaliit:

• Q8_0 — halos lossless; gamitin kung kinakain ng VRAM mo ang 8.5 bits kada weight nang hindi napapansin.
• Q6_K / Q5_K_M — isang hakbang pababa sa laki, ekselente pa rin para sa 30B+ models.
• Q4_K_M — ang default. Para sa 7–14B models, dito tumataas ang quality-per-GB.
• IQ4_XS / Q3_K_M — para isiksik ang malaking model sa maliit na card; kapansin-pansin na ang quality loss.
• Q2_K at pababa — huling resorte; nagsisimulang mabulok ang model sa kaululan sa gitna ng pangungusap.

Ang rule of thumb sa pagkasya: dapat pumapasok sa VRAM mo ang file size sa GB plus ~1–2 GB ng context overhead. Kumportable ang 4.7 GB na Q4_K_M ng 9B model sa 8 GB card. Piliin ang mas maliit na model sa mas mataas na quant kaysa mas malaking model sa kahila-hilakbot na quant — kadalasang panalo ang Q8 4B laban sa Q2 9B.

GGUF vs Safetensors: aling format ang kailangan mo?

Ang Safetensors ang unquantised archive format — full-precision weights para sa training, fine-tuning, at mga tools tulad ng transformers at ComfyUI. Ang GGUF ang quantised, runnable format para sa inference sa sarili mong hardware. Hindi pwedeng i-fine-tune ang GGUF, at hindi pwedeng tumakbo ang safetensors file sa Ollama o llama.cpp nang walang conversion muna (para diyan ang convert_hf_to_gguf.py script sa llama.cpp). Rule: training o image pipelines → safetensors; local chat at serving → GGUF. Kung nagsimula ang search mo bilang “gguf vs safetensors”, ang paghahating iyan ang buong sagot.

Aling GGUF runner ang gagamitin mo?

Runner	Pinakamainam para sa	Install	GPU offload	OpenAI-compatible API
Ollama	Set-and-forget service	curl one-liner	Automatic	Oo (:11434/v1)
llama.cpp	Maximum control, pinakabagong features	Build o package manager	Manwal na -ngl dial	Oo (llama-server)
LM Studio	Desktop GUI, model browsing	App download	Automatic	Oo (local server)
vLLM	Batched multi-user serving	pip install vllm	Automatic	Oo (native)

Pumili ng Ollama kung gusto mong tumatakbo ito sa boot at hindi nakikita — ito ang gamit ko sa homelab ko para mag-serve ng models sa lahat sa network. Pumili ng llama.cpp kapag kailangan mo ang feature sa araw mismo ng labas nito (bagong architectures ang unang dumadating doon) o gusto mo ng layer-level memory control. LM Studio para sa GUI. vLLM lang kapag isang model ang dapat magsilbi sa maraming sabay-sabay na users — gumagana ang GGUF support nito pero second-class ito katabi ng mga native format nito.

Bakit ayaw mag-load ng GGUF model ko?

Apat na errors ang sumasakop sa kalakhan ng mga kaso:

1. unknown model architecture — gumagamit ang GGUF ng architecture na mas bata ang runtime mo (bagong MoE at vision models ang palaging dumadating). I-update ang Ollama o i-rebuild ang llama.cpp; walang ibang lunas.
2. Out of memory sa load — masyadong malaki ang quant para sa VRAM mo plus context. Bumaba ka ng isang hagdan (Q4_K_M → Q3_K_M), babaan ang -ngl, o liitan ang context gamit ang -c 4096.
3. Truncated / corrupt ang download — bumabagsak ang GGUF load na may magic-number o metadata error. I-download muli at ikumpara ang SHA256 na ipinapakita sa Hugging Face page.
4. Tumatanggi ang ollama run ./model.gguf — inaasahan iyan: model names ang tinatanggap ng run ng Ollama, hindi file paths. Gamitin ang Modelfile route sa itaas.

Huling anggulo na worth malaman: magandang kapares ang local GGUF endpoint ng agentic coding tools — itutok mo ang OpenAI-compatible client dito at kuryente lang ang presyo ng completions. Sinubok ng best local LLMs for coding kung aling models ang deserving sa slot kapag gumana na ang plumbing ng guide na ito.

Kapag sumulpot na ang tanong sa runtime, basahin mo ang llama.cpp vs Ollama — isang linggo ng head-to-head na gamit, at hindi ang inaakala ng mga README ang mga trade-off.