llama.cpp Schnellstart mit CLI und Server

Ich komme immer wieder zu llama.cpp für lokale Inferenz – es gibt Ihnen die Kontrolle, die Ollama und andere abstrahieren, und es funktioniert einfach. Es ist leicht, GGUF-Modelle interaktiv mit llama-cli zu nutzen oder eine OpenAI-kompatible HTTP-API mit llama-server bereitzustellen.

Wenn Sie noch zwischen lokalen, selbstgehosteten und Cloud-Ansätzen entscheiden, beginnen Sie mit dem Leitfaden LLM-Hosting im Jahr 2026: Lokal, Selbstgehostet & Cloud-Infrastruktur im Vergleich.

Warum llama.cpp im Jahr 2026

llama.cpp ist ein leichtgewichtiger Inferenzmotor mit einem Schwerpunkt auf:

• Portabilität über CPUs und mehrere GPU-Backends,
• vorhersehbare Latenz auf einem einzigen Rechner,
• Flexibilität bei der Bereitstellung, von Laptops bis hin zu On-Prem-Nodes.

Es ist besonders nützlich, wenn Sie Datenschutz und Offline-Betrieb benötigen, 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-Infrastruktur zu laufen lassen.

Es ist auch hilfreich, llama.cpp zu verstehen, selbst wenn Sie später einen höherdurchsatzfähigen Server-Laufzeit-Stack wählen. Zum Beispiel, wenn Ihr Ziel die maximale Auslastung auf GPUs ist, möchten Sie möglicherweise auch mit vLLM vergleichen: vLLM Quickstart: Hochleistungsfähige LLM-Bereitstellung und Sie können Benchmark-Tool-Optionen in: Ollama vs vLLM vs LM Studio: Beste Art, LLMs lokal im Jahr 2026 zu laufen?.

Installieren Sie llama.cpp auf Windows, macOS und Linux

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

Installieren Sie über Paketmanager

Dies ist die schnellste Option, um es zu starten.

# 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

Installieren Sie ü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-Release veröffentlicht wurden. Sie decken normalerweise mehrere Ziel-OS und mehrere Backends (CPU-only und GPU-aktiviert) ab.

Ein typischer Workflow:

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

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

Erstellen Sie aus der Quelle für Ihre exakte Hardware

Wenn Sie sich dafür interessieren, die beste Leistung aus Ihrem CPU/GPU-Backend herauszuholen, erstellen Sie aus der Quelle 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 normalerweise hier:

ls -la ./build/bin/

GPU-Build in einem Befehl

Aktivieren Sie das Backend, das Ihrem 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-Throughwalk

Auf Ubuntu 24.04 mit einer NVIDIA GPU benötigen Sie das CUDA-Toolkit und OpenSSL, bevor Sie den Build durchführen. 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 zu Ihrer Umgebung hinzu (hinzufügen zu ~/.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

Dann führen Sie source ~/.bashrc aus oder öffnen Sie ein neues Terminal.

3. Installieren Sie OpenSSL-Entwickler-Header (erforderlich für einen sauberen Build):

sudo apt update
sudo apt install libssl-dev

4. Bauen Sie llama.cpp (aus dem Verzeichnis, das Ihre llama.cpp-Klon enthält, mit CUDA aktiviert):

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
cp llama.cpp/build/bin/llama-* llama.cpp

Dies erzeugt llama-cli, llama-mtmd-cli, llama-server 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 zu durchführen, benötigen Sie eine GGUF-Modell-Datei (*.gguf). GGUF ist ein Einzeldateiformat, das Modellgewichte plus standardisierte Metadaten enthält, die von Motoren wie llama.cpp benötigt werden.

Zwei Wege, um ein Modell zu erhalten

Option A: Verwenden Sie eine lokale GGUF-Datei

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

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

Dann führen Sie sie mit dem Pfad aus:

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

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

Moderne llama.cpp-Bauten können von Hugging Face herunterladen und Dateien in einen lokalen Cache speichern. Dies ist oft der einfachste Workflow 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 "Einmal, im Zeitalter..." \
  -n 200

Sie können auch die Quantisierung im Repo-Selektor angeben und das Tool eine passende Datei auswählen:

llama-cli \
  --hf-repo unsloth/phi-4-GGUF:q4_k_m \
  -p "Zusammenfassen Sie den Begriff der Quantisierung in einem Absatz." \
  -n 160

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

Quantisierungswahl für lokale Inferenz

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

Ein pragmatischer Ausgangspunkt:

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

Denken Sie auch an den Kontextfenster: 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 überprüfen, ob Ihr Modell geladen wird, Ihr Backend funktioniert und Ihre Prompts sich verhalten.

Minimaler Lauf

llama-cli \
  -m models/my-model.gguf \
  -p "Schreiben Sie einen kurzen Vergleich zwischen TCP und UDP." \
  -n 200

Interaktiver Chat-Modus

Der Konversationsmodus ist für Chat-Vorlagen konzipiert. Er aktiviert typischerweise interaktives Verhalten und formatiert Prompts gemäß dem Modell-Vorlage.

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

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

Wichtige llama-cli-Flaggen

Statt 200 Flaggen zu merken, konzentrieren Sie sich auf diejenigen, die die Korrektheit, Latenz und Speicherdominieren.

Modell und Download

Kontext und Durchsatz

GPU-Entlastung und Hardwareauswahl

Sampling und Ausgabekualität

Beispiel-Arbeitslasten mit llama-cli

Eine Datei zusammenfassen, nicht nur einen Prompt

llama-cli \
  -m models/my-model.gguf \
  --system-prompt "Sie erstellen Zusammenfassungen technischer Dokumente. Geben Sie maximal fünf Aufzählungspunkte aus." \
  --file ./docs/incident-report.txt \
  -n 300

Ergebnisse reproduzierbarer machen

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

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

llama-server Quickstart mit OpenAI-kompatibler API

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

• OpenAI-kompatible Endpunkte für Chat, Completion, Embeddings und Antworten,
• eine Web-Oberfläche für interaktive Tests,
• optional Monitoring-Endpunkte für Produktions-Überwachung.

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 eines Docker-Containers oder eines LANs), geben Sie Host und Port an:

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

Wichtige Server-Flaggen

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 hilfreicher Assistent." },
      { "role": "user", "content": "Geben Sie mir schnell einen llama.cpp-Checkliste." }
    ],
    "temperature": 0.7
  }'

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

OpenAI Python-Client, der llama-server anzielt

Mit einem OpenAI-kompatiblen Server können viele Clients durch Ändern von nur base_url funktionieren.

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ägnanter 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 an /v1/embeddings exponiert, aber das Modell muss eine 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 laufen, überlegen Sie, den Server im Embedding-only-Modus zu starten:

llama-server \
  -m models/my-embedding-model.gguf \
  --embeddings \
  --host 127.0.0.1 \
  --port 8080

Leistung, Überwachung und Produktionsverstärkung

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

• Speicherdeckel ist normalerweise die erste Einschränkung (RAM auf CPU, VRAM auf GPU).
• Kontextgröße ist ein großer Speichermultiplikator.
• GPU-Schichtentlastung ist oft der schnellste Weg zu mehr Token pro Sekunde.
• Batch-Größen und Threads können Durchsatz verbessern, können aber auch Speicherdruck erhöhen.

Für einen tieferen, engineering-first-Ansatz: siehe: LLM-Leistung im Jahr 2026: Benchmarks, Engpässe & Optimierung.

Überwachung von llama-server mit Prometheus und Grafana

llama-server kann Prometheus-kompatible Metriken an /metrics exponieren, wenn --metrics aktiviert ist. Dies passt natürlicherweise zu Prometheus scrape-Konfigurationen und Grafana-Dashboards.

Für Dashboards und Warnungen spezifisch für llama.cpp (und vLLM, TGI): Überwachen Sie LLM-Inferenz in der Produktion (2026): Prometheus & Grafana für vLLM, TGI, llama.cpp. Weitere Leitfäden: Beobachtbarkeit: Monitoring, Metriken, Prometheus & Grafana Guide und Beobachtbarkeit für LLM-Systeme.

Grundlegende Verstärkungscheckliste

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 benötigen es,
• überlegen Sie sich TLS über die SSL-Flaggen des Servers oder beenden Sie TLS an einem Reverse-Proxy,
• beschränken Sie die Konkurrenz mit --parallel, um Latenz unter Last zu schützen.

Schnelle Lösungen für Problemlösung

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

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

• llama-cli --conversation plus einen expliziten --system-prompt,
• überprüfen Sie, ob Ihr Modell eine Anweisungs- oder Chat-tuned-Variante ist,
• testen Sie mit der Server-Web-Oberfläche, bevor Sie es in eine Anwendung integrieren.

Sie stoßen auf Out-of-Memory

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

• verringern Sie --ctx-size,
• verringern 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,
• moderate Batch-Größen,
• Validieren Sie, dass Sie eine Build-Installation installiert haben, die Ihrem Rechner entspricht (CPU-Funktionen und Backend).

Referenzen

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