Lokale KI mit Ollama klingt verlockend – bis man merkt, dass das falsch gewählte Modell entweder gar nicht auf die GPU passt oder so langsam läuft, dass produktives Arbeiten ausgeschlossen ist. Die Kernfrage lautet: Welche Kombination aus Modellgröße, Quantisierungsstufe und GPU ermöglicht für KMU-Aufgaben wie Coding, deutschsprachiges Reasoning, Dokumentenverarbeitung oder Tool-Calling tatsächlich brauchbare Geschwindigkeit? Diese Anleitung gibt dir eine klare Entscheidungshilfe – mit konkreten VRAM-Zahlen, Tokens/s-Werten und den häufigsten Fallstricken.

Voraussetzungen

NVIDIA-GPU mit mindestens 8 GB VRAM (empfohlen ab 12 GB): RTX 3060 12 GB (~250 EUR), RTX 4060 Ti 16 GB (~400 EUR), RTX 4090 24 GB (~1.800 EUR), RTX 5090 32 GB (~2.000 EUR)
Systemarbeitsspeicher: mindestens 16 GB RAM, empfohlen 32 GB (für KV-Cache-Overflow und parallele Prozesse)
NVMe-SSD mit ausreichend freiem Speicherplatz: 7B Q4_K_M ~5 GB, 14B ~9 GB, 32B ~20 GB, 70B ~42 GB
Windows 10/11 mit aktuellen NVIDIA-Treibern (CUDA 12.x), Linux (Ubuntu 22.04+) oder macOS (Apple Silicon)
Ollama installiert und lauffähig – Grundinstallation siehe Ollama + Open WebUI: Lokales LLM einrichten
CUDA-Toolkit wird von Ollama automatisch genutzt, kein separates Setup nötig

Schritt 1: Quantisierungsstufen verstehen – warum Q4_K_M der Standard ist

Quantisierung reduziert die numerische Präzision der Modellgewichte, um VRAM zu sparen. Ollama nutzt GGUF-Format mit verschiedenen Quantisierungsstufen. Der entscheidende Unterschied zwischen altem Q4_0 und modernem Q4_K_M: Die „K-Quants"-Methode speichert qualitätssensitive Schichten (Attention-Heads, bestimmte MLP-Layer) in 6-bit, den Rest in 4-bit. Gleicher VRAM-Bedarf, messbar bessere Qualität – deshalb ist Q4_K_M seit 2024 der Ollama-Standard-Tag.

Quantisierung	VRAM 7B	VRAM 14B	VRAM 32B	Qualität vs. FP16	Empfehlung
FP16	14 GB	28 GB	64 GB	100 % (Referenz)	Nur Forschung/Benchmarks
Q8_0	7–8 GB	14–15 GB	32 GB	~99,5 %	Coding, Mathe, JSON-Extraktion
Q5_K_M	5,7 GB	11 GB	22 GB	~98 %	Guter Kompromiss bei VRAM-Spielraum
Q4_K_M	4,5 GB	9 GB	20 GB	~97–98 %	Standard für allgemeine KMU-Nutzung
Q4_0 (veraltet)	4,5 GB	9 GB	20 GB	~95 %	Vermeiden – schlechter als Q4_K_M bei gleichem VRAM
Q3_K_M	3,5 GB	7 GB	15 GB	~92 %	Nur bei absolutem VRAM-Mangel

Faustregel VRAM-Berechnung für Q4_K_M: Modellparameter (Milliarden) × 0,6 GB + KV-Cache (1–2 GB bei 8k Kontext). Ein 7B-Modell braucht also rund 4,2 GB Modellgewichte + 1,5 GB KV-Cache = ~5,7 GB VRAM. Wichtig: Ollamas VRAM-Anzeige zeigt nur das Modell, nicht den KV-Cache. Bei längeren Kontexten kann dieser massiv anwachsen – 128k Kontext bedeutet bis zu 20 GB allein für den Cache.

Schritt 2: Die richtige GPU für deine Modellgröße wählen

Die wichtigste Regel: Das Modell muss vollständig in den VRAM passen. Sobald Ollama Schichten in den System-RAM auslagert (CPU-Offloading), bricht die Geschwindigkeit von typischen 40–60 Tokens/s auf 2–8 Tokens/s ein – ein Faktor von 4–15×. Das macht produktives Arbeiten praktisch unmöglich.

GPU	VRAM	Preis ca.	Empfohlene Modelle (Q4_K_M)	Max. Tokens/s	Nicht geeignet für
RTX 3060	12 GB	~250 EUR	Qwen3 8B, Qwen2.5-Coder 7B, Qwen3 14B (knapp)	40–60 (7B)	Modelle > 14B Parameter
RTX 4060 Ti	16 GB	~400 EUR	Qwen3 14B Q4/Q8, Mistral Small 3.2, Llama 3.1 8B Q8	50–80 (14B)	32B-Modelle in Q4_K_M
RTX 4090	24 GB	~1.800 EUR	Qwen3 32B, DeepSeek-R1 32B, Qwen2.5-Coder 32B	80–150 (32B)	70B-Modelle (ohne Dual-GPU)
RTX 5090	32 GB	~2.000 EUR	Qwen3 32B Q8, Llama 3.3 70B Q5, DeepSeek-R1 32B Q8	150–200 (32B)	70B in Q8 (~56 GB nötig)

Wichtige Einschränkung bei der RTX 3060 12 GB: Qwen3 14B Q4_K_M passt mit ~10,7 GB VRAM noch rein, lässt aber kaum Spielraum für den KV-Cache bei längeren Gesprächen. Bei 8k Kontext werden die 12 GB knapp. Für produktive Nutzung mit längeren Kontexten ist Qwen3 8B Q4_K_M die zuverlässigere Wahl auf dieser GPU.

Schritt 3: Das richtige Modell nach KMU-Aufgabe auswählen

Nicht jedes Modell ist für jede Aufgabe gleich gut geeignet. Die folgende Tabelle zeigt die besten Optionen nach KMU-Anwendungsfall, geordnet nach Budget:

Aufgabe	Empfohlenes Modell	VRAM (Q4_K_M)	Benchmark/Stärke	Budget-Alternative
Coding / Code-Completion	Qwen2.5-Coder 32B	~20 GB	92,7 % HumanEval	Qwen2.5-Coder 7B (5 GB, 88,4 % HumanEval)
Reasoning / Mathe	DeepSeek-R1 32B	~20 GB	79,8 MATH-Score, Chain-of-Thought	DeepSeek-R1 14B (9 GB VRAM)
Deutsches NLP / Texte	Qwen3 8B oder Mistral Small 3.2	5–9 GB	119 Sprachen (Qwen3), starkes Deutsch	Qwen3 8B (6,5 GB, ~40–55 Tokens/s)
Dokument-Extraktion / RAG	Llama 3.1 8B	~5 GB	Textbasiertes RAG, bewährt	nomic-embed-text (~0,5 GB, nur Embeddings)
OCR / Tabellen aus Scans	Qwen2.5-VL 7B (Vision)	~6 GB	Vision-Language-Modell, Bildverständnis	–
Tool-Calling / Agenten	Gemma 3 oder DeepSeek-R1-0528	je nach Größe	Natives Function-Calling, verbessertes JSON	Qwen3 14B (unterstützt Function-Calling)

Hinweis zu deutschen Texten: Modelle unter 7B Parametern (z. B. Llama 3.2 3B) zeigen bei deutschen Texten deutliche Qualitätsprobleme – Grammatikfehler, Codeswitching ins Englische, schiefe Übersetzungen. Für produktives deutsches NLP mindestens 7B verwenden, empfohlen sind Qwen3 8B oder Mistral Small 3.2.

Schritt 4: Modell herunterladen und GPU-Nutzung prüfen

Lade das gewünschte Modell mit ollama pull und prüfe danach mit ollama ps, ob es vollständig auf der GPU läuft. „100% GPU" ist das Ziel – alles andere bedeutet CPU-Offloading.

# Modell herunterladen (Q4_K_M ist Ollama-Standard-Tag)
ollama pull qwen3:8b
ollama pull qwen2.5-coder:32b

# Spezifische Quantisierungsstufe explizit wählen
ollama pull qwen3:14b-q8_0
ollama pull deepseek-r1:32b-qwen-q4_K_M

# Geladene Modelle und GPU-Nutzung prüfen
# Ziel: "100% GPU" - kein CPU-Anteil
ollama ps

# GPU-VRAM-Belegung parallel überwachen (Windows PowerShell)
nvidia-smi

Zeigt ollama ps einen CPU/GPU-Split, passt das Modell nicht vollständig in den VRAM. Die Lösung: entweder ein kleineres Modell wählen oder auf eine aggressivere Quantisierung wechseln.

Schritt 5: Kontextlänge und Flash Attention optimieren

Ollamas Standard-Kontextfenster beträgt nur 4.096 Tokens. Das ist für viele KMU-Aufgaben zu wenig – und für Reasoning-Modelle wie DeepSeek-R1 fatal: Diese Modelle puffern ihr Chain-of-Thought-Denken intern. Mit nur 4k Kontext werden Denkprozesse abgeschnitten und Antworten unvollständig. Empfehlung: mindestens 8.192, besser 16.384 Tokens konfigurieren.

# Kontextlänge dauerhaft per Modelfile erhöhen
# Datei "Modelfile" erstellen:
FROM deepseek-r1:32b
PARAMETER num_ctx 16384

# Modelfile anwenden und Modell starten
ollama create mein-deepseek -f Modelfile
ollama run mein-deepseek

# Alternativ: Kontext per API-Request setzen (ohne Modelfile)
curl http://localhost:11434/api/generate -d '{
  "model": "qwen3:14b",
  "prompt": "Analysiere diesen Vertrag:",
  "options": {"num_ctx": 8192}
}'

# Oder interaktiv im Chat:
ollama run qwen3:14b
/set parameter num_ctx 8192

Flash Attention und KV-Cache-Quantisierung reduzieren den VRAM-Bedarf des KV-Caches erheblich, besonders bei langen Kontexten:

# Windows (PowerShell) - Flash Attention aktivieren
$env:OLLAMA_FLASH_ATTENTION=1
# KV-Cache-Quantisierung setzen (halbiert den KV-Cache-VRAM)
$env:OLLAMA_KV_CACHE_TYPE="q8_0"
ollama serve

# Linux/macOS
OLLAMA_FLASH_ATTENTION=1 OLLAMA_KV_CACHE_TYPE=q8_0 ollama serve

Mit q8_0 für den KV-Cache halbiert sich dessen VRAM-Bedarf bei minimalem Präzisionsverlust. q4_0 reduziert ihn auf ein Viertel, ist aber nur sinnvoll bei extremem VRAM-Mangel. Flash Attention ist besonders ab 16k Kontext empfehlenswert.

Wichtig für Windows-Nutzer: Per PowerShell gesetzte $env:-Variablen gelten nur für die aktuelle Session, nicht für den Ollama-Windows-Dienst. Damit die Einstellungen dauerhaft wirken, müssen sie in den Windows-Systemumgebungsvariablen (Systemeigenschaften → Umgebungsvariablen) gesetzt werden.

Schritt 6: Multi-GPU und parallele Anfragen konfigurieren

Ollama unterstützt seit v0.4 automatische Multi-GPU-Erkennung und verteilt Layer automatisch auf alle erkannten NVIDIA/AMD-GPUs. Ollama bevorzugt Single-GPU, wenn das Modell passt – weniger PCIe-Overhead bedeutet mehr Durchsatz. Bei gemischten GPU-Generationen (z. B. RTX 3090 + RTX 4060) kann die schwächere GPU zum Flaschenhals werden.

# Nur bestimmte GPUs nutzen (Windows PowerShell)
$env:CUDA_VISIBLE_DEVICES="0"

# Parallele Anfragen und maximale geladene Modelle konfigurieren
$env:OLLAMA_NUM_PARALLEL=2
$env:OLLAMA_MAX_LOADED_MODELS=2
ollama serve

# Linux
export CUDA_VISIBLE_DEVICES=0
export OLLAMA_NUM_PARALLEL=2
export OLLAMA_MAX_LOADED_MODELS=2
ollama serve

Achtung bekannte Verwechslung: OLLAMA_NUM_GPU bezieht sich auf die Anzahl der Layer, nicht die Anzahl der GPUs (GitHub Issue #11437). Für GPU-Auswahl immer CUDA_VISIBLE_DEVICES verwenden.

Für ein vollständiges RAG-System mit lokalen Embeddings hilft diese Anleitung weiter: Qdrant RAG-System lokal mit Embeddings einrichten. Das Embedding-Modell für die Dokumentensuche lässt sich separat laden:

# Embedding-Modell für RAG (nur ~0,5 GB VRAM)
ollama pull nomic-embed-text

Troubleshooting / Typische Fehler

CPU-Offloading-Falle: ollama ps zeigt „CPU/GPU split" statt „100% GPU". Das Modell passt nicht vollständig in den VRAM. Geschwindigkeit bricht auf 2–8 Tokens/s ein. Lösung: Kleineres Modell oder höhere Quantisierung wählen.
Unsichtbarer KV-Cache-Overflow: Modell lädt korrekt, crasht aber bei langen Gesprächen. Ursache: Ollamas VRAM-Kalkulation zählt nur Modellgewichte, nicht den KV-Cache. Bei 32k Kontext kommen schnell 5+ GB extra dazu. Lösung: Flash Attention aktivieren und/oder KV-Cache-Quantisierung auf q8_0 setzen.
Reasoning-Modelle mit 4k Kontext abgeschnitten: DeepSeek-R1 und Qwen3-Thinking-Modelle brauchen ihren internen Chain-of-Thought-Puffer. Mit Standard-4096-Tokens werden Denkprozesse mitten in der Berechnung abgebrochen. Immer num_ctx auf mindestens 8.192 erhöhen.
Q4_0 statt Q4_K_M geladen: Ältere GGUF-Dateien von Hugging Face nutzen noch Q4_0 mit sichtbar schlechterer Qualität bei gleichem VRAM. Immer den offiziellen Ollama-Tag ohne manuellen Suffix prüfen – der Standard-Tag ist üblicherweise Q4_K_M.
Windows-Dienst ignoriert PowerShell-Umgebungsvariablen: Per $env: gesetzte Variablen gelten nur für die aktuelle PowerShell-Session. Für dauerhaften Effekt: Windows-Systemumgebungsvariablen setzen (Rechtsklick Arbeitsplatz → Eigenschaften → Umgebungsvariablen).
Zu kleines Modell für deutsche Texte: Modelle unter 7B (z. B. Llama 3.2 3B) zeigen bei deutschen Texten Grammatikfehler und Codeswitching. Für produktives Deutsch mindestens Qwen3 8B oder Mistral Small 3.2 einsetzen.
70B-Modell auf RTX 4090 24 GB: Llama 3.3 70B Q4_K_M braucht ~45 GB VRAM – passt nicht. Empfehlung: Qwen3 32B Q4_K_M (~22 GB) als leistungsstarke Alternative.

Häufige Fragen

Welches Modell läuft auf meiner RTX 3060 12 GB produktiv?

Qwen3 8B Q4_K_M (6,5 GB VRAM, ~40–55 Tokens/s) und Qwen2.5-Coder 7B Q4_K_M sind die zuverlässigsten Optionen. Qwen3 14B Q4_K_M (10,7 GB VRAM) passt noch rein, lässt aber wenig Spielraum für den KV-Cache bei längeren Gesprächen. Modelle über 14B solltest du auf 12 GB VRAM nicht einsetzen.

Was ist der Unterschied zwischen Q4_0 und Q4_K_M?

Q4_0 quantisiert alle Gewichte gleichmäßig auf 4-bit. Q4_K_M (K-Quants) ist eine Mischpräzision: qualitätssensitive Schichten werden in 6-bit gespeichert, der Rest in 4-bit. Gleicher VRAM-Bedarf, messbar bessere Qualität. Q4_K_M ist der aktuelle Ollama-Standard. Ältere, manuell importierte GGUF-Dateien können noch Q4_0 sein – das lohnt sich nicht.

Wann lohnt sich der Wechsel von Q4_K_M auf Q8_0?

Bei Coding-Aufgaben (komplexe Multi-File-Refactorings), mathematischen Berechnungen, strukturierter Datenextraktion (JSON-Schemas) oder wenn Quelltexte in die Eingabe eingespeist werden, die exakte Token-Reproduktion erfordern. Q8_0 ist bei diesen Aufgaben 0,5–3 % präziser. Der Haken: Der benötigte VRAM verdoppelt sich gegenüber Q4_K_M. Q5_K_M ist ein guter Kompromiss, wenn der VRAM knapp ist.

Wie prüfe ich, ob mein Modell wirklich auf der GPU läuft?

Mit ollama ps – zeigt Modellname, VRAM-Verbrauch und Prozessorzuweisung. „100% GPU" bedeutet alles korrekt. Alternativ nvidia-smi in einer separaten PowerShell-Session öffnen: Der VRAM-Verbrauch muss beim Laden des Modells sichtbar ansteigen.

Kann ich ein 70B-Modell auf einer RTX 4090 24 GB laufen lassen?

Mit erheblichen Einschränkungen: Llama 3.3 70B Q4_K_M benötigt ~45 GB VRAM – passt nicht allein in 24 GB. Optionen: (a) Q3_K_M Quantisierung (~28 GB, spürbare Qualitätsverluste), (b) Dual-GPU-Setup mit zwei RTX 4090, (c) CPU/GPU-Split akzeptieren (sehr langsam). Die pragmatische Empfehlung: Qwen3 32B Q4_K_M (~22 GB) als 70B-Alternative auf der 4090.

Welches Modell eignet sich für Tool-Calling und Agenten-Workflows im KMU?

Gemma 3 (nativ Tool-Calling), DeepSeek-R1-0528 (Mai 2025 Update mit verbessertem JSON und Function-Calling) und Qwen3-Modelle unterstützen alle Funktionsaufrufe. Für produktive Agenten-Systeme mindestens ein 14B-Modell in Q4_K_M einsetzen – kleinere Modelle produzieren häufig fehlerhafte JSON-Strukturen. Für fertige Agenten-Plattformen bietet sich Dify: KI-Apps und Agenten-Plattform mit Docker an.

Wie viel VRAM brauche ich für lange Kontextfenster?

Der KV-Cache wächst quadratisch mit der Kontextlänge. Faustregel für ein 7B-Modell: 8k Kontext = ~1,5 GB extra, 32k Kontext = ~5 GB extra, 128k Kontext = ~20 GB extra allein für den Cache. Mit Flash Attention und KV-Cache-Quantisierung lässt sich das erheblich reduzieren.

Fazit

Die Modellauswahl für Ollama ist kein Rätselraten, wenn man die drei Kernprinzipien verinnerlicht hat: Erstens muss das Modell vollständig in den VRAM passen – CPU-Offloading macht lokale KI praktisch unbrauchbar. Zweitens ist Q4_K_M für die meisten KMU-Aufgaben der richtige Einstiegspunkt; nur bei Coding, Mathe und strukturierter Extraktion lohnt Q8_0 den doppelten VRAM-Bedarf. Drittens brauchen Reasoning-Modelle deutlich mehr Kontext als der Ollama-Standard hergibt – 16.384 Tokens sollte das Minimum für DeepSeek-R1 und Qwen3-Thinking sein. Mit diesen Regeln und den Tabellen in dieser Anleitung findest du für jede KMU-Aufgabe und jedes Budget das richtige Modell.

Weiterführende Anleitungen und Quellen

Quellen: Ollama VRAM Requirements: Complete 2026 Guide (LocalLLM.in) · Ollama Hardware Selection Guide 2026 (BetterLink Blog) · Best Ollama Models 2026 (Local AI Master) · Ollama FAQ – Offizielle Dokumentation · LLM Quantization 2026: Q4_K_M vs Q8_0 (PromptQuorum) · Ollama Performance Tuning: GPU Optimization (Collabnix)