llama.cpp: Die Engine unter der Haube

Was dieser Artikel über llama.cpp behandelt

• Was llama.cpp ist und warum es die zentrale Inferenz-Engine der lokalen-KI-Welt ist
• Wie Du llama.cpp installierst, entweder als Pre-built Binary oder aus dem Quellcode kompiliert
• Welche GPU-Backends (CUDA, Metal, ROCm, Vulkan) unterstützt werden und wie Du sie aktivierst
• Wie Du Modelle lädst, ausführst und den Server-Modus für eine OpenAI-kompatible API nutzt
• Wann llama.cpp die richtige Wahl ist und wann Du besser zu Ollama oder LM Studio greifst

Einleitung: llama.cpp verständlich erklärt

Wenn Du Dich mit lokaler KI beschäftigst, kommst Du an einem Namen nicht vorbei: llama.cpp. Hinter Tools wie Ollama und LM Studio steckt genau diese C++-Bibliothek als Inferenz-Engine. Sie ist das Fundament, auf dem ein Großteil der lokalen-KI-Software aufbaut.

llama.cpp wurde ursprünglich von Georgi Gerganov entwickelt, um das LLaMA-Modell von Meta auf handelsüblicher Hardware lauffähig zu machen. Mittlerweile unterstützt das Projekt Dutzende Modellarchitekturen und läuft auf so gut wie jedem Gerät, vom Raspberry Pi bis zum High-End-Workstation mit mehreren GPUs.

Dieser Artikel erklärt Dir, was llama.cpp macht, wie Du es installierst und einsetzt, und wann sich der direkte Einsatz lohnt, statt auf eine komfortable Oberfläche zurückzugreifen. Wenn Du noch ganz am Anfang stehst, hilft Dir der Artikel Was ist lokale KI? als Einstieg.

Warum brauche ich llama.cpp?

Stell Dir vor, Du betreibst ein lokales LLM auf Deinem Rechner und möchtest jedes Quäntchen Performance herauskitzeln. Du hast eine spezifische GPU mit einer bestimmten CUDA-Version, und die vorgefertigten Binaries von Ollama nutzen nicht alle Optimierungen, die Deine Hardware hergibt. Oder Du brauchst eine Funktion, die in den grafischen Oberflächen nicht freigeschaltet ist, etwa bestimmte Sampling-Parameter oder einen Custom-Backend.

Genau hier kommt llama.cpp ins Spiel. Es ist die unterste Schicht, die direkte Kontrolle über Kompilierung, Backend-Auswahl und Inferenz-Parameter bietet. Wer wissen will, was Lokale KI Software unter der Haube eigentlich tut, kommt an llama.cpp vorbei.

Ein weiterer Grund: llama.cpp ist das Referenzprojekt für neue Modellformate und Quantisierungsmethoden. Wenn eine neue Modellarchitektur veröffentlicht wird, ist llama.cpp oft das erste Projekt, das sie unterstützt. Wer experimentell arbeitet und Zugang zu den neuesten Entwicklungen braucht, nutzt llama.cpp direkt.

llama.cpp kurz erklärt

llama.cpp ist eine C++-Bibliothek und ein Satz von Kommandozeilen-Tools für die Inferenz von Large Language Models. Der Kern besteht aus einer reinen C/C++-Implementierung, die keine externen Deep-Learning-Frameworks wie PyTorch oder TensorFlow benötigt. Das macht das Projekt leicht zu kompilieren und auf eine breite Palette von Plattformen portierbar.

Die wichtigsten Komponenten:

• llama-cli: Führt ein Modell aus und generiert Text im Dialogmodus.
• llama-server: Startet einen HTTP-Server mit einer OpenAI-kompatiblen API.
• llama-quantize: Quantisiert Modelle in verschiedene GGUF-Formate.
• libllama: Die Bibliothek, die andere Programme einbinden können.

Modelle werden im GGUF-Format geladen, das Quantisierung und Metadaten in einer einzigen Datei bündelt. llama.cpp unterstützt eine wachsende Liste von Architekturen, darunter LLaMA, Mistral, Qwen, Phi, Gemma und viele mehr.

Für wen ist llama.cpp gedacht?

llama.cpp richtet sich an mehrere Zielgruppen:

• Entwicklerinnen und Entwickler, die eine Inferenz-Engine in eigene Anwendungen einbinden wollen.
• Power-User, die maximale Kontrolle über Parameter und Performance brauchen.
• Forscherinnen und Forscher, die mit neuen Modellarchitekturen oder Quantisierungsmethoden experimentieren.
• Systemadministratoren, die einen lokalen Inferenz-Server mit OpenAI-kompatibler API betreiben wollen.

Wenn Du einfach nur schnell ein Modell ausprobieren möchtest, ohne Dich mit Build-Systemen und Kommandozeilen-Flags zu beschäftigen, bist Du mit Ollama oder LM Studio besser bedient. Diese Tools nutzen llama.cpp unter der Haube, verpacken es aber in eine benutzerfreundliche Oberfläche. Mehr dazu im Artikel LLM lokal betreiben.

Wichtige Begriffe rund um llama.cpp

Begriff	Erklärung
llama.cpp	C++-Inferenz-Engine für LLMs, ohne Abhängigkeit von PyTorch oder TensorFlow
GGUF	Dateiformat für quantisierte Modelle, löst das ältere GGML-Format ab
GGML	Das ursprüngliche Modellformat, mittlerweile durch GGUF ersetzt
Quantisierung	Reduzierung der Genauigkeit von Modellgewichten, um Speicher und Rechenzeit zu sparen
CUDA	Nvidias Plattform für GPU-Programmierung, wichtigster GPU-Backend für llama.cpp
Metal	Apples GPU-API, genutzt für Macs mit Apple Silicon oder AMD-GPUs
BLAS	Basic Linear Algebra Subprograms, Bibliotheken für optimierte Matrixoperationen
AVX	Advanced Vector Extensions, CPU-Befehlssatz für parallele Gleitkommaoperationen
KV-Cache	Zwischenspeicher für Key- und Value-Tensoren, beschleunigt die Textgenerierung
Context Window	Maximale Anzahl an Tokens, die das Modell gleichzeitig verarbeiten kann

Was macht llama.cpp besonders?

Drei Eigenschaften heben llama.cpp von anderen Inferenz-Engines ab:

CPU-Optimierung als Kernkompetenz. llama.cpp wurde von Anfang an dafür gebaut, auf CPUs effizient zu laufen. Es nutzt SIMD-Befehlssätze wie AVX, AVX2, AVX-512 und NEON, um die Matrixoperationen der Inferenz zu beschleunigen. Auf einer modernen CPU kannst Du damit ein 7B-Modell in 4-bit-Quantisierung mit akzeptabler Geschwindigkeit ausführen, ganz ohne GPU. Details dazu im Artikel CPU vs. GPU.

Quantisierung als integraler Bestandteil. Statt Modelle in voller 16-bit-Genauigkeit zu laden, nutzt llama.cpp quantisierte GGUF-Dateien. Die gängigsten Formate sind Q4_K_M, Q5_K_M und Q8_0, die einen Kompromiss zwischen Größe, Geschwindigkeit und Qualität bieten. Du kannst Modelle selbst quantisieren oder fertige GGUF-Dateien von Plattformen wie Hugging Face herunterladen. Mehr zur Theorie im Artikel Quantisierung.

Breite Hardware-Unterstützung. llama.cpp läuft auf x86, ARM, WebAssembly und RISC-V. Es unterstützt Nvidias CUDA, Apples Metal, AMDs ROCm, Vulkan und OpenCL als GPU-Backends. Diese Vielfalt macht es zum Schweizer Taschenmesser der lokalen Inferenz.

Installation: Pre-built Binaries

Der schnellste Weg zu llama.cpp führt über die vorgefertigten Binaries. Im GitHub-Repository unter Releases findest Du fertige Builds für Windows, macOS und Linux.

Windows: Lade die llama-bXXXX-bin-win-cuda-cu12.x-x64.zip herunter, wenn Du eine Nvidia-GPU hast, oder die CPU-Variante llama-bXXXX-bin-win-avx2-x64.zip. Entpacke das Archiv und führe die enthaltenen .exe-Dateien aus.

macOS: Für Macs mit Apple Silicon gibt es Builds mit Metal-Support. Lade llama-bXXXX-bin-macos-arm64.zip herunter. Auf Intel-Macs nutze die x64-Variante.

Linux: Hier ist die Auswahl am größten. Es gibt Builds für CPU, CUDA und ROCm. Wähle die Variante, die zu Deiner Hardware passt.

Beachte, dass die Pre-built Binaries nicht für jede Kombination aus CPU-Befehlssatz und GPU-Treiber optimal sind. Wenn Du das letzte bisschen Performance herausholen willst, ist die Kompilierung aus dem Quellcode der bessere Weg.

Kompilierung aus dem Quellcode

Die Kompilierung von llama.cpp ist dank CMake unkompliziert. Du brauchst einen C++-Compiler, CMake und Git.

CPU-only Build

git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp
cmake -B build
cmake --build build --config Release

Danach findest Du die Binaries im Verzeichnis build/bin/.

CUDA-Build (Nvidia)

Für CUDA musst Du das CUDA Toolkit installiert haben. Aktiviere CUDA mit einem CMake-Flag:

cmake -B build -DGGML_CUDA=ON
cmake --build build --config Release -j

Das -j-Flag nutzt alle verfügbaren CPU-Kerne für den Build, was den Vorgang deutlich beschleunigt.

Metal-Build (macOS)

Auf Macs mit Apple Silicon ist Metal standardmäßig aktiviert. Ein normaler Build reicht:

cmake -B build
cmake --build build --config Release

Falls Metal nicht automatisch erkannt wird, kannst Du es explizit aktivieren:

cmake -B build -DGGML_METAL=ON
cmake --build build --config Release

Vulkan-Build

Vulkan ist nützlich, wenn Du eine GPU hast, die weder CUDA noch Metal unterstützt. Aktiviere es so:

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

Du brauchst die Vulkan-SDK auf Deinem System.

GPU-Support

llama.cpp unterstützt mehrere GPU-Backends, die Du je nach Hardware aktivierst:

CUDA (Nvidia): Der ausgereifteste und performanteste GPU-Backend. Wenn Du eine Nvidia-GPU hast, ist CUDA die erste Wahl. Du kannst Teile des Modells auf die GPU auslagern und den Rest auf der CPU berechnen lassen. Mehr dazu im Artikel GPU-Offloading.

Metal (Apple): Auf Macs mit M1- bis M4-Chips nutzt llama.cpp Metal für GPU-Beschleunigung. Der Unified Memory von Apple Silicon ist hier ein Vorteil, da kein expliziter Transfer zwischen CPU- und GPU-Speicher nötig ist.

ROCm (AMD): Für AMD-GPUs, vor allem unter Linux. ROCm ist weniger ausgereift als CUDA, wird aber aktiv weiterentwickelt.

Vulkan: Ein plattformübergreifender Backend, der auf einer breiten Palette von GPUs funktioniert. Die Performance ist typischerweise geringer als bei CUDA, aber die Kompatibilität ist höher.

Du kannst mehrere Backends gleichzeitig kompilieren. llama.cpp wählt zur Laufzeit den besten verfügbaren Backend aus.

Modelle laden und ausführen

Nach der Installation brauchst Du ein Modell im GGUF-Format. Lade eines von Hugging Face herunter, zum Beispiel einen quantisierten Llama- oder Mistral-Varianten.

Die einfachste Nutzung sieht so aus:

./llama-cli -m model.gguf -p "Erkläre mir Quantisierung in drei Sätzen." -n 256

Die wichtigsten Flags:

• -m: Pfad zur GGUF-Modelldatei.
• -p: Der Prompt, der verarbeitet werden soll.
• -n: Maximale Anzahl der zu generierenden Tokens.
• -c: Größe des Context Windows, Standard ist 2048.
• -t: Anzahl der CPU-Threads.
• -ngl: Anzahl der Layer, die auf die GPU ausgelagert werden.

Für einen interaktiven Dialog nutze -i:

./llama-cli -m model.gguf -i -c 4096 -ngl 33

Hier werden 33 Layer auf die GPU ausgelagert, was für ein 7B-Modell mit 4-bit-Quantisierung typisch ist.

Server-Modus

llama.cpp enthält einen HTTP-Server, der eine OpenAI-kompatible API bereitstellt. Das ist praktisch, wenn Du Anwendungen hast, die bereits mit der OpenAI-API sprechen, und Du auf ein lokales Modell wechseln willst.

Starte den Server so:

./llama-server -m model.gguf -c 4096 -ngl 33 --port 8080

Danach erreichst Du die API unter http://localhost:8080. Ein Beispiel-Aufruf:

curl http://localhost:8080/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "local-model",
    "messages": [{"role": "user", "content": "Hallo, wer bist Du?"}]
  }'

Der Server unterstützt Streaming, Function Calling (bei geeigneten Modellen) und mehrere parallele Requests. Für die Einbindung in eigene Anwendungen ist der Server-Modus oft der einfachste Weg.

llama.cpp vs. Ollama vs. LM Studio

Eigenschaft	llama.cpp	Ollama	LM Studio
Zielgruppe	Entwickler, Power-User	Einsteiger, Entwickler	Einsteiger, visuelle Nutzer
Oberfläche	Kommandozeile	Kommandozeile, API	Grafische Desktop-App
Installation	Build oder Binary	Ein Befehl	Download, Drag-and-Drop
Modellverwaltung	Manuell (GGUF-Dateien)	Automatisch (Modell-Registry)	Automatisch (Hugging Face-Integration)
GPU-Support	Alle Backends, volle Kontrolle	CUDA, Metal (vorgefertigt)	CUDA, Metal (vorgefertigt)
API	OpenAI-kompatibel (Server)	OpenAI-kompatibel	OpenAI-kompatibel
Customisierung	Sehr hoch	Mittel	Niedrig

Wann llama.cpp: Wenn Du maximale Kontrolle brauchst, spezielle Hardware konfigurieren willst oder llama.cpp in ein eigenes Projekt einbindest.

Wann Ollama: Wenn Du schnell loslegen willst und eine saubere CLI mit API bevorzugst. Ollama nutzt llama.cpp unter der Haube und abstrahiert die Komplexität.

Wann LM Studio: Wenn Du eine grafische Oberfläche bevorzugst und Modelle per Klick herunterladen und testen willst. Auch LM Studio nutzt llama.cpp als Inferenz-Engine.

Typische Stolpersteine bei llama.cpp

1. Falscher CPU-Befehlssatz. Wenn Du ein Binary nutzt, das für AVX2 kompiliert wurde, Deine CPU aber nur AVX unterstützt, stürzt das Programm ab oder läuft extrem langsam. Prüfe mit lscpu unter Linux, welche Befehlssätze Deine CPU unterstützt.

2. Zu wenig GPU-Speicher. Wenn Du mit -ngl mehr Layer auf die GPU legst, als Speicher vorhanden ist, bricht die Inferenz mit einem Fehler ab. Reduziere den Wert schrittweise, bis das Modell läuft.

3. Context Window zu klein. Ein zu kleines Context Window führt dazu, dass das Modell den Anfang eines langen Prompts vergisst. Setze -c auf einen ausreichend hohen Wert, zum Beispiel 4096 oder 8192, je nach Modell.

4. Falsche GGUF-Variante. Es gibt mehrere Quantisierungsstufen. Q4_K_M ist ein guter Standard, aber wenn Du höchste Qualität brauchst, wähle Q8_0. Q2 oder Q3 sind sehr klein, aber mit spürbarem Qualitätsverlust verbunden.

5. Veraltete GGUF-Dateien. Das GGUF-Format entwickelt sich weiter. Sehr alte GGUF-Dateien sind möglicherweise nicht mehr mit der aktuellen llama.cpp-Version kompatibel. Lade Modelle neu herunter oder konvertiere sie mit llama-quantize.

6. Threads falsch konfiguriert. Mehr Threads sind nicht immer besser. Als Faustregel gilt: Nutze so viele Threads wie physische Kerne, nicht mehr. Hyperthreads können die Performance sogar verschlechtern.

7. CUDA-Version stimmt nicht. Die CUDA-Version des Binaries muss zur installierten Nvidia-Treiberversion passen. Wenn Du CUDA 12.x-Binary nutzt, brauchst Du auch einen Treiber, der CUDA 12 unterstützt.

8. Metal wird nicht erkannt. Auf älteren macOS-Versionen oder mit bestimmten Xcode-Versionen kann Metal nicht gefunden werden. Stelle sicher, dass Dein macOS und Xcode auf dem aktuellen Stand sind.

Hardware, Kosten und Sicherheit bei llama.cpp

Hardware: llama.cpp läuft auf fast jeder Hardware. Für akzeptable Performance mit 7B-Modellen brauchst Du mindestens 8 GB RAM und eine CPU mit AVX2. Eine GPU mit 8 GB VRAM ermöglicht GPU-Offloading und deutlich schnellere Inferenz. Für 13B- oder 33B-Modelle sind 16 GB bzw. 32 GB RAM bzw. VRAM empfehlenswert.

Kosten: llama.cpp ist Open Source unter der MIT-Lizenz und komplett kostenlos. Die einzigen Kosten entstehen durch die Hardware, auf der Du es betreibst. Es fallen keine API-Kosten oder Abogebühren an, was einen wesentlichen Vorteil gegenüber Cloud-basierten KI-Diensten darstellt.

Sicherheit: Da llama.cpp lokal läuft, verlassen Deine Prompts und Daten nie Deinen Rechner. Das ist besonders relevant für sensible Daten in Bereichen wie Medizin, Recht oder Unternehmensinterna. Du musst keine Daten an externe Server senden. Achte trotzdem darauf, dass Modelle, die Du herunterlädst, aus vertrauenswürdigen Quellen stammen, da GGUF-Dateien theoretisch manipuliert sein könnten.

Weiterführende Links und Infos zu llama.cpp

• llama.cpp auf GitHub - Offizielles Repository mit Dokumentation und Releases
• GGUF-Modelle auf Hugging Face - Große Auswahl an fertigen GGUF-Dateien
• llama.cpp Discussions - Community-Support und Tipps
• Ollama - Komfortable Oberfläche auf Basis von llama.cpp
• LM Studio - Grafische Desktop-App mit llama.cpp als Engine
• Quantisierung - Hintergrundwissen zu GGUF und Quantisierungsstufen
• GPU-Offloading - Wie Du Modell-Layer auf die GPU auslagerst

FAQ: llama.cpp - Typische Fragen

Was ist llama.cpp genau? llama.cpp ist eine C++-Bibliothek und ein Satz von Kommandozeilen-Tools für die Inferenz von Large Language Models. Es benötigt keine Deep-Learning-Frameworks wie PyTorch und ist leicht zu kompilieren.

Brauche ich eine GPU für llama.cpp? Nein. llama.cpp läuft auch rein auf der CPU. Eine GPU beschleunigt die Inferenz erheblich, ist aber keine Voraussetzung.

Was ist der Unterschied zwischen GGML und GGUF? GGML war das ursprüngliche Modellformat von llama.cpp. GGUF ist der Nachfolger und löst mehrere Probleme von GGML, etwa fehlende Metadaten und Inkompatibilitäten. Aktuelle llama.cpp-Versionen nutzen GGUF.

Kann ich llama.cpp in meine eigene Anwendung einbinden? Ja. llama.cpp wird als Bibliothek (libllama) bereitgestellt, die Du in C, C++ oder über Bindings in Python, Go, Rust und anderen Sprachen nutzen kannst.

Wie viele Layer sollte ich auf die GPU auslagern? Das hängt vom verfügbaren VRAM ab. Starte mit einem kleinen Wert und erhöhe schrittweise, bis der VRAM fast voll ist. Bei einem 7B-Modell mit Q4-Quantisierung passen meist alle 32 Layer auf eine 8-GB-GPU.

Ist llama.cpp schneller als Ollama? Ollama nutzt llama.cpp als Engine, daher ist die rohe Inferenz-Geschwindigkeit vergleichbar. Ein selbst kompiliertes llama.cpp kann durch hardwareoptimierte Flags minimal schneller sein.

Kann llama.cpp mehrere Modelle gleichzeitig laden? Der Server-Modus kann mehrere Modelle verwalten, wenn Du sie mit unterschiedlichen Ports startest. True Multi-Model-Inference in einem Prozess ist aktuell nicht vorgesehen.

Welche Modellarchitekturen unterstützt llama.cpp? Eine wachsende Liste, darunter LLaMA, LLaMA 2, LLaMA 3, Mistral, Mixtral, Qwen, Phi-2, Phi-3, Gemma, Falcon, Baichuan und viele mehr. Die vollständige Liste findest Du in der Dokumentation.

Wie aktualisiere ich llama.cpp? Wenn Du aus dem Quellcode kompiliert hast, führe git pull aus und kompiliere neu. Bei Pre-built Binaries lade einfach die neueste Version von der Release-Seite herunter.

Ist llama.cpp kostenlos? Ja, llama.cpp ist Open Source unter der MIT-Lizenz. Du kannst es kostenlos nutzen, auch kommerziell.

Brauche ich Internet, um llama.cpp zu nutzen? Nur für den Download von llama.cpp selbst und von GGUF-Modellen. Die Inferenz läuft vollständig offline auf Deinem Rechner.

Quellen und weiterführende Literatur

• Gerganov, G. (2023). llama.cpp [Software]. GitHub. https://github.com/ggerganov/llama.cpp
• GGUF Format Specification. Hugging Face. https://github.com/ggerganov/ggml/blob/master/docs/gguf.md
• llama.cpp Build Documentation. GitHub. https://github.com/ggerganov/llama.cpp/blob/master/docs/build.md
• CUDA Toolkit Documentation. Nvidia. https://docs.nvidia.com/cuda/
• Metal Performance Shaders. Apple Developer. https://developer.apple.com/metal/