Ollama-Modelle 2026 richtig auswählen: VRAM, Quantisierung und Modellvergleich für KMU

Welche Kombination aus Modellgröße, Quantisierung und GPU liefert für KMU-Aufgaben wie Coding, deutschsprachiges Reasoning, Dokumentenverarbeitung oder Tool-Calling brauchbare Geschwindigkeit? Diese Entscheidungshilfe nennt VRAM-Zahlen, Tokens/s-Werte und Fallstricke.

Voraussetzungen

1. NVIDIA-GPU mit mindestens 8 GB VRAM (empfohlen ab 12 GB): z. B. RTX 3060 12 GB, RTX 4060 Ti 16 GB, RTX 4090 24 GB oder RTX 5090 32 GB
2. Mindestens 16 GB RAM, empfohlen 32 GB (KV-Cache-Overflow, parallele Prozesse)
3. NVMe-SSD mit Platz: 7B Q4_K_M ~5 GB, 14B ~9 GB, 32B ~20 GB, 70B ~42 GB
4. Windows 10/11 mit NVIDIA-Treiber ab Version 550, Linux (Ubuntu 22.04+) oder macOS (Apple Silicon). Seit Ollama 0.40 laufen unterstützte Modellarchitekturen auf Apple Silicon automatisch über die MLX-Laufzeit statt über llama.cpp; die Modellnamen und Befehle dieser Anleitung bleiben gleich.
5. Ollama installiert und lauffähig – Grundinstallation siehe Ollama + Open WebUI: Lokales LLM einrichten
6. CUDA nutzt Ollama automatisch, kein separates Setup

Schritt 1: Quantisierungsstufen verstehen – warum Q4_K_M der Standard ist

Quantisierung senkt die Präzision der Modellgewichte, um VRAM zu sparen. Ollama speichert die Gewichte (über llama.cpp) im GGUF-Format mit verschiedenen Stufen. Unterschied zwischen altem Q4_0 und 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, messbar bessere Qualität; deshalb ist Q4_K_M seit 2024 der Ollama-Standard-Tag.

Faustregel VRAM für Q4_K_M: Parameter (Milliarden) × 0,6 GB + KV-Cache (1–2 GB bei 8k Kontext). Ein 7B-Modell braucht also rund 4,2 GB + 1,5 GB = ~5,7 GB. Der KV-Cache hält die bereits verarbeiteten Tokens des Gesprächs vor; Ollamas VRAM-Anzeige zeigt ihn nicht mit. Bei langen Kontexten wächst er stark: 128k Kontext bedeutet bis zu 20 GB allein für den Cache.

Verifizieren: Rechnen Sie die Faustregel für Ihr Wunschmodell durch und vergleichen Sie das Ergebnis mit der Downloadgröße auf ollama.com/library (z. B. qwen3:8b rund 5,2 GB, qwen3:32b rund 20 GB). Liegt die Summe aus Downloadgröße und 1 bis 2 GB KV-Cache unter dem VRAM Ihrer Karte, ist die Stufe geeignet.

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

Wichtigste Regel: Das Modell muss vollständig in den VRAM passen. Lagert Ollama Schichten in den System-RAM aus (CPU-Offloading), fällt die Geschwindigkeit von typisch 40–60 auf 2–8 Tokens/s, Faktor 4–15×.

Einschränkung RTX 3060 12 GB: Qwen3 14B Q4_K_M passt mit ~10,7 GB, lässt aber kaum Raum für den KV-Cache; bei 8k Kontext wird es knapp. Für längere Kontexte ist Qwen3 8B Q4_K_M auf dieser GPU zuverlässiger.

Verifizieren: nvidia-smi --query-gpu=name,memory.total --format=csv zeigt Modell und Gesamt-VRAM Ihrer Karte, z. B. NVIDIA GeForce RTX 3060, 12288 MiB. Wählen Sie die Tabellenzeile, die zu diesem Wert passt.

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

Die besten Optionen nach KMU-Anwendungsfall, geordnet nach Budget:

Deutsche Texte: Modelle unter 7B (z. B. Llama 3.2 3B) zeigen Grammatikfehler, Codeswitching ins Englische und schiefe Übersetzungen. Produktiv mindestens 7B, empfohlen Qwen3 8B oder Mistral Small 3.2.

Verifizieren: ollama show qwen3:8b listet unter „Capabilities“ die Fähigkeiten des Modells. Für Tool-Calling muss dort tools stehen, für OCR und Bildverständnis vision. Fehlt der Eintrag, wählen Sie ein anderes Modell aus der Tabelle.

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

Modell mit ollama pull laden, dann mit ollama ps prüfen: Ziel ist „100% GPU“, 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-distill-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, kleineres Modell oder aggressivere Quantisierung wählen.

Verifizieren: Starten Sie das Modell mit ollama run qwen3:8b und rufen Sie in einem zweiten Terminal ollama ps auf. Die Spalte PROCESSOR zeigt 100% GPU. Ein Wert wie 48%/52% CPU/GPU bedeutet, dass ein Teil im System-RAM liegt.

Schritt 5: Kontextlänge und Flash Attention optimieren

Ollamas Standard-Kontext richtet sich nach dem VRAM: unter 24 GiB nur 4.096 Tokens, bei 24 bis 48 GiB 32.768, ab 48 GiB 256k. Auf 8- bis 16-GB-Karten ist das oft zu wenig, für Reasoning-Modelle wie DeepSeek-R1 fatal: Sie puffern ihr Chain-of-Thought intern, bei 4k werden Denkprozesse abgeschnitten. Empfehlung: mindestens 8.192, besser 16.384 Tokens.

# 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 als Server-Standard für alle Modelle:
OLLAMA_CONTEXT_LENGTH=16384 ollama serve

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

Flash Attention und KV-Cache-Quantisierung senken den KV-Cache-Bedarf erheblich, besonders bei langen Kontexten. Aktuelle Ollama-Versionen aktivieren Flash Attention automatisch, wenn Backend und GPU es unterstützen; OLLAMA_FLASH_ATTENTION=1 erzwingt es. KV-Cache-Quantisierung wirkt nur mit Flash Attention.

# 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

q8_0 halbiert den KV-Cache bei minimalem Präzisionsverlust, q4_0 viertelt ihn (nur bei extremem VRAM-Mangel). Flash Attention lohnt besonders ab 16k Kontext.

Windows: Per PowerShell gesetzte $env:-Variablen gelten nur für die aktuelle Session, nicht für die Ollama-App in der Taskleiste. Dauerhaft: Ollama über das Taskleistensymbol beenden, in den Einstellungen „Umgebungsvariablen für dieses Konto bearbeiten“ öffnen, Variablen anlegen, Ollama aus dem Startmenü neu starten.

Verifizieren: ollama ps zeigt in aktuellen Versionen die Spalte CONTEXT mit dem wirksamen Wert, z. B. 16384. Steht dort weiterhin 4096, greift die Einstellung nicht; prüfen Sie dann, ob der Server nach dem Setzen der Variablen neu gestartet wurde.

Schritt 6: Multi-GPU und parallele Anfragen konfigurieren

Seit v0.4 erkennt Ollama mehrere GPUs und verteilt Layer auf alle NVIDIA/AMD-GPUs, bevorzugt aber eine einzelne GPU, wenn das Modell passt (weniger PCIe-Overhead). Bei gemischten Generationen (z. B. RTX 3090 + RTX 4060) kann die schwächere GPU bremsen.

# 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 Verwechslung: OLLAMA_NUM_GPU meint die Anzahl der Layer, nicht der GPUs (GitHub Issue #11437). GPU-Auswahl immer über CUDA_VISIBLE_DEVICES.

Für ein RAG-System mit lokalen Embeddings: Qdrant RAG-System lokal mit Embeddings einrichten. Das Embedding-Modell laden Sie separat:

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

Verifizieren: Nach dem Neustart mit CUDA_VISIBLE_DEVICES=0 zeigt nvidia-smi den Ollama-Prozess nur auf GPU 0. Schicken Sie zwei Anfragen gleichzeitig (z. B. zwei ollama run-Fenster): Mit OLLAMA_NUM_PARALLEL=2 antworten beide parallel, statt nacheinander.

Troubleshooting / Typische Fehler

1. CPU-Offloading-Falle: ollama ps zeigt z. B. „48%/52% CPU/GPU“ statt „100% GPU“, nur 2–8 Tokens/s. Kleineres Modell oder stärkere Quantisierung wählen.
2. Unsichtbarer KV-Cache-Overflow: Modell lädt, crasht aber bei langen Gesprächen, weil Ollama den KV-Cache nicht einrechnet (bei 32k Kontext schnell 5+ GB extra). Flash Attention und/oder KV-Cache q8_0.
3. Reasoning-Modelle abgeschnitten: DeepSeek-R1 und Qwen3-Thinking brauchen mehr als die 4.096 Tokens Standard (GPUs unter 24 GiB); num_ctx auf mindestens 8.192.
4. Q4_0 statt Q4_K_M: Ältere GGUF-Dateien von Hugging Face nutzen Q4_0 mit schlechterer Qualität bei gleichem VRAM. Offiziellen Ollama-Tag ohne manuellen Suffix nutzen (üblicherweise Q4_K_M).
5. Ollama-App ignoriert PowerShell-Variablen: $env: gilt nur für die Session; dauerhaft wie in Schritt 5 setzen.
6. Zu kleines Modell für Deutsch: unter 7B; mindestens Qwen3 8B oder Mistral Small 3.2.
7. 70B-Modell auf RTX 4090 24 GB: Llama 3.3 70B Q4_K_M braucht ~43 GB, passt nicht. Alternative: Qwen3 32B Q4_K_M (~20 GB).

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. Qwen3 14B Q4_K_M (10,7 GB) passt, lässt aber wenig KV-Cache-Spielraum; über 14B nicht auf 12 GB.

Was ist der Unterschied zwischen Q4_0 und Q4_K_M?

Q4_0 quantisiert alle Gewichte gleichmäßig auf 4-bit, Q4_K_M mischt 6-bit (sensitive Schichten) und 4-bit: gleicher VRAM, bessere Qualität (Schritt 1). Manuell importierte ältere GGUF-Dateien können noch Q4_0 sein.

Wann lohnt sich der Wechsel von Q4_K_M auf Q8_0?

Bei Coding (komplexe Multi-File-Refactorings), Mathematik, strukturierter Extraktion (JSON-Schemas) oder wenn Quelltexte exakt reproduziert werden müssen: Q8_0 ist dort 0,5–3 % präziser, braucht aber doppelten VRAM. Q5_K_M ist ein Kompromiss bei knappem VRAM.

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

ollama ps zeigt Modell, VRAM und Prozessorzuweisung; Ziel „100% GPU“. Alternativ nvidia-smi in separater PowerShell: Der VRAM-Verbrauch muss beim Laden steigen.

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

Nur eingeschränkt: Llama 3.3 70B Q4_K_M braucht ~43 GB. Optionen: (a) Q3_K_M (~34 GB, auch mit einer Karte nur per CPU-Offloading, spürbare Qualitätsverluste), (b) zwei RTX 4090, (c) CPU/GPU-Split (sehr langsam). Pragmatisch: Qwen3 32B Q4_K_M (~20 GB).

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

Qwen3, Mistral Small 3.2 und DeepSeek-R1-0528 (Mai-2025-Update mit besserem JSON und Function-Calling) tragen in der Ollama-Bibliothek die Fähigkeit „tools“, Gemma 3 nicht. Produktiv mindestens 14B in Q4_K_M; kleinere Modelle liefern oft fehlerhaftes JSON. Fertige Agenten-Plattform: Dify: KI-Apps und Agenten-Plattform mit Docker.

Wie viel VRAM brauche ich für lange Kontextfenster?

Der KV-Cache wächst linear mit dem Kontext. Faustregel 7B: 8k = ~1,5 GB, 32k = ~5 GB, 128k = ~20 GB extra; Flash Attention und KV-Cache-Quantisierung senken das erheblich.

Fazit

Drei Kernprinzipien: Erstens muss das Modell vollständig in den VRAM passen. Zweitens ist Q4_K_M für die meisten KMU-Aufgaben richtig; nur bei Coding, Mathe und strukturierter Extraktion lohnt Q8_0 den doppelten VRAM. Drittens brauchen Reasoning-Modelle mehr Kontext als der Ollama-Standard unter 24 GB: mindestens 8.192, besser 16.384 Tokens.

Weiterführende Anleitungen und Quellen

1. Ollama + Open WebUI: Lokales LLM einrichten (Docker)
2. Qdrant RAG-System lokal mit Embeddings einrichten
3. Dify: KI-Apps und Agenten-Plattform mit Docker
4. LocalAI: OpenAI-kompatibler KI-Server mit Docker

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 · Ollama: Context length · Ollama: Hardware support · LLM Quantization 2026: Q4_K_M vs Q8_0 (PromptQuorum) · Ollama Performance Tuning: GPU Optimization (Collabnix)