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

RAG Corretivo

Aula 15 de 18 Atualizada a 2 de novembro de 2026 Programador
Nesta página
  1. Quando a recuperação não é suficiente
  2. O classificador de documentos
  3. A rede de segurança da web
  4. O pipeline montado
  5. Pontos-chave

Quando a recuperação não é suficiente

O sistema RAG que construiu assenta numa premissa implícita: os fragmentos mais semelhantes à pergunta são os corretos. Esta premissa é frequentemente válida, mas nem sempre. Se consultar o seu índice sobre um tema que este não cobre, o FAISS devolverá ainda assim os cinco vetores mais próximos, independentemente de quão fora de contexto estejam — um motor de similaridade não sabe dizer «não tenho nada». O modelo recebe então um contexto inadequado e, como o prompt lhe pede para se basear nesse contexto, produz uma resposta com aparência de autoridade, mas sem fundamento. Este é o cenário de alucinação mais insidioso, pois a cadeia técnica funcionou sem erros.

O RAG Corretivo (CRAG) insere uma etapa de avaliação entre a recuperação e a geração. Um LLM examina cada documento recuperado e decide: relevante ou não. Se o veredito for negativo, o sistema não se limita a gerar com o que tem; ativa uma pesquisa na web para encontrar a informação em falta no seu corpus noutro local. O fluxo tem, portanto, quatro fases: recuperação padrão na loja de vetores, classificação de cada documento face à pergunta, decisão de ativar uma pesquisa na web se pelo menos um documento for considerado irrelevante e, finalmente, geração com os melhores documentos disponíveis.

O classificador de documentos

Tudo depende do classificador. O truque consiste em pedir ao LLM um julgamento binário em formato JSON, em vez de uma avaliação em texto livre: {"score": "yes"} ou {"score": "no"}, nada mais. O parâmetro response_format={"type": "json_object"} garante um resultado analisável e temperature=0 elimina a variabilidade: o mesmo par pergunta/documento deve receber sempre o mesmo veredito, caso contrário o comportamento do seu pipeline torna-se irreproduzível.

from mistralai.client import Mistral
import json

client = Mistral(api_key=api_key)

def grade_document(question, document):
    """Avalia se um documento é relevante para uma pergunta."""
    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"

# Teste
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

O teste no final do bloco merece atenção. A receita de tiramisu ilustra exatamente o que a similaridade de vetores deixa passar: se o seu corpus falar apenas de cozinha e o consultar sobre RAG, este fragmento ficará em primeiro lugar por falta de concorrência. O classificador, no entanto, não compara vetores, mas lê o conteúdo e rejeita-o.

Aplicado a todos os fragmentos recuperados, este julgamento produz duas informações: a lista filtrada de documentos a manter e um booleano que indica se é necessário complementar com a web. O limiar escolhido aqui é deliberadamente rigoroso: um único documento descartado é suficiente para ativar o mecanismo de fallback, com o fundamento de que o contexto fica então incompleto.

def grade_documents(question, retrieved_chunks):
    """Avalia e filtra documentos recuperados."""
    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

A rede de segurança da web

Quando os documentos locais não são suficientes, o sistema procura noutro local. A Mistral fornece uma ferramenta integrada para o efeito, web_search, que ativa através da API Conversations: o modelo executa a pesquisa e redige a sua resposta citando as fontes. Este detalhe é importante porque uma simples chamada client.chat.complete não pode pesquisar na web: o modelo responderia de memória, com o risco de inventar exatamente o que o CRAG procura evitar. Além disso, desde a versão 3.0 do SDK, as conclusões de chat rejeitam efetivamente a ferramenta web_search.

O ponto chave do design é o formato de retorno: a função devolve uma lista de dicionários com a mesma estrutura dos seus fragmentos locais, com um campo source definido como web_search, e adiciona os URLs citados. Esta uniformidade permite que as etapas seguintes ignorem completamente a origem dos documentos, preservando ao mesmo tempo o rasto para o utilizador final.

def web_search_fallback(question):
    """Fallback de pesquisa na web quando os documentos locais são insuficientes."""
    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,  # não é necessário manter a conversa no lado da Mistral
    )

    texte, urls = "", []
    for entry in response.outputs:
        if entry.type != "message.output":
            continue  # ignora a entrada que descreve a execução da ferramenta
        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)

    # Devolve como um documento "web", com fontes citadas
    return [{
        "text": texte,
        "source": "web_search",
        "urls": urls,
    }]

A resposta contém dois tipos de entradas: uma entrada tool.execution, que descreve a pesquisa lançada, e uma entrada message.output, cujo conteúdo alterna fragmentos de texto e referências (tool_reference) que contêm o título e o URL das páginas consultadas. Um administrador da organização pode restringir os domínios consultados através de uma lista de permissões (allowlist) ou de bloqueio (blocklist); os resultados filtrados desaparecem sem aviso, pelo que uma lista de permissões demasiado restritiva pode deixar a pesquisa sem resultados.

Fonte oficial: Websearch (documentação da Mistral)

O pipeline montado

A classe CorrectiveRAG retoma a estrutura do pipeline padrão, inserindo a classificação. O valor padrão k=4 é ligeiramente mais generoso do que os habituais três fragmentos, o que faz sentido: como a filtragem descartará alguns, é melhor começar com uma margem. O método ask orquestra as quatro fases e exibe cada uma delas, permitindo-lhe acompanhar o raciocínio do sistema em tempo real — quantos documentos sobreviveram à classificação, se o fallback foi ativado. O dicionário de retorno também expõe web_search_used: este é um indicador valioso para monitorizar em produção, pois uma taxa de utilização da web anormalmente elevada não sinaliza uma falha do CRAG, mas uma lacuna no seu corpus.

class CorrectiveRAG:
    """Pipeline RAG Corretivo com avaliação e fallback para a web."""

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

    def retrieve(self, question, k=4):
        """Fase 1: recuperação padrão."""
        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):
        """Fase 2: avaliar a relevância."""
        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):
        """Fase 3: gerar a resposta."""
        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 completo."""
        print(f"\n=== Question : {question} ===")

        # 1. Recuperação
        print("1. Retrieval...")
        docs = self.retrieve(question, k=k)

        # 2. Classificação
        print("2. Grading...")
        relevant_docs, need_web = self.grade(question, docs)

        # 3. Fallback de pesquisa na web se necessário
        if need_web:
            print("3. Fallback web search...")
            web_docs = web_search_fallback(question)
            relevant_docs.extend(web_docs)

        # 4. Geração
        print("4. Generation...")
        answer = self.generate(question, relevant_docs)

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

# Utilização
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']}")

Esta fiabilidade tem um custo que deve aceitar conscientemente: com k=4, cada pergunta aciona quatro chamadas de classificação antes mesmo de a geração começar. A latência percecionada pelo utilizador aumenta proporcionalmente, assim como a fatura. A compensação difere consoante o caso de uso: para um assistente jurídico ou médico, a verificação é inegociável; para um motor de busca interno onde o utilizador vê as fontes e julga por si mesmo, é menos crítico.

Pontos-chave

  • O RAG Corretivo adiciona uma etapa de avaliação de relevância após a recuperação
  • Um LLM serve de «classificador» para julgar cada documento: relevante ou não
  • Se os documentos forem considerados irrelevantes, é ativado um fallback para pesquisa na web
  • Esta abordagem reduz significativamente as alucinações devidas a um contexto inadequado
  • A classificação adiciona latência, mas melhora fortemente a fiabilidade das respostas