Snelstartgids voor llama.cpp met CLI en Server

Ik keer steeds terug naar llama.cpp voor lokale inferentie – het geeft je controle die Ollama en anderen abstracteren, en het werkt gewoon. Het is eenvoudig om GGUF-modellen interactief te draaien met llama-cli of een OpenAI-compatibele HTTP-API bloot te stellen met llama-server.

Als je nog twijfelt tussen lokale, self-hosted en cloud-oplossingen, begin dan met de basisgids: LLM-hosting in 2026: Lokale, self-hosted en cloudinfrastructuur vergeleken.

Waarom llama.cpp in 2026

llama.cpp is een lichtgewicht inferentie-engine met een voorkeur voor:

• portabiliteit over CPUs en meerdere GPU-backends,
• voorspelbare latentie op een enkele machine,
• flexibiliteit in implementatie, van laptops tot on-premise nodes.

Het blinkt uit wanneer je privacy en offline-werkzaamheid wilt, wanneer je deterministische controle nodig hebt over runtime-vlaggen, of wanneer je inferentie wilt integreren in een groter systeem zonder een volledige Python-zware stack te draaien.

Het is ook nuttig om llama.cpp te begrijpen, zelfs als je later kiest voor een serverruntime met een hogere doorvoer. Als je doel bijvoorbeeld maximale serving-doorvoer op GPUs is, kun je het ook vergelijken met vLLM met behulp van: vLLM Quickstart: High-Performance LLM Serving en je kunt toolkeuzes benchmarken in: Ollama vs vLLM vs LM Studio: De beste manier om LLMs lokaal te draaien in 2026?.

llama.cpp installeren op Windows, macOS en Linux

Er zijn drie praktische installatiepaden, afhankelijk van of je convenience, portabiliteit of maximale prestaties wilt.

Installeren via pakketbeheerders

Dit is de snelste optie om het “draaiend” te krijgen.

# macOS of Linux
brew install llama.cpp

# Windows
winget install llama.cpp

# macOS (MacPorts)
sudo port install llama.cpp

# macOS of Linux (Nix)
nix profile install nixpkgs#llama-cpp

Tip: Controleer na het installeren of de tools bestaan:

llama-cli --version
llama-server --version

Installeren via vooraf gebouwde binaries

Als je een schone installatie wilt zonder compilers, gebruik dan de officiële vooraf gebouwde binaries die zijn gepubliceerd in de llama.cpp GitHub-releases. Deze dekken meestal meerdere OS-doelen en meerdere backends (varianten voor alleen CPU en GPU-enabled).

Een veelvoorkomende workflow:

# 1) Download het juiste archief voor je OS en backend
# 2) Pak het uit
# 3) Voer het uit vanuit de uitgepakte map

./llama-cli --help
./llama-server --help

Bouwen van broncode voor je exacte hardware

Als het je doel is om de beste prestaties uit je CPU/GPU-backend te persen, bouw dan van broncode met CMake.

git clone https://github.com/ggml-org/llama.cpp
cd llama.cpp

# CPU build
cmake -B build
cmake --build build --config Release

Na het bouwen staan de binaries meestal hier:

ls -la ./build/bin/

GPU-builds in één commando

Schakel de backend in die past bij je hardware (voorbeelden voor CUDA en Vulkan):

# NVIDIA CUDA
cmake -B build -DGGML_CUDA=ON
cmake --build build --config Release

# Vulkan
cmake -B build -DGGML_VULKAN=ON
cmake --build build --config Release

Ubuntu 24.04 + NVIDIA GPU: Volledige build-walkthrough

Op Ubuntu 24.04 met een NVIDIA GPU heb je de CUDA-toolkit en OpenSSL nodig voordat je bouwt. Hier is een geteste sequentie:

1. Installeer CUDA toolkit 13.1

wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2404/x86_64/cuda-ubuntu2404.pin
sudo mv cuda-ubuntu2404.pin /etc/apt/preferences.d/cuda-repository-pin-600
wget https://developer.download.nvidia.com/compute/cuda/13.1.1/local_installers/cuda-repo-ubuntu2404-13-1-local_13.1.1-590.48.01-1_amd64.deb
sudo dpkg -i cuda-repo-ubuntu2404-13-1-local_13.1.1-590.48.01-1_amd64.deb
sudo cp /var/cuda-repo-ubuntu2404-13-1-local/cuda-*-keyring.gpg /usr/share/keyrings/
sudo apt-get update
sudo apt-get -y install cuda-toolkit-13-1

2. Voeg CUDA toe aan je omgeving (voeg toe aan ~/.bashrc):

# cuda toolkit
export PATH=/usr/local/cuda-13.1/bin:$PATH
export LD_LIBRARY_PATH=/usr/local/cuda-13.1/lib64:$LD_LIBRARY_PATH

Voer vervolgens source ~/.bashrc uit of open een nieuwe terminal.

3. Installeer OpenSSL-development headers (vereist voor een schone build):

sudo apt update
sudo apt install libssl-dev

4. Bouw llama.cpp (vanuit de map met je llama.cpp-clone, met CUDA ingeschakeld):

cmake llama.cpp -B llama.cpp/build -DBUILD_SHARED_LIBS=OFF -DGGML_CUDA=ON
cmake --build llama.cpp/build --config Release -j --clean-first --target llama-cli llama-mtmd-cli llama-server llama-gguf-split llama-embedding
cp llama.cpp/build/bin/llama-* llama.cpp

Dit produceert llama-cli, llama-mtmd-cli, llama-server, llama-embedding en llama-gguf-split in de llama.cpp-map.

Je kunt ook meerdere backends compileren en apparaten op runtime kiezen. Dit is handig als je dezelfde build implementeert op heterogene machines.

Kies een GGUF-model en een quantisatie

Om inferentie uit te voeren, heb je een GGUF-modelbestand (*.gguf) nodig. GGUF is een enkel-bestandsformaat dat modelgewichten bundelt plus gestandaardiseerde metadata die nodig is voor engines zoals llama.cpp.

Twee manieren om een model te krijgen

Optie A: Gebruik een lokaal GGUF-bestand

Download of kopieer een GGUF naar ./models/:

mkdir -p models
# Plaats je GGUF op models/my-model.gguf

Voer het vervolgens uit via pad:

llama-cli -m models/my-model.gguf -p "Hallo! Leg uit wat llama.cpp is." -n 128

Optie B: Laat llama.cpp downloaden van Hugging Face

Moderne llama.cpp-builds kunnen downloaden van Hugging Face en bestanden opslaan in een lokale cache. Dit is vaak de eenvoudigste workflow voor snelle experimenten.

# Download een model van HF en voer een prompt uit
llama-cli \
  --hf-repo ggml-org/tiny-llamas \
  --hf-file stories15M-q4_0.gguf \
  -p "Er was eens," \
  -n 200

Je kunt ook de quant specificeren in de repo-selector en de tool laten kiezen voor een passend bestand:

llama-cli \
  --hf-repo unsloth/phi-4-GGUF:q4_k_m \
  -p "Vat het concept van quantisatie samen in één alinea." \
  -n 160

Als je later een volledig offline workflow nodig hebt, forceert --offline cachegebruik en voorkomt het netwerktoegang.

Quantisatiekeuze voor lokale inferentie

Quantisatie is het praktische antwoord op de vraag “Welke GGUF-quantisatie moet je kiezen voor lokale inferentie” omdat het direct afweegt tussen kwaliteit, modelgrootte en snelheid.

Een pragmatisch startpunt:

• begin met een Q4- of Q5-variant voor CPU-first machines,
• ga naar hogere precisie (of minder agressieve quantisatie) als je de RAM- of VRAM-kosten kunt dragen,
• als het model voor je taak “dom” aanvoelt, is de oplossing vaak een beter model of een minder agressieve quant, niet alleen sampling-aanpassingen.

Vergeet ook niet dat de contextvenster grootte van belang is: grotere contextgroottes verhogen het geheugengebruik (soms drastisch), zelfs als het GGUF-bestand zelf past.

llama-cli quickstart en belangrijke parameters

llama-cli is de snelste manier om te valideren dat je model laadt, je backend werkt en je prompts zich gedragen zoals verwacht.

Minimale run

llama-cli \
  -m models/my-model.gguf \
  -p "Schrijf een korte vergelijking van TCP versus UDP." \
  -n 200

Interactieve chat-run

Gespreksmodus is ontworpen voor chattemplates. Het schakelt meestal interactief gedrag in en formatteert prompts volgens het template van het model.

llama-cli \
  -m models/my-model.gguf \
  --conversation \
  --system-prompt "Je bent een beknopte systeemengineeringassistent." \
  --ctx-size 4096

Om de generatie te beëindigen wanneer het model een specifieke sequentie afdrukt, gebruik je een reverse prompt. Dit is vooral handig in interactieve modus.

Belangrijkste llama-cli-vlaggen

In plaats van 200 vlaggen te onthouden, richt je op degenen die correctheid, latentie en geheugen domineren.

Model en download

Context en doorvoer

GPU-offload en hardwareselectie

Sampling en outputkwaliteit

Voorbeeldworkloads met llama-cli

Vat een bestand samen, niet alleen een prompt

llama-cli \
  -m models/my-model.gguf \
  --system-prompt "Je vat technische documenten samen. Maximaal vijf bullets." \
  --file ./docs/incident-report.txt \
  -n 300

Maak resultaten reproduceerbaarder

Wanneer je prompts debugt, fix de seed en verminder willekeur:

llama-cli \
  -m models/my-model.gguf \
  -p "Extract de belangrijkste risico's uit deze ontwerpnoot." \
  -n 200 \
  --seed 42 \
  --temp 0.2

llama-server quickstart met OpenAI-compatibele API

llama-server is een ingebouwde HTTP-server die kan blootstellen:

• OpenAI-compatibele endpoints voor chat, completies, embeddings en antwoorden,
• een Web UI voor interactief testen,
• optionele monitoringseindpunten voor productiezichtbaarheid.

Start een server met een lokaal model

llama-server \
  -m models/my-model.gguf \
  -c 4096

Standaard luistert het op 127.0.0.1:8080.

Om extern te binden (bijvoorbeeld binnen Docker of een LAN), specificeer host en poort:

llama-server \
  -m models/my-model.gguf \
  -c 4096 \
  --host 0.0.0.0 \
  --port 8080

Optioneel maar belangrijke servervlaggen

Als je in containers draait, kunnen veel instellingen ook worden beheerd via LLAMA_ARG_*-omgevingsvariabelen.

Voorbeeld API-aanroepen

Chat-completies met curl

curl http://localhost:8080/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer no-key" \
  -d '{
    "model": "gpt-3.5-turbo",
    "messages": [
      { "role": "system", "content": "Je bent een behulpzame assistent." },
      { "role": "user", "content": "Geef me een snelle llama.cpp checklist." }
    ],
    "temperature": 0.7
  }'

Tip voor echte implementaties: als je --api-key instelt, kun je deze verzenden via een x-api-key-header (of blijf Authorization-headers gebruiken, afhankelijk van je gateway).

OpenAI Python-client gericht op llama-server

Met een OpenAI-compatibele server kunnen veel clients werken door alleen base_url te wijzigen.

import openai

client = openai.OpenAI(
    base_url="http://localhost:8080/v1",
    api_key="sk-no-key-required",
)

resp = client.chat.completions.create(
    model="gpt-3.5-turbo",
    messages=[
        {"role": "system", "content": "Je bent een beknopte assistent."},
        {"role": "user", "content": "Leg threads versus batch-grootte uit in llama.cpp."},
    ],
)

print(resp.choices[0].message.content)

Embeddings

OpenAI-compatibele embeddings zijn blootgesteld op /v1/embeddings, maar het model moet een embedding-pooling-modus ondersteunen die niet none is.

curl http://localhost:8080/v1/embeddings \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer no-key" \
  -d '{
    "input": ["hello", "world"],
    "model": "GPT-4",
    "encoding_format": "float"
  }'

Als je een dedicated embedding-model draait, overweeg dan om de server in alleen-embeddings-modus te starten:

llama-server \
  -m models/Qwen3-Embedding-0.6B-Q8_0.gguf \
  --embeddings \
  --host 127.0.0.1 \
  --pooling last \
  --port 8080

of als je llama-cpp met embedding-model op CPU wilt draaien:

CUDA_VISIBLE_DEVICES="" llama-server \
  -m models/Qwen3-Embedding-0.6B-Q8_0.gguf \
  --embeddings \
  --host 127.0.0.1 \
  --pooling last \
  --port 8080

Probeer het zo:

CUDA_VISIBLE_DEVICES="" llama-embedding \
  -m /path/to/Qwen3-Embedding-0.6B-Q8_0.gguf \
  -p "je tekst hier" \
  --pooling last \
  --verbose-prompt

Meerdere modellen serveren vanuit één proces

De bovenstaande voorbeelden binden llama-server bij het opstarten aan een enkel model. Als je tussen modellen wilt schakelen op basis van een request — zonder het proces opnieuw te starten — is dat waar router-mode voor is. Zie llama-server router-modus: dynamisch modelwisselen zonder herstart. Voor een scriptbare unload-all-flow die VRAM vrijmaakt zonder de router opnieuw te starten, zie Alle llama.cpp Router-modellen ontladen zonder herstarten.

Prestaties, monitoring en productieversterking

De FAQ-vraag “Welke llama.cpp command-line-opties zijn het belangrijkst voor snelheid en geheugen” wordt veel makkelijker als je inferentie als een systeem behandelt:

• Geheugencapaciteit is meestal de eerste beperking (RAM op CPU, VRAM op GPU).
• Contextgrootte is een grote geheugenvermenigvuldiger.
• GPU-lagenoffload is vaak de snelste weg naar meer tokens per seconde.
• Batchgroottes en threads kunnen de doorvoer verbeteren, maar kunnen ook de geheugenbelasting verhogen.

Voor een diepere, engineering-first blik, zie: LLM-prestaties in 2026: Benchmarks, bottlenecks & optimalisatie.

Als je gemeten llama-cli-achtige resultaten wilt op een GPU van 16 GB-klassering — tokens per seconde, VRAM en GPU-belasting tijdens het vegen van context (19K / 32K / 64K) over dense en MoE GGUFs — zie 16 GB VRAM LLM-benchmarks met llama.cpp (snelheid en context).

Voor Qwen 3.6 specifiek, ondersteunt llama.cpp nu ingebouwde Multi-Token Prediction (MTP) speculatieve decoding die de generatiedoorvoer aanzienlijk kan verhogen. Zie Qwen 3.6 27B en 35B MTP versus Standard op 16GB GPU voor gemeten generatiesnelheden, VRAM-overhead en aanbevolen --spec-draft-n-max-waarden.

Monitoring van llama-server met Prometheus en Grafana

llama-server kan Prometheus-compatibele metrics blootstellen op /metrics wanneer --metrics is ingeschakeld. Dit past natuurlijk bij Prometheus scrape-configs en Grafana-dashboards.

Voor dashboards en alerts specifiek voor llama.cpp (en vLLM, TGI): Monitor LLM-Inferentie in Productie (2026): Prometheus & Grafana voor vLLM, TGI, llama.cpp. Brede gidsen: Observabiliteit: Monitoring, Metrics, Prometheus & Grafana Gids en Observabiliteit voor LLM-systemen.

Basis-versterkingschecklist

Wanneer je llama-server bereikbaar is buiten localhost:

• gebruik --api-key (of --api-key-file) zodat requests geauthenticeerd zijn,
• vermijd binding aan 0.0.0.0 tenzij je het nodig hebt,
• overweeg TLS via de SSL-vlaggen van de server of TLS-terminatie bij een reverse proxy,
• beperk concurrentie met --parallel om latentie onder load te beschermen.

Snelle oplossingen voor probleemoplossing

Het model laadt, maar antwoorden zijn vreemd in chat

Chat-endpoints werken het beste wanneer het model een ondersteund chattemplate heeft. Als outputs ongestructureerd lijken, probeer dan:

• llama-cli --conversation te gebruiken plus een expliciete --system-prompt,
• te verifiëren dat je model een instructie- of chat-tuned variant is,
• te testen met de server Web UI voordat je het in een app integreert.

Je krijgt out of memory

Verlaag de context of kies een kleinere quant:

• verlaag --ctx-size,
• verlaag --n-gpu-layers als VRAM het probleem is,
• schakel over naar een kleiner model of een meer gecomprimeerde quant.

Het is traag op CPU

Begin met:

• --threads gelijk aan je fysieke kernen,
• matige batchgroottes,
• valideren dat je een build hebt geïnstalleerd die past bij je machine (CPU-functies en backend).

Referenties

• Officiële llama.cpp-repository en documentatie
• Officiële CLI-vlaggendocumentatie
• Officiële llama-server-documentatie en API-details