Siirry pääsisältöön
Suomi— Valitse kieli
Valikko

Corrective RAG

Oppitunti 15 / 18 Päivitetty 2. marraskuuta 2026 Kehittäjä
Tällä sivulla
  1. Quand la récupération ne suffit pas
  2. Le noteur de documents
  3. Le filet de sécurité web
  4. Le pipeline assemblé
  5. Keskeiset asiat

Quand la récupération ne suffit pas

Le système RAG que tu as 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. Interroge ton 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 faire autorité mais n’a aucun 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 ailleurs l’information manquante dans ton 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 ton 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 ton corpus ne parle que de cuisine et que tu l’interroges 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 regarde ailleurs. Mistral fournit pour cela un outil intégré, web_search, que tu actives 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 ayant la même forme que tes 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 trace 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 de l’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, te 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 ton 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 tu dois 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.

Keskeiset asiat

  • 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