Tokens et fenêtre de contexte : c'est quoi, et pourquoi ça décide de tout

Deux mots décident du prix que tu payes, de la longueur des documents que tu peux traiter et du moment où une IA « oublie » le début d’une conversation : token et fenêtre de contexte. Ce ne sont pas des détails d’ingénieur — ce sont les unités physiques de l’IA générative. Tant que tu ne les as pas en tête, tu raisonnes sur l’IA comme sur un produit gratuit à mémoire infinie. Elle n’est ni l’un ni l’autre. Cette page pose les deux définitions proprement, puis montre les trois conséquences pratiques qui touchent ton portefeuille et tes résultats.

Le token : l’unité que le modèle lit vraiment

Un LLM ne lit ni des lettres, ni des mots. Il lit des tokens : des fragments de texte qu’il traite comme des unités de base. Un token, c’est en moyenne un bout de mot — quelques caractères. Parfois un mot entier court (« le », « et »), parfois un morceau d’un mot long.

Le découpage n’est pas arbitraire. Il vient d’un algorithme de tokenisation (le plus répandu, le BPE, fusionne itérativement les paires de symboles les plus fréquentes du corpus d’entraînement). Résultat : les mots courants et anglais se découpent efficacement, les mots rares ou très français beaucoup moins. « anticonstitutionnellement » peut peser cinq ou six tokens à lui seul.

Les ordres de grandeur à retenir, parce que tu vas t’en servir pour estimer un coût :

• En anglais : 1 token ≈ 0,75 mot. Soit environ 1 000 tokens pour 750 mots.
• En français : plus gourmand. Compte plutôt 1 mot ≈ 1,3 à 2 tokens. La même page coûte donc sensiblement plus cher en français qu’en anglais — un biais réel quand on facture au token.
• Repère mental : une page A4 de texte, c’est de l’ordre de 600 à 1 000 tokens selon la densité et la langue.

Le « so what » immédiat : tout se compte en tokens. La taille de ce que tu envoies, la longueur de ce que le modèle répond, et la facture. Quand un fournisseur affiche « 128 000 tokens de contexte » ou « 3 $ le million de tokens », tu sais maintenant que l’unité, c’est ce fragment-là, pas le mot ni le caractère.

La fenêtre de contexte : la mémoire de travail, pas la mémoire tout court

La fenêtre de contexte (context window) est le nombre maximum de tokens que le modèle peut prendre en compte en un seul appel. Et « en un seul appel » englobe tout :

• ta question (le prompt),
• l’historique de la conversation renvoyé à chaque tour,
• les documents que tu colles ou qu’un RAG injecte,
• et la réponse que le modèle est en train de générer.

C’est sa mémoire de travail, pas sa mémoire à long terme. La métaphore juste : un bureau d’une taille fixe. Tout ce sur quoi le modèle peut raisonner doit tenir sur le bureau à l’instant T. Ce qui dépasse tombe par terre — le modèle ne le voit plus.

En 2026, la fenêtre va de quelques dizaines de milliers de tokens (suffisant pour une conversation normale) à un million et au-delà sur les modèles à long contexte (assez pour avaler un livre entier ou une grosse base de code). Mais grande ne veut pas dire gratuite ni parfaite — c’est tout l’objet des deux sections suivantes.

La nuance qui tue une idée reçue : la fenêtre de contexte n’est pas la connaissance du modèle. Sa connaissance (figée à sa date d’entraînement, la knowledge cutoff) est dans ses poids. La fenêtre, elle, est ce que tu lui mets sous les yeux maintenant. Deux mémoires distinctes : l’une apprise une fois pour toutes, l’autre rechargée à chaque message.

Pourquoi une IA « oublie » : la fenêtre glissante

Voici la conséquence qui surprend tout le monde. Un LLM n’a aucune mémoire persistante entre deux messages. Zéro. À chaque tour de conversation, l’application (ChatGPT, Claude, ton propre code) lui renvoie l’intégralité de l’historique comme contexte. Le modèle, lui, repart de rien à chaque fois et relit tout.

Tant que la conversation tient dans la fenêtre, l’illusion de mémoire est parfaite. Mais dès que l’historique cumulé dépasse la limite, il faut faire de la place : les messages les plus anciens sont tronqués. Ils sortent littéralement de la fenêtre. Le modèle ne peut plus s’y référer — non parce qu’il a « oublié » au sens humain, mais parce que ce texte n’est plus sur le bureau.

C’est une fenêtre glissante : elle avance avec la conversation et largue la queue. D’où les comportements classiques d’une longue session : le modèle perd une consigne donnée au début, recontredit un choix posé plus tôt, redemande une info déjà fournie.

Les fonctions de « mémoire » des produits grand public ne contredisent pas ça — elles le contournent. Au lieu d’agrandir le modèle, elles réinjectent des résumés ou des faits clés dans le contexte au bon moment. La mémoire est gérée par l’application autour du modèle, jamais par le modèle lui-même. Et un agent IA, qui enchaîne des étapes en accumulant outils et résultats intermédiaires, sature cette fenêtre encore plus vite — gérer son contexte est l’un de ses vrais défis d’ingénierie.

Pourquoi ça décide du coût (et comment le maîtriser)

Le point le plus concret pour un founder. Les API d’IA (OpenAI, Anthropic, Mistral, Google) facturent au token, avec deux tarifs séparés :

• Tokens d’entrée : ton prompt + l’historique + les documents fournis.
• Tokens de sortie : la réponse générée — en général nettement plus chère au token que l’entrée.

La conséquence est contre-intuitive et coûteuse : comme l’historique entier repart à chaque tour, une conversation qui s’allonge coûte de plus en plus cher au message, même si tes questions restent courtes. Tu repayes tout le passé à chaque fois. Sur un produit qui tient des conversations longues à grande échelle, c’est un poste de dépense majeur, pas une ligne de frais marginale.

Les leviers qui marchent vraiment, du plus simple au plus technique :

• Des prompts denses. Pas de bavardage, pas de politesses inutiles dans les instructions système. Chaque token compte au sens propre.
• Ne fournir que l’utile. Coller un PDF de 50 pages quand trois paragraphes suffisent, c’est payer 47 pages pour rien — à chaque appel. C’est exactement le problème que résout le RAG : récupérer et injecter seulement les passages pertinents.
• Résumer l’historique d’une longue conversation au lieu de le renvoyer entier.
• Le cache de prompt. La plupart des fournisseurs permettent de mettre en cache la partie stable du contexte (un long prompt système, un document de référence) pour ne pas la repayer plein tarif à chaque appel. Gain réel sur du volume.
• Mesurer d’abord. Les API renvoient le décompte exact de tokens d’entrée et de sortie par requête. Optimiser sans mesurer, c’est deviner.

Et le coût au token lui-même n’est pas une fatalité : il dépend du matériel d’inférence, ce qui rejoint directement l’enjeu d’infrastructure décortiqué dans l’édition Cerebras vs Nvidia.

Le piège du « grand contexte » : plus n’est pas mieux

Quand les fenêtres ont atteint le million de tokens, beaucoup ont conclu : « plus besoin de RAG, je colle tout. » C’est un raccourci qui coûte cher, pour trois raisons.

• Le coût. Tu payes l’intégralité des tokens injectés, à chaque appel. Coller un million de tokens à répétition est ruineux face à n’envoyer que les 2 000 tokens pertinents.
• La latence. Plus le contexte est gros, plus la réponse est lente à venir. Un million de tokens à traiter, ça se sent.
• Le « perdu au milieu » (lost in the middle). C’est le résultat le plus contre-intuitif, établi par une étude de Stanford en 2023 : un fait enfoui au centre d’un long contexte est nettement moins bien retrouvé qu’un fait placé au début ou à la fin. La performance suit une courbe en U. Autrement dit, gaver la fenêtre ne garantit pas que le modèle exploite ce que tu y as mis — il peut « voir » l’info sans s’en servir.

La conclusion pratique : la grande fenêtre et le RAG ne sont pas substituables, ils sont complémentaires. La fenêtre fixe le plafond de ce qui est techniquement possible ; le RAG décide intelligemment de ce qu’il vaut la peine d’y mettre. Le bon réflexe n’est jamais « comment tout faire tenir », mais « quel est le contexte minimal suffisant pour une bonne réponse ». Pour le panorama complet de ces briques (modèle, contexte, RAG, agents), la page pour comprendre l’IA générative relie le tout.

Token et fenêtre de contexte, en une phrase

Si tu dois retenir une seule chose : le token est l’unité de facturation et de mesure de l’IA ; la fenêtre de contexte est la mémoire de travail finie dans laquelle tout doit tenir à chaque appel. Tout le reste en découle — le prix qui grimpe avec la conversation, l’oubli des longues sessions, l’arbitrage entre tout coller et cibler le contexte utile. Raisonner en tokens, c’est passer de « l’IA est magique et gratuite » à « l’IA est un budget que je sais estimer et optimiser ». C’est exactement la bascule qui sépare l’utilisateur du builder.