Schnellstart mit llama.cpp: CLI und Server

Ich komme immer wieder zu llama.cpp für die lokale Inferenz zurück – es gibt Ihnen Kontrolle, die Ollama und andere abstrahieren, und es funktioniert einfach. Das interaktive Ausführen von GGUF-Modellen mit llama-cli oder das Bereitstellen einer OpenAI-kompatiblen HTTP-API mit llama-server ist einfach.

Falls Sie sich noch zwischen lokalen, selbst gehosteten und Cloud-Ansätzen entscheiden müssen, beginnen Sie mit dem Leitfaden LLM-Hosting 2026: Lokale, selbst gehostete und Cloud-Infrastrukturen im Vergleich.

Warum llama.cpp im Jahr 2026

llama.cpp ist eine leichtgewichtige Inferenz-Engine mit einer Neigung zu:

• Portabilität über CPUs und mehrere GPU-Backends hinweg,
• vorhersehbare Latenz auf einer einzelnen Maschine,
• Flexibilität bei der Bereitstellung, von Laptops bis hin zu On-Premise-Knoten.

Es glänzt, wenn Sie Datenschutz und Offline-Betrieb wünschen, wenn Sie deterministische Kontrolle über Laufzeitflags benötigen oder wenn Sie Inferenz in ein größeres System einbetten möchten, ohne eine vollständige Python-lastige Stack zu betreiben.

Es ist auch hilfreich, llama.cpp zu verstehen, auch wenn Sie später einen Server-Laufzeit mit höherem Durchsatz wählen. Wenn Ihr Ziel maximaler Serving-Durchsatz auf GPUs ist, möchten Sie es möglicherweise mit vLLM vergleichen, indem Sie verwenden: vLLM-Schnellstart: Hochleistungs-LLM-Serving und Sie können Tool-Entscheidungen in folgenden Bereichen benchmarken: Ollama vs. vLLM vs. LM Studio: Beste Art, LLMs lokal im Jahr 2026 auszuführen?.

Installieren Sie llama.cpp auf Windows, macOS und Linux

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

Installation über Paketmanager

Dies ist die schnellste Option, um „es laufen zu lassen".

# 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: Überprüfen Sie nach der Installation, ob die Tools vorhanden sind:

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

Installation über vorgefertigte Binärdateien

Wenn Sie eine saubere Installation ohne Compiler wünschen, verwenden Sie die offiziellen vorgefertigten Binärdateien, die in den llama.cpp GitHub-Releases veröffentlicht wurden. Sie decken in der Regel mehrere Betriebssystemziele und mehrere Backends ab (nur CPU und GPU-fähige Varianten).

Ein üblicher Workflow:

# 1) Laden Sie das richtige Archiv für Ihr Betriebssystem und Backend herunter
# 2) Extrahieren Sie es
# 3) Führen Sie es aus dem extrahierten Ordner aus

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

Kompilieren aus dem Quellcode für Ihre exakte Hardware

Wenn es Ihnen darauf ankommt, das Beste aus Ihrem CPU/GPU-Backend herauszuholen, kompilieren Sie aus dem 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 Ihrer Hardware entspricht (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-Leitfaden

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

1. Installieren Sie das 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. Fügen Sie CUDA Ihrer Umgebung hinzu (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. Installieren Sie OpenSSL-Entwicklungsheader (für einen sauberen Build erforderlich):

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 Verzeichnis llama.cpp.

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

Wählen Sie ein GGUF-Modell und eine Quantisierung

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

Zwei Möglichkeiten, 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
# Platzieren Sie Ihre GGUF unter models/my-model.gguf

Führen Sie es dann über den Pfad aus:

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

Option B: Lassen Sie llama.cpp von Hugging Face herunterladen

Moderne llama.cpp-Builds können von Hugging Face herunterladen und Dateien in einem lokalen Cache speichern. 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 das Tool eine passende Datei auswählen lassen:

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

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

Quantisierungswahl für lokale Inferenz

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

Ein pragmatischer Ausgangspunkt:

• 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 den RAM oder VRAM aufbringen 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 Kontextfenstergröße eine Rolle spielt: Größere Kontextgrößen erhöhen den Speicherverbrauch (manchmal drastisch), selbst wenn die GGUF-Datei selbst passt.

llama-cli Schnellstart und wichtige Parameter

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

Minimaler Lauf

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

Interaktiver Chat-Lauf

Der Konversationsmodus ist für Chat-Vorlagen konzipiert. Er aktiviert typischerweise interaktives Verhalten und formatiert Prompts entsprechend der Vorlage des Modells.

llama-cli \
  -m models/my-model.gguf \
  --conversation \
  --system-prompt "Sie sind ein präziser Systemengineering-Assistent." \
  --ctx-size 4096

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

Wichtige llama-cli-Flags

Anstatt sich 200 Flags zu merken, konzentrieren Sie sich auf diejenigen, die Korrektheit, Latenz und Speicher dominieren.

Modell und Download

Kontext und Durchsatz

GPU-Offloading 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 Stichpunkte." \
  --file ./docs/incident-report.txt \
  -n 300

Ergebnisse reproduzierbarer machen

Wenn Sie Prompts debuggen, setzen Sie den Seed fest 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 Schnellstart mit OpenAI-kompatibler API

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

• OpenAI-kompatible Endpunkte für Chat, Vervollständigungen, Embeddings und Antworten,
• eine Web-Benutzeroberfläche für interaktive Tests,
• optionale Überwachungsendpunkte für Produktions-Sichtbarkeit.

Starten eines Servers mit einem lokalen Modell

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

Standardmäßig hört es 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-Vervollständigungen 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 hilfreicher Assistent." },
      { "role": "user", "content": "Geben Sie mir eine schnelle llama.cpp-Checkliste." }
    ],
    "temperature": 0.7
  }'

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

OpenAI-Client in Python, der auf llama-server abzielt

Mit einem OpenAI-kompatiblen Server können viele Clients arbeiten, 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 präziser Assistent."},
        {"role": "user", "content": "Erkläre Threads vs. Batch-Größe 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": ["hallo", "welt"],
    "model": "GPT-4",
    "encoding_format": "float"
  }'

Wenn Sie ein dediziertes Embedding-Modell ausführen, erwägen Sie, den Server im Embedding-Only-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 Embedding-Modell auf 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

Probieren Sie es so aus:

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

Bedienen mehrerer Modelle aus einem Prozess

Die Beispiele oben binden llama-server beim Start an ein einzelnes Modell. Wenn Sie zwischen Modellen pro Anfrage wechseln müssen – ohne den Prozess neu zu starten –, ist das der Router-Modus. Siehe llama-server-Router-Modus: Dynamisches Modellwechseln ohne Neustarts.

Leistung, Überwachung und Produktionshärte

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

• Speichergrenze ist meist die erste Einschränkung (RAM auf CPU, VRAM auf GPU).
• Kontextgröße ist ein wichtiger Speichervervielfacher.
• GPU-Layer-Offloading ist oft der schnellste Weg zu höheren Tokens pro Sekunde.
• Batch-Größen und Threads können den Durchsatz verbessern, erhöhen aber auch den Speicherdruck.

Für eine tiefere, engineering-first-Perspektive, sehen Sie: LLM-Leistung 2026: Benchmarks, Engpässe und Optimierung.

Wenn Sie gemessene Ergebnisse im llama-cli-Stil auf einer 16-GB-Klasse-GPU wünschen – Tokens pro Sekunde, VRAM und GPU-Last beim Durchwischen des Kontexts (19K / 32K / 64K) über dichte und MoE-GGUFs – sehen Sie 16-GB-VRAM-LLM-Benchmarks mit llama.cpp (Geschwindigkeit und Kontext).

Überwachung von llama-server mit Prometheus und Grafana

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 Alarme, 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. Umfassendere Leitfäden: Observability: Monitoring, Metriken, Prometheus & Grafana-Leitfaden und Observability für LLM-Systeme.

Grundlegendes Härte-Checkliste

Wenn Ihr llama-server über localhost hinaus erreichbar ist:

• verwenden Sie --api-key (oder --api-key-file), damit Anfragen authentifiziert werden,
• vermeiden Sie die Bindung an 0.0.0.0, es sei denn, Sie benötigen sie,
• 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.

Schnelle Troubleshooting-Erfolge

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

Chat-Endpunkte sind am besten, wenn das Modell eine unterstützte Chat-Vorlage hat. Wenn die Ausgaben unstrukturiert aussehen, versuchen Sie:

• llama-cli --conversation plus einen expliziten --system-prompt zu verwenden,
• zu überprüfen, ob Ihr Modell eine instruktions- oder chat-gestimmte Variante ist,
• mit der Server-Web-Benutzeroberfläche zu testen, bevor Sie es in eine App einbinden.

Sie stoßen auf Speichermangel (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 stärker komprimierten Quantisierung.

Es ist auf der CPU langsam

Beginnen Sie mit:

• --threads gleich Ihren physischen Kernen,
• moderaten Batch-Größen,
• validieren Sie, 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