Schnellstart für llama.cpp mit CLI und Server

Ich komme immer wieder auf llama.cpp für lokale Inferenz zurück – es bietet eine Kontrolle, die Ollama und andere abstrahieren, und es funktioniert einfach. GGUF-Modelle lassen sich mit llama-cli interaktiv und mühelos ausführen oder eine OpenAI-kompatible HTTP-API mit llama-server bereitstellen.

Falls Sie sich noch zwischen lokalen, selbst gehosteten und Cloud-Ansätzen entscheiden, beginnen Sie mit dem Leitfaden LLM-Hosting in 2026: Lokale, Self-Hosted- & Cloud-Infrastrukturen im Vergleich.

Warum llama.cpp 2026?

llama.cpp ist eine leichte Inferenz-Engine mit einem Fokus auf:

• Portabilität über CPUs und mehrere GPU-Backends,
• vorhersehbare Latenz auf einer einzelnen Maschine,
• flexible Deployment-Optionen, von Laptops bis hin zu On-Premise-Knoten.

Es glänzt, wenn Sie Datenschutz und Offline-Betrieb wünschen, wenn Sie deterministische Kontrolle über Runtime-Flags benötigen oder wenn Sie Inferenz in ein größeres System integrieren möchten, ohne einen vollwertigen Python-lastigen Stack zu betreiben.

Es ist auch hilfreich, llama.cpp zu verstehen, selbst wenn Sie sich später für einen Server-Runtime mit höherem Durchsatz entscheiden. Wenn beispielsweise Ihr Ziel der maximale Bereitstellungsdurchsatz auf GPUs ist, könnten Sie auch einen Vergleich mit vLLM über folgende Ressource wünschen: vLLM Quickstart: Hochleistungs-LLM-Serving und Sie können Tool-Auswahlen in folgendem Benchmark testen: Ollama vs. vLLM vs. LM Studio: Der beste Weg, LLMs lokal in 2026 auszuführen?.

Wenn Ollama speziell die Alternative ist, die Sie gegen llama-server abwägen, ist llama.cpp vs. Ollama in 2026 der dedizierte Paarvergleich, mit konkreten Auslösern dafür, wann man Ollama beibehalten und wann man zu direktem llama.cpp wechseln sollte.

llama.cpp auf Windows, macOS und Linux installieren

Es gibt drei praktische Installationspfade, je nachdem, ob Sie Bequemlichkeit, Portabilität oder maximale Leistung bevorzugen.

Installation über Paket-Manager

Das ist die schnellste Option, um es „laufend zu bekommen“.

# macOS oder Linux
brew install llama.cpp

# Windows
winget install llama.cpp

# macOS (MacPorts)
sudo port install llama.cpp

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

Tipp: Prüfen Sie nach der Installation, ob die Tools vorhanden sind:

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

Installation über vorkompilierte Binärdateien

Wenn Sie eine saubere Installation ohne Compiler wünschen, nutzen Sie die offiziellen vorkompilierten Binärdateien, die in den llama.cpp-GitHub-Releases veröffentlicht werden. Sie decken typischerweise mehrere OS-Ziele und mehrere Backends ab (CPU-only- und GPU-fähige Varianten).

Ein üblicher Workflow:

# 1) Das richtige Archiv für Ihr OS und Ihr Backend herunterladen
# 2) Es entpacken
# 3) Aus dem entpackten Ordner ausführen

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

Vom Quellcode für Ihre exakte Hardware kompilieren

Wenn Sie das Beste aus Ihrem CPU/GPU-Backend herausholen wollen, kompilieren Sie den Quellcode mit CMake.

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

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

Nach dem Build befinden sich die Binärdateien typischerweise hier:

ls -la ./build/bin/

GPU-Builds in einem Befehl

Aktivieren Sie das Backend, das zu Ihrer Hardware passt (Beispiele für CUDA und 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: Vollständiger Build-Walkthrough

Auf Ubuntu 24.04 mit einer NVIDIA-GPU benötigen Sie das CUDA-Toolkit und OpenSSL, bevor Sie kompilieren. Hier ist eine getestete Sequenz:

1. CUDA-Toolkit 13.1 installieren

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. CUDA zu Ihrer Umgebung hinzufügen (an ~/.bashrc anhängen):

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

Führen Sie dann source ~/.bashrc aus oder öffnen Sie ein neues Terminal.

3. OpenSSL-Entwicklungs-Header installieren (erforderlich für einen sauberen Build):

sudo apt update
sudo apt install libssl-dev

4. llama.cpp kompilieren (aus dem Verzeichnis, das Ihren llama.cpp-Clone enthält, mit aktiviertem CUDA):

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

Dies erzeugt llama-cli, llama-mtmd-cli, llama-server, llama-embedding und llama-gguf-split im llama.cpp-Verzeichnis.

Sie können auch mehrere Backends kompilieren und Geräte zur Laufzeit auswählen. Dies ist nützlich, wenn Sie denselben Build auf heterogenen Maschinen ausrollen.

Ein GGUF-Modell und eine Quantisierung auswählen

Um Inferenz auszuführen, benötigen Sie eine GGUF-Modelldatei (*.gguf). GGUF ist ein Ein-Datei-Format, das Modellgewichte plus standardisierte Metadaten zusammenfasst, die von Engines wie llama.cpp benötigt werden.

Zwei Wege, ein Modell zu erhalten

Option A: Eine lokale GGUF-Datei verwenden

Laden Sie eine GGUF-Datei herunter oder kopieren Sie sie in ./models/:

mkdir -p models
# Legen Sie Ihre GGUF-Datei nach models/my-model.gguf

Führen Sie sie dann per Pfad aus:

llama-cli -m models/my-model.gguf -p "Hallo! Erkläre, was llama.cpp ist." -n 128

Option B: llama.cpp von Hugging Face herunterladen lassen

Moderne llama.cpp-Builds können von Hugging Face herunterladen und Dateien in einem lokalen Cache behalten. Dies ist oft der einfachste Workflow für schnelle Experimente.

# Ein Modell von HF herunterladen und einen Prompt ausführen
llama-cli \
  --hf-repo ggml-org/tiny-llamas \
  --hf-file stories15M-q4_0.gguf \
  -p "Es war einmal," \
  -n 200

Sie können auch die Quantisierung im Repo-Selektor angeben und dem Tool erlauben, eine passende Datei auszuwählen:

llama-cli \
  --hf-repo unsloth/phi-4-GGUF:q4_k_m \
  -p "Fassen Sie das Konzept der Quantisierung in einem Absatz zusammen." \
  -n 160

Falls Sie später einen vollständig offline Workflow benötigen, erzwingt --offline die Nutzung des Caches und verhindert Netzwerkzugriff.

Quantisierungsentscheidung für lokale Inferenz

Quantisierung ist die praktische Antwort auf die Frage „Welche GGUF-Quantisierung sollten Sie für lokale Inferenz wählen“, da sie direkt einen Kompromiss zwischen Qualität, Modellgröße und Geschwindigkeit eingeht.

Ein pragmatiser Startpunkt:

• Beginnen Sie mit einer Q4- oder Q5-Variante für CPU-first-Maschinen,
• Wechseln Sie zu höherer Präzision (oder weniger aggressiver Quantisierung), wenn Sie sich den RAM oder VRAM leisten können,
• Wenn das Modell für Ihre Aufgabe „dumm“ wirkt, ist die Lösung oft entweder ein besseres Modell oder eine weniger aggressive Quantisierung, nicht nur Sampling-Anpassungen.

Denken Sie auch daran, dass die Kontextgröße wichtig ist: Größere Kontextgrößen erhöhen den Speicherbedarf (manchmal drastisch), selbst wenn die GGUF-Datei selbst passt.

llama-cli Quickstart und wichtige Parameter

llama-cli ist der schnellste Weg, zu validieren, dass Ihr Modell geladen wird, Ihr Backend funktioniert und Ihre Prompts sich erwartungsgemäß verhalten.

Minimale Ausführung

llama-cli \
  -m models/my-model.gguf \
  -p "Schreibe einen kurzen Vergleich von TCP vs. UDP." \
  -n 200

Interaktive Chat-Ausführung

Der Gesprächsmodus ist für Chat-Templates konzipiert. Er aktiviert typischerweise interaktives Verhalten und formatiert Prompts gemäß dem Template des Modells.

llama-cli \
  -m models/my-model.gguf \
  --conversation \
  --system-prompt "Sie sind ein knapper Assistent für Systemtechnik." \
  --ctx-size 4096

Um die Generierung zu beenden, wenn das Modell eine spezifische Sequenz ausgibt, verwenden Sie einen Reverse-Prompt. Dies ist besonders nützlich im interaktiven Modus.

Wichtige llama-cli-Flags

Statt 200 Flags auswendig zu lernen, konzentrieren Sie sich auf diejenigen, die Korrektheit, Latenz und Speicher dominieren.

Modell und Download

Kontext und Durchsatz

GPU-Offload und Hardwareauswahl

Sampling und Ausgabequalität

Beispiel-Workloads mit llama-cli

Eine Datei zusammenfassen, nicht nur einen Prompt

llama-cli \
  -m models/my-model.gguf \
  --system-prompt "Sie fassen technische Dokumente zusammen. Ausgabe: maximal fünf Aufzählungspunkte." \
  --file ./docs/incident-report.txt \
  -n 300

Ergebnisse reproduzierbarer machen

Wenn Sie Prompts debuggen, fixieren Sie den Seed und reduzieren Sie die Zufälligkeit:

llama-cli \
  -m models/my-model.gguf \
  -p "Extrahieren Sie die wichtigsten Risiken aus dieser Designnotiz." \
  -n 200 \
  --seed 42 \
  --temp 0.2

llama-server Quickstart mit OpenAI-kompatibler API

llama-server ist ein integrierter HTTP-Server, der folgende Funktionen bereitstellen kann:

• OpenAI-kompatible Endpunkte für Chat, Completion, Embeddings und Antworten,
• eine Web-Oberfläche für interaktive Tests,
• optionale Monitoring-Endpunkte für Produktivvisibility.

Server mit lokalem Modell starten

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

Standardmäßig lauscht er auf 127.0.0.1:8080.

Um extern zu binden (z. B. in Docker oder einem LAN), geben Sie Host und Port an:

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

Optionale, aber wichtige Server-Flags

Wenn Sie in Containern laufen, können viele Einstellungen auch über LLAMA_ARG_*-Umgebungsvariablen gesteuert werden.

Beispiel-API-Aufrufe

Chat-Completion mit 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": "Sie sind ein hilfsbereiter Assistent." },
      { "role": "user", "content": "Geben Sie mir eine schnelle llama.cpp-Checkliste." }
    ],
    "temperature": 0.7
  }'

Tipp für echte Deployments: Wenn Sie --api-key setzen, können Sie es über einen x-api-key-Header senden (oder weiterhin Authorization-Header verwenden, je nach Gateway).

OpenAI-Python-Client, der llama-server anspricht

Mit einem OpenAI-kompatiblen Server können viele Clients funktionieren, indem nur base_url geändert wird.

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": "Sie sind ein knapper Assistent."},
        {"role": "user", "content": "Erkläre Threads vs. Batch-Size in llama.cpp."},
    ],
)

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

Embeddings

OpenAI-kompatible Embeddings werden unter /v1/embeddings bereitgestellt, aber das Modell muss einen Embedding-Pooling-Modus unterstützen, der nicht none ist.

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"
  }'

Wenn Sie ein dediziertes Embedding-Modell ausführen, erwägen Sie, den Server im nur-Embeddings-Modus zu starten:

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

oder wenn Sie llama-cpp mit einem Embedding-Modell auf der CPU ausführen möchten:

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

versuchen Sie es so:

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

Mehrere Modelle aus einem Prozess bereitstellen

Die obigen Beispiele binden llama-server beim Start an ein einzelnes Modell. Wenn Sie zwischen Modellen auf Per-Request-Basis wechseln müssen – ohne den Prozess neu zu starten –, ist das der Zweck des Router-Modus. Siehe llama-server Router-Modus: Dynamischer Modellwechsel ohne Neustarts. Für einen scriptbaren „unload-all“-Workflow, der VRAM freigibt, ohne den Router neu zu starten, siehe Alle llama.cpp Router-Modelle entladen, ohne neu zu starten.

Leistung, Monitoring und Produktionssicherierung

Die FAQ-Frage „Welche llama.cpp-Command-Line-Optionen sind am wichtigsten für Geschwindigkeit und Speicher“ wird viel einfacher, wenn Sie Inferenz wie ein System behandeln:

• Die Speicherdecke ist normalerweise die erste Einschränkung (RAM auf CPU, VRAM auf GPU).
• Die Kontextgröße ist ein großer Speicher-Multiplikator.
• GPU-Offload von Ebenen ist oft der schnellste Weg zu höheren Tokens pro Sekunde.
• Batch-Größen und Threads können den Durchsatz verbessern, aber auch den Speicherverbrauch erhöhen.

Für eine tiefere, engineering-first-Perspektive, siehe: LLM-Leistung in 2026: Benchmarks, Engpässe & Optimierung.

Wenn Sie gemessene llama-cli-artige Ergebnisse auf einer 16-GB-Klasse-GPU wünschen – Tokens pro Sekunde, VRAM und GPU-Last beim Durchlaufen von Kontexten (19K / 32K / 64K) über dichte und MoE-GGUFs hinweg – siehe 16-GB-VRAM-LLM-Benchmarks mit llama.cpp (Geschwindigkeit und Kontext).

Speziell für Qwen 3.6 unterstützt llama.cpp nun integrierte Multi-Token-Prediction (MTP) spekulatives Dekodieren, das den Generierungsdurchsatz erheblich erhöhen kann. Für einen umfassenden Leitfaden, der alle spekulativen Dekodiermethoden in llama.cpp abdeckt, siehe Spekulatives Dekodieren. Für Qwen-3.6-MTP-spezifische Benchmarks, siehe Qwen 3.6 MTP vs. Standard auf 16GB GPU.

llama-server mit Prometheus und Grafana überwachen

llama-server kann Prometheus-kompatible Metriken unter /metrics bereitstellen, wenn --metrics aktiviert ist. Dies passt natürlich zu Prometheus-Scrape-Konfigurationen und Grafana-Dashboards.

Für Dashboards und Alerts, die spezifisch für llama.cpp (und vLLM, TGI) sind: LLM-Inferenz in der Produktion überwachen (2026): Prometheus & Grafana für vLLM, TGI, llama.cpp. Breitere Leitfäden: Observability: Leitfaden zu Monitoring, Metriken, Prometheus & Grafana und Observability für LLM-Systeme.

Basis-Checkliste für die Härtung

Wenn Ihr llama-server über localhost erreichbar ist:

• Verwenden Sie --api-key (oder --api-key-file), damit Anfragen authentifiziert werden,
• Vermeiden Sie das Binden an 0.0.0.0, es sei denn, Sie brauchen es,
• Erwägen Sie TLS über die SSL-Flags des Servers oder beenden Sie TLS an einem Reverse-Proxy,
• Beschränken Sie die Parallelität mit --parallel, um die Latenz unter Last zu schützen.

Troubleshooting: Schnelle Lösungen

Das Modell lädt, aber die Antworten sind im Chat seltsam

Chat-Endpunkte funktionieren am besten, wenn das Modell ein unterstütztes Chat-Template hat. Wenn die Ausgaben unstrukturiert aussehen, versuchen Sie:

• llama-cli --conversation plus einen expliziten --system-prompt zu verwenden,
• sicherzustellen, dass Ihr Modell eine instruktions- oder chat-taugliche Variante ist,
• zuerst die Server-Web-Oberfläche zu testen, bevor Sie sie in eine App integrieren.

Sie stoßen auf Out-of-Memory

Reduzieren Sie den Kontext oder wählen Sie eine kleinere Quantisierung:

• senken Sie --ctx-size,
• reduzieren Sie --n-gpu-layers, wenn VRAM das Problem ist,
• wechseln Sie zu einem kleineren Modell oder einer komprimierteren Quantisierung.

Es ist langsam auf der CPU

Beginnen Sie mit:

• --threads gleich Ihren physischen Kernen,
• moderaten Batch-Größen,
• der Validierung, dass Sie einen Build installiert haben, der zu Ihrer Maschine passt (CPU-Features und Backend).

Referenzen

• Offizielles llama.cpp-Repository und Dokumentation
• Offizielle CLI-Flags-Dokumentation
• Offizielle llama-server-Dokumentation und API-Details