Parcourir les aide-mémoire · Ingénierie IA pour les données
Optimiser les tokens d’un LLM
Réduisez la consommation de tokens d’un LLM dans vos applications de données sans perdre le contexte ni la qualité utiles : mesurer d’abord, alléger prompts et historique, limiter la récupération, compacter les sorties, mettre en cache et router.
Sur cette page
- Problème
- Réponse rapide
- Notions de base sur les tokens
- Tokens d’entrée et de sortie
- Pourquoi le contexte répété coûte cher
- Code / commandes
- 1. Mesurer avant d’optimiser
- 2. Raccourcir et dédoublonner les instructions
- 3. Garder stables les instructions stables
- 4. Résumer ou tronquer l’historique de conversation
- 5. Limiter le contexte récupéré
- 6. Découper seulement quand c’est utile
- 7. Envoyer le schéma utile, pas tout le catalogue
- 8. Demander des formats de sortie concis
- 9. Sortie structurée ou prose verbeuse
- 10. Mettre en cache le contexte stable et les résultats
- 11. Router les tâches vers le bon modèle, ou vers aucun
- 12. Regrouper les petits éléments quand la tâche le permet
- Tableau de décision des techniques
- Points à vérifier
- Erreurs fréquentes
- 1. Optimiser sans référence
- 2. Utiliser le plafond de tokens de sortie pour raccourcir les réponses
- 3. Faire disparaître les identifiants dans les résumés
- 4. Récupérer un top-20 « au cas où »
- 5. Des données volatiles au début du prompt
- 6. Envoyer des schémas ou catalogues entiers
- 7. Compter en caractères ou en mots
- 8. Supposer que moins de tokens coûte toujours moins cher
- 9. Ignorer les tokens de nouvelles tentatives et de raisonnement
- Notes de production
- Liste de contrôle
- Étape suivante
- Pour aller plus loin
Problème
Une fonctionnalité LLM marche en test. En production :
- la facture augmente plus vite que l’usage
- la latence augmente à mesure que les conversations s’allongent
- des requêtes atteignent la limite de la fenêtre de contexte
- les mêmes instructions et schémas sont renvoyés à chaque appel
- les réponses sont longues alors qu’un court résultat structuré suffirait
Les tokens pilotent trois choses à la fois : le coût, la latence et ce qui tient dans la fenêtre de contexte.
L’objectif n’est pas le prompt le plus court possible. Il s’agit d’envoyer et de générer uniquement ce dont la tâche a besoin, et de prouver que la qualité n’a pas baissé.
Réponse rapide
- Mesurez la consommation de tokens par fonctionnalité, par modèle, en entrée et en sortie.
- Retirez ce dont le modèle n’a pas besoin : instructions en double, schémas complets, historique périmé, extraits peu pertinents.
- Contraignez la sortie : format structuré compact, longueur explicite, plafond de tokens de sortie comme limite de sécurité.
- Réutilisez ce qui se répète : un préfixe de prompt stable (mise en cache de prompt côté fournisseur, quand elle existe) et des résultats en cache pour des requêtes identiques.
- Routez les tâches simples vers un modèle plus petit, ou vers du code classique.
- Revérifiez la qualité sur un jeu d’évaluation après chaque changement.
tokens d'entrée = instructions système + définitions d'outils + exemples
+ historique de conversation + contexte récupéré + résultats d'outils + saisie utilisateur
tokens de sortie = réponse générée (+ tokens de raisonnement, sur les modèles qui les facturent)
Notions de base sur les tokens
- Les modèles lisent et écrivent des tokens, pas des caractères ni des mots. Un token est un fragment de texte produit par le tokenizer du modèle.
- Le nombre de tokens dépend du tokenizer : le même texte peut donner des comptes différents selon la famille de modèles.
- Le code, le JSON, les identifiants longs, les nombres, les espaces et le texte non anglais se découpent souvent moins efficacement que de la prose anglaise.
- Les estimations à partir des caractères suffisent pour planifier. Pour des chiffres réels, utilisez le tokenizer du modèle ou les champs d’usage renvoyés par l’API.
- Tout ce qui est dans la requête compte : prompt système, définitions d’outils/fonctions, exemples, historique, documents récupérés, résultats d’outils.
- La fenêtre de contexte borne ce qu’une requête peut contenir. Selon le modèle, l’entrée et la sortie la partagent, ou la sortie a sa propre limite.
Tokens d’entrée et de sortie
| Tokens d’entrée | Tokens de sortie | |
|---|---|---|
| Quoi | Tout ce que vous envoyez | Tout ce que le modèle génère |
| Levier | Conception du prompt, limites de récupération, politique d’historique | Format de sortie, instructions, plafond de tokens de sortie |
| Tarification | Généralement facturés au token | Généralement facturés au token, souvent plus cher que l’entrée |
| Latence | Ajoute du temps de traitement avant le premier token | Le temps de génération croît avec le nombre de tokens produits |
Les prix et le rapport entrée/sortie varient selon le modèle et évoluent dans le temps. Lisez-les dans la grille tarifaire actuelle du fournisseur, jamais dans un aide-mémoire.
Certains modèles génèrent des tokens de raisonnement internes facturés comme sortie même s’ils ne sont pas renvoyés. Vérifiez les champs d’usage.
Pourquoi le contexte répété coûte cher
Les API LLM courantes sont sans état : une « conversation » renvoie l’historique à chaque tour. Le contexte fixe (instructions, schéma, exemples) est repayé à chaque appel, et l’historique grossit à chaque tour.
def cumulative_input_tokens(base: int, per_turn: int, turns: int) -> int:
"""Tokens d'entrée envoyés sur toute une conversation quand l'historique complet est renvoyé à chaque tour."""
return sum(base + per_turn * (turn - 1) for turn in range(1, turns + 1))
print(cumulative_input_tokens(base=2_000, per_turn=300, turns=20)) # 97000
Avec un contexte fixe de 2 000 tokens et 300 tokens ajoutés par tour, 20 tours envoient 97 000 tokens d’entrée, dont 40 000 correspondent au même contexte fixe répété. La part de l’historique croît à peu près avec le carré du nombre de tours.
Le même calcul s’applique aux pipelines batch : un appel LLM par ligne avec un bloc d’instructions de 1 500 tokens paie ces instructions à chaque ligne.
Code / commandes
1. Mesurer avant d’optimiser
Journalisez l’usage de chaque appel. Faites la correspondance des champs d’usage du fournisseur une seule fois, dans votre wrapper.
import json
import logging
import time
log = logging.getLogger("llm.usage")
def record_usage(feature: str, model: str, prompt_version: str, usage: dict, started: float) -> None:
"""Journalise l'usage en tokens d'un appel. `usage` est le bloc d'usage renvoyé par l'API du fournisseur."""
log.info(json.dumps({
"feature": feature,
"model": model,
"prompt_version": prompt_version,
"input_tokens": usage.get("input_tokens"),
"output_tokens": usage.get("output_tokens"),
"cached_input_tokens": usage.get("cached_input_tokens", 0),
"latency_ms": round((time.monotonic() - started) * 1000),
}))
Journalisez des comptes, pas le texte des prompts : ils peuvent contenir des données sensibles.
Trouvez les plus gros consommateurs (T-SQL sur une table d’usage) :
SELECT
feature,
model,
COUNT(*) AS requests,
AVG(input_tokens) AS avg_input_tokens,
AVG(output_tokens) AS avg_output_tokens,
SUM(input_tokens + output_tokens) AS total_tokens
FROM llm_usage_log
WHERE requested_at >= DATEADD(day, -7, SYSUTCDATETIME())
GROUP BY feature, model
ORDER BY total_tokens DESC;
Puis décomposez un prompt représentatif par composant :
def prompt_breakdown(parts: dict[str, str], count_tokens) -> dict[str, int]:
"""Nombre de tokens par composant du prompt ; `count_tokens` est la fonction de tokenisation du modèle."""
return {name: count_tokens(text) for name, text in parts.items()}
# {"system": 1850, "schema": 4200, "history": 6100, "retrieved": 3900, "question": 40}
Optimisez d’abord le composant le plus gros.
2. Raccourcir et dédoublonner les instructions
Les prompts système longs accumulent des règles répétées, des formules de politesse et des exemples que personne n’a retestés.
Avant :
Tu es un assistant très serviable, attentif et précis. Assure-toi toujours de répondre
avec exactitude. Il est très important d'être exact. Réponds toujours en JSON.
Vérifie que la réponse est en JSON. N'inclus rien d'autre que du JSON dans ta réponse.
Après :
Classe le ticket de support. Renvoie uniquement du JSON conforme au schéma.
Gardez les instructions qui changent le comportement. Supprimez celles qui se répètent, puis relancez le jeu d’évaluation pour confirmer.
3. Garder stables les instructions stables
Placez le contenu fixe en premier et le contenu variable en dernier :
[stable] rôle, règles, schéma de sortie, exemples
[variable] contexte récupéré, saisie utilisateur
Les prompts sont alors plus faciles à versionner, et la mise en cache de prompt/préfixe côté fournisseur peut fonctionner là où elle est proposée (longueur minimale et expiration dépendent du fournisseur).
N’injectez pas d’horodatage, d’ID de requête ni de nom d’utilisateur dans la partie stable : tout changement au début empêche la réutilisation du préfixe.
4. Résumer ou tronquer l’historique de conversation
Options, de la plus simple à la plus élaborée :
- garder les N derniers tours
- garder les N derniers tours plus un résumé glissant des plus anciens
- garder les faits et décisions extraits au lieu des tours bruts
- supprimer les résultats d’outils une fois utilisés
def build_history(turns: list[dict], summary: str | None, keep_last: int = 4) -> list[dict]:
"""Garde les derniers tours tels quels et remplace les plus anciens par un résumé glissant."""
recent = turns[-keep_last:]
if summary and len(turns) > keep_last:
return [{"role": "user", "content": f"Résumé de la conversation précédente :\n{summary}"}] + recent
return recent
Un résumé perd des détails. Demandez au résumeur de conserver mot pour mot les identifiants, les nombres, les noms de tables et les décisions.
5. Limiter le contexte récupéré
Plus d’extraits ne veut pas dire plus de précision. Les extraits peu pertinents coûtent des tokens et peuvent distraire le modèle.
def select_chunks(chunks: list[dict], budget_tokens: int, min_score: float) -> list[dict]:
"""Extraits les mieux notés, sans doublon, qui tiennent dans un budget de tokens."""
selected, seen, used = [], set(), 0
for chunk in sorted(chunks, key=lambda c: c["score"], reverse=True):
if chunk["score"] < min_score or chunk["text_hash"] in seen:
continue
if used + chunk["tokens"] > budget_tokens:
continue
selected.append(chunk)
seen.add(chunk["text_hash"])
used += chunk["tokens"]
return selected
Ajustez budget_tokens et min_score sur un jeu d’évaluation ; il n’existe pas de top-k universel.
6. Découper seulement quand c’est utile
Le découpage (chunking) sert la récupération dans de grands corpus. Il n’est pas toujours nécessaire :
- un document court, entièrement pertinent, peut être envoyé une fois
- les données structurées gagnent généralement à être interrogées (SQL, agrégats) plutôt que découpées en texte
- des extraits trop petits perdent leur contexte ; des extraits trop grands gaspillent des tokens
7. Envoyer le schéma utile, pas tout le catalogue
Pour générer du SQL, n’envoyez que les tables et colonnes nécessaires à la question, sous une forme compacte :
orders(order_id int pk, customer_id int fk->customers, order_date date,
status varchar -- 'open' | 'shipped' | 'cancelled', amount decimal(12,2))
customers(customer_id int pk, country char(2), segment varchar)
Présélectionnez les tables par recherche dans les métadonnées ou par une étape de récupération au niveau des tables. N’ajoutez des descriptions que là où un nom est ambigu.
8. Demander des formats de sortie concis
Indiquez le format et la longueur attendus :
Renvoie uniquement du JSON conforme au schéma. Aucune explication. "reason" : 15 mots maximum.
Fixez aussi un plafond de tokens de sortie, mais comme limite de sécurité, pas comme moyen de raccourcir les réponses : un plafond trop bas coupe la sortie au milieu du JSON.
9. Sortie structurée ou prose verbeuse
Prose :
Après examen attentif du ticket, il semble que le client rencontre très probablement
un problème de facturation, puisqu'il indique avoir été débité deux fois...
Structurée :
{"label": "billing_issue", "confidence": 0.82, "evidence": "débité deux fois"}
La sortie structurée est généralement plus courte, plus facile à valider et à stocker. Les clés coûtent aussi des tokens : gardez-les courtes mais lisibles. Utilisez la fonction de sortie structurée / schéma JSON du fournisseur quand elle existe, et validez quand même.
10. Mettre en cache le contexte stable et les résultats
Deux mécanismes différents :
- Mise en cache de prompt/préfixe (fonction du fournisseur, quand elle existe) : des préfixes identiques répétés peuvent être facturés et traités à moindre coût. Les conditions d’éligibilité varient.
- Cache de résultats applicatif : des entrées identiques renvoient une réponse stockée sans appeler le modèle.
import hashlib
import json
def cache_key(model: str, prompt_version: str, payload: dict) -> str:
"""Clé stable pour un cache de résultats : même modèle, même version de prompt, entrée normalisée."""
raw = json.dumps({"m": model, "v": prompt_version, "p": payload}, sort_keys=True, ensure_ascii=False)
return hashlib.sha256(raw.encode("utf-8")).hexdigest()
Un cache de résultats n’aide que si les entrées se répètent. Incluez la version du prompt et le modèle dans la clé, et fixez une expiration quand les données sous-jacentes changent.
11. Router les tâches vers le bon modèle, ou vers aucun
def route(task: str, text: str) -> str:
if task in {"parse_date", "extract_email"}:
return "code" # analyseur déterministe : pas d'appel LLM
if task in {"classify_ticket", "extract_fields"} and len(text) < 4_000:
return "small-model"
return "large-model"
Le routage ne réduit pas le nombre de tokens ; il rend chaque token moins cher et souvent plus rapide. Escaladez vers un modèle plus grand quand la validation échoue, au lieu de tout envoyer au plus gros.
12. Regrouper les petits éléments quand la tâche le permet
Plusieurs enregistrements par appel partagent une seule copie des instructions :
{"records": [
{"id": "t-101", "text": "Remboursement non reçu"},
{"id": "t-102", "text": "Connexion impossible après réinitialisation"}
]}
Exigez les ID dans la sortie et vérifiez que chaque ID d’entrée revient exactement une fois. Des lots trop gros peuvent dégrader la qualité, et un échec touche alors de nombreux enregistrements.
Tableau de décision des techniques
| Technique | Réduit les tokens d’entrée | Réduit les tokens de sortie | Risque principal |
|---|---|---|---|
| Raccourcir / dédoublonner le prompt système | Oui | — | Supprimer une instruction dont le modèle dépendait |
| Résumer l’historique | Oui | — | Perdre des faits, des ID ou des décisions |
| Réduire les extraits récupérés | Oui | — | Écarter l’extrait qui contenait la réponse |
| N’envoyer que le schéma utile | Oui | — | Mauvaise présélection de tables, SQL faux |
| Demander un JSON compact | — | Oui | Moins d’explications pour les lecteurs humains |
| Plafonner les tokens de sortie | — | Borne le pire cas | Sortie tronquée ou invalide |
| Mise en cache de prompt/préfixe | Réduit le coût de l’entrée répétée, si disponible | — | Tout changement de préfixe l’annule ; règles propres au fournisseur |
| Mettre en cache les résultats | Requête entière évitée | Requête entière évitée | Réponses périmées, mauvaise clé de cache |
| Router les tâches simples vers un modèle plus petit | Mêmes tokens, moins chers | Mêmes tokens, moins chers | Qualité moindre sur les cas difficiles |
| Regrouper les enregistrements par appel | Oui, instructions partagées | Légèrement | Échecs partiels, ID incohérents |
Les gains dépendent de la charge de travail. Mesurez-les ; ne supposez pas de pourcentage.
Points à vérifier
- Quel composant domine l’entrée : instructions, schéma, historique, récupération ou résultats d’outils ?
- Le rapport sortie/entrée par fonctionnalité.
- Les tokens par requête au p50 et au p95, pas seulement la moyenne.
- Les requêtes proches de la limite de la fenêtre de contexte.
- Les nouvelles tentatives : une validation en échec fait payer la requête deux fois.
- Le taux de succès du cache, si vous en utilisez un.
- Dans les boucles d’agents ou d’outils, les résultats d’outils réinjectés à chaque étape.
Erreurs fréquentes
1. Optimiser sans référence
Sans jeu d’évaluation, impossible de savoir si un prompt plus court est moins cher et toujours correct.
2. Utiliser le plafond de tokens de sortie pour raccourcir les réponses
Le modèle ne planifie pas en fonction du plafond ; la sortie est coupée. Demandez la concision dans les instructions et gardez le plafond comme limite de sécurité.
3. Faire disparaître les identifiants dans les résumés
« L’utilisateur a posé une question sur une table » ne sert à rien. Gardez sales.orders, la plage de dates et la décision prise.
4. Récupérer un top-20 « au cas où »
Les extraits en trop coûtent des tokens et peuvent orienter le modèle vers la mauvaise source.
5. Des données volatiles au début du prompt
Des horodatages ou des ID d’utilisateur dans les premières lignes annulent la mise en cache de préfixe et rendent les diffs de prompts illisibles.
6. Envoyer des schémas ou catalogues entiers
Des milliers de colonnes pour une question qui porte sur deux tables.
7. Compter en caractères ou en mots
Les estimations dérivent, surtout pour le code, le JSON et le texte non anglais. Utilisez le tokenizer ou les champs d’usage de l’API.
8. Supposer que moins de tokens coûte toujours moins cher
Un prompt plus court qui provoque des nouvelles tentatives, des escalades ou des réponses fausses peut coûter plus cher par tâche réussie.
9. Ignorer les tokens de nouvelles tentatives et de raisonnement
Ils apparaissent sur la facture, pas dans votre prompt.
Notes de production
- Versionnez les prompts et journalisez la version avec l’usage, pour relier un changement de coût à un changement de prompt.
- Définissez des budgets de tokens par fonctionnalité, avec des alertes.
- Relancez l’évaluation de qualité après chaque optimisation.
- Les tokenizers et les prix dépendent du modèle : mesurez à nouveau en changeant de modèle.
- Gardez de la marge dans la fenêtre de contexte pour la sortie.
- Journalisez les comptes de tokens, pas les prompts bruts, quand ils peuvent contenir des données clients ou sensibles.
Liste de contrôle
- L’usage est journalisé par fonctionnalité, modèle et version de prompt.
- Le plus gros composant du prompt est connu.
- Les instructions sont dédoublonnées et testées.
- Le contenu stable vient en premier, le contenu volatil en dernier.
- L’historique suit une politique de conservation ou de résumé.
- La récupération a un budget de tokens et un seuil de pertinence.
- Seul le schéma utile est envoyé.
- Le format de sortie est compact et validé.
- Le plafond de tokens de sortie sert de limite de sécurité.
- Le cache n’est utilisé que là où les entrées ou les préfixes se répètent vraiment.
- Les tâches simples sont routées vers des modèles moins chers ou vers du code.
- La qualité est revérifiée après chaque changement.
Ce contenu vous a-t-il été utile ?
Que pourrions-nous améliorer ?
Merci — cela m’aide à améliorer Javi Builds.
Restez au courant
Recevez uniquement les nouvelles de Javi Builds qui vous intéressent.
Consultez votre boîte de réception
Je vous ai envoyé un lien de confirmation. Votre abonnement sera actif après confirmation.