Schnellstart mit llama.cpp über CLI und Server

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

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

Warum llama.cpp im Jahr 2026

llama.cpp ist ein leichtgewichtiger Inferenz-Engine mit einem Fokus auf:

• 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 Runtime-Flags benötigen oder wenn Sie Inferenz in ein größeres System einbetten möchten, ohne einen vollständigen Python-lastigen Stack auszuführen.

Es ist auch hilfreich, llama.cpp zu verstehen, auch wenn Sie später einen Server-Runtime mit höherem Durchsatz wählen. Wenn Ihr Ziel beispielsweise maximaler Serving-Durchsatz auf GPUs ist, könnten Sie es auch mit vLLM vergleichen unter Verwendung von: vLLM Quickstart: Hochleistungs-LLM-Serving und Sie können Tool-Entscheidungen in folgendem Vergleich benchmarken: Ollama vs. vLLM vs. LM Studio: Die beste Art, LLMs im Jahr 2026 lokal auszuführen?.

Installation von llama.cpp auf Windows, macOS und Linux

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

Installation über Paketmanager

Dies ist die schnellste Option, um „es zum Laufen zu bringen“.

# 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: Nach der Installation überprüfen Sie, 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, verwenden 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 gängiger Arbeitsablauf:

# 1) Laden Sie das richtige Archiv für Ihr OS und Backend herunter
# 2) Entpacken Sie es
# 3) Führen Sie es aus dem entpackten Ordner aus

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

Kompilierung aus dem Quellcode für Ihre exakte Hardware

Wenn es Ihnen darauf ankommt, die beste Leistung 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 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-Leitfaden

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

1. Installation des CUDA-Toolkits 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. CUDA zur 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. Installation der OpenSSL-Entwicklungskopfzeilen (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 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 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, an ein Modell zu kommen

Option A: Verwenden Sie eine lokale GGUF-Datei

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

mkdir -p models
# Platzieren Sie Ihre GGUF unter models/my-model.gguf

Führen Sie sie 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 halten. Dies ist oft der einfachste Arbeitsablauf für schnelle Experimente.

# Laden Sie ein Modell von HF herunter und führen Sie einen Prompt aus
llama-cli \
  --hf-repo ggml-org/tiny-llamas \
  --hf-file stories15M-q4_0.gguf \
  -p "Es war einmal," \
  -n 200

Sie können die Quantisierung auch im Repo-Selektor angeben und das Tool wählen 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-fähigen Workflow benötigen, erzwingt --offline die Verwendung des Caches und verhindert den Netzwerkzugang.

Quantisierungsentscheidung für die 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 einen Kompromiss zwischen Qualität, Modellgröße und Geschwindigkeit eingeht.

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 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 Kontextgröße von Bedeutung ist: Größere Kontextgrößen erhöhen den Speicherbedarf (manchmal dramatisch), selbst wenn die GGUF-Datei selbst passt.

llama-cli Quickstart und Schlüsselparameter

llama-cli ist der schnellste Weg, um zu validieren, dass Ihr Modell lädt, Ihr Backend funktioniert und Ihre Prompts das erwartete Verhalten zeigen.

Minimaler Lauf

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

Interaktiver Chat-Modus

Der Konversationsmodus 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 präziser Systemtechnik-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

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-Arbeitslasten 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, fixieren Sie den Seed und reduzieren Sie die Zufälligkeit:

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

llama-server Quickstart mit OpenAI-kompatibler API

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

• OpenAI-kompatible Endpunkte für Chat, Completions, Embeddings und Responses,
• eine Web-UI für interaktive Tests,
• optionale Monitoring-Endpunkte für Produktions-Sichtbarkeit.

Starten Sie einen Server mit einem lokalen Modell

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. innerhalb von 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-Completions 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 weiterhin Authorization-Header verwenden, abhängig von Ihrem 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 präziser Assistent."},
        {"role": "user", "content": "Erklären Sie 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": ["hello", "world"],
    "model": "GPT-4",
    "encoding_format": "float"
  }'

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

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

Bereitstellen mehrerer Modelle aus einem Prozess

Die obigen Beispiele binden llama-server beim Start an ein einzelnes Modell. Wenn Sie zwischen Modellen auf Anfragebasis wechseln möchten – ohne den Prozess neu zu starten – ist das der Zweck des Router-Modus. Siehe llama-server Router-Modus: Dynamisches Modellwechseln ohne Neustart. Für einen skriptfähigen Unload-All-Flow, der VRAM freigibt, ohne den Router neu zu starten, siehe Alle llama.cpp Router-Modelle entladen, ohne neu zu starten.

Leistung, Monitoring und Produktions-Härtung

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

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

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

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

Für Qwen 3.6 unterstützt llama.cpp jetzt integrierte Multi-Token-Prediction (MTP) spekulatives Decoding, das den Generierungsdurchsatz erheblich steigern kann. Siehe Qwen 3.6 27B und 35B MTP vs. Standard auf 16GB GPU für gemessene Generierungsgeschwindigkeiten, VRAM-Overhead und empfohlene --spec-draft-n-max-Werte.

Monitoring von llama-server mit Prometheus und Grafana

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

Für Dashboards und Alerts spezifisch für llama.cpp (und vLLM, TGI): 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.

Basis-Härtungs-Checkliste

Wenn Ihr llama-server jenseits von 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 benötigen 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 Erfolge

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

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

• llama-cli --conversation plus einen expliziten --system-prompt zu verwenden,
• zu überprüfen, ob Ihr Modell eine Instruktionen- oder Chat-tuned-Variante ist,
• mit der Server-Web-UI zu testen, bevor Sie es in eine App einbinden.

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 stärker komprimierten Quantisierung.

Es ist langsam auf CPU

Beginnen Sie mit:

• --threads gleich Ihrer physischen Kerne,
• 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 Dokumentation der CLI-Flags
• Offizielle Dokumentation von llama-server und API-Details