Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Corrective RAG

Lekce 15 z 18 Aktualizováno 2. listopadu 2026 Vývojář
Na této stránce
  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. Klíčové poznatky

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 autoritaire 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 l’information manquante ailleurs que 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):
    """Évalue si un document est pertinent pour une 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 du 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):
    """Évalue et filtre les documents récupérés."""
    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 un outil intégré pour cela, 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 structure 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):
    """Repli sur la recherche web quand les documents locaux sont insuffisants."""
    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,  # pas besoin de garder la conversation côté Mistral
    )

    texte, urls = "", []
    for entry in response.outputs:
        if entry.type != "message.output":
            continue  # ignore l'entrée décrivant l'exécution de l'outil
        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)

    # Retourne comme un document "web", avec les sources citées
    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’utilisation du web anormalement élevé ne signale pas un défaut du CRAG mais une lacune dans ton corpus.

class CorrectiveRAG:
    """Pipeline Corrective RAG avec évaluation et repli web."""

    def __init__(self, chunks, embeddings, index):
        self.chunks = chunks
        self.embeddings = embeddings
        self.index = index

    def retrieve(self, question, k=4):
        """Étape 1 : récupération standard."""
        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):
        """Étape 2 : évaluer la pertinence."""
        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):
        """Étape 3 : générer la réponse."""
        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):
        """Pipeline complet."""
        print(f"\n=== Question : {question} ===")

        # 1. Récupération
        print("1. Retrieval...")
        docs = self.retrieve(question, k=k)

        # 2. Notation
        print("2. Grading...")
        relevant_docs, need_web = self.grade(question, docs)

        # 3. Repli recherche web si nécessaire
        if need_web:
            print("3. Fallback web search...")
            web_docs = web_search_fallback(question)
            relevant_docs.extend(web_docs)

        # 4. Génération
        print("4. Generation...")
        answer = self.generate(question, relevant_docs)

        return {
            "answer": answer,
            "sources_used": len(relevant_docs),
            "web_search_used": need_web,
        }

# Utilisation
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.

Klíčové poznatky

  • Le Corrective RAG ajoute une étape d’évaluation de 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