Guide pratique de l'évaluation des RAG : du golden set au garde-fou CI
Intervalle de confiance, échantillonnage stratifié, baseline versionnée, gate CI : la méthode complète pour transformer tes traces de production en évaluation qui décide.
Ton faithfulness tombe de 0,83 à 0,77 après une refonte du chunking et tu annules la mise en production. Sur 30 questions, cet écart ne mesure rien : les deux intervalles de confiance se chevauchent. Le guide précédent du blog t'a montré comment calculer les métriques d'un RAG (Bien démarrer avec les RAG evaluation) ; ici, on industrialise : golden set tiré des traces, harnais versionné, seuils défendables et CI qui ne bloque que les vraies régressions.
Le but n'est pas d'ajouter des métriques, mais de prendre des décisions. Chaque étape ci-dessous est livrée avec le code ou la commande qui va avec.
Un jeu de 30 questions ne mesure rien
Prends un critère binaire par question (réponse fidèle au contexte, oui ou non) et regarde ce que ta taille d'échantillon autorise à conclure.
| Taille du jeu | IC 95 % autour de 80 % | Écart détectable |
|---|---|---|
| 30 items | 0,63 – 0,90 (±14 pts) | aucun, tu lis du bruit |
| 50 items | 0,67 – 0,89 (±11 pts) | environ 25 points |
| 100 items | 0,71 – 0,87 (±8 pts) | environ 18 points |
| 200 items | 0,74 – 0,85 (±5,5 pts) | environ 10 points, si tu apparies |
| 300 items | 0,75 – 0,84 (±4,5 pts) | environ 8 points |
| 1 000 items | 0,77 – 0,82 (±2,5 pts) | environ 5 points |
Ces bornes se calculent en dix lignes, et ça t'évite un comité de revue de deux heures sur un faux positif.
from math import sqrt
Z = 1.959964 # 95 %
def wilson(k, n, z=Z):
"""Intervalle de confiance du taux de réussite k/n."""
p = k / n
d = 1 + z * z / n
centre = (p + z * z / (2 * n)) / d
demi = (z / d) * sqrt(p * (1 - p) / n + z * z / (4 * n * n))
return round(centre - demi, 3), round(centre + demi, 3)
print(wilson(24, 30)) # la veille : (0.63, 0.90)
print(wilson(23, 30)) # la nuit : (0.59, 0.88)
Les deux mesures qui ont déclenché l'alerte se chevauchent presque entièrement : 25/30 puis 23/30. Tu n'as aucune preuve de régression, juste une variance normale.
Deux garde-fous pour la suite. Si ta métrique est un score continu, l'intervalle de Wilson ne s'applique pas : fais un bootstrap sur les items (1 000 rééchantillonnages de tes scores) pour obtenir l'incertitude. Et compare toujours les mêmes items avant/après : un test apparié (McNemar sur du binaire, bootstrap des différences sur du continu) détecte des écarts de 4 à 5 points là où deux intervalles comparés côte à côte ne voient rien.
Étape 1 — Fabrique ton golden set à partir des traces réelles
Un jeu de test écrit depuis la documentation ne teste que les questions que tu connais déjà. Loggue la production : requête, contexte récupéré, réponse, latence, version du prompt.
import json, time
from pathlib import Path
TRACE = Path("traces/2026-10.jsonl")
def log_run(query, contexts, answer, latency_ms, prompt_version="v7"):
rec = {
"ts": time.time(),
"query": query,
"contexts": contexts, # liste de chunks récupérés
"answer": answer,
"latency_ms": latency_ms,
"prompt_version": prompt_version,
}
with TRACE.open("a") as f:
f.write(json.dumps(rec, ensure_ascii=False) + "\n")
Ensuite, échantillonne par cluster plutôt qu'au hasard. Sur un mois d'audit, 4 000 requêtes contenaient 900 quasi-doublons sémantiques : un tirage aléatoire de 200 items ne donnait que 3 questions sur la facturation, alors que ce sujet pèse 22 % du volume réel.
import json, random
from collections import defaultdict
with open("traces/2026-10.jsonl") as f:
runs = [json.loads(l) for l in f]
# "cluster" est un libellé d'intention posé par un classifieur simple
par_cluster = defaultdict(list)
for r in runs:
par_cluster[r.get("cluster", "autre")].append(r)
N = 200
echantillon = []
for cluster, items in par_cluster.items():
part = max(10, round(N * len(items) / len(runs))) # plancher de 10 par cluster
echantillon += random.sample(items, min(part, len(items)))
print(len(echantillon), [len(v) for v in par_cluster.values()])
Pour annoter, une grille de quatre niveaux (faux, partiel, correct, exemplaire) et deux annotateurs sur 50 items afin de mesurer l'accord. Avec un kappa de Cohen inférieur à 0,6, la grille est floue : réécris-la avant d'annoter 200 items pour rien.
Étape 2 — Complète en synthétique, annote 30 % à la main
RAGAS génère des questions depuis ton corpus, sous forme de graphe de connaissances, puis des requêtes à un ou plusieurs sauts.
from langchain_openai import ChatOpenAI
from ragas.llms import LangchainLLMWrapper
from ragas.embeddings import OpenAIEmbeddings
from ragas.testset import TestsetGenerator
from ragas.testset.synthesizers import default_query_distribution
import openai
llm = LangchainLLMWrapper(ChatOpenAI(model="gpt-4o"))
embeddings = OpenAIEmbeddings(client=openai.OpenAI())
generator = TestsetGenerator(llm=llm, embedding_model=embeddings)
distribution = default_query_distribution(llm) # 50 % mono-saut, 50 % multi-sauts
testset = generator.generate(testset_size=80, query_distribution=distribution)
testset.to_pandas().to_json("testset_synthetique.jsonl", orient="records", lines=True)
Le piège classique : ces questions sont écrites par un modèle, parfois celui qui répond ou qui juge. Elles mesurent la couverture du corpus, pas la valeur métier de ta réponse.
Fais relire 30 % du testset par une personne qui parle aux utilisateurs (support, PO, commercial). Sur les 80 questions d'un run précédent, 12 portaient sur des documents obsolètes et 5 reposaient sur un tableau dont la question était indéductible. Sans relecture, ces 17 items injectaient 20 % de faux échecs dans tes scores.
Étape 3 — Mesure la récupération avant d'appeler un juge
Le retrieval ne consomme aucun appel LLM et explique la majorité des régressions. Deux métriques suffisent : le recall@k sur les passages annotés comme pertinents, et le MRR.
def recall_at_k(predits, pertinents, k=5):
top = set(predits[:k])
return len(top & set(pertinents)) / len(pertinents)
def mrr(predits, pertinents):
for i, doc_id in enumerate(predits, start=1):
if doc_id in pertinents:
return 1 / i
return 0.0
# un item du golden set retrieval
item = {"pertinents": ["doc-118", "doc-204"],
"predits": ["doc-118", "doc-77", "doc-204", "doc-3"]}
print(recall_at_k(item["predits"], item["pertinents"]), mrr(item["predits"], item["pertinents"]))
# 1.0 1.0
Exemple concret : recall@5 à 0,68 avant refonte du découpage, 0,81 après (chunks de 512 à 256 tokens avec 64 de chevauchement). Le faithfulness, lui, n'a pas bougé d'un point : tu aurais optimisé la mauvaise couche si tu n'avais regardé que la génération.
Ne conclus pas trop vite en empilant des documents. Le travail sur le positionnement dans le contexte (Lost in the Middle, Liu et al.) montre que les modèles exploitent surtout le début et la fin du contexte : passer de k=5 à k=20 dégrade souvent la précision et double le coût de l'appel.
Pour situer tes chiffres face à l'état de l'art, la campagne TREC RAG publie ses jeux de tests et ses jugements humains. C'est le meilleur garde-fou contre un recall@5 de 0,4 que tout le monde trouve « normal » en interne.
Étape 4 — Passe la génération au juge, avec RAGAS
Tu branches les métriques de génération sur le même jeu, en gardant la réponse de référence là où la métrique l'exige.
from langchain_openai import ChatOpenAI
from ragas import EvaluationDataset, evaluate
from ragas.llms import LangchainLLMWrapper
from ragas.metrics import LLMContextRecall, Faithfulness, FactualCorrectness
juge = LangchainLLMWrapper(ChatOpenAI(model="gpt-4.1-mini"))
dataset = EvaluationDataset.from_list([
{
"user_input": t["query"],
"retrieved_contexts": t["contexts"],
"response": t["answer"],
"reference": t["golden_answer"],
}
for t in echantillon
])
resultat = evaluate(
dataset=dataset,
metrics=[LLMContextRecall(), Faithfulness(), FactualCorrectness()],
llm=juge,
)
print(resultat)
# {'context_recall': 0.9100, 'faithfulness': 0.8571, 'factual_correctness': 0.7280}
Les noms et signatures viennent de la documentation RAGAS : vérifie-les à chaque montée de version, l'API a bougé entre les séries 0.2 et 0.3. Trois métriques, pas dix. Au-delà, tu dilues le signal et tu paies des appels de juge qui ne changeront aucune décision.
Faithfulness compare la réponse au contexte récupéré et tourne sans réponse de référence : c'est la seule des trois que tu peux lancer telle quelle sur les traces de production. Les deux autres ont besoin du golden answer, donc d'un jeu figé et versionné.
Ordre de grandeur de la facture : 200 items multipliés par 3 métriques, c'est environ 600 appels au juge. À 2 500 tokens par appel, tu es autour de 1,5 million de tokens par run complet, dominés par le juge et non par ton système.
Étape 5 — Des seuils qui ne clignotent pas
Un seuil fixe du type « faithfulness sous 0,8, build rouge » sonne à chaque fluctuation d'échantillonnage. Versionne une baseline (le fichier evals/baseline.json, commité à côté du code) et calcule la tolérance à partir de l'incertitude de mesure.
{
"commit": "9f2c1ab",
"n": 200,
"faithfulness": 0.86,
"context_recall": 0.91,
"factual_correctness": 0.74,
"recall_at_5": 0.81,
"ci_demi_largeur": 0.055
}
import json
SENS = {"faithfulness": -1, "context_recall": -1, "recall_at_5": -1}
def gate(courant, baseline, facteur=1.2):
tolerance = baseline["ci_demi_largeur"] * facteur
alertes = []
for metrique, sens in SENS.items():
delta = courant[metrique] - baseline[metrique]
if sens * delta < -tolerance:
alertes.append((metrique, round(delta, 3), round(tolerance, 3)))
return alertes # liste vide = build vert
alertes = gate({"faithfulness": 0.79, "context_recall": 0.90, "recall_at_5": 0.80},
json.load(open("evals/baseline.json")))
print(alertes) # [('faithfulness', -0.07, 0.066)]
Règle que j'applique : tolérance égale à la demi-largeur d'intervalle du run, majorée de 20 % pour absorber la variabilité du juge. Une alerte ne devient une régression qu'après deux runs consécutifs, et toujours à taille d'échantillon constante.
Exemple concret : recall@5 stable (0,81 puis 0,80), faithfulness de 0,86 à 0,79, soit -0,07 pour une tolérance de 0,066. Un second run a confirmé la baisse, causée par un changement de prompt système qui faisait ignorer le troisième document récupéré. C'est exactement le genre de bug que la moyenne mensuelle ne voit jamais.
Étape 6 — Le garde-fou dans la CI
Deux jobs, deux budgets. Le job rapide tourne sur chaque merge request avec un sous-échantillon de 50 items sur la récupération. Le run complet passe la nuit sur les 200 items.
# .github/workflows/rag-eval.yml
name: rag-eval
on: [pull_request]
jobs:
retrieval:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: actions/setup-python@v5
with:
python-version: "3.12"
- run: pip install -r requirements.txt
- run: python evals/retrieval.py --dataset evals/golden/retrieval.jsonl --min-recall 0.75
- run: python evals/ragas_gate.py --dataset evals/golden/rag.jsonl --sample 50 --baseline evals/baseline.json
- run: npx promptfoo@latest eval -c evals/promptfoo.yaml --no-progress-bar
Pour les assertions de contexte sans écrire une ligne de Python, promptfoo couvre la fidélité au contexte, le recall et la pertinence avec un seuil en YAML (guide RAG).
# evals/promptfoo.yaml
prompts:
- file://prompts/rag.txt
providers:
- id: file://rag_provider.py # appelle ton vrai pipeline
tests:
- vars:
query: "Quel est le délai de rétractation ?"
context: "Le délai de rétractation est de 14 jours à compter de la livraison."
assert:
- type: context-faithfulness
threshold: 0.9
- type: context-relevance
threshold: 0.7
- type: context-recall
value: "Le délai de rétractation est de 14 jours à compter de la livraison."
threshold: 1.0
Le job rapide doit rendre son verdict en moins de trois minutes. Passé ce délai, l'équipe finit par le désactiver, et un garde-fou désactivé ne protège plus personne.
Cinq erreurs qui rendent une évaluation inutile
- Faire écrire le jeu de test par le modèle qui produit les réponses : tu mesures sa capacité à répondre à ses propres questions.
- Utiliser un juge non calibré : compare son verdict à celui d'un humain sur 50 réponses annotées. En dessous de 80 % d'accord, change de modèle de juge ou précise la rubric.
- Mesurer la forme : longueur de réponse, présence de citations, ton commercial. Ça passe tous les gates et ne dit rien sur le fond.
- Recopier des seuils : 0,8 de faithfulness ne veut pas dire la même chose sur un RAG juridique et sur une FAQ produit. Mesure ta baseline avant de fixer un chiffre.
- Laisser le golden set vieillir : ajoute chaque mois 20 % de questions issues des nouvelles traces, sinon tu surveilles un produit qui n'existe plus.
FAQ
Faut-il annoter 200 questions à la main ?
Non. 60 à 80 items annotés par des humains suffisent pour la référence, complétés par du synthétique relu et un sous-échantillon mensuel des traces. Ce qui compte, c'est la stabilité de la baseline, pas le volume brut.
RAGAS ou promptfoo ?
Les deux, pour deux usages. RAGAS pour les métriques de fidélité et de rappel de contexte dans ta CI Python, promptfoo pour tester le prompt et le modèle de bout en bout avec des seuils YAML. Les deux acceptent un provider maison qui appelle ton pipeline réel.
Le juge est-il fiable en français ?
Oui, à condition de le calibrer sur tes données plutôt que de le croire sur parole. Sur un échantillon de 50 réponses annotées manuellement, tu vérifies l'accord juge/humain ; une rubric explicite fait monter cet accord plus sûrement qu'un passage à un modèle plus gros.
Combien de métriques afficher sur le tableau de bord ?
Quatre au maximum : le recall@5 de la récupération, le faithfulness, le rappel de contexte et une métrique maison qui compte pour ton métier. Au-delà, personne ne regarde plus le tableau.
Ce que je mets en place lundi matin
- Logguer 100 % des requêtes avec contexte et réponse : trente lignes de Python, aucune infrastructure.
- Échantillonner 200 items stratifiés, faire annoter 50 par deux personnes pour mesurer l'accord, puis figer le golden set.
- Écrire evals/baseline.json et le script retrieval.py qui tourne en deux secondes sur chaque merge request.
- Brancher le run RAGAS nocturne, avec alerte seulement après deux baisses consécutives au-delà de la tolérance.
Si ton RAG tourne déjà en production, la première brique utile n'est pas un framework d'évaluation, c'est le fichier de traces. Tout le reste s'y branche, y compris le suivi de ta couche de récupération.