Ollama v0.40.16 gibt einem Modell 4.096 Token Kontext, wenn es weniger als 23 GiB Grafikspeicher findet, 32.768 ab 23 GiB und 262.144 ab 47 GiB. Ändern lässt sich das mit OLLAMA_CONTEXT_LENGTH, /set parameter num_ctx oder num_ctx; in LM Studio beim Laden des Modells; in llama.cpp mit -c. Und jeder Token kostet Speicher.
Wie viel Speicher? Wir haben es ausgerechnet. Am 5. November 2026 haben wir den Code und die offizielle Dokumentation der 3 stabilen Versionen gelesen (Ollama v0.40.14, LM Studio 0.4.28 und llama.cpp v0.9.0; am 7. November haben wir geprüft, dass Ollama v0.40.15 denselben Kontext-Code und dieselbe Dokumentation hat, und am 10. November, dass auch v0.40.16 beides unverändert hat) und 6 Modelle aus unserem Katalog durch dieselbe Engine geschickt, die unseren Modellfinder antreibt: Wie viel der Kontext-Cache bei 4k, 8k, 32k, 128k und beim Maximum jedes Modells wiegt, und auf wie vielen unserer 18 Rechner jede Kombination passt. Vorweg verraten: Bei einem kleinen Modell kann der volle Kontext 15-mal so viel wiegen wie das Modell selbst.
OllamaProgramm-Datenblatt
LM StudioProgramm-Datenblatt
llama.cppProgramm-Datenblatt
Was die Kontextlänge ist und warum sie Speicher frisst
Der Kontext ist alles, was das Modell auf einmal sieht: Ihre Anweisungen, das bisherige Gespräch, das eingefügte Dokument und die Antwort, die gerade entsteht. Gezählt wird in Token, also Wortstücken: In unseren Messungen mit dem Tokenizer von Qwen3 8B braucht ein deutscher Vertrag 2,27 Token pro Wort.
Damit nicht bei jedem neuen Token alles neu gelesen werden muss, hält die Software einen Cache, den KV-Cache (K und V sind die 2 Hälften, die sie für jeden Token in jeder Schicht speichert). Dieser Cache wird beim Laden des Modells reserviert, für den gesamten angeforderten Kontext, ob Sie ihn nutzen oder nicht. Seine Größe ergibt sich aus der Bauart des Modells: Schichten × KV-Köpfe × Kopfgröße × 2 Hälften × Bytes pro Wert. Bei Qwen3 8B sind das 36 Schichten × 8 Köpfe × 128 × 2 × 2 Bytes: 144 KiB pro Token. Mal 40.960 Token ergibt das 5,6 GiB, mehr als die 4,7 GiB, die das Modell selbst in Q4_K_M wiegt.

Was jeder Kontext an Speicher kostet: 6 Modelle
Wir haben Modelle gewählt, die viele tatsächlich nutzen: 2 kleine Qwen3, Phi-4, Gemma 4 12B, gpt-oss-20b (ein Mixture-of-Experts-Modell, MoE) und Qwen3.6 27B. Die Tabelle zeigt den Speicher, den der Cache hinzufügt, in GiB, bei der voreingestellten Genauigkeit f16; die letzte Spalte sagt, auf wie vielen der 18 Rechner unseres Modellfinders das Modell bei seinem maximalen Kontext passt, mit der Q4_K_M-Datei. Es sind dieselben Zahlen wie im Werkzeug, weil es dieselbe Rechnung ausführt.
| Modell (maximaler Kontext) | 4k | 8k | 32k | 128k | Beim Maximum | Passt beim Maximum |
|---|---|---|---|---|---|---|
| Qwen3 4B 2507 (262.144) | 0,6 | 1,1 | 4,5 | 18,0 | 36,0 | 8 von 18 |
| Qwen3 8B (40.960) | 0,6 | 1,1 | 4,5 | — | 5,6 | 15 von 18 |
| Phi-4 (16.384) | 0,8 | 1,6 | — | — | 3,1 | 15 von 18 |
| Gemma 4 12B (262.144) | 0,4 | 0,4 | 0,8 | 2,3 | 4,3 | 12 von 18 |
| gpt-oss-20b (131.072) | 0,1 | 0,2 | 0,8 | 3,0 | 3,0 | 12 von 18 |
| Qwen3.6 27B (262.144) | 0,3 | 0,5 | 2,0 | 8,0 | 16,0 | 8 von 18 |
Achten Sie auf die Zeilen, die nicht wie die anderen wachsen. Gemma 4 12B nutzt in 40 seiner 48 Schichten ein gleitendes Fenster von 1.024 Token, also behalten nur 8 Schichten das ganze Gespräch: 4,3 GiB bei 262.144 Token. gpt-oss-20b macht es genauso, mit einem Fenster von 128 Token in der Hälfte seiner Schichten: 3,0 GiB bei 131.072. Qwen3.6 27B hält in 48 seiner 64 Schichten einen Zustand fester Größe, nur 16 wachsen mit dem Kontext. Qwen3 und Phi-4 dagegen speichern jeden Token in jeder Schicht, und genau dort tut der Kontext weh. Zählte man alle Schichten von gpt-oss-20b und Qwen3.6 27B als vollständige, bräuchte gpt-oss-20b bei 131.072 Token 6,0 GiB statt 3,0 und Qwen3.6 27B 64 GiB statt 16; unsere Engine liest das Schichtmuster jedes Modells.
2 Fälle, die man kennen sollte. Qwen3 8B mit seinen vollen 40.960 Token passt weder auf eine RTX 3060 noch auf eine RTX 4070 mit 12 GB: Es braucht 11,7 GiB samt Puffern, und diese Karten lassen 11,2 GiB frei. Bei 32.768 passt es, mit 10,4. Phi-4 braucht bei seinen 16.384 Token 12,5 GiB und verfehlt dieselben 2 Karten. Den Cache zu quantisieren, weiter unten, rettet beide.

Ollama: 4k, 32k oder 256k, je nach Grafikspeicher
Ollama wählt den Kontext für Sie, wenn der Server startet. In server/routes.go der v0.40.16 (Zeilen 2579 bis 2584) addiert es den Speicher der erkannten Grafikkarten und setzt 262.144 Token ab 47 GiB, 32.768 ab 23 GiB und 4.096 darunter (ohne erkannte Grafikkarte ist die Summe 0). Das Server-Log nennt die Wahl in einer Zeile mit der Meldung vram-based default context. Mit einer RTX 3060 mit 12 GB bekommen Sie 4.096; mit einer RTX 4090 mit 24 GB 32.768; mit 2 RTX 3090: 262.144.
4 Wege, das zu ändern, vom allgemeinsten zum gezieltesten (Dokumentation von Ollama v0.40.16, docs/faq.mdx, docs/modelfile.mdx und docs/context-length.mdx):
- Für alle Modelle: den Server mit
OLLAMA_CONTEXT_LENGTH=8192 ollama servestarten (envconfig/config.go, Zeile 230). Die Desktop-App hat dafür einen Schieberegler in den Einstellungen. - In einem Chat mit
ollama run:/set parameter num_ctx 8192eingeben (cmd/interactive.go, Zeile 109). - Für ein Modell, dauerhaft: ein Modelfile mit
PARAMETER num_ctx 8192, danachollama create. - Aus Ihrem Code:
"options": {"num_ctx": 8192}in der Anfrage an/api/generateoder/api/chat.
Prüfen Sie es danach mit ollama ps: Die Spalte CONTEXT zeigt, was tatsächlich geladen wurde, und PROCESSOR, ob alles auf der Grafikkarte geblieben ist. 3 Details aus dem Code erklären seltsame Ergebnisse. Verlangen Sie mehr, als das Modell verarbeiten kann, kürzt Ollama auf dieses Maximum (llm/server.go, Zeilen 111 bis 113). Hat Ollama den Kontext selbst gewählt und passt das Modell beim Laden nicht, versucht es genau einmal eine Stufe tiefer: 32.768, wenn es darüber lag, oder 4.096, wenn es zwischen 4.097 und 32.768 lag; bei 4.096 gibt es keinen weiteren Versuch (server/sched.go, Zeilen 694 bis 697, 811 bis 813 und 953 bis 962); haben Sie ihn selbst festgelegt, geht es nicht von allein herunter. Und OLLAMA_NUM_PARALLEL (voreingestellt 1) multipliziert Kontext und Cache mit der Zahl der Anfragen, die gleichzeitig bedient werden können.
Öffnet YouTube (ohne Cookies) erst, wenn Sie auf Play drücken.
Dieses kurze Video zeigt 4 Wege zu prüfen, ob Ollama ein Modell auf Ihrer Grafikkarte oder auf dem Prozessor ausführt. Diese Prüfung gehört nach jeder Erhöhung von num_ctx: Zeigt PROCESSOR nicht mehr 100% GPU, hat der angeforderte Kontext einen Teil des Modells von der Karte verdrängt.

LM Studio: Der Kontext wird beim Laden festgelegt
In LM Studio 0.4.28 (die stabile Version am 5. November 2026) ist die Kontextlänge eine Ladeeinstellung, keine Chat-Einstellung. Setzen Sie in der Modellauswahl das Häkchen bei „Manually choose model load parameters“, dann erscheinen die Ladeeinstellungen, darunter der Kontext, bevor das Modell geladen wird; Sie können sie auch als Standard für dieses Modell speichern, zusammen mit der GPU-Auslagerung und Flash Attention.
Im Terminal erledigt der Befehl lms dasselbe (Dokumentation von LM Studio, lmstudio.ai/docs/cli/local-models/load): lms load <model_key> --context-length 16384 (im Code von lms auch -c 16384). Mit --estimate-only zeigt er den Speicherbedarf samt diesem Kontext an, ohne etwas zu laden: ein kostenloser Weg, 32k auszuprobieren, bevor Sie sich festlegen. Ohne --context-length gilt der für dieses Modell gespeicherte Standardwert. Aus eigenem Code heraus nimmt die REST-API context_length in POST /api/v1/models/load entgegen.

llama.cpp: -c, und ein Standardwert, der das Maximum des Modells ist
llama.cpp v0.9.0 verlangt ab Werk am meisten. In common/arg.cpp (Zeile 1590) steht -c, --ctx-size auf 0, solange Sie nichts angeben, und 0 heißt: der Kontext, mit dem das Modell trainiert wurde, also 40.960 bei Qwen3 8B und 262.144 bei Gemma 4 12B. Was Sie rettet, ist --fit, ab Werk eingeschaltet (common/common.h, Zeile 485): Passt dieser Kontext nicht in den Speicher, wird er verkleinert, aber nie unter 4.096 Token (Zeile 487, einstellbar mit --fit-ctx). Geben Sie selbst -c 0 ein, hört das Kürzen auf und es wird das volle Maximum versucht.
In der Praxis also: llama-server -m modell.gguf -c 16384, und Sie wissen genau, was Sie bezahlen. Bei llama-server kommt ein Detail dazu: Ab Werk öffnet er 4 Slots, die sich einen einzigen Cache in der Größe von -c teilen (tools/server/server.cpp, Zeilen 127 bis 130); 4 lange Gespräche gleichzeitig teilen sich also diese Token.

Der Hebel: den Cache auf q8_0 oder q4_0 quantisieren
Der Cache liegt ab Werk in f16 vor, 2 Bytes pro Wert. Alle 3 Programme können ihn mit weniger Bytes speichern: q8_0 braucht 34 Bytes für je 32 Werte (53 % von f16), q4_0 braucht 18 (28 %). Unsere Engine, mit genau diesen Größen:
- Qwen3 8B bei 40.960 Token: Der Cache sinkt mit q8_0 von 5,6 auf 3,0 GiB, und das Modell passt nun auf die RTX 3060 und die RTX 4070 mit 12 GB (9,0 GiB insgesamt): von 15 auf 17 unserer 18 Rechner.
- Phi-4 bei 16.384: von 3,1 auf 1,7 GiB mit q8_0, und passt ebenfalls auf diese 2 Karten: 17 von 18.
- Qwen3 4B 2507 bei 262.144: von 36,0 auf 10,1 GiB mit q4_0, und von 8 auf 12 Rechner (dazu kommen die RTX 4090, der Mac mit M4 Pro und 24 GB und die 2 Rechner mit 32 GB).
So schalten Sie es ein. In Ollama mit OLLAMA_KV_CACHE_TYPE=q8_0 beim Start des Servers; das gilt für alle Modelle und funktioniert nur mit Flash Attention, das Ollama selbst einschaltet, wenn Ihre Hardware es unterstützt. In llama.cpp mit -ctk q8_0 -ctv q8_0 (--cache-type-k und --cache-type-v, common/arg.cpp Zeilen 2388 und 2401). Eine quantisierte V-Hälfte verlangt Flash Attention: Mit -fa auf auto, dem Standard, schaltet llama.cpp es ein; mit -fa off verweigert es den Start (src/llama-context.cpp, Zeilen 4331 bis 4338). In LM Studio sind es Ladeoptionen seiner llama.cpp-Engine, eine für K und eine für V (llamaKCacheQuantizationType und llamaVCacheQuantizationType im SDK).
Welchen Kontext Sie wählen sollten
Gehen Sie von Ihrer Aufgabe aus, nicht vom Maximum des Modells. Ein Chat mit kurzen Fragen kommt mit 4.096 oder 8.192 Token bestens aus. Einen langen Bericht oder einen Vertrag zusammenzufassen, braucht 16.384 bis 32.768: Ein Vertrag mit 10.000 Wörtern ergibt bei Qwen3 8B auf Deutsch rund 22.700 Token, auf Englisch 11.200, auf Spanisch 15.400 und auf Französisch 15.000, gemessen mit seinem Tokenizer an unseren eigenen Texten. Programmierwerkzeuge und Agenten, die ganze Dateien lesen, wollen 64.000 oder mehr; diese Zahl nennt die Dokumentation von Ollama für sie.
Ist Ollama neu für Sie, beginnt unsere Anleitung für Ollama lokal ganz von vorn, und wenn ein Modell lädt und dann im Schneckentempo läuft, hat Ollama funktioniert nicht die Lösungen. Für die anderen 2: LM Studio lokal einrichten und llama.cpp lokal einrichten. Und um Ollama aus Ihrem eigenen Code aufzurufen: Unsere Anleitung zur Ollama-API erklärt die Routen, die OpenAI-kompatible Schicht und keep_alive.