Le cache KV, le poste oublié

Un Llama 3.1 8B pèse 4,6 Go en Q4. Avec 128k de contexte, son cache KV en réclame 16 Go — plus de trois fois le modèle lui-même. C'est le poste de mémoire que presque tous les calculateurs traitent comme une constante, et c'est celui qui varie le plus.

Ce que le cache KV stocke, et pourquoi il grandit

À chaque token produit, le modèle doit tenir compte de tout ce qui précède. Plutôt que de tout recalculer, il conserve pour chaque token deux tenseurs — les clés et les valeurs — dans chaque couche d'attention. C'est ce stock qu'on appelle le cache KV, et il grossit linéairement avec le contexte : deux fois plus de conversation, deux fois plus de cache.

D'où la mécanique qui surprend : la mémoire nécessaire n'est pas une propriété du modèle seul. Le même modèle, sur la même carte, tient ou ne tient pas selon la longueur de contexte que vous lui laissez.

Trois chiffres du config.json suffisent à le calculer

Le nombre de couches, le nombre de têtes de clés-valeurs et la dimension d'une tête. Ces trois valeurs se lisent dans le fichier de configuration publié de chaque modèle, et elles ne se devinent pas — c'est la seule raison pour laquelle nos chiffres diffèrent des estimateurs approximatifs.

Deux modèles de taille voisine ne coûtent pas la même chose

Comparez Phi-4, 14,7 milliards de paramètres, et Gemma 3 12B, 12,2 milliards. Le premier a un cache de 1,56 Go à 8k, le second de 0,81 Go — presque moitié moins, alors qu'il n'est que 20 % plus petit.

Deux causes. Phi-4 garde dix têtes de clés-valeurs là où Gemma en a huit, ce qui alourdit chaque couche. Et surtout, Gemma 3 n'applique l'attention complète qu'à une couche sur six : les cinq autres ne retiennent que les 1024 derniers tokens, et leur cache cesse de croître au-delà. À 32k de contexte, l'écart passe de 1,9 à 2,7 fois.

Le cache se quantifie, indépendamment du modèle

Comme les poids, le cache peut être stocké en 8 bits plutôt qu'en 16, avec l'option `--cache-type-k` et `--cache-type-v` de llama.cpp. Sur Phi-4 à 8k, il passe de 1,56 à 0,83 Go. Le gain est proportionnel : plus votre contexte est long, plus ce réglage rapporte.

Le consensus veut que ce soit sans effet perceptible sur la qualité, et c'est aujourd'hui un réglage courant. Nous ne l'avons pas mesuré nous-mêmes et ne prétendons pas le contraire. Le sujet est traité plus en détail dans ce que coûte chaque quantification.

Ce qu'il faut en retirer avant d'acheter

Choisissez votre carte sur le contexte que vous utiliserez vraiment, pas sur la taille du modèle. Beaucoup de gens restent à 4k ou 8k et surdimensionnent ; ceux qui donnent des documents entiers à lire sous-dimensionnent gravement. Entre les deux, il y a parfois un palier de carte entier.

Pourquoi tant d'estimateurs se trompent

La plupart des calculateurs qu'on trouve en ligne appliquent un forfait : ils ajoutent un ou deux giga-octets aux poids du modèle et s'arrêtent là. Sur un 8B en 4k de contexte, l'approximation passe presque inaperçue. Sur un Qwen3 32B en 32k, elle manque 6 Go — soit un palier de carte entier.

Le problème n'est pas l'imprécision, c'est le sens de l'erreur. Un forfait sous-estime toujours les cas exigeants, c'est-à-dire précisément ceux où l'utilisateur a besoin d'une réponse fiable avant de dépenser plusieurs centaines d'euros.

Un exemple complet, poste par poste

Prenons Qwen3 32B en Q4_K_M sur une carte de 24 Go. À 8k de contexte, le total est de 21,9 Go : 18,7 Go de poids, 2,0 Go de cache, le reste en tampons de calcul et en réserve d'affichage. Ça passe, avec un peu plus de deux giga-octets de marge.

Passez le contexte à 32k sans rien changer d'autre : le cache quadruple, à 8,0 Go, et le total grimpe à 28,1 Go. La même carte, le même modèle, la même quantification — et le modèle ne tient plus. Aucun forfait ne capture ça.

Le rattrapage existe, et il est indolore : en passant le cache en 8 bits, le total redescend à 24,4 Go. Toujours trop pour une carte de 24 Go strictement, mais l'écart devient une question de réglage plutôt que de matériel.

Le cas particulier des mélanges d'experts

On associe volontiers gros modèle et gros cache. C'est faux, parce que le cache ne dépend pas du nombre de paramètres mais de la géométrie d'attention. gpt-oss 20B en est la démonstration : 21 milliards de paramètres, et un cache de 0,19 Go à 8k — cinq fois moins qu'un Llama 8B, trois fois plus petit.

Deux raisons cumulées : des têtes de dimension 64, deux fois plus étroites que la norme, et une fenêtre glissante de 128 tokens sur une couche sur deux. Conséquence pratique : passer ce modèle de 8k à 128k de contexte ne coûte que 4 Go. Peu de modèles supportent aussi bien le contexte long.

Comment le vérifier sur votre machine

Deux moyens. Le calculateur du site détaille les quatre postes séparément, ce qui permet de voir immédiatement lequel domine. Et au chargement, llama.cpp affiche la taille du cache qu'il vient d'allouer : si elle s'écarte nettement de notre estimation, c'est que votre outil applique un réglage de contexte différent de celui que vous croyez.

Un contexte annoncé n'est pas un contexte utilisable

Les fiches de modèles annoncent volontiers 128k de contexte, et c'est exact au sens strict : le modèle sait traiter cette longueur. Mais l'annonce ne dit rien de la machine qu'il faudrait pour y arriver, et c'est là que le cache KV reprend la parole.

Llama 3.1 8B en est l'illustration la plus nette. Il annonce 128k, et son cache atteint alors 16 Go — soit, poids compris, davantage qu'une carte de 16 Go ne peut offrir. Ce modèle de huit milliards de paramètres, réputé accessible, devient à ce contexte plus exigeant qu'un Gemma 3 12B.

La règle à retenir : lisez le contexte annoncé comme une capacité théorique, et vérifiez systématiquement la longueur que votre matériel autorise. C'est souvent quatre à huit fois moins.

En résumé

• Le cache KV grandit avec le contexte, linéairement, et peut dépasser le poids du modèle.
• Il se calcule à partir de trois valeurs du config.json, jamais d'une approximation.
• Une fenêtre glissante le plafonne : à contexte long, la géométrie compte plus que la taille.
• Il se quantifie séparément des poids, et divise à peu près par deux.