Corrective RAG
Σε αυτήν τη σελίδα
Quand la récupération ne suffit pas
Le système RAG que vous avez construit repose sur une hypothèse implicite : les fragments les plus similaires à la question sont les bons. Cette hypothèse est souvent vraie, mais pas toujours. Interrogez votre index sur un sujet qu’il ne couvre pas, et FAISS renverra tout de même les cinq vecteurs les plus proches, peu importe leur hors-sujet — un moteur de similarité ne sait pas dire « je n’ai rien ». Le modèle reçoit alors un contexte inadapté, et comme l’invite lui demande de s’appuyer sur ce contexte, il produit une réponse qui semble authoritative mais sans fondement. C’est le scénario d’hallucination le plus insidieux, car la chaîne technique a fonctionné sans erreur.
Le Corrective RAG (CRAG) insère une étape d’évaluation entre la récupération et la génération. Un LLM examine chaque document récupéré et décide : pertinent ou non. Si le verdict est négatif, le système ne se contente pas de générer avec ce qu’il a — il bascule vers une recherche web pour trouver l’information manquante ailleurs, hors de votre corpus. Le flux comporte donc quatre étapes : récupération standard depuis le store vectoriel, notation de chaque document par rapport à la question, décision de déclencher une recherche web si au moins un document est jugé non pertinent, et enfin génération avec les meilleurs documents disponibles.
Le noteur de documents
Tout repose sur le noteur. L’astuce consiste à demander au LLM un jugement binaire au format JSON plutôt qu’une évaluation libre : {"score": "yes"} ou {"score": "no"}, rien d’autre. Le paramètre response_format={"type": "json_object"} garantit une sortie analysable, et temperature=0 élimine la variabilité — la même paire question/document doit toujours recevoir le même verdict, sinon le comportement de votre pipeline devient imprévisible.
from mistralai.client import Mistral
import json
client = Mistral(api_key=api_key)
def grade_document(question, document):
"""Evaluate whether a document is relevant to a question."""
prompt = f"""You are a relevance evaluator. Given a question
and a document, determine if the document contains relevant information
to answer the question.
Respond ONLY with a JSON object: {{"score": "yes"}} or {{"score": "no"}}
Question : {question}
Document : {document}
JSON Evaluation:"""
response = client.chat.complete(
model="mistral-large-latest",
messages=[{"role": "user", "content": prompt}],
temperature=0,
response_format={"type": "json_object"},
)
result = json.loads(response.choices[0].message.content)
return result.get("score", "no") == "yes"
# Test
question = "What are the steps of RAG?"
doc_pertinent = "RAG breaks down into retrieval, augmentation, and generation."
doc_non_pertinent = "The tiramisu recipe requires mascarpone."
print(grade_document(question, doc_pertinent)) # True
print(grade_document(question, doc_non_pertinent)) # False
Le test à la fin du bloc mérite attention. La recette de tiramisu illustre exactement ce que la similarité vectorielle laisse passer : si votre corpus ne parle que de cuisine et que vous l’interrogez sur le RAG, ce fragment se classera premier par manque de concurrence. Le noteur, en revanche, ne compare pas des vecteurs mais lit le contenu, et le rejette.
Appliqué à tous les fragments récupérés, ce jugement produit deux informations : la liste filtrée des documents à conserver, et un booléen indiquant s’il faut compléter par le web. Le seuil choisi ici est volontairement strict — un seul document écarté suffit à déclencher le repli, au motif que le contexte est alors incomplet.
def grade_documents(question, retrieved_chunks):
"""Evaluate and filter retrieved documents."""
relevant_docs = []
irrelevant_count = 0
for chunk in retrieved_chunks:
is_relevant = grade_document(question, chunk["text"])
if is_relevant:
relevant_docs.append(chunk)
else:
irrelevant_count += 1
need_web_search = irrelevant_count > 0
print(f" Relevant: {len(relevant_docs)}/{len(retrieved_chunks)}")
print(f" Web search needed: {need_web_search}")
return relevant_docs, need_web_search
Le filet de sécurité web
Quand les documents locaux ne suffisent pas, le système cherche ailleurs. Mistral fournit un outil intégré pour cela, web_search, que vous activez via l’API Conversations : le modèle lance lui-même la recherche, puis rédige sa réponse en citant ses sources. Ce détail compte car un simple appel client.chat.complete ne peut pas chercher sur le web : le modèle répondrait de mémoire, avec le risque d’inventer exactement ce que le CRAG cherche à éviter. Et depuis la version 3.0 du SDK, les complétions de chat rejettent effectivement l’outil web_search.
Le point clé de conception est le format de retour : la fonction renvoie une liste de dictionnaires de même forme que vos fragments locaux, avec un champ source défini à web_search, et ajoute les URL citées. Cette uniformité permet aux étapes suivantes d’ignorer totalement l’origine des documents tout en préservant la traçabilité pour l’utilisateur final.
def web_search_fallback(question):
"""Web search fallback when local documents are insufficient."""
response = client.beta.conversations.start(
model="mistral-medium-latest",
inputs=question,
instructions="Answer factually, relying on web search results.",
tools=[{"type": "web_search"}],
store=False, # no need to keep the conversation on Mistral's side
)
texte, urls = "", []
for entry in response.outputs:
if entry.type != "message.output":
continue # ignore the entry describing tool execution
if isinstance(entry.content, str):
texte += entry.content
continue
for chunk in entry.content:
if chunk.type == "text":
texte += chunk.text
elif chunk.type == "tool_reference" and chunk.url:
urls.append(chunk.url)
# Return as a "web" document, with cited sources
return [{
"text": texte,
"source": "web_search",
"urls": urls,
}]
La réponse contient deux types d’entrées : une entrée tool.execution, qui décrit la recherche lancée, et une entrée message.output, dont le contenu alterne fragments de texte et références (tool_reference) portant le titre et l’URL des pages consultées. Un administrateur d’organisation peut restreindre les domaines interrogés via une liste blanche ou noire ; les résultats filtrés disparaissent sans avertissement, donc une liste blanche trop étroite peut laisser la recherche sans aucun résultat.
Source officielle : Websearch (Documentation Mistral)
Le pipeline assemblé
La classe CorrectiveRAG reprend la structure du pipeline standard en y insérant la notation. La valeur par défaut k=4 est légèrement plus généreuse que les trois fragments habituels, ce qui a du sens : puisque le filtrage en écartera certains, mieux vaut partir avec une marge. La méthode ask orchestre les quatre étapes et affiche chacune d’elles, vous permettant de suivre le raisonnement du système en temps réel — combien de documents ont survécu à la notation, si le repli s’est déclenché. Le dictionnaire de retour expose aussi web_search_used : c’est un indicateur précieux à surveiller en production, car un taux d’usage web anormalement élevé ne signale pas un défaut du CRAG mais une lacune dans votre corpus.
class CorrectiveRAG:
"""Corrective RAG pipeline with evaluation and web fallback."""
def __init__(self, chunks, embeddings, index):
self.chunks = chunks
self.embeddings = embeddings
self.index = index
def retrieve(self, question, k=4):
"""Step 1: standard retrieval."""
response = client.embeddings.create(
model="mistral-embed",
inputs=[question],
)
query_vec = np.array([response.data[0].embedding], dtype=np.float32)
distances, indices = self.index.search(query_vec, k)
results = []
for dist, idx in zip(distances[0], indices[0]):
if idx >= 0:
results.append({
"text": self.chunks[idx]["text"],
"source": self.chunks[idx].get("source", "local"),
})
return results
def grade(self, question, documents):
"""Step 2: evaluate relevance."""
relevant = []
for doc in documents:
if grade_document(question, doc["text"]):
relevant.append(doc)
need_web = len(relevant) < len(documents)
return relevant, need_web
def generate(self, question, documents):
"""Step 3: generate the answer."""
context = "\n\n---\n\n".join([d["text"] for d in documents])
prompt = f"""Context :\n{context}\n\nQuestion : {question}"""
response = client.chat.complete(
model="mistral-large-latest",
messages=[
{"role": "system", "content": "Answer based on the context."},
{"role": "user", "content": prompt},
],
temperature=0.1,
)
return response.choices[0].message.content
def ask(self, question, k=4):
"""Full pipeline."""
print(f"\n=== Question : {question} ===")
# 1. Retrieval
print("1. Retrieval...")
docs = self.retrieve(question, k=k)
# 2. Grading
print("2. Grading...")
relevant_docs, need_web = self.grade(question, docs)
# 3. Web search fallback if needed
if need_web:
print("3. Fallback web search...")
web_docs = web_search_fallback(question)
relevant_docs.extend(web_docs)
# 4. Generation
print("4. Generation...")
answer = self.generate(question, relevant_docs)
return {
"answer": answer,
"sources_used": len(relevant_docs),
"web_search_used": need_web,
}
# Usage
crag = CorrectiveRAG(chunks, embeddings, index)
result = crag.ask("How does Mistral implement embeddings?")
print(f"\nAnswer : {result['answer']}")
print(f"Web search used : {result['web_search_used']}")
Cette fiabilité a un coût que vous devez accepter en toute connaissance de cause : avec k=4, chaque question déclenche quatre appels de notation avant même que la génération ne commence. La latence perçue par l’utilisateur augmente d’autant, tout comme la facture. L’arbitrage diffère selon le cas d’usage — pour un assistant juridique ou médical, la vérification est non négociable ; pour un moteur de recherche interne où l’utilisateur voit les sources et juge par lui-même, c’est moins critique.
Βασικά σημεία
- Le Corrective RAG ajoute une étape d’évaluation de la pertinence après la récupération
- Un LLM sert de « noteur » pour juger chaque document : pertinent ou non
- Si des documents sont jugés non pertinents, un repli vers la recherche web se déclenche
- Cette approche réduit significativement les hallucinations dues à un contexte inadapté
- La notation ajoute de la latence mais améliore fortement la fiabilité des réponses