Ein LLM auf einer 6 bis 8 GB Karte ausführen

Kurze Antwort: Auf einer Karte mit 6–8 GB läuft ein Modell mit 7–8B in 4 Bit mit mäßigem Kontext, oder eines mit 3–4B in höherer Präzision. Was nicht läuft, ist ein 13–14B-Modell in 4 Bit: Es braucht etwa 10 GB, bevor der Desktop seinen Anteil nimmt. Der Unterschied zwischen 6 und 8 GB ist nicht kosmetisch, aber kleiner, als die meisten Ratgeber suggerieren.

Das ist kein Benchmark einzelner Karten. Alle Zahlen kommen aus derselben Formel wie unser VRAM-Rechner, du kannst also jede Zeile mit deinem Modell nachrechnen. Geprüft am 2. November 2026.

Was „6–8 GB“ wirklich bedeutet

Die Zahl auf der Packung ist nicht die, die du hast. Der Desktop-Compositor, der Browser mit Hardwarebeschleunigung und jede andere GPU-Anwendung belegen schon Speicher auf der Karte, bevor dein Modell startet. Auf einem Rechner mit 8 GB zeigt `nvidia-smi` im Leerlauf oft 0,6 bis 1,6 GB als belegt an.

Die erste Gewohnheit ist deshalb, den echten Wert zu lesen statt das Datenblatt:

nvidia-smi bei NVIDIA
rocm-smi bei AMD
Aktivitätsanzeige → GPU-Verlauf bei Apple Silicon

Dann gilt die Regel des Rechners: Ein Modell, das unter 85 % der Karte belegt, läuft bequem; bis 100 % ist es knapp; darüber läuft es in den System-RAM über oder bricht ab.

Die vier Dinge, die deinen VRAM fressen

1. Gewichte. Das Modell selbst: Parameter × Bits pro Gewicht ÷ 8.
2. KV-Cache. Die Attention-Keys und -Values des bisherigen Gesprächs. Er wächst mit dem Kontextfenster, das du erlaubst.
3. Overhead der Engine. Engine, GPU-Kontext und Arbeitspuffer. Wir rechnen mit 0,8 GB.
4. Alles andere. Desktop, Browser, andere Anwendungen. Diesen Teil vergisst man, und deshalb stürzt ein Modell ab, das „passt“, sobald es 95 % erreicht.

gewichte_GB = parameter_B × bits ÷ 8
kv_GB ≈ (kontext ÷ 8192) × parameter_B × 0,15
gesamt ≈ gewichte + kv + 0,8

Die KV-Zeile ist bewusst eine Näherung: Der genaue Wert hängt von der Architektur ab, davon, wie viele Schichten sich einen Cache teilen, und vom Datentyp des Caches. Für die Entscheidung, ob ein Modell passt, reicht es.

Was bei 8.192 Token Kontext passt

Modell	Q4_K_M	Q5_K_M	Q8	Urteil auf 8 GB	Urteil auf 6 GB
3B	2,8 GB	3,1 GB	4,3 GB	Bequem, sogar in Q8	Bequem
4B	3,6 GB	4,0 GB	5,6 GB	Bequem	Passt in Q5
7B	5,4 GB	5,6 GB	7,4 GB	Bequem	Knapp
8B	6,0 GB	7,0 GB	10,0 GB	Knapp / bequem, siehe unten	Nur mit 4k Kontext
14B	9,9 GB	11,7 GB	16,9 GB	Passt nicht	Passt nicht

Bei der 8B-Zeile wird die Frage 6 gegen 8 GB konkret. Mit 6,0 GB auf einer 6-GB-Karte bist du bei 100 %: technisch drin, praktisch am Rand. Auf 8 GB bist du bei 75 %, das lässt Platz für den Desktop und für einen etwas längeren Prompt.

Der Kontext ist der Hebel, den niemand erwartet

Die Gewichte ändern sich nicht mit dem Gespräch, der Cache schon. Mit einem 8B-Modell in Q4_K_M:

Kontext	KV-Cache	Gesamt
4.096	0,6 GB	5,4 GB
8.192	1,2 GB	6,0 GB
16.384	2,4 GB	7,2 GB
32.768	4,8 GB	9,6 GB

Das ist die ganze Geschichte von „gestern lief es noch“: Dasselbe Modell braucht bei 32k rund 3,6 GB mehr als bei 8k. Wenn ein Chat, der lief, jetzt abbricht, senke den Kontext, bevor du an der Quantisierung drehst. Du verlierst Gesprächsgedächtnis, nicht Antwortqualität.

Modelle und Quantisierungen für den Anfang

7–8B in Q4_K_M: die vernünftige Wahl

Das ist der Punkt, an dem die Qualität keine Demo mehr ist und die Datei noch auf eine Mittelklasse-Karte passt. Ein Hinweis aus unserem GGUF-Ratgeber: Q4_K_M sind keine vier Bits pro Gewicht. llama.cpp misst für Llama 3.1 8B etwa 4,89, deshalb ist die Datei auf der Platte größer, als die Arithmetik oben suggeriert. Der Rechner bleibt bei der einfachen Version, damit die Zahlen reproduzierbar sind; nimm die Dateigröße als Untergrenze, nicht als Antwort.

13–14B: wann es sich lohnt (nicht auf dieser Karte)

In Q4_K_M braucht ein 14B-Modell bei 8k Kontext rund 9,9 GB. Auf einer 8-GB-Karte kommst du nur hin, indem du Schichten in den System-RAM verlagerst, was die Geschwindigkeit einbrechen lässt und sich meist schlechter anfühlt als ein 8B, das komplett auf der GPU läuft. Nimm 12 GB oder mehr, bevor du darüber nachdenkst.

Kleine Modelle und Mixture-of-Experts

Modelle mit 3–4B in Q5 oder Q6 sind die unterschätzte Option für 6 GB: Sie passen mit Luft, antworten schneller und reichen zum Zusammenfassen, Umschreiben und Klassifizieren. MoE-Modelle sind ein anderer Tausch: Sie aktivieren pro Token nur einen Bruchteil ihrer Parameter, können also schnell sein, aber das ganze Modell muss im Speicher liegen. Ein 30B-MoE mit 3B aktiven Parametern passt nicht auf eine 8-GB-Karte, nur weil es sich wie ein 3B anfühlt.

Die Engine einstellen

Ollama

Ollama entscheidet selbst, wie viele Schichten auf die GPU gehen. `ollama ps` zeigt die Aufteilung nach dem Laden: Steht dort 100 % GPU, liegt alles auf der Karte.

ollama run llama3.1:8b
ollama ps
ollama run llama3.1:8b --verbose

Der Kontext wird pro Modell im Modelfile gesetzt (`PARAMETER num_ctx 8192`) oder pro Sitzung mit `/set parameter num_ctx 4096`. Ihn zu senken ist der schnellste Weg aus einem Speicherfehler. Die übrigen Befehle stehen in unserem Ollama-Cheatsheet.

LM Studio

Der GPU-Offload-Regler ist dieselbe Entscheidung in Schichten: weniger Schichten auf der GPU, mehr im RAM, langsamer, aber machbar. Stelle die Kontextlänge bewusst ein, statt sie auf Maximum zu lassen, und prüfe nach dem Laden das Offload-Panel, um zu sehen, wie viel Speicher tatsächlich belegt wurde.

llama.cpp

`-ngl` (Schichten auf der GPU), `-c` (Kontext) und `-b` (Batch) sind hier die drei wichtigen Parameter. Ein kleinerer Batch senkt die Speicherspitze beim Verarbeiten des Prompts — und dort entstehen viele der Speicherfehler, nicht beim Generieren.

Wenn „out of memory“ kommt

1. Halbiere den Kontext. Von 32k auf 16k spart bei einem 8B etwa 2,4 GB.
2. Schließe den Browser. Hardwarebeschleunigung hält Hunderte Megabyte auf der Karte. Ein Game-Launcher oder ein Videoanruf ebenso.
3. Senke die Batch-Größe, wenn du lange Prompts oder Dokumente schickst.
4. Dann senke die Quantisierung, von Q5 auf Q4. Erwarte einen echten, aber moderaten Qualitätsverlust.
5. Erst dann wechsle das Modell. Wenn ein 8B in Q4 mit 4k Kontext immer noch nicht passt, ist die Karte die Grenze, nicht die Einstellung.

Woran du merkst, dass es wirklich gut läuft

Drei Zahlen, alle leicht zu bekommen:

• Zeit bis zum ersten Token (TTFT). Wie lange es dauert, bis die Antwort beginnt. Bestimmt von der Prompt-Verarbeitung; sie wächst mit der Prompt-Länge und mit Schichten, die im RAM liegen.
• Token pro Sekunde. Generierungsgeschwindigkeit. Für Chat fühlen sich etwa 10 Tokens/s schon brauchbar an; unter 5 wirkt es kaputt. Miss es mit `--verbose` in Ollama oder lies es in der Fußzeile von LM Studio.
• VRAM-Spitze. Beobachte `nvidia-smi -l 1` in einem zweiten Fenster, während du den längsten Prompt schickst, den du erwartest.

Wiederhole denselben Prompt dann dreimal und nimm den Median. Temperatur und Sampling machen eine Einzelmessung rauschig; ein Test, den du nicht wiederholen kannst, sagt nichts über deinen Rechner.

Checkliste

• Lies den verfügbaren VRAM, nicht die Spezifikation der Karte.
• Nimm 7–8B in Q4_K_M, oder 3–4B in Q5/Q6, wenn die Karte 6 GB hat.
• Starte mit 8k Kontext, nicht mit 32k.
• Bestätige mit `ollama ps` oder dem Offload-Panel, dass alles auf der Karte liegt.
• Miss TTFT und Tokens/s; wenn es langsam ist, prüfe, ob Schichten im RAM liegen.
• Erst dann justiere die Quantisierung.

Unser VRAM-Ratgeber hat die vollständige Tabelle nach Modellgröße und Karte, und der Rechner macht die Arithmetik für dein genaues Modell, deine Quantisierung und deinen Kontext.

Weiterlesen

• Wie viel VRAM brauchst du? — Gewichte, KV-Cache und Overhead, mit reproduzierbarer Formel.
• GGUF-Quantisierung erklärt — was Q4_K_M und die anderen wirklich bedeuten.
• Ollama-Befehle — Modelle starten, laden, ausliefern und prüfen.
• Ollama vs LM Studio vs LlamaCpp — welche Engine zu deinem Arbeitsablauf passt.

Quellen und Datum: Die Formel und die Schwellen für „was passt“ stammen aus dem VRAM-Rechner auf dieser Seite; der Wert für Bits pro Gewicht bei Q4_K_M stammt aus der Quantisierungsdokumentation von llama.cpp; die Engine-Parameter (num_ctx, -ngl, -b) sind die dokumentierten Optionen von Ollama, LM Studio und llama.cpp. Geprüft am 2. November 2026. Modellgrößen und Standardwerte der Engines ändern sich; rechne mit deinem eigenen Modell nach, bevor du 5 GB Gewichte herunterlädst.