Un modèle ne répond bien que s'il a sous les yeux la bonne information, en quantité raisonnable, bien ordonnée. Composer ce contexte est un métier d'ingénierie.
⏱️ Durée : environ 105 minutes · 🎓 Niveau : avancé · 🏅 Badge : Metteur en contexte
🎬 L'histoire
L'assistant de support de HashBox répond bien aux premières questions d'une conversation, puis se met à contredire ses propres réponses et à oublier le nom du client. Dans les journaux, Kodi découvre pourquoi : l'application envoie à chaque tour tout l'historique, les 40 articles d'aide, la politique de remboursement et 12 descriptions d'outils. Au quinzième tour, la fenêtre est pleine ; le début de la conversation est coupé en silence, y compris le nom du client et l'objet du litige. Le coût par conversation a triplé.
« Le prompt, c'est ce qu'on dit au modèle, explique Sam. Le contexte, c'est tout ce qu'il a sous les yeux : consignes, historique, documents, outils, résultats d'outils, mémoire. La qualité d'un système à base d'IA se joue souvent là : quoi mettre, en quelle quantité, dans quel ordre, avec quel résumé — et quoi laisser dehors. »
Tu apprends à compter les jetons, à budgéter une fenêtre de contexte, à sélectionner l'information la plus utile sous contrainte, à résumer et compresser un historique, à ordonner pour limiter l'oubli du milieu, et à gérer une mémoire qui dure plus qu'une conversation.
🎯 Ta mission
À la fin, je serai capable de :
- décrire les composantes d'un contexte (consignes, historique, connaissances, outils, mémoire) et leurs coûts
- estimer et budgéter des jetons dans une fenêtre limitée
- sélectionner l'information la plus pertinente sous contrainte (sac à dos pondéré par la pertinence)
- résumer et compresser un historique sans perdre les faits critiques
- ordonner et structurer le contexte, et gérer une mémoire à plusieurs niveaux
🧩 Défi d'échauffement (5 XP)
Tu prépares un dossier pour un collègue qui doit décider en cinq minutes. Tu as 200 pages de documents. Tu peux lui en donner 5. Lesquelles ? Dans quel ordre ? Que fais-tu des 195 autres ? Et si sa décision dépend d'un chiffre caché à la page 87, comment t'assures-tu qu'il le voit ?
💡 Le concept
Qu'est-ce que le contexte ?
Tout ce que le modèle reçoit pour produire sa réponse, dans une fenêtre de contexte limitée (mesurée en jetons) qui contient entrée + sortie.
| Composante | Rôle | Coût typique |
|---|---|---|
| Consignes système | rôle, règles, ton, limites | stable, souvent mise en cache |
| Historique de conversation | continuité | croît à chaque tour |
| Connaissances récupérées (RAG) | faits à utiliser (mission 4) | variable |
| Définitions d'outils | ce que le modèle peut appeler (mission 5) | chaque outil coûte des jetons |
| Résultats d'outils | observations | peuvent être volumineux |
| Mémoire | faits retenus d'une conversation à l'autre | à gérer |
| Entrée de l'utilisateur | la demande | petite |
Pourquoi « ingénierie »
- Plus n'est pas mieux. Une fenêtre pleine coûte plus cher (jetons), ralentit, et dilue l'information utile : un modèle retrouve moins bien un fait noyé dans beaucoup de bruit.
- L'information utile doit y être. Si elle n'est pas dans le contexte, le modèle ne la connaît pas (mission 1).
- Le contexte est un budget. Chaque jeton est un coût en argent, en temps et en attention.
Budgéter
fenêtre = consignes + historique + connaissances + outils + réserve de sortie + marge
Règle pratique : réserver la sortie (on ne peut pas remplir la fenêtre d'entrée à 100 %), garder une marge (estimation des jetons approximative), prévoir ce qui est fixe (consignes, outils) et ce qui est variable (historique, connaissances).
Estimation grossière : 1 jeton ≈ 0,75 mot en anglais, ≈ 0,6 à 0,75 en français (≈ 4 caractères). Pour compter exactement, utiliser le compteur de jetons du fournisseur.
Sélectionner sous contrainte
Chaque morceau d'information (document, extrait, message passé) a :
- une pertinence estimée pour la question (score de récupération, mission 4) ;
- un coût en jetons.
Choisir ce qu'on inclut = problème de sac à dos : maximiser la pertinence totale sous le budget. Un glouton par pertinence / coût donne souvent un très bon résultat. Ajouter une diversité (ne pas inclure cinq fois la même information) améliore la couverture.
Résumer et compresser
| Technique | Principe | Risque |
|---|---|---|
| Fenêtre glissante | garder les N derniers tours | oublie le début (objet du litige !) |
| Résumé de l'historique ancien | condenser en quelques lignes | perte de détails, erreurs de résumé |
| Faits épinglés | garder toujours certains faits critiques (identité, objet, décisions) hors du résumé | à bien choisir |
| Résumé extractif | garder les phrases les plus informatives | moins fluide mais fidèle |
| Élagage des résultats d'outils | ne garder que les champs utiles | oubli d'un champ nécessaire plus tard |
Règle : ne jamais résumer ce qui doit rester exact (chiffres, identifiants, engagements) : l'épingler textuellement.
Ordre et structure
- Instructions importantes au début et rappelées à la fin.
- Les modèles retrouvent mieux l'information placée au début ou à la fin du contexte que au milieu (« perdu au milieu »).
- Structurer avec des délimiteurs et des titres :
<documents>,<historique>,<question>. - Séparer clairement instructions (fiables) et données (non fiables, mission 9).
- Placer la question après les documents longs.
Mémoire
| Niveau | Durée | Contenu | Exemple |
|---|---|---|---|
| Court terme | la conversation | tours récents | historique |
| Résumé de session | la conversation | accord, décisions | « le client veut un remboursement de la facture 123 » |
| Mémoire durable | entre conversations | préférences, faits stables | « préfère les réponses courtes » |
| Connaissances externes | permanentes | documents, base | RAG |
Une mémoire doit pouvoir être consultée, corrigée et effacée par l'utilisateur (vie privée), et ne jamais contenir de secrets.
Cache de prompt
Les fournisseurs savent réutiliser le début identique d'un contexte d'une requête à l'autre : mettre le contenu stable (consignes, définitions d'outils) au début et le variable à la fin réduit coût et latence.
Mesurer
Taux de réussite en fonction de la taille et du contenu du contexte ; jetons par conversation ; coût par tâche réussie ; tests de rappel : un fait est-il retrouvé en fin de longue conversation ?
🧠 Astuce : pour chaque élément de ton contexte, demande-toi : « si je le retire, la réponse change-t-elle ? » Si non, il coûte sans servir.
🔍 Exemple pas à pas
Problème : estimer des jetons, bâtir un gestionnaire de budget de contexte, sélectionner des extraits sous contrainte (glouton avec diversité contre sac à dos exact), résumer un historique tout en épinglant les faits critiques, et mesurer l'oubli avec une fenêtre glissante.
import itertools, math, re
from collections import Counter
# ---------------- 1. estimation de jetons (approximation) ----------------
def jetons(texte): return max(1, round(len(texte) / 4)) # ≈ 4 caractères par jeton
assert jetons("a" * 400) == 100
# ---------------- 2. budget d'une fenêtre ----------------
class Budget:
def __init__(self, fenetre, reserve_sortie, marge=0.05):
self.disponible = int(fenetre * (1 - marge)) - reserve_sortie; self.postes = {}
def ajouter(self, poste, texte, obligatoire=False):
t = jetons(texte)
if t > self.disponible and obligatoire: raise MemoryError(f"poste obligatoire « {poste} » ({t} jetons) ne tient pas : il reste {self.disponible}")
if t > self.disponible: return False
self.postes[poste] = .postes.get(poste, ) + t; .disponible -= t;
b = Budget(fenetre=, reserve_sortie=)
b.ajouter(, * , obligatoire=); b.ajouter(, * , obligatoire=)
(, b.disponible, , b.postes)
b.disponible == * - - -
: b.ajouter(, * , obligatoire=); AssertionError
MemoryError e: (, e)
EXTRAITS = [
(, , , ), (, , , ), (, , , ),
(, , , ), (, , , ), (, , , ),
(, , , ), (, , , ), (, , , ),
]
BUDGET_DOCS =
():
choisis, reste, themes = [], budget, Counter()
nom, p, t, theme (extraits, key= e: -(e[] / e[])):
malus = ** themes[theme] diversite
t <= reste p * malus > ( diversite ): choisis.append((nom, p, t, theme)); reste -= t; themes[theme] +=
choisis
():
meilleur = (, ())
r ((extraits) + ):
combo itertools.combinations(extraits, r):
(e[] e combo) <= budget:
v = (e[] e combo)
v > meilleur[]: meilleur = (v, combo)
meilleur
g, gd = glouton(EXTRAITS, BUDGET_DOCS), glouton(EXTRAITS, BUDGET_DOCS, diversite=); o = optimal(EXTRAITS, BUDGET_DOCS)
nom, sel ((, g), (, gd)):
()
()
(e[] e g) >= * o[] ({e[] e gd}) >= ({e[] e g})
[e[] e g] [e[] e gd]
HISTORIQUE = [
(, ),
(, ),
(, ),
(, ),
(, ),
(, ),
(, ),
(, ),
]
MOTIF_EPINGLE = re.()
(): ({m.group() _, t historique m MOTIF_EPINGLE.finditer(t)})
():
mots = Counter(w _, t historique w re.findall(, t.lower()) (w) > )
score = t: (mots[w] w (re.findall(, t.lower())) (w) > ) / ((t) ** )
[t _, t (historique, key= x: -score(x[]))[:n_phrases]]
(): historique[-n:]
epingles = epingler(HISTORIQUE); (, epingles)
( e e epingles) ( e e epingles) ( e e epingles)
():
strategie == : .join(t _, t fenetre_glissante(historique, ))
strategie == : .join(resume_extractif(historique[:-]) + [t _, t historique[-:]])
.join(epingles + resume_extractif(historique[:-]) + [t _, t historique[-:]])
()
resultats = {}
s (, , ):
c = contexte(HISTORIQUE, s); r = ( c, c, c); resultats[s] = r
()
(resultats[]) (resultats[])
():
x = position / (n - ); + * (( * x - )) **
n =
()
p (, , , , ): ()
poids_attention(, n) < poids_attention(, n) poids_attention(, n) < poids_attention(, n)
Lecture :
- Le budget de la fenêtre doit tenir compte de la réserve de sortie et d'une marge ; un poste obligatoire qui ne tient pas lève une erreur claire au lieu d'être coupé en silence.
- La sélection sous contrainte par rapport pertinence / coût est presque aussi bonne que l'optimum exact (≥ 90 % de la pertinence) ; avec une pénalité de diversité, on évite d'inclure plusieurs fois la même politique.
- Une fenêtre glissante de trois tours perd la facture, le montant ou l'adresse ; le résumé seul risque de déformer les faits. En épinglant les faits critiques (identifiants, montants, adresses) hors du résumé, on conserve exactement ce qui doit l'être.
- Le modèle simple d'attention illustre l'effet « perdu au milieu » : l'information placée au centre d'un long contexte est moins bien exploitée.
✍️ À toi, avec aide (10 XP)
Un assistant a une fenêtre de 16 000 jetons. Postes fixes : consignes 900, définitions de 8 outils (250 chacun), réserve de sortie 2 000. Historique : 350 jetons par tour, 20 tours déjà échangés. Documents récupérés : 5 extraits de 600 jetons.
- Calcule le total demandé. Tient-il dans la fenêtre avec une marge de 5 % ?
- Combien de tours d'historique peut-on garder en complet si l'on garde tous les documents ?
- Propose une stratégie pour tout faire tenir (résumé des anciens tours, élagage des outils, moins de documents) et chiffre l'économie de chaque option.
- Quel est l'effet sur le coût si le fournisseur facture par jeton d'entrée ?
💡 Indice 1
Total = 900 + 8 × 250 + 20 × 350 + 5 × 600 + 2 000.
💡 Indice 2
Fenêtre utile = 16 000 × 0,95 = 15 200.
💡 Indice 3
Un résumé de 15 tours en 600 jetons économise 15 × 350 − 600.
✅ Réponse
FENETRE, MARGE = 16000, 0.05
fixe = 900 + 8 * 250 + 2000
historique, docs = 20 * 350, 5 * 600
total = fixe + historique + docs
utile = int(FENETRE * (1 - MARGE))
print(f"total demandé {total} jetons ; fenêtre utile {utile} ; dépassement {total - utile}")
tours_gardes = (utile - fixe - docs) // 350
print("tours complets gardables :", tours_gardes)
economie = {"résumé des 15 plus anciens tours (600 jetons)": 15 * 350 - 600, "outils réduits à ceux utiles à la tâche (3 sur 8)": 5 * 250, "3 extraits au lieu de 5": 2 * 600}
print(economie)
assert total == 14900 + 0 or total > utile
- Total : 900 + 2 000 + 2 000 + 7 000 + 3 000 = 14 900 jetons ; la fenêtre utile (avec 5 % de marge) est de 15 200 : ça tient à peine, sans aucune marge d'erreur si les estimations sont approximatives, et rien ne reste pour croître d'un tour.
- Avec tous les documents, on peut garder environ — mais seulement tant que les tours restent à 350 jetons.
🚀 À toi, en solo (20 XP)
Gestionnaire de mémoire de conversation. Écris GestionnaireContexte qui assemble un contexte pour chaque tour d'une longue conversation :
- des faits épinglés (extraits automatiquement par expressions régulières : identifiants, montants, adresses, décisions « d'accord pour… ») conservés textuellement ;
- un résumé glissant des anciens tours (extractif, ≤ 150 jetons) mis à jour tous les 6 tours ;
- les 4 derniers tours complets ;
- des documents sélectionnés sous contrainte (pertinence/coût avec diversité) pour la question courante ;
- un budget global avec priorités : consignes > faits épinglés > derniers tours > documents > résumé ;
- un test de rappel : on insère un fait au tour 3 (« mon code de dossier est D-7731 »), on pose la question au tour 30 ; compare 3 stratégies (fenêtre seule, résumé seul, résumé + faits épinglés) sur 100 conversations simulées où le fait peut être placé à des positions différentes ;
- mesure le coût moyen en jetons par tour pour chaque stratégie.
✅ Pistes de correction
import random, re
from collections import Counter
EPINGLE = re.compile(r"(\b[A-Z]-?\d{3,}(?:-\d+)*\b|\b\d+[,.]\d{2}\s*€|[\w.]+@[\w.]+\.\w+|d'accord pour [^.,;]+)")
def jetons(t): return max(1, round(len(t) / 4))
class GestionnaireContexte:
def __init__(self, strategie, budget=1200, dernier=4):
self.strategie, self.budget, self.dernier = strategie, budget, dernier
self.tours, self.epingles, self.resume = [], [], ""
def ajouter(self, role, texte):
self.tours.append((role, texte))
if self.strategie == "résumé + faits épinglés":
for m in EPINGLE.finditer(texte):
if m.group(0) not in self.epingles: self.epingles.append(m.group())
(.tours) % == .strategie != :
anciens = .tours[:-.dernier]
mots = Counter(w _, t anciens w re.findall(, t.lower()) (w) > )
phrases = (anciens, key= x: -(mots[w] w (re.findall(, x[].lower())) (w) > ) / ((x[]) ** ))[:]
.resume = .join(t _, t phrases)[:]
():
morceaux = []
.strategie == .epingles: morceaux.append( + .join(.epingles))
morceaux += [ r, t .tours[-.dernier:]]
.resume: morceaux.append( + .resume)
texte = .join(morceaux)
jetons(texte) > .budget (morceaux) > : morceaux.pop(); texte = .join(morceaux)
texte
BAVARDAGE = [, , ,
, , ]
():
rng, g = random.Random(graine), GestionnaireContexte(strategie); jetons_total =
t (longueur):
texte = rng.choice(BAVARDAGE)
t == position_fait: texte =
g.ajouter( t % == , texte)
jetons_total += jetons(g.contexte())
g.contexte(), jetons_total / longueur
()
res = {}
s (, , ):
ok = n = ; cout =
pos (, ):
g ():
r, c = conversation(s, pos, graine=g); ok += r; n += ; cout += c
res[s] = (ok / n, cout / n); ()
res[][] == res[][] < res[][] <= res[][] <= res[][]
⚠️ Pièges classiques
| Piège | Pourquoi c'est un problème | Comment l'éviter |
|---|---|---|
| Tout mettre dans le contexte | Coût, latence, information diluée | Sélectionner sous contrainte, mesurer l'utilité |
| Couper l'historique en silence | Le modèle oublie l'objet de la conversation | Faits épinglés, résumé, test de rappel |
| Résumer des chiffres ou des identifiants | Erreurs de recopie | Épingler textuellement ce qui doit rester exact |
| Ne pas réserver la sortie | Réponse tronquée | Budget avec réserve et marge |
🐉 Mini-boss (40 XP)
Assembleur de contexte du support HashBox. Construis un assembleur complet :
- consignes, définitions d'outils (8 outils de 200 à 400 jetons), historique, documents (30 extraits avec pertinence), mémoire durable de l'utilisateur ;
- budget global avec priorités et réserve de sortie ; erreur claire si un poste obligatoire ne tient pas ;
- sélection des documents par pertinence/coût avec diversité, comparée à l'optimum exact sur de petites instances ;
- gestion de l'historique : faits épinglés, résumé glissant, derniers tours ;
- sélection dynamique des outils (seuls les outils plausibles pour la question sont inclus) ;
- placement : consignes au début, documents puis question à la fin, rappel des règles critiques à la fin ;
- batterie de tests de rappel sur 200 conversations simulées (fait au milieu, au début, à la fin ; fait dans un résultat d'outil) ; rapport : taux de rappel, jetons moyens par tour, coût ;
- recommandation chiffrée de la stratégie à retenir.
✅ Pistes de correction
Un bon travail : budget avec priorités, sélection documentaire presque optimale, gestion d'historique avec faits épinglés qui conserve 100 % des faits critiques à coût faible, sélection d'outils qui réduit de 40 à 60 % les jetons fixes, rapport de rappel par position, et une recommandation comparant coût moyen et rappel (la combinaison résumé + faits épinglés + sélection d'outils domine les stratégies naïves).
⚡ Quiz éclair (15 XP si 4/5 ou plus)
1. La fenêtre de contexte d'un modèle contient :
- A. uniquement la question
- B. l'entrée et la sortie, en jetons, avec une limite totale
- C. uniquement la réponse
2. Pour conserver un identifiant exact lors d'une compression d'historique, on :
- A. le fait résumer par le modèle
- B. le supprime
- C. l'épingle textuellement hors du résumé
3. Plus de contexte n'est pas toujours mieux parce que :
- A. cela coûte plus, ralentit et dilue l'information utile
- B. le modèle refuse les longs textes
- C. cela réduit les hallucinations
4. 🔁 Révision mission 02 : Un bon prompt orienté tâche contient :
- A. uniquement un mot poli
- B. tâche, contexte, contraintes, format de sortie et critères de réussite
- C. le plus de mots possible
5. 🔁 Révision mission 02 : Avant d'utiliser la sortie JSON d'un modèle dans un programme, il faut :
- A. l'exécuter directement
- B. supposer qu'elle est correcte
- C. la valider contre un schéma et gérer l'échec
✅ Réponses
- B.
- C.
- A.
- B.
- C.
🪞 Je réfléchis (10 XP)
- Quel élément de ton contexte actuel ne change jamais la réponse mais coûte des jetons à chaque requête ?
- Quel fait de ta dernière longue conversation avec un assistant a été oublié, et comment l'aurais-tu protégé ?
🎒 À retenir
- Contexte = consignes, historique, connaissances, outils, résultats, mémoire.
- Budget : fenêtre − réserve de sortie − marge ; postes fixes et variables.
- Sélection sous contrainte : pertinence / coût, avec diversité.
- Épingler les faits exacts ; résumer le reste ; tester le rappel.
- Ordre : consignes au début, question à la fin ; éviter le milieu pour l'essentiel.
flowchart LR
T(["Context engineering"])
T --> R1["1. Contexte = consignes, historique, connaissances, outils, résultats,…"]
T --> R2["2. Budget : fenêtre − réserve de sortie − marge ; postes fixes et…"]
T --> R3["3. Sélection sous contrainte : pertinence / coût, avec diversité."]
T --> R4["4. Épingler les faits exacts ; résumer le reste ; tester le rappel."]
T --> R5["5. Ordre : consignes au début, question à la fin ; éviter le milieu pour…"]
Description du schéma : la mission au centre, reliée aux cinq idées à retenir.
🏅 Récompenses
Total possible : 100 XP · 🏅 Badge Metteur en contexte
← Mission 02 — Prompt engineering orienté tâche · Mission 04 — RAG et recherche de connaissances →
HEF-160 — IA et augmentation humaine

