Tokens et fenêtre de contexte : comment lit l'IA

Les modèles de langage ne lisent ni des lettres ni des mots. Ils lisent des tokens : de petits morceaux de texte, souvent un mot entier, parfois une partie de mot. Et ils ne peuvent en prendre en compte qu'un nombre limité à la fois, une limite appelée fenêtre de contexte. Ces deux idées expliquent pourquoi les outils d'IA sont facturés comme ils le sont, pourquoi les longues conversations finissent par oublier les consignes du début, et pourquoi un modèle peut avoir du mal à compter les lettres d'un mot qu'il vient d'écrire correctement.

Qu'est-ce qu'un token en IA ?

Avant qu'un modèle voie votre prompt, un programme appelé tokenizer découpe le texte en morceaux tirés d'un vocabulaire fixe et transforme chaque morceau en nombre. Le modèle travaille uniquement avec ces nombres, et il écrit sa réponse de la même manière, un token à la fois, que l'application retransforme ensuite en texte.

Le vocabulaire est appris sur de grandes quantités de texte : les mots courants forment en général un seul token et les mots plus rares sont découpés en plusieurs morceaux familiers. Un espace est souvent rattaché au début du mot qui le suit. Une phrase anglaise pourrait être découpée à peu près ainsi :

Token ization isn 't magic .

Ce découpage est donné à titre d'illustration. Chaque famille de modèles a son propre tokenizer, et une même phrase peut donner un nombre de morceaux différent avec chacun. De nombreux fournisseurs publient un outil de tokenisation ou une API de comptage de tokens pour vérifier les chiffres réels.

Les images, l'audio et les fichiers sont eux aussi convertis en tokens quand un modèle les accepte, c'est pourquoi une capture d'écran jointe consomme une partie du même budget que votre texte.

Combien de mots dans un token ?

Pour un texte anglais, une règle approximative répandue est d'environ quatre caractères par token, soit à peu près trois quarts de mot. Selon cette estimation, 1 000 tokens correspondent à environ 750 mots anglais, et un article de 3 000 mots à environ 4 000 tokens.

Le rapport varie selon le contenu :

• Les autres langues demandent souvent plus de tokens pour le même sens. Les tokenizers sont entraînés sur des données où l'anglais est très représenté : les mots anglais obtiennent des tokens compacts, tandis que les textes en français, en japonais, en coréen, en arabe, en hindi et dans bien d'autres langues sont découpés en plus de morceaux. L'écart dépend du tokenizer et s'est réduit avec les plus récents, mais il n'a pas disparu.
• Le code consomme des tokens pour l'indentation, les parenthèses, les opérateurs et les identifiants longs : un fichier coûte donc souvent plus de tokens que son nombre de mots ne le laisse penser.
• Les nombres, les URL et les chaînes inhabituelles comme les identifiants et les hachages ont tendance à être découpés en nombreux petits tokens.

Pourquoi les tokens comptent

Le coût. Les API facturent au token, avec des prix distincts pour les tokens envoyés et les tokens écrits par le modèle. Dans un chat, toute la conversation est renvoyée à chaque nouveau message : une longue conversation coûte donc plus cher par message qu'une courte.

Les limites. Un modèle dispose d'une fenêtre de contexte pour tout ce qu'il lit et écrit dans une requête, et souvent d'un plafond séparé pour la longueur d'une réponse. Dans l'API, vous pouvez fixer ce plafond vous-même, et avec l'API d'Anthropic vous y êtes obligé : max_tokens est un paramètre requis.

La vitesse. La réponse est produite token après token : une réponse plus longue met donc proportionnellement plus de temps à se terminer.

Les tâches d'orthographe. Comme un modèle voit un mot comme magic sous forme d'une ou deux unités et non de cinq lettres, les tâches qui dépendent des caractères individuels, comme compter des lettres, inverser un mot ou trouver des mots d'une longueur exacte, sont plus difficiles pour lui qu'elles n'en ont l'air. Les modèles récents s'en sortent mieux sur beaucoup d'entre elles, mais quand les caractères comptent, vérifiez la réponse ou demandez d'abord au modèle d'écrire le mot lettre par lettre.

Qu'est-ce qu'une fenêtre de contexte ?

La fenêtre de contexte est le nombre maximal de tokens qu'un modèle peut prendre en compte dans une seule requête. Voyez-la comme la mémoire de travail du modèle : tout ce qu'il peut utiliser pour écrire sa réponse doit y tenir en même temps, notamment :

• le prompt système, celui de l'application et le vôtre
• la conversation jusque-là, chaque message utilisateur et chaque réponse
• les fichiers joints, les documents collés et les résultats de recherche ou d'outils
• la réponse en cours d'écriture

Tout ce qui est hors de la fenêtre n'existe pas pour le modèle. Il n'a aucune mémoire d'arrière-plan à consulter. La taille des fenêtres de contexte varie beaucoup d'un modèle à l'autre et ne cesse d'augmenter : consultez la documentation de votre fournisseur pour celui que vous utilisez plutôt que de vous fier à un chiffre lu dans un article.

Le modèle ne garde rien non plus d'une requête à l'autre. Ce qui ressemble à de la mémoire dans un chat, c'est l'application qui renvoie toute la conversation à chaque fois. Les fonctions de mémoire des applications de chat marchent de la même façon : l'application enregistre des notes sur vous, ou cherche dans vos anciennes conversations, et insère ce qu'elle trouve dans le contexte des nouvelles.

Quand une conversation devient longue

Quand une conversation dépasse la fenêtre de contexte, il faut bien céder quelque part. Selon l'application, les messages les plus anciens sont supprimés, les parties anciennes sont remplacées par un résumé, ou l'on vous indique que la conversation a atteint sa limite et qu'il faut en ouvrir une nouvelle. Dans chaque cas, les détails du début, y compris les consignes données dans le premier message, peuvent cesser d'influencer les réponses.

Une fenêtre pleine n'est pas le seul problème. Plus le modèle a de contenu sous les yeux, plus il y a de choses à laisser passer, et dans une longue conversation, les décisions du début sont en concurrence avec tout ce qui a été dit depuis. Les symptômes : des réponses qui ignorent une contrainte fixée plus tôt, du code qui revient à une version déjà corrigée, ou un modèle qui répète une idée que vous aviez écartée.

Travailler avec la fenêtre de contexte

Ouvrez une nouvelle conversation pour chaque tâche. Une conversation neuve avec un premier message clair vaut en général mieux qu'une longue conversation qui a dérivé sur plusieurs sujets.

Emportez un résumé avec vous. Quand une conversation a accumulé des décisions utiles, demandez un résumé rédigé pour être collé dans une nouvelle conversation, puis continuez là. Remplissez les champs ci-dessous selon votre travail.

Continuer dans une nouvelle conversation

EditCopy

Fill inélémentmots

Cette conversation devient longue. Rédige un résumé que je peux coller dans une nouvelle conversation pour continuer le travail. Inclus : l'objectif, les décisions prises et leurs raisons, la version actuelle de le schéma de base de données, et les questions ouvertes. Le résumé doit faire moins de 200 mots, sans compter le schéma de base de données lui-même.

Try it

Example replyReplies vary between models and runs.

Objectif : une base de données pour une petite application de bibliothèque, stockée dans SQLite.

Décisions :

• Les prêts ont leur propre table, pour conserver tout l'historique des emprunts.
• Un livre est disponible quand il n'a aucun prêt dont returned_at est vide.

Schéma actuel :

CREATE TABLE books (id INTEGER PRIMARY KEY, title TEXT NOT NULL, author TEXT NOT NULL);
CREATE TABLE members (id INTEGER PRIMARY KEY, name TEXT NOT NULL, email TEXT UNIQUE);
CREATE TABLE loans (
  id INTEGER PRIMARY KEY,
  book_id INTEGER NOT NULL REFERENCES books(id),
  member_id INTEGER NOT NULL REFERENCES members(id),
  loaned_at TEXT NOT NULL,
  returned_at TEXT
);

Questions ouvertes :

• Faut-il des pénalités de retard ?
• La bibliothèque doit-elle suivre plusieurs exemplaires d'un même livre ?

Ne collez que ce dont la tâche a besoin. La fonction qui contient le bug et le code qui l'appelle, pas tout le dépôt. La clause du contrat concernée, pas les quarante pages. Moins de contenu, c'est moins de choses à laisser passer.

Placez la question après un long contenu, et rappelez ce qui compte. Quand vous collez un long document, posez votre question à la fin, après lui, et répétez-y les contraintes clés. La consigne se trouve alors juste à l'endroit où le modèle commence à écrire.

Découpez un document trop long pour un seul message. Certaines applications limitent ce que vous pouvez coller dans un message, même quand la fenêtre du modèle pourrait en contenir davantage. Envoyer le document en plusieurs parties contourne la limite par message, mais pas la fenêtre de contexte : chaque partie y est comptée. Dites au modèle dès le départ de ne pas répondre avant d'avoir tout reçu.

Envoyer chaque partiePoser la question

EditCopy

Fill intotalquestion

Je vais t'envoyer un long document en 3 parties. Après chaque partie, réponds uniquement "Partie N sur 3 reçue" et rien d'autre. Ne résume rien et ne réponds à rien tant que je n'ai pas posé ma question. Partie 1 sur 3 : """ [collez la partie 1] """

Try it

Example replyReplies vary between models and runs.

Partie 1 sur 3 reçue

Comptez les tokens quand ça compte. Si vous développez avec une API, comptez avant d'envoyer. La bibliothèque open source tiktoken d'OpenAI tokenise le texte avec les tokenizers d'OpenAI, et l'API d'Anthropic propose un point d'accès de comptage de tokens. Les chiffres obtenus avec le tokenizer d'un fournisseur ne sont qu'une estimation pour un autre.

import tiktoken

enc = tiktoken.get_encoding("o200k_base")  # one of OpenAI's tokenizers
tokens = enc.encode("Tokenization isn't magic.")
print(len(tokens))
print([enc.decode([t]) for t in tokens])

Quand vous construisez une application autour d'un modèle, décider de ce qui entre dans la fenêtre et dans quel ordre devient un problème de conception à part entière. Context engineering traite ce sujet, et chaînage de prompts montre comment découper un gros travail en étapes qui tiennent chacune à l'aise. Pour voir comment un message s'insère dans l'entrée complète, voir qu'est-ce qu'un prompt.