LLM on kenji.blog

Einführung in die Nutzung und C++-Anpassung von llama.cpp

Fri, 11 Sep 2026 11:00:00 +0900

In den letzten Jahren war die Entwicklung von Large Language Models (LLMs) enorm und ihre Anwendungsbereiche erweitern sich täglich. Um jedoch Modelle mit Milliarden oder zig Milliarden Parametern in einer lokalen Umgebung auszuführen, benötigt man normalerweise eine High-End-GPU mit enorm viel VRAM. llama.cpp hat diese „Hardware-Barriere“ durchbrochen und ermöglicht praktische LLM-Inferenz auf gewöhnlichen PCs, Macs und sogar auf Geräten wie dem Raspberry Pi.

In diesem Artikel erklären wir nicht nur die Nutzung als reines Kommandozeilentool, sondern gehen für Entwickler äußerst detailliert auf die zugrunde liegende ggml-Architektur, den mathematischen Hintergrund von Transformern und Quantisierung sowie die Nutzung der C++-API ein, um LLMs in eigene Anwendungen zu integrieren und anzupassen.

1. Übersicht über llama.cpp und ggml

llama.cpp ist eine von Georgi Gerganov in C/C++ geschriebene, leichtgewichtige LLM-Inferenz-Engine. Ursprünglich wurde sie entwickelt, um Metas LLaMA-Modelle auf Apple Silicon (M1/M2 Macs) mit hoher Geschwindigkeit auszuführen, unterstützt aber mittlerweile verschiedene Architekturen und Modelle.

Das größte Merkmal ist, dass es sich um eine reine C/C++-Implementierung ohne externe Abhängigkeiten handelt. Da kein riesiges Ökosystem wie Python oder PyTorch benötigt wird und es als einzelne ausführbare Datei kompiliert werden kann, ist die Bereitstellung extrem einfach.

Das Herzstück von llama.cpp ist die Tensor-Berechnungsbibliothek ggml. ggml wurde von Grund auf neu entwickelt, um Matrixoperationen für maschinelles Lernen auf der CPU (und teilweise GPU) bis zum Äußersten zu optimieren.

1.1 Warum ist llama.cpp so schnell?

Nutzung von Memory Mapping (mmap): Beim Laden der Modellgewichte in den Speicher wird durch die Nutzung der mmap-Funktion des Betriebssystems das vollständige Laden in den RAM vermieden, was zu einem schnellen Start und Speicherplatzeinsparungen führt.
Umfassende Optimierung von SIMD-Befehlen: CPU-spezifische Befehlssätze wie AVX2, AVX-512, ARM NEON und Apple AMX werden genutzt, um Matrixmultiplikationen extrem zu beschleunigen.
Quantisierung (Quantization): Die Gewichte in 16-Bit-Gleitkommazahlen (FP16) werden in 4-Bit-, 5-Bit- oder 8-Bit-Ganzzahlen komprimiert, um Engpässe in der Speicherbandbreite zu beseitigen (Details siehe unten).

2. Mathematischer Hintergrund: Transformer und Quantisierung

Um llama.cpp tiefgreifend zu verstehen, muss man die mathematischen Formeln kennen, die es berechnet, und wissen, wie es diese Berechnungen annähert.

2.1 Transformer-Inferenzprozess

Modelle wie LLaMA verwenden eine autoregressive (Auto-regressive) Transformer-Decoder-Architektur. Der Kern der Textgenerierung ist der Self-Attention-Mechanismus.

Für eine Eingabematrix von verborgenen Zuständen $X \in \mathbb{R}^{N \times d}$ werden Query $Q$, Key $K$ und Value $V$ durch Multiplikation mit Gewichtsmatrizen berechnet:

$$ Q = X W_Q, \quad K = X W_K, \quad V = X W_V $$

Hierbei ist die Ausgabe der Attention wie folgt definiert:

$$ \text{Attention}(Q, K, V) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right)V $$

In der Inferenzschleife von llama.cpp liegt der Engpass in der Multiplikation dieser riesigen Matrizen $W_Q, W_K, W_V$ und der Gewichtsmatrizen des Feed-Forward-Networks (FFN) mit dem Vektor $X$ (da in der Generierungsphase Token für Token verarbeitet wird, ist $N=1$), also GEMV (General Matrix-Vector Multiplication).

2.2 Mathematische Grundlagen der Quantisierung

In der Inferenz, bei der die Speicherzugriffsbandbreite der Engpass ist, ist die Quantisierung, bei der Gewichtsparameter mit einer kleinen Anzahl von Bits dargestellt werden, unerlässlich. Wir erklären das Grundprinzip der in llama.cpp weit verbreiteten blockweisen Quantisierung (z. B. Q4_K oder Q4_0).

Betrachten wir zum Beispiel einen Block $w = [w_1, w_2, \dots, w_B]$ der Länge $B$ (normalerweise 32 oder 64), der Teil der FP16-Gewichtsmatrix $W$ ist. Dieser Block wird durch eine 4-Bit-Ganzzahl $q_i \in [-8, 7]$ und einen einzelnen Skalierungsfaktor $\Delta$ (FP16 oder FP32) angenähert.

$$ w_i \approx \Delta \times q_i $$

$\Delta$ wird basierend auf dem maximalen Absolutwert innerhalb des Blocks bestimmt.

$$ \Delta = \frac{\max_i |w_i|}{7} $$

Wenn das Skalarprodukt $y = w \cdot x$ unter Verwendung der quantisierten Gewichte berechnet wird und der Eingabevektor $x$ ebenfalls quantisiert wird, sodass $x_i \approx \Delta_x \times q_{x, i}$, gilt:

$$ y = \sum_{i=1}^{B} w_i x_i \approx \Delta \Delta_x \sum_{i=1}^{B} q_i q_{x, i} $$

Dieser Teil $\sum q_i q_{x, i}$ ist eine reine Ganzzahloperation und kann mithilfe von SIMD-Befehlen extrem schnell parallel berechnet werden. Das ist der mathematische Trick, der llama.cpp auf CPUs atemberaubende Geschwindigkeiten erreichen lässt.

3. Architektur und Inferenzfluss

Um die interne Funktionsweise von llama.cpp zu verstehen, zeigt das folgende Mermaid-Diagramm die Gesamtsystemarchitektur und den Datenfluss.

graph TD A["Benutzereingabe (String)"] --> B["llama.cpp Tokenizer"] B --> C["Token-IDs (int32-Array)"] C --> D["Kontextpuffer (KV Cache)"] D --> E["ggml-Berechnungsgraph"] E --> F["Transformer-Schichten"] subgraph "ggml Engine" F --> G["Self-Attention (RoPE)"] G --> H["Feed Forward Network"] H --> F end F --> I["Logits (Vokabulargröße)"] I --> J["Sampler (Temperature, Top-K, Top-P)"] J --> K["Ausgewählte Token-ID"] K --> L["llama.cpp Detokenizer"] L --> M["Ausgabe-String"] K -. "Autoregressive Schleife" .-> D

Die Textgenerierung ist eine autoregressive Schleife, bei der jedes ausgegebene Token als nächste Eingabe in den KV-Cache aufgenommen wird und den Berechnungsgraphen erneut durchläuft.

4. Einrichtung der Umgebung und Build-Methode

Bevor wir llama.cpp in ein C++-Projekt integrieren, lassen Sie uns zunächst den Quellcode kompilieren (builden).

4.1 Klonen des Repositorys

1
2


git clone https://github.com/ggerganov/llama.cpp.git
cd llama.cpp

4.2 Build mit CMake

Wenn Sie es als C++-Projekt in andere Anwendungen integrieren möchten, ist die Verwendung von CMake der Standardweg. Durch die Aktivierung von plattformspezifischen Beschleunigern (Backends) können Berechnungen beschleunigt werden.

Nur CPU (Basis-Build):

1
2
3


mkdir build && cd build
cmake ..
cmake --build . --config Release -j 8

Bei Verwendung einer NVIDIA-GPU (CUDA):

1
2
3


mkdir build && cd build
cmake .. -DGGML_CUDA=ON
cmake --build . --config Release -j 8

Bei Verwendung von Apple Silicon (Metal):

1
2
3


mkdir build && cd build
cmake .. -DGGML_METAL=ON
cmake --build . --config Release -j 8

Bei einem erfolgreichen Build werden ausführbare Dateien wie llama-cli und die llama-Bibliothek (sowie die ggml-Bibliothek) zur Verlinkung mit der unten beschriebenen C++-API im Verzeichnis build/bin/ generiert.

5. Einführung in die C++-Anpassung: Nutzung der llama.cpp API

Von hier an behandeln wir das Hauptthema: die Steuerung von llama.cpp aus C++-Code. Um ein LLM in Ihre eigenen Anwendungen (z. B. Spiel-Engines, Desktop-Apps, eingebettete Systeme usw.) zu integrieren, anstatt nur das Kommandozeilentool zu verwenden, müssen Sie die C++-API direkt aufrufen.

llama.cpp bietet hauptsächlich eine C-Schnittstelle über eine Header-Datei namens llama.h. Auch beim Aufruf aus C++ wird diese Schnittstelle verwendet.

5.1 Nötigste Includes und Einstellungen

Wenn Sie llama.cpp in Ihrem eigenen Projekt verwenden, inkludieren Sie Folgendes:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


#include "llama.h"
#include <iostream>
#include <vector>
#include <string>
#include <stdexcept>

// Makro zur Fehlerbehandlung
#define LLAMA_ASSERT(x) \
 do { \
 if (!(x)) { \
 std::cerr << "Assertion failed: " << #x << std::endl; \
 std::terminate(); \
 } \
 } while (0)

5.2 Modell laden und Kontext initialisieren

Zuerst laden wir die Modelldatei im .gguf-Format und reservieren den Kontext (Speicherplatz und KV-Cache) für die Inferenz.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36


int main(int argc, char ** argv) {
 if (argc < 2) {
 std::cerr << "Usage: " << argv[0] << " <model.gguf>" << std::endl;
 return 1;
 }
 std::string model_path = argv[1];

 // 1. Initialisierung des Backends (Umgebungs-Setup wie CPU/GPU)
 llama_backend_init();

 // 2. Standardeinstellungen für Modellparameter abrufen
 llama_model_params model_params = llama_model_default_params();
 model_params.n_gpu_layers = 35; // Anzahl der auf die GPU ausgelagerten Schichten

 // 3. Modell laden
 llama_model * model = llama_load_model_from_file(model_path.c_str(), model_params);
 if (model == nullptr) {
 std::cerr << "Failed to load model" << std::endl;
 return 1;
 }

 // 4. Kontextparameter einstellen
 llama_context_params ctx_params = llama_context_default_params();
 ctx_params.n_ctx = 2048; // Maximale Kontextgröße (Anzahl der Tokens)
 ctx_params.n_threads = 8; // Anzahl der für die Inferenz verwendeten CPU-Threads

 // 5. Kontext erstellen
 llama_context * ctx = llama_new_context_with_model(model, ctx_params);
 if (ctx == nullptr) {
 std::cerr << "Failed to create context" << std::endl;
 llama_free_model(model);
 return 1;
 }

 std::cout << "Model and context loaded successfully!" << std::endl;
 // ... folgende Verarbeitung

5.3 Tokenisierung des Prompts (Tokenization)

LLMs verstehen Text nicht direkt, sondern verarbeiten ihn als eine Reihe von ganzzahligen IDs (Tokens). Die Eingabezeichenfolge muss in Tokens umgewandelt werden.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


 std::string prompt = "Q: Was ist die Hauptstadt von Japan?\nA:";
 std::vector<llama_token> tokens_list;
 tokens_list.resize(prompt.length() + 4); // Puffergröße mit etwas Spielraum

 // Ob spezielle Token (BOS: Begin of Sequence etc.) am Anfang hinzugefügt werden sollen
 bool add_special = true;
 // Zeichenfolge in ein Array von Token-IDs umwandeln
 int n_tokens = llama_tokenize(
 model,
 prompt.c_str(),
 prompt.length(),
 tokens_list.data(),
 tokens_list.size(),
 add_special,
 false // parse_special
 );

 if (n_tokens < 0) {
 // Logik für Neuallokation und Wiederholung erforderlich, wenn der Puffer nicht ausreicht (hier zur Vereinfachung weggelassen)
 std::cerr << "Failed to tokenize prompt" << std::endl;
 return 1;
 }
 tokens_list.resize(n_tokens);

5.4 Inferenzschleife und Sampling

Wir erstellen eine Schleife, in der Tokens in das Modell eingespeist werden, die Wahrscheinlichkeitsverteilung (Logits) für das nächste Token abgerufen wird, und dann durch Sampling das nächste Token bestimmt wird.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72


 // Maximale Anzahl der zu generierenden Tokens
 const int max_gen_tokens = 100;

 // Struktur für die Batch-Evaluierung initialisieren
 llama_batch batch = llama_batch_init(512, 0, 1);

 // Prompt-Tokens zum Batch hinzufügen
 for (size_t i = 0; i < tokens_list.size(); i++) {
 llama_batch_add(batch, tokens_list[i], i, { 0 }, false);
 }
 // So einstellen, dass Logits (Vorhersageergebnisse) nur für das letzte Token des Prompts ausgegeben werden
 batch.logits[batch.n_tokens - 1] = true;

 // Erste Evaluierung (Modell mit Prompt füttern)
 if (llama_decode(ctx, batch) != 0) {
 std::cerr << "llama_decode() failed" << std::endl;
 return 1;
 }

 int n_cur = batch.n_tokens; // Aktuelle Kontextlänge
 int n_decode = 0;

 std::cout << "\nOutput: ";

 // Sampler-Kontext initialisieren (Einstellungen wie Temperature, Top-K, Top-P etc.)
 llama_sampler * smpl = llama_sampler_chain_init(llama_sampler_chain_default_params());
 llama_sampler_chain_add_top_k(smpl, 40);
 llama_sampler_chain_add_top_p(smpl, 0.9f, 1);
 llama_sampler_chain_add_temp(smpl, 0.7f);
 llama_sampler_chain_add_dist(smpl, 1234); // Seed-Wert

 while (n_decode < max_gen_tokens) {
 // 1. Sampling: Vorhersage des nächsten Tokens basierend auf dem aktuellen Kontext
 llama_token new_token_id = llama_sampler_sample(smpl, ctx, -1);

 // 2. Wenn das Token EOS (End of Sequence) ist, Schleife beenden
 if (llama_token_is_eog(model, new_token_id)) {
 break;
 }

 // 3. Token in einen String (Text) dekodieren und anzeigen
 char buf[128];
 int n_chars = llama_token_to_piece(model, new_token_id, buf, sizeof(buf), 0, false);
 if (n_chars > 0) {
 std::cout << std::string(buf, n_chars) << std::flush;
 }

 // 4. Das neu generierte Token als nächsten Batch vorbereiten
 llama_batch_clear(batch);
 llama_batch_add(batch, new_token_id, n_cur, { 0 }, true);

 // 5. Modellevaluierung (KV-Cache aktualisieren und nächstes vorhersagen)
 if (llama_decode(ctx, batch) != 0) {
 std::cerr << "Failed to evaluate" << std::endl;
 break;
 }

 n_cur += 1;
 n_decode += 1;
 }

 std::cout << std::endl;

 // Bereinigung
 llama_sampler_free(smpl);
 llama_batch_free(batch);
 llama_free(ctx);
 llama_free_model(model);
 llama_backend_free();

 return 0;
}

Dieser Code implementiert eine eigene Inferenzschleife mit der Basis-API von llama.cpp. Er verwendet die llama_batch-Struktur zur Verwaltung der Tokengruppen und führt mit llama_decode einen Forward-Pass (Vorwärtsausbreitung) des neuronalen Netzwerks aus.

6. Fortgeschrittenes Anpassungsbeispiel: Logit-Manipulation und Penalty-Steuerung mit C++

Wenn Sie nicht nur einfachen Text generieren, sondern eine Ausgabe in einem bestimmten Format (z. B. nur JSON) erzwingen oder die Ausgabe bestimmter verbotener Wörter verhindern möchten, können Sie die Logits vor dem Sampling direkt in C++ manipulieren.

Sie können das Array der rohen Scores (Werte vor der Umwandlung in Wahrscheinlichkeiten) kurz vor der Ausgabe jedes Tokens durch das Modell abrufen.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


// Rufen Sie das Array der rohen Logits direkt nach der Inferenz und vor dem Sampling ab
float * logits = llama_get_logits_ith(ctx, batch.n_tokens - 1);
int n_vocab = llama_n_vocab(model);

// Liste der IDs verbotener Tokens (Beispiel: 1234, 5678)
std::vector<llama_token> forbidden_tokens = { 1234, 5678 };

// Setzen Sie die Auftrittswahrscheinlichkeit verbotener Tokens auf 0 (Logit auf minus unendlich)
for (llama_token bad_tok : forbidden_tokens) {
 logits[bad_tok] = -INFINITY;
}

Durch die direkte Nutzung der C++-API werden „Eingriffe im Mikrosekundenbereich pro Inferenzzyklus“ möglich, die über LangChain oder Python nur schwer zu realisieren wären oder mit großem Overhead verbunden sind.

7. Die Geheimnisse der Leistungsoptimierung (Performance Tuning)

Nach Abschluss der C++-Implementierung finden Sie hier einige Kontrollpunkte, um die Geschwindigkeit für den praktischen Einsatz auf das Maximum zu steigern.

Optimierung der Batch-Verarbeitung: Bei der gleichzeitigen Verarbeitung von Anfragen mehrerer Benutzer können Sie mehrere Sequenzen in einen llama_batch aufnehmen und llama_decode einmalig aufrufen (Continuous Batching). Dies bündelt Speicherzugriffe und kann den Durchsatz drastisch verbessern.
Flash Attention aktivieren: Durch Setzen von ctx_params.flash_attn = true; in den Kontextparametern können Sie die Attention-Berechnung beschleunigen und gleichzeitig den Speicherverbrauch reduzieren. Bei der Arbeit mit langen Kontexten (Zehntausende von Tokens) ist diese Einstellung zwingend erforderlich.
NUMA-Unterstützung: In Multi-Socket-Serverumgebungen kann die Speicherzugriffslatenz reduziert werden, indem NUMA vor dem Aufruf von llama_backend_init() entsprechend konfiguriert wird.

8. Fazit

In diesem Artikel haben wir detailliert alles vom mathematischen Hintergrund von llama.cpp über die Erklärung seiner Architektur bis hin zur Erstellung einer benutzerdefinierten Inferenz-Engine mithilfe der C++-API behandelt.

Während das Python-Ökosystem sehr nützlich für Prototyping ist, zeigt die direkte Steuerung des C/C++-basierten llama.cpp in Produktionsumgebungen, die Deployments auf Edge-Geräten, Integrationen in Spiele und Echtzeitverarbeitung erfordern, ihre überwältigende Stärke.

Wir laden Sie ein, eigenen C++-Code zu schreiben und den Spaß zu erleben, LLMs in Ihrer lokalen Umgebung frei zu steuern.

Referenzlinks

llama.cpp Official Repository

ggml - Tensor Library

Attention Is All You Need (Vaswani et al., 2017)

【2026 Aktuell】Der ultimative Leitfaden zur Ausführung von lokalen LLMs unter Windows

Fri, 11 Sep 2026 10:00:00 +0900

1. Einführung: Warum gerade jetzt lokale LLMs unter Windows?

Im Jahr 2026 hat die Entwicklung generativer KI und großer Sprachmodelle (LLMs) einen gewaltigen Paradigmenwechsel vollzogen – von riesigen API-Diensten in der Cloud hin zu “lokalen LLMs”, die auf privaten PCs oder in On-Premise-Umgebungen laufen. Cloud-KIs wie GPT-5 von OpenAI und Claude 3.5 von Anthropic sind extrem leistungsstark, aber Unternehmen und Privatpersonen können nicht all ihre Daten in die Cloud senden. Aus Gründen des Datenschutzes, der Sicherheit, der Latenzzeit sowie der langfristigen und nachhaltigen Kosten ist die Nachfrage nach lokalen LLMs so explosionsartig gestiegen wie nie zuvor.

Besonders im Windows-Umfeld ist die Entwicklung des Ökosystems für lokale LLMs bemerkenswert. Noch vor einigen Jahren galt “KI-Entwicklung und -Ausführung gleich Linux” als gängige Regel, doch im Jahr 2026 hat sich Windows zu einer äußerst leistungsstarken und zugänglichen KI-Plattform gewandelt.

In diesem Artikel bieten wir einen vollständigen Leitfaden zur Einrichtung, zum Betrieb und zur Optimierung lokaler LLMs in einer Windows-Umgebung, basierend auf den neuesten Technologietrends von 2026. Von der einfachen Einrichtung für Anfänger mit Ollama über die extreme Optimierung für Fortgeschrittene mithilfe von llama.cpp bis hin zu tiefergehenden mathematischen Ansätzen zur VRAM-Berechnung, dem Verständnis der Architektur und lokalem Fine-Tuning – wir erklären alles ausführlich und in gewaltigem Umfang.

1.1 Technologietrends rund um lokale LLMs im Jahr 2026

Die wichtigsten Trends, die das aktuelle Ökosystem für lokale LLMs prägen, sind:

Vollständige Verbreitung des GGUF-Formats: GGUF (GPT-Generated Unified Format), das Metadaten und Tensoren in einer einzigen Datei vereint, hat sich vollständig als De-facto-Standard etabliert. Dadurch genügt es, eine einzige Datei von Hugging Face herunterzuladen, um sie in beliebigen Umgebungen auszuführen.
Demokratisierung der MoE-Architektur (Mixture of Experts): Es wurden zahlreiche kleine, aber leistungsstarke MoE-Modelle veröffentlicht. Indem während der Inferenz nur ein Teil der Experten aktiviert wird, erreichen sie die Leistung riesiger Modelle, während die Rechenlast für Consumer-PCs gering gehalten wird.
Fortgeschrittene Abstraktion und Optimierung von Inferenz-Engines: Tools wie Ollama, LM Studio und AnythingLLM wurden so verfeinert, dass sich der Benutzer nicht mehr um komplexe Abhängigkeiten wie die Installation von CUDA-Treibern kümmern muss. Zudem hat die native Windows-Unterstützung von FlashAttention 3 die Inferenzgeschwindigkeit drastisch erhöht.
Nutzung von NPUs und der Aufstieg von Windows Copilot+ PCs: Die Technologie zur Ausführung kleiner LLMs (SLM: Small Language Models) mit geringem Stromverbrauch unter Nutzung der verbauten NPU (Neural Processing Unit) hat auch bei Laptops ohne GPU die Praxisreife erreicht.

2. Hardwareanforderungen und OS-Vorbereitung

Um ein lokales LLM mit praktikabler Geschwindigkeit (15 bis 30 Token pro Sekunde oder mehr) auszuführen, ist die Wahl der Hardware von entscheidender Bedeutung.

2.1 Empfohlene Hardwarekonfiguration

Mit der Weiterentwicklung von AI-PCs haben sich auch die Spezifikationsanforderungen geändert.

OS: Windows 11 Pro (24H2 oder neuer). Zwingend erforderlich für die volle Funktionalität von WSL2, erweitertes Speichermanagement sowie die Nutzung der neuesten APIs von DirectML.
CPU: Intel Core Ultra 200 Serie oder neuer, bzw. AMD Ryzen 9000 Serie oder neuer. Bei gleichzeitiger Nutzung der CPU-Inferenz ist eine hohe Speicherbandbreite unerlässlich.
RAM: Mindestens 32 GB, empfohlen 64 GB oder mehr. Die Bandbreite des Hauptspeichers (MB/s) wird zum entscheidenden Flaschenhals bei CPU-Inferenz oder Offloading. Schneller DDR5-6000 Speicher oder höher ist ideal.
GPU: NVIDIA RTX 4000/5000 Serie. Bei lokalen LLMs ist nicht die Rechenleistung, sondern die “VRAM-Kapazität” das Wichtigste.
- Einsteiger: RTX 4060 Ti (16GB-Version) - Bestes Preis-Leistungs-Verhältnis. Ideal für Modelle der 8B- bis 14B-Klasse.
- Mittelklasse: RTX 4070 Ti SUPER (16GB) / RTX 4080 SUPER (16GB)
- High-End: RTX 4090 (24GB) / RTX 5090 (32GB) - Erforderlich für die Ausführung quantisierter Modelle der 30B- bis 70B-Klasse.
Speicher: PCIe Gen4 oder Gen5 NVMe SSD. Reduziert die Ladezeiten für zig Gigabyte große Modelle drastisch.

2.2 Einrichtung von WSL2 (Windows Subsystem for Linux 2)

Viele GUI-Tools laufen nativ unter Windows, aber für die Python-Entwicklung, das Kompilieren neuester Tools und das spätere LoRA-Fine-Tuning ist WSL2 äußerst praktisch. In den neuesten Windows 11-Umgebungen muss lediglich der NVIDIA-Treiber auf dem Host installiert werden, um die GPU (CUDA) transparent aus WSL2 heraus nutzen zu können.

Öffnen Sie PowerShell mit Administratorrechten und führen Sie Folgendes aus:

1
2
3
4
5


# Installation von WSL2 und dem neuesten Ubuntu
wsl --install -d Ubuntu-24.04

# Kernel-Update
wsl --update

Führen Sie nach der Installation nvidia-smi im WSL2-Terminal aus. Wenn die GPU korrekt erkannt wird, war die Einrichtung erfolgreich.

3. Architektur lokaler LLMs und Inferenzmechanismus

Das Verständnis der internen Struktur, wie ein Modell in einer lokalen Umgebung Text generiert, ist für die Fehlerbehebung und Optimierung äußerst nützlich.

Das folgende Mermaid-Diagramm zeigt eine typische Inferenz-Pipeline eines lokalen LLMs.

graph TD User["Benutzereingabe (Prompt)"] --> Tokenizer["Tokenizer (Tokenizer)"] Tokenizer --> Embedding["Embedding-Schicht (Embedding)"] subgraph "Transformer Block (x Layers)" Embedding --> Attn["Selbst-Aufmerksamkeit (Self-Attention)"] Attn --> KVCache["KV-Cache (Key/Value-Erhalt)"] Attn --> FFN["Feed-Forward-Netzwerk (FFN)"] end FFN --> Logits["Logit-Berechnung (Logits)"] Logits --> Sampler["Sampler (Temperature, Top-K, Top-P)"] Sampler --> OutputToken["Ausgabe-Token"] OutputToken --> |"Autoregressive Generierung"| Tokenizer OutputToken --> Decoder["Detokenizer (Detokenizer)"] Decoder --> FinalOutput["Finaler Ausgabetext"]

3.1 Zwei Phasen: Prefill und Decode

Die Textgenerierung bei LLMs unterteilt sich in zwei Phasen mit unterschiedlichen Berechnungseigenschaften.

Prefill-Phase (Prompt-Verarbeitung): In dieser Phase wird der gesamte eingegebene Prompt auf einmal verarbeitet und verstanden. Da parallele Berechnungen möglich sind, steht die Rechenleistung der GPU (FLOPS) in direktem Zusammenhang mit der Geschwindigkeit. Bei langen Prompts kann diese Phase mehrere Sekunden dauern.
Decode-Phase (Token-Generierung): In dieser Phase wird iterativ ein Token vorhergesagt und als nächste Eingabe zurückgeführt (autoregressiv). Da hier parallele Berechnungen eingeschränkt sind, wird die VRAM-Bandbreite (Memory Bandwidth) der GPU zum entscheidenden Flaschenhals.

4. Berechnung des VRAM-Verbrauchs und mathematisches Verständnis der Modellgröße

Um richtig einschätzen zu können, “welches Modell auf meinem PC läuft”, muss man die Berechnungsformel für den VRAM verstehen. Ein Fallback auf den Systemspeicher (RAM) aufgrund von VRAM-Mangel macht die Inferenzgeschwindigkeit 10- bis 100-mal langsamer.

4.1 Basis-VRAM basierend auf der Parametergröße

Dies ist die Speichermenge, die benötigt wird, um die Gewichte (Weights) des Modells in den VRAM zu laden. Sie wird anhand der Modellgröße $P$ (Anzahl der Parameter, Einheit: 1 Milliarde = 1B) und der Anzahl der Bytes pro Parameter $B$ berechnet.

$$ V_{base} = P \times B \quad \text{(GB)} $$

Wenn Sie beispielsweise ein 8B (8 Milliarden) Parameter-Modell in FP16 (Halbgenauigkeits-Gleitkommazahl, 16 Bit = 2 Byte) laden:

$$ V_{base} = 8 \times 2 = 16 \text{ GB} $$

Das bedeutet, selbst wenn Ihre GPU 16 GB VRAM hat, ist allein durch das Laden des Modells das Limit fast erreicht.

4.2 Die Magie der Quantisierung (Quantization)

Hier kommt die “Quantisierung” ins Spiel. Durch Verringern der Parametergenauigkeit wird die Modellgröße drastisch reduziert. Bei der gängigsten 4-Bit-Quantisierung (z. B. Q4_K_M) beträgt ein Parameter im Durchschnitt etwa 0,55 Byte.

$$ V_{base\_4bit} = 8 \times 0.55 = 4.4 \text{ GB} $$

Dadurch können Sie mit 16 GB VRAM problemlos ein 8B-Modell mit ausreichend Spielraum ausführen.

4.3 Berechnung des KV-Caches (GQA-unterstützte Version)

Während der Inferenz verbraucht der “KV-Cache”, der den bisherigen Kontext speichert, VRAM. In neuesten Modellen wie Llama 3 wird GQA (Grouped Query Attention) eingesetzt, um Speicher zu sparen.

Der Verbrauch des KV-Caches $V_{kv}$ (in Gigabyte) lässt sich durch folgende Formel darstellen:

$$ V_{kv} = 2 \times b \times s \times l \times \left( \frac{h_{kv}}{h_q} \right) \times h_q \times d \times B_{kv} \div 10^9 $$

Vereinfacht ausgedrückt, kann es mithilfe der Anzahl der Key- und Value-Köpfe $h_{kv}$ einfach berechnet werden:

$$ V_{kv} = 2 \times b \times s \times l \times h_{kv} \times d \times B_{kv} \div 10^9 $$

Hierbei ist:

$b$: Batch-Größe (bei lokaler Einzelnutzung meist 1)
$s$: Sequenzlänge (Kontextlänge, z. B. 8192)
$l$: Anzahl der Schichten (Layer, z. B. 32)
$h_{kv}$: Anzahl der KV-Köpfe (KV-Heads, z. B. 8)
$d$: Dimensionalität pro Kopf (z. B. 128)
$B_{kv}$: Bytegröße des KV-Caches (2 für FP16)

Berechnungsbeispiel (Llama 3 8B, Kontext 8192, FP16 Cache): $V_{kv} = 2 \times 1 \times 8192 \times 32 \times 8 \times 128 \times 2 \div 10^9 \approx 1.07 \text{ GB}$

Beachten Sie, dass der erforderliche VRAM linear ansteigt, je länger die Kontextlänge $s$ gewählt wird.

5. Praxis 1: Schnellstes und kürzestes Setup mit Ollama

Da wir nun die Theorie verstehen, lassen Sie uns ein LLM tatsächlich in einer Windows-Umgebung ausführen. Im Jahr 2026 ist das benutzerfreundlichste Tool “Ollama”. Es bietet ein Docker-ähnliches, intuitives CLI.

5.1 Installation und Ausführung

Laden Sie den Windows-Installer von der offiziellen Ollama-Website herunter und führen Sie ihn aus.
Öffnen Sie PowerShell und geben Sie den folgenden Befehl ein. Hier verwenden wir das japanischsprachige llama3:8b.

1

ollama run llama3:8b

Beim ersten Ausführen wird das Modell heruntergeladen. Sobald dies abgeschlossen ist, können Sie direkt im Terminal chatten.

5.2 Erstellen einer benutzerdefinierten KI mit Modelfile

Sie können ganz einfach eine KI mit einer bestimmten Persona erstellen. Erstellen Sie ein Modelfile an einem beliebigen Ort.

1
2
3
4
5
6
7
8
9


FROM llama3:8b

SYSTEM """
Sie sind ein hervorragender Senior-Software-Ingenieur.
Beantworten Sie Benutzerfragen stets mit Codebeispielen, logisch und präzise.
"""

PARAMETER temperature 0.3
PARAMETER num_ctx 8192

Erstellen und starten Sie Ihr eigenes Modell mit den folgenden Befehlen:

1
2


ollama create SeniorDev -f ./Modelfile
ollama run SeniorDev

5.3 Nutzung über externe Apps (KI-Editoren)

Ollama stellt einen OpenAI-kompatiblen API-Endpunkt unter http://localhost:11434 zur Verfügung. Indem Sie diese URL in den Backend-Einstellungen von VS-Code-Erweiterungen wie Cursor oder Continue.dev angeben und als Modellnamen z.B. SeniorDev festlegen, erhalten Sie kostenlos einen leistungsstarken lokalen Coding-Assistenten.

6. Praxis 2: Extreme Leistungsoptimierung mit llama.cpp

Wenn Sie feinkörnige Speicherverwaltung wünschen oder die neuesten Formate (wie EXL2 oder IQ-Quantisierung) schnell ausprobieren möchten, steuern Sie die Kern-Engine llama.cpp direkt.

6.1 Schritte zum Kompilieren von llama.cpp

In einer Windows-Umgebung ist es am besten, mithilfe von CUDA Toolkit und CMake aus dem Quellcode zu kompilieren.

1
2
3
4
5
6
7
8


git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp
mkdir build
cd build

# Für CUDA konfigurieren und kompilieren
cmake .. -DLLAMA_CUBLAS=ON -DBUILD_SHARED_LIBS=OFF
cmake --build . --config Release -j 16

6.2 Fortgeschrittener Start im Server-Modus

Verwenden Sie die kompilierte llama-server.exe, um das Modell zu hosten.

1
2
3
4
5
6
7


.\bin\Release\llama-server.exe `
 --model "C:\models\Llama-3-8B-Instruct.Q4_K_M.gguf" `
 --ctx-size 8192 `
 --n-gpu-layers 99 `
 --threads 8 `
 --flash-attn `
 --port 8080

--n-gpu-layers 99: Verlagert so viele Layer wie möglich auf den GPU VRAM.
--flash-attn: Aktiviert FlashAttention 3, um die Inferenzgeschwindigkeit zu erhöhen und den VRAM-Verbrauch des KV-Caches zu senken.

7. GUI-Frontends: LM Studio und Aufbau lokaler RAGs

Wenn Sie die Kommandozeile meiden möchten oder RAG (Retrieval-Augmented Generation) intuitiv umsetzen wollen, nutzen Sie eine GUI.

7.1 LM Studio

LM Studio ist eine fantastische Anwendung, die Modellsuche, Download, Überprüfung der Systemanforderungen und eine Chat-UI in einem vereint. Durch einfaches Klicken auf den Button “Local Server” in der App wird eine OpenAI-kompatible API gestartet.

7.2 RAG-Architektur mit AnythingLLM

Hier ist das Architekturdiagramm einer RAG-Umgebung zum Einlesen interner Dokumente oder privater Notizen.

graph LR Document["Dokument (PDF, MD)"] --> Chunking["Chunk-Aufteilung"] Chunking --> EmbedModel["Embedding-Modell"] EmbedModel --> VectorDB["Vektordatenbank"] UserQuery["Benutzeranfrage"] --> EmbedQuery["Anfrage-Embedding"] EmbedQuery --> VectorDB VectorDB --> |"Ähnlichkeitssuche"| RetrievedDocs["Extrahierte relevante Dokumente"] UserQuery --> PromptBuilder["Prompt-Generierung"] RetrievedDocs --> PromptBuilder PromptBuilder --> LocalLLM["Lokales LLM"] LocalLLM --> Answer["Finale Antwort"]

Mit der Desktop-Version von AnythingLLM (für Windows) können Sie diese Architektur in wenigen Minuten aufbauen, indem Sie in den Einstellungen Ollama (für LLM und Embedding) auswählen und eine lokale Vektor-DB (LanceDB) festlegen. Dies ist die Geburtsstunde einer privaten KI, die keinerlei Daten nach außen sendet.

8. Fine-Tuning (LoRA) auf Windows WSL2

Wenn Sie Modelle nicht nur lokal ausführen, sondern mit Ihren eigenen Daten intelligenter machen wollen, ist ein Fine-Tuning mit LoRA (Low-Rank Adaptation) möglich. Im Jahr 2026 können Sie mit der Bibliothek “Unsloth” in einer Windows WSL2-Umgebung das Training eines 8B-Modells mit 16 GB VRAM in wenigen Stunden abschließen.

Richten Sie die Umgebung ein, indem Sie Folgendes in WSL2 Ubuntu ausführen:

1
2
3
4


conda create --name unsloth_env python=3.11
conda activate unsloth_env
pip install "unsloth[colab-new] @ git+https://github.com/unslothai/unsloth.git"
pip install --no-deps trl peft accelerate bitsandbytes

Unsloth optimiert CUDA-Kernel bis zum Äußersten, verdoppelt die Trainingsgeschwindigkeit im Vergleich zu Standard-Hugging-Face-Bibliotheken und halbiert den VRAM-Verbrauch. Starten Sie einfach ein Jupyter Notebook, laden Sie Ihren Datensatz (im JSONL-Format) ein, und schon ist ein Training über mehrere Epochen selbst auf einer RTX 4060 Ti mit 12 GB bis 16 GB VRAM möglich.

9. Leistungs-Fehlerbehebung (Troubleshooting)

Häufig auftretende Probleme und deren Lösungen.

1. Inferenzgeschwindigkeit ist extrem langsam (1-2 tokens/s)

Ursache: Das Modell passt nicht in den VRAM und wird auf den Systemspeicher (RAM) ausgelagert. Lösung: Überprüfen Sie den “Dedizierten GPU-Speicher” im Task-Manager. Wenn das Limit erreicht ist, verringern Sie die Kontextgröße (-c) oder verwenden Sie ein quantisiertes Modell mit niedrigerer Bitrate (z. B. Q4_K_M).

2. “CUDA out of memory” Fehler

Ursache: Der VRAM ist vollständig erschöpft. Tritt besonders dann auf, wenn der Dialog lang wird und der KV-Cache anwächst. Lösung: Begrenzen Sie bewusst die Werte für num_ctx bei Ollama oder -c bei llama.cpp.

3. Japanische (oder eine andere) Generierung ist seltsam

Ursache: Falsches Prompt-Template oder inkompatibles Modell. Lösung: Verwenden Sie Modelle, die Instruct im Namen tragen, und stellen Sie sicher, dass das vom Modellautor angegebene korrekte Template (wie ChatML oder Llama3-Format) im Tool ausgewählt ist.

10. Zusammenfassung und zukünftige Aussichten

Im Jahr 2026 ist der Aufbau lokaler LLMs unter Windows kein Privileg mehr für eine kleine Gruppe von Ingenieuren. Durch den De-facto-Standard des GGUF-Formats, das Erscheinen ausgereifter Ökosysteme wie Ollama und LM Studio und Hardware-Optimierungen wie FlashAttention kann heute jeder ganz einfach eine KI-Umgebung auf Unternehmensniveau einrichten.

Bitte nutzen Sie die in diesem Artikel erläuterten Punkte:

Wählen Sie durch mathematische VRAM-Berechnungen logisch die optimale Modellgröße und Quantisierungsstufe für die Spezifikationen Ihres PCs aus.
Bauen Sie mit Ollama in kürzester Zeit eine Umgebung auf und steigern Sie die Produktivität drastisch durch die Integration mit einem KI-Editor.
Holen Sie durch erweiterte Parametersteuerung mit llama.cpp die maximale Leistung aus Ihrer Hardware heraus.
Errichten Sie mit AnythingLLM ein sicheres lokales RAG-System, das auch vertrauliche Daten verarbeiten kann.
Nutzen Sie Unsloth (WSL2), um Ihre eigene benutzerdefinierte KI mit Fachwissen zu trainieren.

Die “Demokratisierung” der KI ist nicht länger nur ein Schlagwort, sondern ein reales System, das auf Ihrem Windows-Desktop läuft. Befreien Sie sich von Cloud-API-Kosten sowie Risiken von Informationslecks und treten Sie noch heute in die freie und mächtige Welt der privaten KI ein.