RAG correctivo
En esta página
Cuando la recuperación no es suficiente
El sistema RAG que has construido se basa en una suposición implícita: los fragmentos más similares a la pregunta son los correctos. Esta suposición suele ser cierta, pero no siempre. Si consultas tu índice sobre un tema que no cubre, FAISS seguirá devolviendo los cinco vectores más cercanos, por muy fuera de lugar que estén; un motor de similitud no sabe decir «no tengo nada». El modelo recibe entonces un contexto inadecuado y, como el prompt le pide basarse en ese contexto, genera una respuesta con apariencia de autoridad pero sin fundamento. Este es el escenario de alucinación más insidioso, porque la cadena técnica ha funcionado sin errores.
El RAG correctivo (CRAG) inserta un paso de evaluación entre la recuperación y la generación. Un LLM examina cada documento recuperado y decide: ¿relevante o no? Si el veredicto es negativo, el sistema no se limita a generar con lo que tiene, sino que activa una búsqueda web para encontrar la información que falta en tu corpus en otro lugar. El flujo consta, por tanto, de cuatro etapas: recuperación estándar desde el almacén vectorial, calificación de cada documento frente a la pregunta, decisión de activar una búsqueda web si al menos un documento se considera irrelevante y, finalmente, generación con los mejores documentos disponibles.
El calificador de documentos
Todo depende del calificador. El truco consiste en pedir al LLM un juicio binario en formato JSON en lugar de una evaluación en texto libre: {"score": "yes"} o {"score": "no"}, nada más. El parámetro response_format={"type": "json_object"} garantiza una salida analizable, y temperature=0 elimina la variabilidad: el mismo par pregunta/documento debe recibir siempre el mismo veredicto; de lo contrario, el comportamiento de tu canalización sería irreproducible.
from mistralai.client import Mistral
import json
client = Mistral(api_key=api_key)
def grade_document(question, document):
"""Evalúa si un documento es relevante para una pregunta."""
prompt = f"""Eres un evaluador de relevancia. Dada una pregunta
y un documento, determina si el documento contiene información relevante
para responder a la pregunta.
Responde ÚNICAMENTE con un objeto JSON: {{"score": "yes"}} o {{"score": "no"}}
Pregunta : {question}
Documento : {document}
Evaluación JSON:"""
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"
# Prueba
question = "¿Cuáles son los pasos del RAG?"
doc_pertinent = "El RAG se divide en recuperación, aumento y generación."
doc_non_pertinent = "La receta de tiramisú requiere mascarpone."
print(grade_document(question, doc_pertinent)) # True
print(grade_document(question, doc_non_pertinent)) # False
La prueba al final del bloque merece atención. La receta de tiramisú ilustra exactamente lo que la similitud vectorial deja pasar: si tu corpus solo habla de cocina y lo consultas sobre RAG, este fragmento ocupará el primer puesto por falta de competencia. El calificador, sin embargo, no compara vectores, sino que lee el contenido y lo rechaza.
Aplicado a todos los fragmentos recuperados, este juicio produce dos informaciones: la lista filtrada de documentos que se deben conservar y un booleano que indica si es necesario complementar con la web. El umbral elegido aquí es deliberadamente estricto: basta con descartar un solo documento para activar la alternativa, bajo la premisa de que el contexto queda entonces incompleto.
def grade_documents(question, retrieved_chunks):
"""Evalúa y filtra los 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" Relevantes: {len(relevant_docs)}/{len(retrieved_chunks)}")
print(f" Búsqueda web necesaria: {need_web_search}")
return relevant_docs, need_web_search
La red de seguridad web
Cuando los documentos locales no son suficientes, el sistema busca en otro lugar. Mistral proporciona una herramienta integrada para ello, web_search, que activas a través de la API de Conversaciones: el modelo realiza la búsqueda por sí mismo y luego escribe su respuesta citando sus fuentes. Este detalle es crucial porque una llamada simple a client.chat.complete no puede buscar en la web: el modelo respondería de memoria, con el riesgo de inventar exactamente lo que CRAG pretende evitar. Además, desde la versión 3.0 del SDK, las completaciones de chat rechazan realmente la herramienta web_search.
El punto clave de diseño es el formato de retorno: la función devuelve una lista de diccionarios con la misma estructura que tus fragmentos locales, con un campo source establecido en web_search, y añade las URL citadas. Esta uniformidad permite que los pasos posteriores ignoren completamente el origen de los documentos mientras se preserva el rastro para el usuario final.
def web_search_fallback(question):
"""Alternativa de búsqueda web cuando los documentos locales son insuficientes."""
response = client.beta.conversations.start(
model="mistral-medium-latest",
inputs=question,
instructions="Responde basándote en hechos, apoyándote en los resultados de la búsqueda web.",
tools=[{"type": "web_search"}],
store=False, # no es necesario guardar la conversación en el lado de Mistral
)
texte, urls = "", []
for entry in response.outputs:
if entry.type != "message.output":
continue # ignora la entrada que describe la ejecución de la herramienta
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)
# Devuelve como un documento "web", con fuentes citadas
return [{
"text": texte,
"source": "web_search",
"urls": urls,
}]
La respuesta contiene dos tipos de entradas: una entrada tool.execution, que describe la búsqueda lanzada, y una entrada message.output, cuyo contenido alterna fragmentos de texto y referencias (tool_reference) que llevan el título y la URL de las páginas consultadas. Un administrador de la organización puede restringir los dominios consultados mediante una lista de permitidos (allowlist) o una lista de bloqueados (blocklist); los resultados filtrados desaparecen sin aviso, por lo que una lista de permitidos demasiado estrecha puede dejar la búsqueda sin resultados.
Fuente oficial: Websearch (documentación de Mistral)
La canalización ensamblada
La clase CorrectiveRAG retoma la estructura de la canalización estándar insertando la calificación. El valor por defecto k=4 es ligeramente más generoso que los tres fragmentos habituales, lo cual tiene sentido: dado que el filtrado descartará algunos, es mejor empezar con un margen. El método ask orquesta las cuatro etapas y muestra cada una, permitiéndote seguir el razonamiento del sistema en tiempo real: cuántos documentos sobrevivieron a la calificación, si se activó la alternativa. El diccionario de retorno también expone web_search_used: este es un indicador valioso para monitorizar en producción, porque una tasa de uso web anormalmente alta no señala un fallo de CRAG, sino una laguna en tu corpus.
class CorrectiveRAG:
"""Canalización RAG correctiva con evaluación y alternativa web."""
def __init__(self, chunks, embeddings, index):
self.chunks = chunks
self.embeddings = embeddings
self.index = index
def retrieve(self, question, k=4):
"""Paso 1: recuperación estándar."""
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):
"""Paso 2: evaluar relevancia."""
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):
"""Paso 3: generar la respuesta."""
context = "\n\n---\n\n".join([d["text"] for d in documents])
prompt = f"""Contexto :\n{context}\n\nPregunta : {question}"""
response = client.chat.complete(
model="mistral-large-latest",
messages=[
{"role": "system", "content": "Responde basándote en el contexto."},
{"role": "user", "content": prompt},
],
temperature=0.1,
)
return response.choices[0].message.content
def ask(self, question, k=4):
"""Canalización completa."""
print(f"\n=== Pregunta : {question} ===")
# 1. Recuperación
print("1. Recuperación...")
docs = self.retrieve(question, k=k)
# 2. Calificación
print("2. Calificación...")
relevant_docs, need_web = self.grade(question, docs)
# 3. Alternativa de búsqueda web si es necesario
if need_web:
print("3. Alternativa de búsqueda web...")
web_docs = web_search_fallback(question)
relevant_docs.extend(web_docs)
# 4. Generación
print("4. Generación...")
answer = self.generate(question, relevant_docs)
return {
"answer": answer,
"sources_used": len(relevant_docs),
"web_search_used": need_web,
}
# Uso
crag = CorrectiveRAG(chunks, embeddings, index)
result = crag.ask("¿Cómo implementa Mistral los embeddings?")
print(f"\nRespuesta : {result['answer']}")
print(f"Búsqueda web utilizada : {result['web_search_used']}")
Esta fiabilidad tiene un coste que debes aceptar conscientemente: con k=4, cada pregunta desencadena cuatro llamadas de calificación antes incluso de que comience la generación. La latencia percibida por el usuario aumenta en consecuencia, y la factura también. La compensación difiere según el caso de uso: para un asistente legal o médico, la verificación es innegociable; para un motor de búsqueda interno donde el usuario ve las fuentes y juzga por sí mismo, es menos crítico.
Puntos clave
- El RAG correctivo añade un paso de evaluación de relevancia tras la recuperación
- Un LLM actúa como «calificador» para juzgar cada documento: relevante o no
- Si los documentos se consideran irrelevantes, se activa una alternativa de búsqueda web
- Este enfoque reduce significativamente las alucinaciones debidas a un contexto inadecuado
- La calificación añade latencia, pero mejora notablemente la fiabilidad de las respuestas