Accueil›Guides›Longueur de contexte dans Ollama, LM Studio et llama.cpp : comment la changer et ce qu’elle coûte en mémoire

Installer · Guide

Longueur de contexte dans Ollama, LM Studio et llama.cpp : comment la changer et ce qu’elle coûte en mémoire

Ollama v0.40.14 donne à un modèle 4 096 tokens de contexte sous 23 Gio de mémoire graphique, 32 768 dès 23 Gio et 262 144 dès 47 Gio. Il se change avec OLLAMA_CONTEXT_LENGTH, /set parameter num_ctx ou num_ctx ; dans LM Studio, au chargement ; dans llama.cpp, avec -c. Chaque token coûte de la mémoire.

Mesuré et rédigé par Local AI ScopePublié le Chiffres mesurés par Local AI Scope

Ollama v0.40.16 donne à un modèle 4 096 tokens de contexte sous 23 Gio de mémoire graphique, 32 768 dès 23 Gio et 262 144 dès 47 Gio. Il se change avec OLLAMA_CONTEXT_LENGTH, /set parameter num_ctx ou num_ctx ; dans LM Studio, au chargement ; dans llama.cpp, avec -c. Chaque token coûte de la mémoire.

Combien de mémoire ? Nous l’avons calculé. Le 5 novembre 2026, nous avons lu le code et la documentation officielle des 3 versions stables (Ollama v0.40.14, LM Studio 0.4.28 et llama.cpp v0.9.0 ; le 7 novembre, nous avons vérifié qu’Ollama v0.40.15 garde le même code de contexte et la même documentation, et le 10 novembre que la v0.40.16 aussi) et passé 6 modèles de notre catalogue dans le moteur qui fait tourner notre trouveur de modèle : ce que pèse le cache du contexte à 4k, 8k, 32k, 128k et au maximum de chaque modèle, et sur combien de nos 18 machines chaque combinaison tient. Petit spoiler : sur un petit modèle, le contexte complet peut peser 15 fois plus que le modèle lui-même.

OllamaOllamaFiche logiciel LM StudioLM StudioFiche logiciel llama.cppllama.cppFiche logiciel

La longueur de contexte, et pourquoi elle dévore la mémoire

Le contexte, c’est tout ce que le modèle voit d’un coup : vos instructions, la conversation jusqu’ici, le document que vous avez collé et la réponse en cours d’écriture. Il se compte en tokens, des morceaux de mots : dans nos mesures avec le tokenizer de Qwen3 8B, un contrat en français coûte 1,50 token par mot.

Pour ne pas tout relire à chaque nouveau token, le logiciel garde un cache, le cache KV (K et V sont les 2 moitiés qu’il stocke pour chaque token, dans chaque couche). Ce cache est réservé au chargement du modèle, pour tout le contexte demandé, que vous vous en serviez ou non. Sa taille découle de la conception du modèle : couches × têtes KV × taille de tête × 2 moitiés × octets par valeur. Pour Qwen3 8B, 36 couches × 8 têtes × 128 × 2 × 2 octets : 144 Kio par token. Multipliez par 40 960 tokens et vous obtenez 5,6 Gio, plus que les 4,7 Gio du modèle lui-même en Q4_K_M.

PC avec une NVIDIA GeForce RTX 3060
Un PC avec une NVIDIA GeForce RTX 3060 de 12 Go : notre moteur laisse 11,2 Gio pour le modèle, son cache et les tampons du logiciel Photo : NVIDIA

Ce que coûte chaque contexte en mémoire : 6 modèles

Nous avons pris des modèles que l’on fait vraiment tourner : 2 petits Qwen3, Phi-4, Gemma 4 12B, gpt-oss-20b (un modèle à mélange d’experts, MoE) et Qwen3.6 27B. Le tableau donne la mémoire qu’ajoute le cache, en Gio, en précision f16 par défaut, et la dernière colonne indique sur combien des 18 machines de notre trouveur le modèle tient à son contexte maximal, avec le fichier Q4_K_M. Ce sont les chiffres de l’outil, puisqu’il fait le même calcul.

Modèle (contexte maximal) 4k 8k 32k 128k À son maximum Tient à son maximum
Qwen3 4B 2507 (262 144) 0,6 1,1 4,5 18,0 36,0 8 sur 18
Qwen3 8B (40 960) 0,6 1,1 4,5 — 5,6 15 sur 18
Phi-4 (16 384) 0,8 1,6 — — 3,1 15 sur 18
Gemma 4 12B (262 144) 0,4 0,4 0,8 2,3 4,3 12 sur 18
gpt-oss-20b (131 072) 0,1 0,2 0,8 3,0 3,0 12 sur 18
Qwen3.6 27B (262 144) 0,3 0,5 2,0 8,0 16,0 8 sur 18

Regardez les lignes qui ne grimpent pas comme les autres. Gemma 4 12B utilise une fenêtre glissante de 1 024 tokens dans 40 de ses 48 couches : seules 8 couches gardent toute la conversation, d’où 4,3 Gio à 262 144 tokens. gpt-oss-20b fait de même avec une fenêtre de 128 tokens dans la moitié de ses couches : 3,0 Gio à 131 072. Qwen3.6 27B garde un état de taille fixe dans 48 de ses 64 couches, et seules 16 grandissent avec le contexte. Qwen3 et Phi-4, eux, stockent chaque token dans chaque couche, et c’est là que le contexte fait mal. Si l’on comptait comme complètes toutes les couches de gpt-oss-20b et de Qwen3.6 27B, gpt-oss-20b demanderait 6,0 Gio à 131 072 au lieu de 3,0, et Qwen3.6 27B 64 Gio au lieu de 16 ; notre moteur lit le schéma de couches de chaque modèle.

2 cas à connaître. Qwen3 8B avec ses 40 960 tokens complets ne tient ni sur une RTX 3060 ni sur une RTX 4070 de 12 Go : il demande 11,7 Gio avec les tampons, et ces cartes en laissent 11,2. À 32 768, il tient, avec 10,4. Phi-4 à ses 16 384 demande 12,5 Gio et rate les 2 mêmes cartes. Quantifier le cache, plus bas, les sauve tous les deux.

Puce Apple M4
Puce Apple M4. Sur un Mac, le cache partage la mémoire unifiée avec le modèle et le système : sur une machine de 16 Go, notre moteur laisse 13 Gio au modèle, à son cache et aux tampons Image : Apple

Ollama : 4k, 32k ou 256k selon votre mémoire graphique

Ollama choisit le contexte à votre place au démarrage du serveur. Dans server/routes.go de la v0.40.16 (lignes 2579 à 2584), il additionne la mémoire des cartes graphiques qu’il détecte et retient 262 144 tokens à partir de 47 Gio, 32 768 à partir de 23 Gio et 4 096 en dessous (sans carte détectée, le total vaut 0). Le journal du serveur indique son choix, sur une ligne portant le message vram-based default context. Avec une RTX 3060 de 12 Go, vous aurez 4 096 ; avec une RTX 4090 de 24 Go, 32 768 ; avec 2 RTX 3090, 262 144.

4 façons de le changer, de la plus large à la plus ciblée (documentation d’Ollama v0.40.16, docs/faq.mdx, docs/modelfile.mdx et docs/context-length.mdx) :

  • Pour tous les modèles : lancez le serveur avec OLLAMA_CONTEXT_LENGTH=8192 ollama serve (envconfig/config.go, ligne 230). L’application de bureau a un curseur pour cela dans ses réglages.
  • Dans une discussion avec ollama run : tapez /set parameter num_ctx 8192 (cmd/interactive.go, ligne 109).
  • Pour un modèle, durablement : un Modelfile avec PARAMETER num_ctx 8192, puis ollama create.
  • Depuis votre code : "options": {"num_ctx": 8192} dans la requête vers /api/generate ou /api/chat.

Vérifiez ensuite avec ollama ps : la colonne CONTEXT montre ce qui a vraiment été chargé, et PROCESSOR vous dit si tout est resté sur la carte graphique. 3 détails du code expliquent les résultats étranges. Si vous demandez plus que ce que le modèle accepte, Ollama le ramène à ce maximum (llm/server.go, lignes 111 à 113). Si c’est Ollama qui a choisi le contexte et que le modèle ne tient pas au chargement, il réessaie une seule fois, un cran plus bas : 32 768 s’il était au-dessus, ou 4 096 s’il était entre 4 097 et 32 768 ; à 4 096, il ne réessaie pas (server/sched.go, lignes 694 à 697, 811 à 813 et 953 à 962) ; si c’est vous qui l’avez fixé, il ne descend pas tout seul. Et OLLAMA_NUM_PARALLEL (1 par défaut) multiplie le contexte, et le cache, par le nombre de requêtes qu’il peut servir en même temps.

S’ouvre sur YouTube (sans cookies) seulement si vous appuyez.

Cette courte vidéo passe en revue 4 façons de vérifier si Ollama fait tourner un modèle sur votre carte graphique ou sur le processeur. C’est le contrôle à faire après avoir monté num_ctx : si PROCESSOR n’affiche plus 100% GPU, le contexte demandé a poussé une partie du modèle hors de la carte.

Logo d’Ollama
Logo d’Ollama. Sa v0.40.16 choisit le contexte selon la mémoire graphique : 4 096, 32 768 ou 262 144 tokens Logo : Ollama

LM Studio : le contexte se choisit au chargement du modèle

Dans LM Studio 0.4.28 (la version stable au 5 novembre 2026), la longueur de contexte est un réglage de chargement, pas de discussion. Dans le sélecteur de modèles, cochez « Manually choose model load parameters » et les réglages de chargement, dont le contexte, apparaissent avant que le modèle ne se charge ; vous pouvez aussi les enregistrer comme valeurs par défaut de ce modèle, avec le déchargement sur le GPU et Flash Attention.

En ligne de commande, son outil lms fait la même chose (documentation de LM Studio, lmstudio.ai/docs/cli/local-models/load) : lms load <model_key> --context-length 16384 (dans le code de lms, aussi -c 16384). Ajoutez --estimate-only et il affiche la mémoire nécessaire, ce contexte compris, sans rien charger : une façon gratuite d’essayer 32k avant de vous lancer. Sans --context-length, c’est la valeur enregistrée par défaut pour ce modèle qui s’applique. Côté code, l’API REST accepte context_length dans POST /api/v1/models/load.

Sélecteur de modèles de LM Studio avec la case « Manually choose model load parameters » cochée
Sélecteur de modèles de LM Studio avec la case « Manually choose model load parameters » cochée : c’est là que se règle la longueur de contexte avant le chargement Image : LM Studio

llama.cpp : -c, et une valeur par défaut qui est le maximum du modèle

llama.cpp v0.9.0 est celui qui demande le plus par défaut. Dans common/arg.cpp (ligne 1590), -c, --ctx-size vaut 0 si vous n’y touchez pas, et 0 signifie le contexte d’entraînement du modèle : 40 960 pour Qwen3 8B, 262 144 pour Gemma 4 12B. Ce qui vous sauve, c’est --fit, activé par défaut (common/common.h, ligne 485) : si ce contexte ne tient pas en mémoire, il le réduit, mais jamais sous 4 096 tokens (ligne 487, réglable avec --fit-ctx). Si vous tapez vous-même -c 0, il cesse de réduire et tente le maximum complet.

En pratique : llama-server -m modele.gguf -c 16384, et vous savez exactement ce que vous payez. Avec llama-server, un détail de plus : par défaut il ouvre 4 emplacements qui partagent un seul cache de la taille de -c (tools/server/server.cpp, lignes 127 à 130), donc 4 longues conversations simultanées se partagent ces tokens.

L’interface web intégrée du serveur llama.cpp, avec une nouvelle discussion et le menu des outils ouvert
L’interface web intégrée du serveur llama.cpp : ce que vous fixez avec -c est l’espace que se partagent toutes ses discussions Capture : ggml-org / llama.cpp

Le levier : quantifier le cache en q8_0 ou q4_0

Le cache est stocké en f16 par défaut, 2 octets par valeur. Les 3 logiciels savent le stocker sur moins d’octets : q8_0 utilise 34 octets pour 32 valeurs (53 % du f16) et q4_0 en utilise 18 (28 %). Notre moteur, avec ces tailles exactes :

  • Qwen3 8B à 40 960 tokens : le cache passe de 5,6 à 3,0 Gio en q8_0, et le modèle tient désormais sur les RTX 3060 et RTX 4070 de 12 Go (9,0 Gio au total) : de 15 à 17 de nos 18 machines.
  • Phi-4 à 16 384 : de 3,1 à 1,7 Gio en q8_0, et il tient lui aussi sur ces 2 cartes : 17 sur 18.
  • Qwen3 4B 2507 à 262 144 : de 36,0 à 10,1 Gio en q4_0, et de 8 à 12 machines (la RTX 4090, le Mac M4 Pro de 24 Go et les 2 machines de 32 Go entrent dans la liste).

Comment l’activer. Dans Ollama, OLLAMA_KV_CACHE_TYPE=q8_0 au lancement du serveur ; cela vaut pour tous les modèles et ne marche qu’avec Flash Attention, qu’Ollama active de lui-même quand votre matériel le permet. Dans llama.cpp, -ctk q8_0 -ctv q8_0 (--cache-type-k et --cache-type-v, common/arg.cpp lignes 2388 et 2401). Une moitié V quantifiée exige Flash Attention : avec -fa sur auto, la valeur par défaut, llama.cpp l’active ; avec -fa off, il refuse de démarrer (src/llama-context.cpp, lignes 4331 à 4338). Dans LM Studio, ce sont des options de chargement de son moteur llama.cpp, une pour K et une pour V (llamaKCacheQuantizationType et llamaVCacheQuantizationType dans son SDK).

Quel contexte choisir

Partez de votre tâche, pas du maximum du modèle. Une discussion faite de questions courtes vit très bien avec 4 096 ou 8 192 tokens. Résumer un long rapport ou un contrat demande de 16 384 à 32 768 : un contrat de 10 000 mots fait environ 15 000 tokens pour Qwen3 8B en français, 11 200 en anglais, 15 400 en espagnol et 22 700 en allemand, mesurés avec son tokenizer sur nos propres textes. Les outils de programmation et les agents qui lisent des fichiers entiers veulent 64 000 ou plus, le chiffre que donne la documentation d’Ollama pour eux.

Si Ollama est nouveau pour vous, notre guide pour démarrer Ollama en local part de zéro, et si un modèle se charge puis avance à la vitesse d’un escargot, Ollama ne fonctionne pas a les solutions. Pour les 2 autres, voyez comment démarrer LM Studio en local et comment démarrer llama.cpp en local. Et pour appeler Ollama depuis votre propre code, notre guide de l’API d’Ollama détaille ses routes, sa couche compatible OpenAI et keep_alive.