Salt la conținutul principal
Română— Alege o limbă
Meniu

Self-RAG

Lecția 16 din 18 Actualizată 2 noiembrie 2026 Dezvoltator
Pe această pagină
  1. Auto-réflexion dans le RAG
  2. Vérification de l’ancrage factuel
  3. Vérification de l’utilité
  4. La boucle d’auto-correction
  5. Le coût de la fiabilité
  6. Puncte cheie

Auto-réflexion dans le RAG

Le RAG correctif contrôle ce qui entre dans le prompt, mais pas ce qui en sort. Même un contexte parfait ne garantit pas une bonne réponse : le modèle peut ajouter des détails absents des documents ou produire un texte exact qui élude la question posée. Self-RAG (RAG auto-réflexif) comble cette lacune en ajoutant deux vérifications après la génération. La première examine l’ancrage factuel : la réponse s’appuie-t-elle réellement sur les documents fournis ? La seconde examine l’utilité : répond-elle vraiment à la question ? Si l’une de ces vérifications échoue, le système boucle et réessaie, faisant de ce mécanisme une auto-correction plutôt qu’un simple filtre.

Le flux étend donc le RAG correctif. Vous conservez la récupération suivie de l’évaluation des documents, puis la génération. Deux nouveaux nœuds s’ajoutent ensuite : la vérification d’hallucination, qui compare la réponse aux documents, et la vérification de la réponse, qui la compare à la question. Si une vérification échoue, le système retourne soit à la génération, soit récupère de nouveaux éléments sur le web, selon le type d’échec.

Vérification de l’ancrage factuel

Le premier vérificateur reçoit deux entrées : les documents concaténés et la réponse générée. Sa tâche n’est pas de juger si la réponse est vraie dans l’absolu, mais si elle est entièrement ancrée dans ce qui lui a été fourni. Cette distinction est cruciale : une affirmation exacte absente des documents doit être rejetée car elle provient de la mémoire d’entraînement du modèle, non de votre corpus, et rien ne garantit que l’affirmation suivante sera exacte. Le format de sortie correspond à celui de l’évaluateur : un objet JSON binaire à température zéro.

import json
from mistralai.client import Mistral

client = Mistral(api_key=api_key)

def check_hallucination(documents, generation):
    """Check whether the generation is grounded in the documents."""
    docs_text = "\n\n".join([d["text"] for d in documents])

    prompt = f"""You are a factual grounding evaluator. Given a set of
documents and a generated answer, determine whether the answer is entirely
grounded in the information contained in the documents.

Respond ONLY with a JSON object: {{"grounded": "yes"}} or {{"grounded": "no"}}

Documents:
{docs_text}

Generated answer:
{generation}

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("grounded", "no") == "yes"

Vérification de l’utilité

Le second vérificateur ne voit ni les documents ni les résultats de la récupération, mais uniquement la question et la réponse. Ce champ de vision restreint est délibéré car il isole un défaut que le premier vérificateur laisse passer. Imaginez que l’on demande combien de dimensions produit un modèle d’embeddings, et que la réponse décrive longuement l’usage des embeddings sans jamais donner le nombre. Tout est ancré dans les documents, donc le premier vérificateur répond « oui », et l’utilisateur repart sans son information. Le second vérificateur répond « non » et déclenche une nouvelle tentative.

def check_answer_usefulness(question, generation):
    """Check whether the answer actually addresses the question."""
    prompt = f"""You are an answer quality evaluator. Given a question
and an answer, determine whether the answer usefully and completely addresses the question.

Respond ONLY with a JSON object: {{"useful": "yes"}} or {{"useful": "no"}}

Question: {question}
Answer: {generation}

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("useful", "no") == "yes"

La boucle d’auto-correction

La classe SelfRAG réutilise les étapes familières de récupération et d’évaluation, puis les englobe dans une boucle de réessai limitée par max_retries. La logique de la boucle est plus subtile qu’il n’y paraît car les deux types d’échec reçoivent un traitement différent. Une hallucination détectée entraîne simplement une régénération avec le même contexte : le problème vient du modèle, qui a dépassé les bornes, et un nouveau tirage suffit souvent. Une réponse jugée inutile déclenche en revanche une recherche web supplémentaire avant de réessayer : ici, le problème vient du contexte, trop mince pour soutenir une réponse complète, et régénérer sans rien ajouter donnerait le même résultat.

Notez la sortie de secours après la boucle. Lorsque toutes les tentatives sont épuisées, le système ne lève pas d’exception : il renvoie la dernière génération accompagnée de ses drapeaux grounded et useful. C’est un choix de conception délibéré : mieux vaut renvoyer une réponse imparfaite étiquetée comme telle, que votre interface peut signaler à l’utilisateur, que de lancer une erreur brute.

import numpy as np

class SelfRAG:
    """Self-RAG pipeline with self-correction."""

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

    def retrieve(self, question, k=4):
        """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)

        return [
            {"text": self.chunks[idx]["text"], "source": self.chunks[idx].get("source", "")}
            for dist, idx in zip(distances[0], indices[0]) if idx >= 0
        ]

    def grade_documents(self, question, documents):
        """Evaluate document relevance."""
        relevant = []
        for doc in documents:
            if grade_document(question, doc["text"]):
                relevant.append(doc)
        return relevant, len(relevant) < len(documents)

    def generate(self, question, documents):
        """Generate an 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": "user", "content": prompt}],
            temperature=0.2,
        )
        return response.choices[0].message.content

    def ask(self, question, k=4):
        """Complete Self-RAG pipeline with self-correction."""
        print(f"\n=== Self-RAG: {question[:60]}... ===")

        # 1. Retrieval
        print("1. Retrieval...")
        docs = self.retrieve(question, k=k)

        # 2. Grading
        print("2. Grading documents...")
        relevant_docs, need_web = self.grade_documents(question, docs)

        if need_web:
            print("   -> Fallback web search")
            web_docs = web_search_fallback(question)
            relevant_docs.extend(web_docs)

        # 3. Generation loop with self-correction
        for attempt in range(self.max_retries + 1):
            print(f"3. Generation (attempt {attempt + 1})...")
            generation = self.generate(question, relevant_docs)

            # 4. Hallucination check
            print("4. Checking hallucinations...")
            is_grounded = check_hallucination(relevant_docs, generation)

            if not is_grounded:
                print("   -> HALLUCINATION detected, retrying...")
                continue

            # 5. Usefulness check
            print("5. Checking usefulness...")
            is_useful = check_answer_usefulness(question, generation)

            if not is_useful:
                print("   -> Answer NOT USEFUL, fallback web search...")
                web_docs = web_search_fallback(question)
                relevant_docs.extend(web_docs)
                continue

            # Success
            print("   -> Answer validated!")
            return {
                "answer": generation,
                "attempts": attempt + 1,
                "grounded": True,
                "useful": True,
            }

        # If all attempts fail
        print("   -> Maximum attempts reached")
        return {
            "answer": generation,
            "attempts": self.max_retries + 1,
            "grounded": is_grounded,
            "useful": is_useful,
        }

# Usage
self_rag = SelfRAG(chunks, embeddings, index, max_retries=2)
result = self_rag.ask("What are the advantages of RAG over fine-tuning?")

print(f"\nAnswer: {result['answer']}")
print(f"Attempts: {result['attempts']}")
print(f"Grounded: {result['grounded']}, Useful: {result['useful']}")

Le coût de la fiabilité

Chaque garde-fou ajoute un appel LLM supplémentaire, et le total augmente rapidement. La fonction ci-dessous le rend explicite en détaillant les appels par étape : un appel d’évaluation par document, puis la génération, la vérification d’ancrage et la vérification d’utilité, chacun répété à chaque réessai. Avec quatre documents et un seul réessai, vous atteignez dix appels pour une seule question, là où le RAG de base en nécessitait deux. Exécutez cette estimation avec vos propres valeurs avant de définir k et max_retries : ce calcul vous indique si votre budget et vos exigences de latence permettent d’utiliser Self-RAG sur tout le trafic, ou seulement pour les questions les plus sensibles.

def estimate_self_rag_cost(n_docs=4, n_retries=1):
    """Estimate the number of LLM calls for a Self-RAG question."""
    calls = {
        "grading": n_docs,           # 1 call per document
        "generation": 1 + n_retries, # 1 initial + retries
        "hallucination_check": 1 + n_retries,
        "answer_check": 1 + n_retries,
    }
    total = sum(calls.values())
    print(f"Estimated LLM calls: {total}")
    for step, count in calls.items():
        print(f"  {step}: {count}")
    return total

estimate_self_rag_cost(n_docs=4, n_retries=1)
# Estimated LLM calls: 10

Puncte cheie

  • Self-RAG ajoute deux vérifications post-génération : hallucinations et utilité
  • Si la réponse n’est pas ancrée dans les documents, le système régénère
  • Si la réponse n’est pas utile, le système effectue une recherche web et réessaie
  • Le nombre de réessais doit être limité pour maîtriser la latence
  • Self-RAG est plus coûteux (plus d’appels LLM) mais plus fiable