Tokens, Contexte et Fenêtre de Conversation
Σε αυτήν τη σελίδα
Tokens, Contexte et Fenêtre de Conversation
Le token est l’unité que le modèle manipule et celle que votre facture suit. Tant que ce concept reste flou, vos coûts le seront aussi, et vous finirez par rencontrer une erreur de limite de contexte sans en comprendre la raison. Cette leçon clarifie ces deux points.
Qu’est-ce qu’un Token ?
Un token n’est pas un mot. C’est un fragment de texte que le modèle traite comme une unité indivisible. En français, un token représente environ 0,7 mot en moyenne. La bibliothèque tiktoken vous permet de voir exactement comment le texte se découpe : remarquez comment « allez-vous » se divise en deux tokens tandis que « aujourd’hui », qui apparaît plus souvent dans le corpus d’entraînement, tient en un seul. Ce détail explique pourquoi un texte en français consomme plus de tokens qu’un texte anglais de longueur comparable.
from openai import OpenAI
client = OpenAI()
# To estimate tokens, use the tiktoken library
import tiktoken
# cl200k_base is used here as an example: each model generation has its own encoder.
# Check the encoder for the model you call before relying on the count.
enc = tiktoken.get_encoding("cl200k_base")
texte = "Bonjour, comment allez-vous aujourd'hui ?"
tokens = enc.encode(texte)
print(f"Text: {texte}")
print(f"Number of tokens: {len(tokens)}")
print(f"Tokens: {tokens}")
print(f"Decoded: {[enc.decode([t]) for t in tokens]}")
# Result:
# Text: Bonjour, comment allez-vous aujourd'hui ?
# Number of tokens: 9
# Tokens: [38025, 11, 4068, 67590, 5072, 76439, 30, ...]
# Decoded: ['Bonjour', ',', ' comment', ' allez', '-vous', " aujourd'hui", ' ?']
Vérifiez toujours quel encodeur correspond au modèle que vous appelez. Un comptage effectué avec le mauvais encodeur reste une approximation utile, mais ne correspondra pas exactement à votre facture.
La Fenêtre de Contexte
Chaque modèle possède une fenêtre de contexte maximale, et le piège pour les débutants est qu’elle inclut à la fois l’entrée et la sortie. Ce n’est pas un budget d’entrée : c’est un budget total. Si votre prompt occupe 190 000 tokens d’une fenêtre de 200 000 tokens, il ne reste que 10 000 tokens pour la réponse. Le modèle s’interrompra au milieu d’une phrase sans aucun avertissement supplémentaire.
# Previous generation, for reference:
# GPT-5.4: 1,000,000 context tokens
# GPT-5.3: 200,000 context tokens
# gpt-5.6-sol : 200,000 context tokens
# gpt-5.6-terra : 200,000 context tokens
# Example: if your input is 190,000 tokens in a 200,000-token window,
# only 10,000 tokens remain for the response
response = client.responses.create(
model="gpt-5.6-terra",
input="A very long text...",
max_output_tokens=10000 # Limit explicitly
)
Après coup, vous pouvez lire le comptage exact dans response.usage, qui distingue les tokens d’entrée, les tokens de sortie et le total :
response = client.responses.create(
model="gpt-5.6-terra",
input="Explain tokens in three sentences."
)
usage = response.usage
print(f"Input tokens: {usage.input_tokens}")
print(f"Output tokens: {usage.output_tokens}")
print(f"Total: {usage.total_tokens}")
# Result:
# Input tokens: 12
# Output tokens: 58
# Total: 70
Trois Leviers d’Optimisation
Le premier levier est la concision du prompt. Les formules de politesse et les précautions rhétoriques n’améliorent pas la réponse et coûtent des tokens jusqu’au dernier : la première version ci-dessous utilise trente-cinq tokens pour un résultat identique à la seconde, qui n’en utilise que dix. À l’échelle d’un service traitant un million de requêtes, la différence n’est plus anecdotique.
# BAD — verbose prompt (35 tokens)
response = client.responses.create(
model="gpt-5.6-terra",
input="Could you please give me a list "
"of three fruits that are red in color, if that "
"does not bother you of course?"
)
# GOOD — concise prompt (10 tokens)
response = client.responses.create(
model="gpt-5.6-terra",
input="List 3 red fruits."
)
Le deuxième levier cible la sortie, qui coûte plusieurs fois plus cher que l’entrée. Combinez l’instruction dans le prompt avec un plafond technique : le premier cadre la rédaction, le second garantit que votre budget est respecté même si le modèle ignore l’instruction.
# No limit — the model can generate many tokens
response = client.responses.create(
model="gpt-5.6-terra",
input="Explain photosynthesis."
)
# With limit — cost control
response = client.responses.create(
model="gpt-5.6-terra",
input="Explain photosynthesis in 2 sentences maximum.",
max_output_tokens=100
)
Le troisième levier est l’estimation du coût avant l’appel, ce qui devient essentiel dès que vous traitez des documents de taille variable. Vous pouvez ainsi rejeter ou diviser une requête trop lourde plutôt que de la découvrir sur votre facture.
import tiktoken
def estimate_cost(text: str, model: str = "gpt-5.6-terra") -> dict:
"""Estimate the cost of an API call."""
enc = tiktoken.get_encoding("cl200k_base")
input_tokens = len(enc.encode(text))
# Approximate prices per million tokens (check current prices)
prices = {
"gpt-5.6-sol": {"input": 5.0, "output": 30.0},
"gpt-5.6-terra": {"input": 2.0, "output": 12.0},
"gpt-5.6-luna": {"input": 0.20, "output": 1.20},
}
input_cost = (input_tokens / 1_000_000) * prices[model]["input"]
return {
"input_tokens": input_tokens,
"input_cost_usd": round(input_cost, 6),
"model": model
}
print(estimate_cost("Explain relativity in 3 sentences."))
# Result: {'input_tokens': 10, 'input_cost_usd': 2.5e-05, 'model': 'gpt-5.6-terra'}
Le Contexte s’Accumule au Fil de la Conversation
Lorsque vous enchaînez les échanges en utilisant previous_response_id, chaque tour repart de l’intégralité des tours précédents. Les tokens d’entrée augmentent donc continuellement : un dialogue qui commence à 50 tokens pèse 150 au deuxième tour et bien plus au dixième. C’est la cause la plus fréquente de factures qui s’envolent sans augmentation du trafic, et la surveillance de response.usage.input_tokens constitue votre signal d’alarme.
# Turn 1: 50 tokens
r1 = client.responses.create(
model="gpt-5.6-terra",
input="Hello, I am a Python developer."
)
# Turn 2: 50 + 100 = 150 tokens (cumulative context)
r2 = client.responses.create(
model="gpt-5.6-terra",
input="Which web frameworks do you recommend?",
previous_response_id=r1.id
)
# Turn 10: tokens accumulate!
# Monitor response.usage.input_tokens to avoid surprises
print(f"Cumulative tokens at turn 2: {r2.usage.input_tokens}")
Pour les longues conversations, la solution consiste à tronquer activement l’historique : supprimez les messages les plus anciens jusqu’à descendre sous une limite choisie, tout en conservant le premier, qui porte généralement le contexte fondateur de l’échange.
def conversation_with_limit(messages: list, token_limit: int = 50000):
"""Keep the conversation under a token limit."""
enc = tiktoken.get_encoding("cl200k_base")
total = sum(len(enc.encode(m["content"])) for m in messages)
# Remove oldest messages if necessary
while total > token_limit and len(messages) > 2:
removed = messages.pop(1) # Keep the first message (context)
total -= len(enc.encode(removed["content"]))
return messages
Βασικά σημεία
- Un token équivaut à environ 0,7 mot en français
- La fenêtre de contexte inclut l’entrée ET la sortie
- Les fenêtres varient selon le modèle : dans la génération précédente, 1 million de tokens pour GPT-5.4 et 200 000 pour GPT-5.3, o3-pro et o4-mini
- Utilisez
tiktokenpour compter les tokens avant l’appel - Surveillez
response.usagepour contrôler vos coûts - Gérez activement le contexte lors des longues conversations