Au lieu de demander au modèle ce qu'il croit savoir, on va chercher la bonne information dans vos documents et on lui demande de répondre à partir de ce qu'on lui montre.
⏱️ Durée : environ 110 minutes · 🎓 Niveau : avancé · 🏅 Badge : Bibliothécaire de l'IA
🎬 L'histoire
HashBox veut un assistant qui répond aux questions des membres sur le règlement, les remboursements et les certificats. Le premier essai interroge directement un modèle : il répond avec aplomb des règles qui n'existent pas (« remboursement sous 60 jours » alors que HashBox rembourse sous 14 jours). Maya propose une autre approche : « Quand une question arrive, on cherche d'abord les passages pertinents de nos propres documents, on les donne au modèle, et on exige qu'il réponde uniquement à partir d'eux, en citant la source. Et s'il n'y a rien de pertinent, il dit qu'il ne sait pas. »
« C'est le principe du RAG, ajoute Sam : Retrieval-Augmented Generation. Ça ne supprime pas toutes les erreurs, mais ça remplace "ce que le modèle croit se rappeler" par "ce qu'on peut lui montrer et vérifier". Tout se joue dans la qualité de la recherche — que l'on peut mesurer. »
Tu apprends à découper des documents en morceaux, à indexer et rechercher (TF-IDF, BM25, similarité cosinus), à fusionner plusieurs classements, à mesurer la qualité de la recherche (rappel@k, MRR), à produire des réponses avec citations, et à refuser de répondre quand l'information manque.
🎯 Ta mission
À la fin, je serai capable de :
- décrire le pipeline RAG : découpage, indexation, récupération, assemblage, génération, citation
- implémenter une recherche lexicale (TF-IDF, BM25) et une similarité par vecteurs
- mesurer la qualité de la récupération (rappel@k, MRR) et l'effet de la taille des morceaux
- fusionner des classements (fusion de rangs réciproques) et reclasser
- répondre de façon extractive avec citations et refuser quand la preuve est insuffisante
🧩 Défi d'échauffement (5 XP)
Un étudiant passe un examen à livre ouvert avec 300 pages de cours. Stratégie A : tout lire pendant l'examen. Stratégie B : utiliser l'index et la table des matières pour trouver les 3 pages utiles, puis répondre en citant la page. Que faut-il pour que B fonctionne ? Que se passe-t-il si l'index est mauvais ? Que doit faire l'étudiant si les pages trouvées ne contiennent pas la réponse ?
💡 Le concept
Le pipeline RAG
flowchart LR
D["Documents"] --> C["Découpage en morceaux"]
C --> I["Index (lexical et/ou vectoriel)"]
Q["Question"] --> R["Recherche des k meilleurs morceaux"]
I --> R
R --> A["Assemblage du contexte + consignes"]
A --> G["Génération (modèle)"]
G --> V["Réponse avec citations, ou refus"]
Description du schéma : les documents sont découpés puis indexés. Pour une question, on recherche les meilleurs morceaux, on les assemble avec des consignes, le modèle génère une réponse citant ses sources, ou refuse si la preuve manque.
Pourquoi le RAG
| Problème | Apport du RAG |
|---|---|
| Connaissances absentes ou datées | on récupère des documents à jour |
| Données privées | elles ne sont pas dans le modèle, on les fournit à la demande |
| Hallucinations | la réponse s'appuie sur des passages vérifiables |
| Traçabilité | on cite les sources |
| Coût de ré-entraînement | on met à jour l'index, pas le modèle |
Découper (chunking)
| Choix | Effet |
|---|---|
| Petits morceaux (100-300 mots) | récupération précise, mais contexte perdu |
| Grands morceaux (500-1000 mots) | contexte riche, mais bruit et coût |
| Chevauchement (10-20 %) | évite de couper une réponse en deux |
| Découpage par structure (titres, sections) | préserve le sens |
| Métadonnées (titre, date, source) | filtrage, citation |
La taille idéale dépend des documents et des questions : se mesure (rappel@k).
Rechercher
Lexicale (mots)
- TF-IDF : un mot compte d'autant plus qu'il est fréquent dans le morceau (TF) et rare dans le corpus (IDF = log(N / df)).
- BM25 : amélioration de TF-IDF avec saturation de la fréquence et normalisation de la longueur ; référence solide.
BM25(q, d) = Σ_t IDF(t) · tf·(k1+1) / (tf + k1·(1 − b + b·|d|/avgdl))
Forte pour les termes exacts (noms, codes), faible pour les synonymes.
Vectorielle (sémantique)
Chaque texte devient un vecteur (plongement, embedding) ; les textes de sens proche sont proches. On compare par similarité cosinus. Forte pour les paraphrases, plus faible pour les termes exacts rares. (Ici, on illustre le principe avec des vecteurs de mots simples ; les vrais plongements viennent d'un modèle.)
Hybride et reclassement
Combiner lexical et sémantique, puis éventuellement reclasser (rerank) les meilleurs candidats avec un modèle plus précis. La fusion de rangs réciproques (RRF) combine des classements sans calibrer les scores :
score(d) = Σ_classements 1 / (k + rang(d)) (k ≈ 60)
Mesurer la récupération
On construit un jeu d'évaluation : questions + morceau(x) correct(s).
| Mesure | Définition |
|---|---|
| Rappel@k | part des questions dont un morceau correct est dans les k premiers |
| MRR | moyenne de 1/rang du premier morceau correct |
| Précision@k | part des k morceaux qui sont pertinents |
Si la récupération échoue, aucun modèle ne peut répondre correctement (sauf en devinant). Mesurer la récupération séparément de la génération.
Générer à partir des preuves
Consignes typiques : « Réponds uniquement à partir des extraits ci-dessous. Cite le numéro de l'extrait pour chaque affirmation. Si les extraits ne contiennent pas la réponse, réponds : Je ne trouve pas cette information. »
Même ainsi, le modèle peut mal lire, mélanger ou extrapoler : vérifier que chaque citation existe et soutient l'affirmation (mission 8).
Quand refuser
Un seuil de confiance : si le meilleur score de récupération est faible, ou si aucun extrait ne recoupe les mots essentiels de la question, ne pas répondre (ou poser une question de clarification). Refuser à tort coûte un peu ; répondre à tort coûte la confiance.
Pièges
- Fuite entre utilisateurs : un index partagé sans contrôle d'accès expose des documents confidentiels (mission 9).
- Documents contradictoires ou périmés : gérer versions et dates.
- Instructions cachées dans des documents (injection indirecte, mission 9).
- Questions multi-étapes : une seule récupération ne suffit pas (agents, mission 6).
- Évaluation seulement « à l'œil ».
🧠 Astuce : regarde toujours les extraits récupérés avant de juger la réponse. Neuf fois sur dix, une mauvaise réponse vient d'une mauvaise récupération.
🔍 Exemple pas à pas
Problème : construire un petit système de recherche (découpage, TF-IDF, BM25, vecteurs de mots), l'évaluer (rappel@k, MRR) en fonction de la taille des morceaux, fusionner les classements, produire une réponse extractive avec citations, et refuser quand la preuve est insuffisante.
import math, re
from collections import Counter
DOCUMENTS = {
"remboursement": "Politique de remboursement. Un membre peut demander le remboursement d'un abonnement dans un délai de 14 jours après l'achat, à condition de ne pas avoir terminé plus de 20 % du parcours. "
"Le remboursement est effectué sur le moyen de paiement d'origine sous 5 jours ouvrés. Les achats de certificats ne sont pas remboursables.",
"certificats": "Certificats. Un certificat est délivré lorsque tous les modules d'un parcours sont validés avec une note d'au moins 70 %. Le certificat est téléchargeable au format PDF et vérifiable en ligne grâce à un code unique. "
"La réémission d'un certificat perdu coûte 5 euros.",
"comptes": "Comptes. Pour changer de mot de passe, ouvrez Compte puis Sécurité. L'authentification à deux facteurs est recommandée. Un compte inactif pendant 24 mois est supprimé après notification par e-mail.",
"sessions": "Sessions en direct. Les sessions en direct ont lieu le mardi et le jeudi à 18 heures. L'enregistrement est disponible 24 heures après la fin de la session. Les questions peuvent être posées dans le forum du parcours.",
}
def mots(texte): return [m for m in re.findall(r"[a-zàâçéèêëîïôûùüÿœ0-9]+", texte.lower()) if len(m) > 2 and m not in {"les", "des", "une", "est", "pour", "que", "qui", "dans", "sur", , , , , , , , }]
():
phrases = [p.strip() p re.split(, texte) p.strip()]
morceaux, i = [],
i < (phrases):
courant, n = [],
j = i
j < (phrases) (n + (phrases[j].split()) <= taille courant): courant.append(phrases[j]); n += (phrases[j].split()); j +=
morceaux.append((doc_id, .join(courant)))
i = (i + , j - (, ((courant) * chevauchement)))
morceaux
(): [m d, t DOCUMENTS.items() m decouper(d, t, taille)]
:
():
.morceaux, .tfs = morceaux, [Counter(mots(t)) _, t morceaux]
.n = (morceaux); .longueurs = [(tf.values()) tf .tfs]; .moy = (.longueurs) / .n
.df = Counter(m tf .tfs m tf)
(): math.log( + (.n - .df[m] + ) / (.df[m] + ))
():
q = mots(question); scores = []
tf, L (.tfs, .longueurs):
scores.append((.idf(t) * tf[t] * (k1 + ) / (tf[t] + k1 * ( - b + b * L / .moy)) t q t tf))
scores
():
vq = {t: c * .idf(t) t, c Counter(mots(question)).items()}; nq = math.sqrt((v * v v vq.values()))
scores = []
tf .tfs:
vd = {t: c * .idf(t) t, c tf.items()}; nd = math.sqrt((v * v v vd.values()))
scores.append((vq[t] * vd.get(t, ) t vq) / (nq * nd))
scores
(): ((.n), key= i: -scores[i])
EVAL = [(, ), (, ),
(, ), (, ),
(, ), (, ),
(, ), (, )]
():
idx = Index(indexer(taille)); rappel = mrr =
question, doc EVAL:
scores = idx.bm25(question) methode == idx.tfidf_cosinus(question)
ordre = idx.classement(scores); docs = [idx.morceaux[i][] i ordre]
rappel += doc docs[:k]; mrr += / (docs.index(doc) + ) doc docs
rappel / (EVAL), mrr / (EVAL)
()
taille (, , , ):
nb = (indexer(taille)); b, t = evaluer(taille, ), evaluer(taille, )
()
evaluer(, )[] >= evaluer(, )[] >=
():
score = Counter()
c classements:
rang, i (c): score[i] += / (k + rang + )
[i i, _ score.most_common()]
idx = Index(indexer())
hybride_ok =
question, doc EVAL:
fusion = rrf([idx.classement(idx.bm25(question)), idx.classement(idx.tfidf_cosinus(question))])
hybride_ok += idx.morceaux[fusion[]][] == doc
()
hybride_ok / (EVAL) >= evaluer(, )[]
():
idx = Index(indexer()); scores = idx.bm25(question); ordre = idx.classement(scores)[:k]
scores[ordre[]] < seuil: , []
q = (mots(question)); candidates = []
rang, i (ordre, ):
doc, texte = idx.morceaux[i]
phrase re.split(, texte):
candidates.append(((q & (mots(phrase))), ))
meilleure = (candidates, key= x: x[])
meilleure[], [(rang, idx.morceaux[i][]) rang, i (ordre, )]
question (, , ):
reponse, sources = repondre(question)
()
repondre()[] repondre()[].startswith()
Lecture :
- Le découpage influe sur la récupération : des morceaux trop petits (12 mots) perdent le contexte ; des morceaux très grands mélangent plusieurs sujets. Le mieux se mesure avec le rappel@1 et le MRR sur un jeu de questions.
- BM25 et TF-IDF cosinus se comportent différemment selon les questions ; la fusion de rangs réciproques les combine sans calibrage de scores.
- La réponse est extractive : on cite la phrase du document avec sa source (
[1:remboursement]), donc on peut vérifier. - Quand le meilleur score est sous le seuil, le système refuse de répondre plutôt que d'inventer (« prix de la lune », « bitcoin »).
✍️ À toi, avec aide (10 XP)
Un système de recherche a retourné, pour 6 questions, les classements suivants des morceaux (le morceau correct est indiqué) :
| Question | Rang du premier morceau correct |
|---|---|
| Q1 | 1 |
| Q2 | 3 |
| Q3 | 1 |
| Q4 | non trouvé dans les 10 premiers |
| Q5 | 2 |
| Q6 | 1 |
- Calcule le rappel@1, le rappel@3 et le MRR (en considérant 0 pour « non trouvé »).
- Si l'on affiche k = 3 morceaux au modèle, quelle part des questions a au moins une chance d'être bien répondue (en supposant que le modèle sait lire un morceau correct) ?
- Un second système obtient les rangs (1, 1, 2, 5, 1, 2). Lequel est meilleur selon chaque mesure ? Peut-on conclure avec 6 questions ?
💡 Indice 1
MRR = moyenne de 1/rang ; 0 si non trouvé.
💡 Indice 2
Rappel@k = part des questions dont le rang est ≤ k.
💡 Indice 3
Avec 6 questions, l'incertitude est grande.
✅ Réponse
def mesures(rangs, ks=(1, 3)):
n = len(rangs)
mrr = sum(1 / r for r in rangs if r) / n
return {k: sum(1 for r in rangs if r and r <= k) / n for k in ks}, mrr
A = [1, 3, 1, None, 2, 1]
B = [1, 1, 2, 5, 1, 2]
for nom, r in (("système A", A), ("système B", B)):
rappels, mrr = mesures(r); print(f"{nom} : rappel@1 = {rappels[1]:.2f}, rappel@3 = {rappels[3]:.2f}, MRR = {mrr:.2f}")
assert round(mesures(A)[1], 2) == mesures(A)[][] == (mesures(A)[][], ) ==
🚀 À toi, en solo (20 XP)
Système RAG évalué de bout en bout. Sur un corpus de 10 documents (à écrire, 100 à 200 mots chacun, sur HashBox) et 30 questions (dont 5 sans réponse dans le corpus) :
- implémente BM25, TF-IDF cosinus et une recherche « vectorielle » avec des vecteurs de mots-clés regroupés par thèmes (un petit dictionnaire de synonymes) ;
- évalue chaque méthode et leur fusion par RRF : rappel@1, rappel@3, MRR, avec intervalle bootstrap ;
- choisis une taille de morceau en faisant varier de 10 à 150 mots ;
- implémente le seuil de refus et mesure, pour 20 seuils, les deux erreurs : questions sans réponse auxquelles on répond (faux positifs) et questions avec réponse que l'on refuse (faux négatifs) ; trace la courbe et choisis un seuil avec une règle écrite d'avance ;
- vérifie par code que chaque réponse extractive cite un morceau qui contient bien la phrase citée ;
- rédige un rapport : forces et faiblesses de chaque méthode avec un exemple d'échec pour chacune.
✅ Pistes de correction
import math, random, re
from collections import Counter
DOCS = {
"remb1": "Remboursement. Un abonnement peut être remboursé dans les 14 jours suivant l'achat si moins de 20 % du parcours est terminé. Le remboursement se fait sur le moyen de paiement d'origine sous 5 jours ouvrés.",
"remb2": "Achats non remboursables. Les certificats achetés séparément et les sessions de mentorat déjà consommées ne sont pas remboursables.",
"cert1": "Certificats. Un certificat est délivré après validation de tous les modules avec 70 % de bonnes réponses au minimum. Il est téléchargeable en PDF.",
"cert2": "Réémission. Un certificat perdu peut être réédité pour 5 euros depuis votre espace personnel.",
"cpt1": "Mot de passe. Pour changer de mot de passe, ouvrez Compte puis Sécurité et suivez les instructions.",
"cpt2": "Suppression. Un compte inactif depuis 24 mois est supprimé après notification par e-mail.",
"live1": "Sessions en direct. Elles ont lieu le mardi et le jeudi à 18 heures, heure de Paris.",
"live2": "Enregistrements. L'enregistrement d'une session est publié 24 heures après sa fin dans l'espace du parcours.",
"mentor": "Mentorat. Un mentor est disponible 2 heures par semaine pour répondre aux questions sur les projets.",
"prix": "Tarifs. L'abonnement mensuel coûte 29 euros ; l'abonnement annuel coûte 290 euros.",
}
QUESTIONS = [("combien de jours pour être remboursé ?", "remb1"), ("le remboursement prend combien de temps ?", "remb1"), ("peut-on rembourser un certificat acheté ?", ),
(, ), (, ), (, ),
(, ), (, ), (, ), (, ),
(, ), (, )] * + [(, ), (, ), (, ), (, ), (, )] + [(, )] *
(): [m m re.findall(, t.lower()) (m) > m {, , , , , , , , , , , }]
SYN = {: , : , : , : , : , : , : , : , : , : }
(): SYN.get(m, m[:])
:
():
.ids = (DOCS); .tf = {i: Counter(mots(t)) i, t DOCS.items()}; .n = (DOCS); .L = {i: (c.values()) i, c .tf.items()}; .moy = (.L.values()) / .n
.df = Counter(m c .tf.values() m c); .tfs = {i: Counter(racine(m) m mots(t)) i, t DOCS.items()}; .dfs = Counter(m c .tfs.values() m c)
():
out = {}
i .ids:
s =
t mots(q):
t .tf[i]: idf = math.log( + (.n - .df[t] + ) / (.df[t] + )); f = .tf[i][t]; s += idf * f * (k1 + ) / (f + k1 * ( - b + b * .L[i] / .moy))
out[i] = s
out
():
out = {}
i .ids:
s =
t {racine(m) m mots(q)}:
t .tfs[i]: s += math.log( + .n / .dfs[t]) * ( + math.log(.tfs[i][t]))
out[i] = s
out
(): (sc, key= i: -sc[i])
():
s = Counter()
c cl:
r, i (c): s[i] += / (k + r + )
[i i, _ s.most_common()]
idx = Idx(); repondables = [(q, d) q, d QUESTIONS d]
():
r1 = r3 = mrr = ; rangs = []
q, d repondables:
c = methode(q); rg = c.index(d) + ; rangs.append(rg); r1 += rg == ; r3 += rg <= ; mrr += / rg
n = (repondables); r1 / n, r3 / n, mrr / n, rangs
METHODES = {: q: classer(idx.bm25(q)), : q: classer(idx.semantique(q)), : q: rrf(classer(idx.bm25(q)), classer(idx.semantique(q)))}
()
nom, f METHODES.items():
r1, r3, mrr, rangs = metriques(f); rng = random.Random()
boot = (( / rng.choice(rangs) _ rangs) / (rangs) _ ())
()
():
fp = fn =
q, d QUESTIONS:
s = (idx.bm25(q).values()); repond = s >= seuil
d repond: fp +=
d repond: fn +=
fp / ( _, d QUESTIONS d ), fn / (repondables)
()
courbe = {}
seuil (, , , , , , ):
courbe[seuil] = erreurs(seuil); ()
choisi = (s s (courbe) courbe[s][] <= courbe[s][] <= ) (courbe[s][] <= courbe[s][] <= s courbe)
(, choisi)
metriques(METHODES[])[] >=
⚠️ Pièges classiques
| Piège | Pourquoi c'est un problème | Comment l'éviter |
|---|---|---|
| Juger la réponse sans regarder les extraits | On corrige le prompt alors que la recherche a échoué | Mesurer la récupération séparément (rappel@k, MRR) |
| Morceaux trop petits ou trop grands | Perte de contexte ou bruit | Tester plusieurs tailles et mesurer |
| Toujours répondre | Hallucination quand l'information manque | Seuil de confiance et réponse « je ne sais pas » |
| Index partagé sans contrôle d'accès | Fuite de documents confidentiels | Filtrer par droits avant la récupération |
🐉 Mini-boss (40 XP)
Assistant documentaire de HashBox avec évaluation complète.
- corpus de 15 documents (politiques, tutoriels, FAQ) avec métadonnées (titre, date, niveau d'accès) ;
- découpage par sections avec chevauchement, métadonnées conservées ;
- recherche hybride (BM25 + vecteurs de racines/synonymes + RRF) avec filtre par droits d'accès appliqué avant la récupération ;
- génération extractive avec citations ; refus sous seuil ; clarification quand deux documents se contredisent (dates différentes → choisir le plus récent et le dire) ;
- jeu d'évaluation de 40 questions (dont 8 sans réponse, 4 sur documents contradictoires, 4 sur documents à accès restreint) ;
- métriques : rappel@k, MRR, taux de refus justifié, taux de réponse à tort, fuite de documents restreints (doit être 0) ;
- vérification automatique des citations (la phrase citée existe dans le morceau cité) ;
- rapport : 3 échecs analysés (récupération ou lecture) et améliorations testées avec effet mesuré.
✅ Pistes de correction
Un bon travail : pipeline complet testé sur 40 questions; fuite de documents restreints mesurée à 0 grâce au filtre avant récupération; arbitrage entre documents contradictoires par date; vérificateur de citations qui rejette toute phrase absente du morceau; rapport avec échecs analysés (par exemple une question utilisant un synonyme absent du vocabulaire BM25, corrigée par un dictionnaire de synonymes ou la fusion vectorielle).
⚡ Quiz éclair (15 XP si 4/5 ou plus)
1. Le RAG consiste à :
- A. rechercher des passages pertinents dans vos documents et les fournir au modèle pour qu'il réponde à partir d'eux
- B. ré-entraîner le modèle à chaque question
- C. désactiver le modèle
2. Le MRR est :
- A. le nombre de documents
- B. la moyenne de 1/rang du premier résultat correct
- C. la longueur moyenne des réponses
3. Quand aucun extrait récupéré ne soutient la question, un bon système doit :
- A. inventer la réponse la plus plausible
- B. répondre quand même avec assurance
- C. refuser de répondre ou demander une précision
4. 🔁 Révision mission 03 : La fenêtre de contexte d'un modèle contient :
- A. l'entrée et la sortie, en jetons, avec une limite totale
- B. uniquement la question
- C. uniquement la réponse
5. 🔁 Révision mission 03 : Pour conserver un identifiant exact lors d'une compression d'historique, on :
- A. le fait résumer par le modèle
- B. l'épingle textuellement hors du résumé
- C. le supprime
✅ Réponses
- A.
- B.
- C.
- A.
- B.
🪞 Je réfléchis (10 XP)
- Dans ton organisation, quels documents contiennent la réponse à 80 % des questions répétitives, et sont-ils à jour ?
- Que ferait ton système si deux documents se contredisaient ?
🎒 À retenir
- RAG : découper, indexer, récupérer, assembler, générer avec citations.
- TF-IDF, BM25 (lexical), vecteurs (sémantique), RRF pour fusionner.
- Mesurer la récupération : rappel@k, MRR, sur un jeu d'évaluation.
- Réponse extractive avec citations vérifiables ; seuil de refus.
- Droits d'accès avant la récupération ; documents périmés ou contradictoires.
🏅 Récompenses
Total possible : 100 XP · 🏅 Badge Bibliothécaire de l'IA
← Mission 03 — Context engineering · Mission 05 — Tool use et MCP →
HEF-160 — IA et augmentation humaine

