Contexte LLM : dimensionner la fenêtre, le cache KV et le prompt caching

Dimensionner le contexte à la tâche

Une grande fenêtre donne au modèle accès à davantage d’éléments, mais la qualité dépend surtout de leur pertinence, de leur ordre et de la capacité du modèle à les exploiter, tandis que chaque jeton mobilise du calcul, de la mémoire ou une ligne de facturation.

• Trop peu de contexte : le modèle manque de faits privés, récents ou spécifiques et doit davantage s’appuyer sur ses paramètres.
• Contexte utile : les instructions, sources et exemples nécessaires sont présents sans répétition excessive.
• Trop de contexte : les distracteurs, contradictions et historiques obsolètes peuvent réduire la qualité et allonger le traitement.

Cette optimisation recouvre quatre grandeurs qu’il faut mesurer séparément pour éviter des conclusions trompeuses sur la complexité ou le coût.

• Prefill : traitement en parallèle des jetons d’entrée ; l’attention dense standard a un travail quadratique en longueur, mais les noyaux, l’attention creuse et le matériel modifient la latence observée.
• Decode : génération séquentielle ; avec cache KV, chaque nouveau jeton lit le contexte conservé, si bien que le travail par jeton augmente généralement avec la séquence sans recalculer tout le préfixe.
• Stockage KV : mémoire dynamique approximativement linéaire en longueur de séquence et en taille de lot.
• Facturation API : barème contractuel par catégorie de jetons, cache, stockage, niveau de service ou outils, qui ne reproduit pas nécessairement le coût physique du fournisseur.

Quand le contexte ne suffit plus

Un prompt insuffisant ne crée pas automatiquement une hallucination, mais il prive la réponse de preuves contrôlables et fragilise les tâches qui dépendent de documents internes, d’un état transactionnel ou d’une chaîne de contraintes complète.

• Connaissances de longue traîne : une procédure interne ou une référence rare peut être absente ou mal mémorisée dans les poids.
• Actualité et traçabilité : un document récupéré permet de dater et de citer la réponse au lieu de supposer que la mémoire paramétrique est à jour.
• Cohérence de tâche : les dépendances, exceptions et décisions antérieures doivent tenir dans l’état transmis au modèle.

Le seuil pertinent est donc fonctionnel et non lexical : il se trouve par une évaluation où l’on ajoute ou retire des sources et où l’on observe la qualité, plutôt que par des catégories fixes telles que « optimal sous 25 000 jetons ».

• Mesurez le rappel de récupération avant d’accuser la fenêtre de contexte.
• Vérifiez que les passages décisifs sont effectivement présents et non contradictoires.
• Comparez plusieurs budgets de contexte avec les mêmes cas de test et le même modèle versionné.

Ce que montrent les longs contextes

Liu et al. ont observé une courbe souvent en U sur des tâches de récupération : selon le modèle et le jeu d’essai, une information pertinente au milieu d’un long prompt est moins bien utilisée que la même information placée au début ou à la fin [1].

• Ce résultat établit un biais positionnel dans les expériences étudiées, pas une incapacité universelle du milieu de contexte.
• Les modèles, longueurs et tâches récents doivent être testés à nouveau dans l’application visée.
• Placer les instructions stables et les passages prioritaires à des positions saillantes reste une hypothèse de conception à valider.

Plusieurs mécanismes distincts peuvent dégrader un contexte long, et les confondre empêche de choisir le bon correctif.

• Puits d’attention : certains premiers jetons reçoivent une attention disproportionnée dans les modèles étudiés par Xiao et al. [2].
• Distraction sémantique : des éléments hors sujet mais plausibles peuvent détourner une trajectoire de résolution, comme dans GSM-IC [3].
• Longueur seule : Du et al. rapportent, sur cinq modèles et plusieurs tâches, une dégradation variable malgré une récupération parfaite [4].
• Glissement du raisonnement : un préprint de 2026 observe des traces internes plus courtes dans certains longs contextes ; ce signal préliminaire ne permet pas de généraliser à tous les modèles [5].

La forme « fiabilité en cloche » est une intuition de conception plutôt qu’une loi quantitative : une entrée utile peut améliorer une tâche, un distracteur peut la dégrader, et l’emplacement du meilleur compromis varie.

• Construisez un jeu de cas représentatifs avec critères de réussite explicites.
• Faites varier séparément longueur, pertinence, position et contradictions.
• Retenez le plus petit contexte qui atteint la qualité cible avec une marge stable.

Cache KV local : mémoire, prefill et decode

En inférence locale, les poids constituent une charge relativement statique tandis que le cache KV conserve, pour chaque jeton traité, les clés et valeurs nécessaires aux couches d’attention afin d’éviter de recalculer tout le préfixe à chaque étape de decode.

• La phase de prefill calcule les représentations du prompt et remplit le cache.
• La phase de decode réutilise ce cache, mais lit un historique croissant pour produire chaque nouveau jeton.
• La mémoire totale inclut aussi activations temporaires, espaces de travail des noyaux, buffers et fragmentation du runtime.

Pour un transformeur dense où chaque couche stocke des clés et valeurs de même précision, l’approximation suivante rend visibles les paramètres architecturaux qui gouvernent la mémoire.

M_KV = 2 × L × H_kv × D_head × N_seq × B × P_bytes

• L : nombre de couches d’attention.
• H_kv : nombre de têtes de clés et valeurs ; GQA ou MQA le réduit par rapport à l’attention multi-têtes classique.
• D_head : dimension d’une tête ; N_seq : longueur conservée ; B : taille de lot.
• P_bytes : octets par élément, par exemple 2 en FP16/BF16 ou 1 en INT8 ; le facteur 2 représente K et V.

Llama 3.1 8B fournit un exemple reproductible avec 32 couches, 8 têtes KV et une dimension de tête de 128 [6], soit 128 Kio de cache BF16 par jeton et par séquence.

2 × 32 × 8 × 128 × 32 768 × 1 × 2 = 4 294 967 296 octets = 4 Gio

• À 4 096 jetons, la même approximation donne 0,5 Gio.
• À 32 768 jetons, elle donne 4 Gio, auxquels s’ajoutent les poids et les allocations du moteur.
• Pour un lot de 4 séquences de même longueur, le cache brut monte à 16 Gio.

La formule est spécifique à l’architecture et au runtime : l’attention latente, les fenêtres glissantes, le cache paginé, le partage de préfixes, la quantification et l’éviction peuvent changer sensiblement le résultat réel.

Scénario Llama 3.1 8B, BF16, lot 1	Poids théoriques	Cache KV calculé	Somme avant surcoûts du runtime
4 096 jetons	≈ 16 Go	0,5 Gio	≈ 16,5 Go
32 768 jetons	≈ 16 Go	4 Gio	≈ 20 Go

La quantification KV réduit directement le terme P_bytes, mais son effet sur la qualité et le débit dépend du modèle, du moteur et du matériel, donc une réduction théorique de mémoire ne constitue pas une garantie de performance.

• INT8 divise par deux le stockage brut par rapport au BF16 ; INT4 le divise théoriquement par quatre.
• KIVI étudie une quantification asymétrique à 2 bits par canal pour les clés et par jeton pour les valeurs [10].
• PyramidKV alloue un budget de cache différent selon la profondeur et l’importance des jetons ; il s’agit d’une compression, pas simplement d’un changement uniforme de précision [11].

Prompt caching : comparer des factures datées

Le prompt caching permet à une API de reconnaître ou de conserver un préfixe déjà prérempli, mais une lecture moins chère ne signifie ni que le fournisseur ne consomme aucune ressource ni que toutes les requêtes répétées seront réutilisées.

• Un cache hit dépend d’un préfixe compatible, du routage, de la durée de rétention et des règles du fournisseur.
• Les jetons dynamiques et les sorties restent facturés selon leurs propres catégories.
• Une écriture, une durée de stockage ou un niveau de service peuvent ajouter des coûts absents du simple tarif de lecture.

Cette comparaison arrêtée au 6 septembre 2026 utilise des modèles et API nommés ; elle doit être relue avant toute décision d’achat, car les prix et seuils changent indépendamment.

Fournisseur et référence	Entrée standard	Lecture en cache	Écriture / stockage	Activation et seuil documenté
Anthropic · Claude Sonnet 4.6, API Claude [12]	3,00 $/M	0,30 $/M	3,75 $/M pour 5 min ; 6,00 $/M pour 1 h	Cache automatique ou points cache_control ; minimum 1 024 jetons au 6 sept. 2026
OpenAI · GPT-5.5, fiche modèle historique du 23 avr. 2026 [13]	5,00 $/M	0,50 $/M	Pas de ligne d’écriture sur cette fiche	Détection automatique des préfixes pris en charge à partir de 1 024 jetons
Google · Gemini 3.1 Pro Preview, generateContent [14]	2,00 $/M jusqu’à 200k	0,20 $/M jusqu’à 200k	Cache explicite : 4,50 $/M jetons/heure	Implicite et explicite ; minimum documenté 4 096 jetons pour ce modèle, pas 32 768 universellement
DeepSeek · V4 Flash depuis le 16 août 2026 [15]	0,22 $/M creuses ; 0,44 $/M pleines	0,007 $/M creuses ; 0,014 $/M pleines	Pas de ligne séparée d’écriture dans le barème cité	Préfixe automatique ; les métriques de cache doivent confirmer le hit

Chez Google, l’API choisie change le mécanisme disponible : Interactions ne propose que le cache implicite, tandis que generateContent permet aussi de créer un cache explicite avec TTL et facturation de stockage [14].

• Les seuils minimums sont listés par modèle et peuvent évoluer.
• La réduction implicite est transmise lorsqu’un hit survient, sans garantie qu’une requête donnée touchera le cache.
• Le cache explicite garantit le tarif associé au contenu référencé, mais ajoute du stockage proportionnel aux jetons et à la durée.

Un calcul simple montre pourquoi il faut intégrer l’écriture ou le stockage au seuil de rentabilité : avec 100 000 jetons stables sur Claude Sonnet 4.6 et un cache de cinq minutes, une première écriture coûte 0,375 $, puis chaque lecture 0,03 $ au lieu de 0,30 $ pour une entrée standard.

• Deux appels sans cache coûtent 0,60 $ d’entrée stable.
• Une écriture suivie d’une lecture coûte 0,405 $, soit 0,195 $ de moins dans cet exemple.
• Le résultat change si le second appel arrive après expiration, si le préfixe varie ou si d’autres multiplicateurs tarifaires s’appliquent.

Pour augmenter le taux de hit sans promettre une réutilisation universelle, l’application doit stabiliser le début du prompt et déplacer les valeurs volatiles après ce préfixe.

• Placez outils, instructions système, schémas et corpus stables avant les questions variables.
• Évitez timestamps, identifiants et ordre non déterministe dans la partie censée être identique.
• Suivez les compteurs de création, lecture et échec de cache fournis par l’API.
• Calculez le coût complet par résultat utile, sorties et stockage compris.

Une chaîne de contexte mesurable

Une architecture robuste réduit progressivement le volume transmis tout en conservant les preuves nécessaires, puis vérifie la qualité à chaque étape au lieu de supposer qu’une technique ou un nombre de jetons convient à tous les modèles.

• Récupération : maximiser le rappel initial sur une collection versionnée.
• Reranking : utiliser un modèle plus précis pour ordonner les passages par rapport à la question.
• Assemblage : dédupliquer, résoudre les contradictions et placer les éléments prioritaires de manière testée.
• Évaluation : mesurer exactitude, citations, latence, mémoire et facture sur plusieurs budgets.

Les outils LLMLingua illustrent trois compromis de compression distincts qu’il faut évaluer sur les documents et la tâche ciblés.

• LLMLingua utilise la perplexité d’un petit modèle et rapporte jusqu’à 20× de compression dans ses expériences [16].
• LLMLingua-2 apprend une classification conserver/supprimer indépendante de la question et rapporte généralement des taux plus modérés avec un traitement plus rapide [17].
• LongLLMLingua tient compte de la question, filtre et réordonne les documents pour les scénarios de long contexte [18].

La décomposition multi-agent peut réduire le contexte individuel quand les sous-tâches sont réellement séparables, mais elle ajoute des messages, des synthèses, des risques d’incohérence et des jetons facturés.

• Définissez des sorties structurées et des critères d’acceptation pour chaque sous-tâche.
• Transmettez les preuves nécessaires à l’agent de synthèse, pas seulement des conclusions.
• Comparez cette topologie à un appel unique reranké : davantage d’agents ne garantit ni coût inférieur ni qualité supérieure.

Protocole de décision

La taille de contexte doit être traitée comme une variable expérimentale reliée à une version de modèle, une architecture d’inférence, une politique de cache et un objectif métier mesurable.

• Qualité : testez présence des preuves, exactitude et résistance aux distracteurs.
• Performance locale : profilez séparément temps de prefill, débit de decode, VRAM des poids et cache KV.
• Coût API : exploitez les compteurs d’usage et le barème daté, y compris écritures, stockage, sorties et outils.
• Exploitation : alertez sur les chutes de taux de hit, les dérives de longueur et les changements de modèle.

Passer de la théorie à votre cas d’usage

L’audit de maturité IA Junyr est un échange vidéo gratuit de 30 minutes, sans engagement, qui situe votre organisation sur l’échelle, identifie le principal blocage et le premier projet raisonnable, puis fournit une synthèse d’une page.

• Réserver l’audit de maturité IA.
• Approfondir les prix, budgets et routes dans Budgets tokens et API IA : le guide FinOps des PME.

Sources

[1] Nelson F. Liu et al., Lost in the Middle: How Language Models Use Long Contexts, TACL 2024. https://arxiv.org/abs/2307.03172

[2] Guangxuan Xiao et al., Efficient Streaming Language Models with Attention Sinks, ICLR 2024. https://arxiv.org/abs/2309.17453

[3] Freda Shi et al., Large Language Models Can Be Easily Distracted by Irrelevant Context, ICML 2023. https://arxiv.org/abs/2302.00093

[4] Yufeng Du et al., Context Length Alone Hurts LLM Performance Despite Perfect Retrieval, Findings of EMNLP 2025. https://arxiv.org/abs/2510.05381

[5] Gleb Rodionov, Roman Garipov et George Yakushev, Reasoning Shift: How Context Silently Shortens LLM Reasoning, préprint 2026. https://arxiv.org/abs/2604.01161

[6] Meta, configuration de Llama 3.1 8B Instruct. https://huggingface.co/meta-llama/Llama-3.1-8B-Instruct/blob/main/config.json

[10] Zirui Liu et al., KIVI: A Tuning-Free Asymmetric 2bit Quantization for KV Cache. https://arxiv.org/abs/2402.02750

[11] Zefan Zhang et al., PyramidKV: Dynamic KV Cache Compression based on Pyramidal Information Funneling. https://arxiv.org/abs/2406.02069

[12] Anthropic, Prompt caching et tarifs, consultés le 6 septembre 2026. https://platform.claude.com/docs/en/build-with-claude/prompt-caching

[13] OpenAI, fiche modèle GPT-5.5 et Prompt caching, fiche tarifaire datée du 23 avril 2026, consultées le 6 septembre 2026. https://developers.openai.com/api/docs/models/gpt-5.5 et https://developers.openai.com/api/docs/guides/prompt-caching

[14] Google AI for Developers, Context caching pour generateContent, Interactions et tarifs Gemini, mis à jour le 2 septembre 2026 pour la page generateContent, consultés le 6 septembre 2026. https://ai.google.dev/gemini-api/docs/generate-content/caching et https://ai.google.dev/gemini-api/docs/caching et https://ai.google.dev/gemini-api/docs/pricing

[15] DeepSeek, changement de prix annoncé le 13 août et effectif le 16 août 2026. https://api-docs.deepseek.com/news/news260813/

[16] Huiqiang Jiang et al., LLMLingua: Compressing Prompts for Accelerated Inference of Large Language Models. https://arxiv.org/abs/2310.05736

[17] Zhuoshi Pan et al., LLMLingua-2: Data Distillation for Efficient and Faithful Task-Agnostic Prompt Compression. https://arxiv.org/abs/2403.12968

[18] Huiqiang Jiang et al., LongLLMLingua: Accelerating and Enhancing LLMs in Long Context Scenarios via Prompt Compression. https://arxiv.org/abs/2310.06839

Écrit par Paul-Antoine TUAL, AI Transformation Leader et créateur de la Méthode Junyr™.