Benchmarks

Tailles des fenêtres de contexte des LLM et classement Needle in a Haystack

2026-09-02·18 min min de lecture·LLMPodium Team

### Réponse rapide : fenêtres de contexte de 1M+ de tokens et précision de récupération

En 2026, les fenêtres de contexte de plus d'un million de tokens sont prêtes pour la production sur Gemini 2.5 Flash (2M), Code-SuperNova (1M), Claude 3.7 Sonnet (200k–1M étendu) et Kimi K2.5 (2M). Alors que les scores au test de l'aiguille dans une botte de foin (Needle In A Haystack - NIAH) à clé unique dépassent 99 % sur ces quatre modèles, la récupération associative multi-aiguilles se dégrade nettement au-delà de 256k tokens, entraînant une baisse de fidélité de 14 % à 38 % selon la profondeur de la requête.

1. Vue d'ensemble stratégique : l'ère du contexte à 1M+ de tokens en 2026

La frontière du contexte long pour les grands modèles de langage (LLM) a radicalement changé. Alors que les fenêtres de 32k et 128k tokens représentaient des jalons architecturaux en 2023–2024, les systèmes en production à la fin de 2026 ingèrent couramment des monorepos Git entiers, des bilans financiers pluriannuels et des centaines de contrats juridiques au sein d'un seul prompt.

Cette révolution architecturale est menée par quatre grandes familles de modèles :

  1. Google Gemini 2.5 Flash & Pro (2M de tokens) : pionnier en production du traitement multimodal natif de 2 097 152 tokens, avec routage d'attention linéaire et inférence accélérée matériellement sur TPU v6e.
  2. Code-SuperNova 1M (1 048 576 tokens) : modèle spécialisé pour les développeurs, pré-entraîné sur des graphes multi-dépôts tokenisés par AST avec des capacités de Fill-in-the-Middle (FIM) sur l'ensemble du contexte.
  3. Anthropic Claude 3.7 Sonnet (200k natif / 1M bêta étendu) : architecture hybride prenant en charge un raisonnement à budget de pensée dynamique ainsi qu'une fenêtre de contexte bêta de 1M de tokens, avec 90 % de réduction via la mise en cache des prompts.
  4. Moonshot AI Kimi K2.5 (2M de tokens) : modèle frontière bilingue chinois-anglais nativement long-contexte, exploitant des variantes de RingAttention et un routage sélectif d'espace d'états parcimonieux (sparse state-space).

Cependant, afficher une fenêtre de contexte de 1M ou 2M de tokens ne garantit pas qu'un modèle soit capable d'extraire, d'analyser ou de synthétiser fidèlement des informations enfouies dans un tel volume. L'utilisation effective du contexte est régie par les courbes de dégradation des benchmarks synthétiques Needle In A Haystack (NIAH), la perte de références croisées multi-documents, les limites de bande passante mémoire et la réalité économique des coûts d'ingestion des prompts.

2. Matrice quantitative : classement des fenêtres de contexte à 1M+ de tokens

L'évaluation des modèles frontière à long contexte nécessite d'analyser le rappel d'une aiguille unique (single-needle), la synthèse multi-documents, le débit d'inférence (tokens par seconde, TPS), le délai d'obtention du premier token (Time-to-First-Token, TTFT) et la rentabilité économique de la mise en cache des prompts.

Modèle et fenêtre de contexte NIAH aiguille unique (1M) NIAH multi-aiguilles (1M, 5 aiguilles) LiveCodeBench v6 (Long-Repo) TTFT @ 1M tokens (p50) TPS en sortie Coût d'entrée / 1M (sans cache) Coût d'entrée / 1M (avec cache) Coût de sortie / 1M
Gemini 2.5 Flash (2M) 99.8% 94.2% 66.4% 1.85s 148 tps $0.30 $0.075 $1.20
Code-SuperNova 1M (1M) 99.4% 95.1% 71.8% 2.40s 112 tps $0.80 $0.160 $3.20
Claude 3.7 Sonnet (1M Ext.) 99.6% 93.8% 71.2% 4.10s 78 tps $3.00 $0.300 $15.00
Kimi K2.5 (2M) 99.1% 89.6% 63.5% 2.90s 96 tps $0.25 $0.100 $1.00
GPT-4.1 (Base 128k) 98.2% (@128k) 88.0% (@128k) 62.1% 1.20s 82 tps $2.50 $1.250 $10.00

Observations clés du benchmark :

  • Code-SuperNova 1M obtient le taux de rétention multi-aiguilles le plus élevé (95,1 %) et le meilleur score LiveCodeBench (71,8 %) sur les dépôts volumineux, prouvant que le masquage d'attention basé sur l'AST et adapté au code préserve les dépendances syntaxiques sur 1M de tokens.
  • Gemini 2.5 Flash domine le débit de traitement (148 TPS) et affiche un TTFT ultra-faible (1,85 seconde pour 1M de tokens), soutenu par des optimisations matérielles profondes sur TPU v6e et des couches d'attention sous-quadratiques.
  • Claude 3.7 Sonnet offre la synthèse conceptuelle et le raisonnement les plus profonds sur de la documentation technique dense, bien que son coût d'entrée sans cache de 3,00 $ / 1M impose des architectures rigoureuses de mise en cache des prompts.
  • Kimi K2.5 présente la tarification d'entrée de gamme la plus agressive (0,25 $ en entrée / 1,00 $ en sortie par million de tokens) avec une récupération bilingue chinois-anglais remarquable jusqu'à 1M de tokens, mais montre une dégradation sensible en multi-aiguilles au-delà de 1,5M de tokens.

3. Analyse approfondie des modèles en lice

+---------------------------------------------------------------------------------------------------+
|                        PROFILS ARCHITECTURAUX DES FENÊTRES DE CONTEXTE 1M+                        |
+---------------------------------------------------------------------------------------------------+
| Modèle                | Taille fenêtre| Mécanisme d'attention     | Compression KV / Sparsité     |
+-----------------------+---------------+---------------------------+-------------------------------+
| Gemini 2.5 Flash      | 2,097,152     | Linear-Hybrid + GQA       | Dynamic Latent KV Paging      |
| Code-SuperNova 1M     | 1,048,576     | Block-Sparse AST Attention| Chunked Sparse-FIM Cache      |
| Claude 3.7 Sonnet     | 1,000,000     | Extended RoPE + GQA       | Tiered Ephemeral KV Cache     |
| Kimi K2.5             | 2,097,152     | RingAttention + Dual-SSM  | Continuous State-Space Chunks |
+-----------------------+---------------+---------------------------+-------------------------------+

Google Gemini 2.5 Flash (2M de tokens)

Gemini 2.5 Flash incarne l'architecture de pointe à haute efficacité de Google. En combinant la Grouped-Query Attention (GQA) avec des sous-couches d'attention hybrides linéaires propriétaires, Gemini 2.5 Flash atténue la barrière de calcul quadratique $O(N^2)$. Lors de l'inférence sur de longs contextes, son empreinte mémoire évolue de manière quasi linéaire :

$$\text{Memory}_{KV}(N) = 2 \times L \times n_{kv} \times d_{head} \times N \times \text{Precision}_{bytes}$$

Pour 2M de tokens en précision FP8 avec $L=64$ couches, $n_{kv}=8$ têtes et $d_{head}=128$, un cache KV non compressé consommerait environ :

$$2 \times 64 \times 8 \times 128 \times 2,097,152 \times 1 \approx 274.8 \text{ GB}$$

Gemini 2.5 Flash résout ce problème sur des clusters de TPU v6e grâce à une pagination dynamique des KV latents (dynamic latent KV paging) et à la quantification des activations, ramenant le stockage actif du cache KV à moins de 38 Go tout en maintenant le TTFT p50 sous la barre des 2 secondes.

Code-SuperNova 1M (1M de tokens)

Spécifiquement conçu pour l'ingénierie logicielle à l'échelle de l'entreprise, Code-SuperNova 1M est optimisé pour la compilation de dépôts complets, le parcours d'AST (arbres de syntaxe abstraite) et la compréhension des graphes d'appels inter-fichiers. Son pipeline d'entraînement intègre :

  • Chunked Fill-In-The-Middle (FIM) : appliqué simultanément sur plus de 50 fichiers interconnectés.
  • Block-Sparse AST Attention : les tokens représentant des définitions de symboles, des signatures de fonctions et des instructions d'importation bénéficient d'ancres d'attention globale, tandis que les implémentations denses de fonctions au sein des dépendances tierces font l'objet d'une compression paresseuse (lazy compression).
  • Deterministic Syntax Recovery : empêche l'hallucination de signatures d'API lors de la résolution d'imports situés 800k tokens plus tôt dans le prompt.

Anthropic Claude 3.7 Sonnet (200k natif / 1M en bêta)

Claude 3.7 Sonnet associe le moteur de raisonnement hybride de pointe d'Anthropic (tokens de pensée configurables) à une fenêtre de contexte étendue à 1M de tokens. Anthropic applique une interpolation avancée des Rotary Position Embeddings (RoPE) basée sur YaRN, complétée par un recalibrage précis des fréquences :

$$\theta_i' = \theta_i \cdot \left(1 - \gamma\right) + \gamma \cdot \frac{\theta_i}{s}$$

Cette approche prévient la perte de discrimination positionnelle à haute fréquence sur des segments de contexte éloignés. Lorsqu'il fonctionne en mode de contexte étendu, Claude 3.7 Sonnet maintient une cohérence sémantique rigoureuse, ce qui en fait le modèle privilégié pour le débogage autonome de systèmes critiques et l'audit d'architectures logicielles multicouches.

Moonshot AI Kimi K2.5 (2M de tokens)

Moonshot AI s'est imposé comme pionnier du traitement distribué de contextes longs grâce aux topologies RingAttention, distribuant la dimension de la séquence sur des clusters de GPU reliés par des interconnexions à très haute bande passante (NVLink/InfiniBand). Kimi K2.5 associe des blocs Transformer à des couches d'espace d'états sélectives (SSM), permettant un traitement soutenu de 2M de tokens de données conversationnelles et tabulaires structurées, tout en proposant une tarification par token parmi les plus compétitives du marché.

4. Needle in a Haystack (NIAH) : analyse mono-aiguille vs multi-aiguilles

Le piège des benchmarks synthétiques

Les tests standards de « l'aiguille dans une botte de foin » à aiguille unique (single-needle NIAH) consistent à insérer un fait isolé (par exemple : « Le mot de passe secret de la salle des serveurs est PineApple-7749 ») à divers paliers de profondeur (de 0 % à 100 %) au sein d'un corpus de texte arbitraire (comme des essais de Paul Graham ou de la documentation open source).

Tous les modèles de pointe modernes affichent un score parfait (> 99,0 %) au test NIAH mono-aiguille à 1M de tokens. Pourtant, les charges de travail en production ne se limitent jamais à la recherche d'un mot-clé isolé. Les cas d'usage réels impliquent :

  1. La récupération multi-aiguilles (Multi-Needle Retrieval) : identifier 5 à 20 variables interdépendantes réparties dans des documents hétérogènes.
  2. Le raisonnement en chaîne associative (Associative Chain Reasoning) : extraire l'aiguille A (schéma de base de données), la relier à l'aiguille B (requête ORM) et synthétiser l'aiguille C (correctif de sécurité).
+-----------------------------------------------------------------------------------------------+
|             COURBES DE DÉGRADATION DE RÉCUPÉRATION MULTI-AIGUILLES (5 AIGUILLES)              |
+-----------------------------------------------------------------------------------------------+
| Profondeur (tokens)   | 64k       | 128k      | 256k      | 512k      | 1M        | 2M        |
+-----------------------+-----------+-----------+-----------+-----------+-----------+-----------+
| Gemini 2.5 Flash      | 99.7%     | 99.2%     | 98.4%     | 96.8%     | 94.2%     | 88.5%     |
| Code-SuperNova 1M     | 99.8%     | 99.5%     | 98.9%     | 97.4%     | 95.1%     | N/A       |
| Claude 3.7 Sonnet     | 99.9%     | 99.6%     | 98.7%     | 96.5%     | 93.8%     | N/A       |
| Kimi K2.5             | 99.4%     | 98.8%     | 97.2%     | 94.1%     | 89.6%     | 81.2%     |
+-----------------------+-----------+-----------+-----------+-----------+-----------+-----------+

Le phénomène du « Lost in the Middle » en 2026

Malgré les progrès architecturaux, la dégradation classique du type « Lost in the Middle » persiste dès lors que la profondeur de contexte dépasse les 500 000 tokens :

  • Effet de primauté (profondeur 0 %–15 %) : la précision de récupération reste supérieure à 98,5 %. Les modèles portent une attention soutenue aux instructions système et aux définitions initiales de structures de données.
  • Effet de récence (profondeur 85 %–100 %) : la précision de récupération demeure au-delà de 99,0 %. L'historique conversationnel immédiat et les instructions finales du prompt ne montrent aucune dégradation.
  • Creux d'inattention (profondeur 35 %–65 %) : lors de tâches multi-aiguilles sur 1M de tokens, la précision de récupération chute en moyenne de 7,4 % à 12,8 % entre le 40e et le 60e centile.
Précision de
récupération
  100% | \                                         /
   95% |   \                                     /
   90% |     \                                 /
   85% |       \                             /
   80% |         \________Creux (40-60%)____/
       +---------------------------------------------
       0%         25%         50%         75%        100%
                          Position dans le contexte

5. Perte de récupération multi-documents et dégradation du contexte (Context Rot)

Lors de l'ingestion de multiples documents complexes, les modèles à contexte long souffrent de dégradation du contexte (Context Rot) — un déclin progressif de la fidélité du raisonnement causé par les interférences d'attention entre documents.

Causes fondamentales du Context Rot :

  1. Dispersion de l'attention : Dans l'attention softmax standard, à mesure que la longueur de séquence $N$ approche $10^6$, la distribution des poids d'attention $\text{softmax}(QK^T / \sqrt{d})$ devient de plus en plus diffuse. Un bruit d'attention de faible amplitude s'accumule à travers des milliers de tokens non pertinents.
  2. Confabulation par chevauchement d'entités : Lorsque 15 fichiers différents référencent des noms de classes similaires (par ex., UserSessionController, AuthSessionManager, UserSessionHandler), les poids d'attention croisée subissent des interférences destructrices, poussant le modèle à mélanger les champs d'entités sans lien direct.
  3. Dérive des instructions (Instruction Drift) : Les prompts longs contenant un volume important de code source amènent les modèles à perdre progressivement leur conformité aux contraintes négatives ou aux exigences de formatage JSON définies dans le prompt système.

Stratégies d'atténuation :

  • Ancrage hiérarchique : Placez les schémas critiques et les contraintes de formatage de sortie à la fois au début ($0\%$) et à la fin ($100\%$) du prompt.
  • Démarcation explicite des documents : Utilisez des balises structurelles XML ou Markdown avec le nombre explicite de tokens et les chemins de fichiers :
<document index="4" path="src/auth/session.ts" tokens="1420">
// Contenu du fichier...
</document>
  • Élagage du contexte avant injection : Filtrez les fichiers de verrouillage (lockfiles), les artefacts de build et les bibliothèques tierces (vendor) pour maintenir le contexte effectif dans la plage de plus haute fidélité du modèle (<512k tokens).

6. Tests pratiques pour développeurs : Implémentation concrète CLI & API

Pour tester le rappel sur un contexte de 1M de tokens en production, les développeurs peuvent exécuter des tests synthétiques NIAH reproductibles à l'aide de Python et de pilotes clients asynchrones.

Exécution d'un benchmark multi-aiguilles à 1M de tokens

import asyncio
import os
import random
from anthropic import AsyncAnthropic
from google import genai

async def run_1m_gemini_niah(haystack_path: str, needles: list[dict]):
    """
    Exécute un test de récupération multi-aiguilles sur Gemini 2.5 Flash à 1M de tokens.
    """
    client = genai.Client(api_key=os.environ["GEMINI_API_KEY"])
    
    with open(haystack_path, "r") as f:
        corpus = f.read()
        
    # Injecter les aiguilles à des intervalles de profondeur déterministes (ex. 20 %, 45 %, 70 %)
    tokens = corpus.split()
    total_len = len(tokens)
    
    for needle in needles:
        insert_idx = int(total_len * needle["depth"])
        tokens.insert(insert_idx, needle["content"])
        
    prompt_payload = " ".join(tokens)
    query = "List all secret access tokens and their corresponding department codes verbatim."
    
    response = await client.aio.models.generate_content(
        model="gemini-2.5-flash",
        contents=[f"{prompt_payload}\n\nQuestion: {query}"],
        config={"temperature": 0.0}
    )
    
    print("Gemini 2.5 Flash Retrieval Result:\n", response.text)

# Appel CLI :
# python -m benchmarks.niah_runner --model gemini-2.5-flash --depths 0.2,0.5,0.8 --tokens 1000000

Analyse en ligne de commande avec Code-SuperNova 1M

# Ingérer un dépôt complet de 850k tokens et auditer les fuites de mémoire zero-day
code-supernova audit \
  --repo-dir ./enterprise-monorepo \
  --context-window 1048576 \
  --needle-mode multi-ast \
  --temperature 0.1 \
  --output ./audit_report.json

7. Économie et coût par requête à 1M de tokens

Dans les architectures à contexte long, la viabilité financière repose sur la mise en cache des prompts (Prompt Caching). Une requête de 1M de tokens soumise sans mise en cache présente un coût prohibitif pour les flux de travail à haute fréquence.

Ventilation des coûts pour 1 000 000 de tokens en entrée

+---------------------------------------------------------------------------------------------------+
|                          ÉCONOMIE D'INGESTION DE REQUÊTES À 1M DE TOKENS                          |
+---------------------------------------------------------------------------------------------------+
| Modèle                | Requête non en cache  | Requête en cache (90%) | 100 requêtes/jour (cache)|
+-----------------------+-----------------------+------------------------+--------------------------+
| Gemini 2.5 Flash      | $0.30                 | $0.075                 | $7.50 / jour             |
| Kimi K2.5             | $0.25                 | $0.100                 | $10.00 / jour            |
| Code-SuperNova 1M     | $0.80                 | $0.160                 | $16.00 / jour            |
| Claude 3.7 Sonnet     | $3.00                 | $0.300                 | $30.00 / jour            |
+-----------------------+-----------------------+------------------------+--------------------------+

Analyse du seuil de rentabilité du Prompt Caching :

  • Sans mise en cache des prompts, l'exécution quotidienne de 50 requêtes sur l'ensemble d'un dépôt avec Claude 3.7 Sonnet coûte 150,00 $ par jour (4 500 $ par mois).
  • Grâce à la remise de 90 % accordée par Anthropic sur le prompt caching, cette même charge de travail ne coûte plus que 15,00 $ par jour (450 $ par mois), représentant une économie immédiate de 4 050 $ par mois.
  • Pour les pipelines d'extraction à haut débit sensibles aux coûts, Gemini 2.5 Flash affiche le coût total de possession le plus bas (0,075 $ pour 1M de tokens en cache) tout en assurant un débit constant de 148 TPS.

8. Recommandations architecturales E-E-A-T et verdict

Matrice de sélection finale :

  1. Choisissez Gemini 2.5 Flash (2M) si votre priorité porte sur un débit élevé, une latence interactive en temps réel, un contexte multimodal massif (vidéo, audio, livres au format PDF) et une tarification d'API particulièrement agressive.
  2. Choisissez Code-SuperNova 1M pour l'ingénierie logicielle automatisée à l'échelle de dépôts entiers, le refactoring multi-fichiers et l'analyse complexe de graphes AST/compilateur, où le respect strict de la syntaxe du code est déterminant.
  3. Choisissez Claude 3.7 Sonnet (1M Extended) pour les travaux de synthèse intellectuelle poussée, les audits de sécurité critiques, l'examen de contrats juridiques complexes et le raisonnement nuancé face à des exigences ambiguës.
  4. Choisissez Kimi K2.5 (2M) pour le traitement bilingue anglais-chinois sur contexte long à coût maîtrisé, l'analyse de données tabulaires et la synthèse documentaire volumineuse.

Bonnes pratiques pour la production :

  • Ne vous fiez jamais exclusivement aux benchmarks à aiguille unique : Évaluez systématiquement les modèles présélectionnés à l'aide de suites de tests multi-aiguilles adaptées à votre domaine et calquées sur la structure exacte de vos données.
  • Définissez des frontières strictes pour la mise en cache des prompts : Agencez vos requêtes afin que le préfixe de contexte statique de plus de 800k tokens demeure rigoureusement identique d'un appel à l'autre, maximisant ainsi la réutilisation du cache KV.
  • Déployez un RAG hybride au-delà de 1M de tokens : Dès lors qu'une base de connaissances franchit le seuil des 2M de tokens, une architecture hybride associant recherche vectorielle/lexicale (restreinte aux 200k tokens les plus pertinents) et capacités de raisonnement d'un LLM à long contexte surpasse systématiquement l'ingestion brute et non filtrée de 2M de tokens, tant sur le plan de la précision que de la latence.
← Tous les Articles
0 / 4
Comparer →