Ir para o conteúdo principal
Português— Escolher um idioma
Menu

Self-RAG

Aula 16 de 18 Atualizada a 2 de novembro de 2026 Programador
Nesta página
  1. Autorreflexão no RAG
  2. Verificação da Fundamentação Factual
  3. Verificação da Utilidade
  4. O Ciclo de Autocorreção
  5. O Custo da Fiabilidade
  6. Pontos-chave

Autorreflexão no RAG

O Corrective RAG controla o que entra no prompt, mas não o que sai. Mesmo com um contexto perfeito, não há garantia de uma boa resposta: o modelo pode adicionar detalhes que não existem nos documentos ou produzir um texto preciso que, no entanto, desvia da pergunta real. O Self-RAG (RAG Autorreflexivo) colmata esta lacuna adicionando duas verificações após a geração. A primeira examina a fundamentação factual — a resposta baseia-se efetivamente nos documentos fornecidos? A segunda examina a utilidade — responde verdadeiramente ao que foi perguntado? Se alguma verificação falhar, o sistema reinicia o ciclo, tornando-se um mecanismo de autocorreção em vez de um simples filtro.

O fluxo estende, portanto, o Corrective RAG. Continua a ter a recuperação seguida da classificação dos documentos e, depois, a geração. Seguem-se dois novos nós: a verificação de alucinações, que compara a resposta com os documentos, e a verificação da resposta, que a compara com a pergunta. Se uma verificação falhar, o sistema regressa à geração ou busca novo material na web, dependendo de qual verificação falhou.

Verificação da Fundamentação Factual

O primeiro verificador recebe duas entradas: os documentos concatenados e a resposta gerada. A sua função não é julgar se a resposta é verdadeira em termos absolutos, mas se está totalmente fundamentada no que lhe foi fornecido. Esta distinção é crucial: uma afirmação precisa que não conste dos documentos deve ser rejeitada, pois provém da memória de treino do modelo, não do seu corpus — e não há garantia de que a próxima afirmação seja precisa. O formato de saída corresponde ao do classificador: um objeto JSON binário com temperatura zero.

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"

Verificação da Utilidade

O segundo verificador não vê nem os documentos nem os resultados da recuperação — apenas a pergunta e a resposta. Este campo de visão restrito é deliberado, pois isola uma falha que o primeiro verificador deixa passar. Imagine que alguém pergunta quantas dimensões produz um modelo de embeddings e a resposta descreve longamente para que servem os embeddings sem nunca indicar o número. Tudo está fundamentado nos documentos, pelo que o primeiro verificador diz «sim», e o utilizador fica sem a sua informação. O segundo verificador diz «não» e desencadeia outra tentativa.

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"

O Ciclo de Autocorreção

A classe SelfRAG reutiliza as etapas familiares de recuperação e classificação, envolvendo-as depois num ciclo de repetição limitado por max_retries. A lógica do ciclo é mais subtil do que parece, pois os dois tipos de falha recebem tratamentos diferentes. Uma alucinação detetada simplesmente regenera a resposta com o mesmo contexto: o problema reside no modelo, que foi demasiado longe, e uma nova tentativa costuma ser suficiente. Uma resposta julgada inútil, no entanto, desencadeia uma pesquisa adicional na web antes de repetir: aqui o problema reside no contexto, que é demasiado ténue para suportar uma resposta completa, e regenerar sem adicionar nada produziria o mesmo resultado.

Note a saída de contingência após o ciclo. Quando todas as tentativas se esgotam, o sistema não lança uma exceção: devolve a última geração juntamente com as suas flags grounded e useful. Esta é uma escolha de desenho deliberada — é preferível devolver uma resposta imperfeita assim assinalada, para que a sua interface a possa sinalizar ao utilizador, do que lançar um erro bruto.

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']}")

O Custo da Fiabilidade

Cada salvaguarda adiciona outra chamada ao LLM, e o total acumula-se rapidamente. A função abaixo torna isto explícito, decompondo as chamadas por etapa: uma chamada de classificação por documento, depois geração, verificação de fundamentação e verificação de utilidade, cada uma repetida em cada nova tentativa. Com quatro documentos e uma única repetição, chega a dez chamadas para uma única pergunta — quando o RAG básico exigia duas. Execute esta estimativa com os seus próprios valores antes de definir k e max_retries: este cálculo indica-lhe se o seu orçamento e requisitos de latência suportam o Self-RAG para todo o tráfego ou apenas para as perguntas mais sensíveis.

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

Pontos-chave

  • O Self-RAG adiciona duas verificações pós-geração: alucinações e utilidade
  • Se a resposta não estiver fundamentada nos documentos, o sistema regenera-a
  • Se a resposta não for útil, o sistema realiza uma pesquisa na web e tenta novamente
  • O número de repetições deve ser limitado para controlar a latência
  • O Self-RAG é mais dispendioso (mais chamadas ao LLM), mas mais fiável