RAG Corretivo
Nesta página
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