Ir al contenido principal
Español— Elegir un idioma
Menú

Self-RAG

Lección 16 de 18 Actualizado el 2 de noviembre de 2026 Desarrollador
En esta página
  1. Autorreflexión en RAG
  2. Comprobación de la fundamentación factual
  3. Comprobación de la utilidad
  4. El bucle de autocorrección
  5. El coste de la fiabilidad
  6. Puntos clave

Autorreflexión en RAG

Corrective RAG controla lo que entra en el prompt, pero no lo que sale. Incluso con un contexto perfecto, no hay garantía de obtener una buena respuesta: el modelo podría añadir detalles que no aparecen en ningún documento o generar un texto preciso que, sin embargo, elude la pregunta real. Self-RAG (RAG autorreflexivo) cierra esta brecha añadiendo dos verificaciones tras la generación. La primera examina la fundamentación factual: ¿se basa realmente la respuesta en los documentos proporcionados? La segunda examina la utilidad: ¿responde verdaderamente a lo preguntado? Si falla alguna de las dos comprobaciones, el sistema vuelve a intentarlo, convirtiéndose en un mecanismo de autocorrección en lugar de un simple filtro.

El flujo, por tanto, amplía el de Corrective RAG. Sigues teniendo la recuperación seguida de la calificación de documentos y, después, la generación. A continuación se añaden dos nuevos nodos: la comprobación de alucinaciones, que compara la respuesta con los documentos, y la comprobación de la respuesta, que la compara con la pregunta. Si falla una comprobación, el sistema vuelve a la generación o recupera nuevo material de la web, dependiendo de qué verificación haya fallado.

Comprobación de la fundamentación factual

El primer comprobador recibe dos entradas: los documentos concatenados y la respuesta generada. Su función no es juzgar si la respuesta es verdadera en términos absolutos, sino si está totalmente fundamentada en lo que se le ha proporcionado. Esta distinción es crucial: una afirmación precisa que no figure en los documentos debe rechazarse porque procede de la memoria de entrenamiento del modelo, no de tu corpus, y no hay garantía de que la siguiente afirmación sea precisa. El formato de salida coincide con el del calificador: un objeto JSON binario a temperatura cero.

import json
from mistralai.client import Mistral

client = Mistral(api_key=api_key)

def check_hallucination(documents, generation):
    """Comprueba si la generación está fundamentada en los documentos."""
    docs_text = "\n\n".join([d["text"] for d in documents])

    prompt = f"""Eres un evaluador de fundamentación factual. Dado un conjunto de
documentos y una respuesta generada, determina si la respuesta está totalmente
fundamentada en la información contenida en los documentos.

Responde ÚNICAMENTE con un objeto JSON: {{"grounded": "yes"}} o {{"grounded": "no"}}

Documentos:
{docs_text}

Respuesta generada:
{generation}

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

Comprobación de la utilidad

El segundo comprobador no ve ni los documentos ni los resultados de la recuperación, solo la pregunta y la respuesta. Este campo de visión reducido es deliberado, ya que aísla un defecto que la primera comprobación deja pasar. Imagina que alguien pregunta cuántas dimensiones produce un modelo de embeddings y la respuesta describe extensamente para qué se utilizan los embeddings sin llegar a dar nunca el número. Todo está fundamentado en los documentos, así que el primer comprobador dice «sí», y el usuario se queda sin su información. El segundo comprobador dice «no» y desencadena otro intento.

def check_answer_usefulness(question, generation):
    """Comprueba si la respuesta aborda realmente la pregunta."""
    prompt = f"""Eres un evaluador de la calidad de las respuestas. Dada una pregunta
y una respuesta, determina si la respuesta aborda la pregunta de forma útil y completa.

Responde ÚNICAMENTE con un objeto JSON: {{"useful": "yes"}} o {{"useful": "no"}}

Pregunta: {question}
Respuesta: {generation}

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

El bucle de autocorrección

La clase SelfRAG reutiliza los pasos familiares de recuperación y calificación, y luego los envuelve en un bucle de reintentos limitado por max_retries. La lógica del bucle es más sutil de lo que parece, porque los dos tipos de fallo reciben un tratamiento diferente. Una alucinación detectada simplemente regenera la respuesta con el mismo contexto: el problema reside en el modelo, que se ha extralimitado, y un nuevo intento suele bastar. Sin embargo, una respuesta juzgada como inútil desencadena una búsqueda web adicional antes de reintentar: aquí el problema reside en el contexto, que es demasiado escaso para sustentar una respuesta completa, y regenerar sin añadir nada produciría el mismo resultado.

Observa la salida de respaldo tras el bucle. Cuando se agotan todos los intentos, el sistema no lanza una excepción: devuelve la última generación junto con sus indicadores grounded y useful. Esta es una decisión de diseño deliberada: es mejor devolver una respuesta imperfecta etiquetada como tal, que tu interfaz puede señalar al usuario, que lanzar un error en bruto.

import numpy as np

class SelfRAG:
    """Pipeline Self-RAG con autocorrección."""

    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):
        """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)

        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):
        """Evalúa la relevancia de los documentos."""
        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):
        """Genera una 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": "user", "content": prompt}],
            temperature=0.2,
        )
        return response.choices[0].message.content

    def ask(self, question, k=4):
        """Pipeline Self-RAG completo con autocorrección."""
        print(f"\n=== Self-RAG: {question[:60]}... ===")

        # 1. Recuperación
        print("1. Recuperación...")
        docs = self.retrieve(question, k=k)

        # 2. Calificación
        print("2. Calificación de documentos...")
        relevant_docs, need_web = self.grade_documents(question, docs)

        if need_web:
            print("   -> Búsqueda web de respaldo")
            web_docs = web_search_fallback(question)
            relevant_docs.extend(web_docs)

        # 3. Bucle de generación con autocorrección
        for attempt in range(self.max_retries + 1):
            print(f"3. Generación (intento {attempt + 1})...")
            generation = self.generate(question, relevant_docs)

            # 4. Comprobación de alucinaciones
            print("4. Comprobando alucinaciones...")
            is_grounded = check_hallucination(relevant_docs, generation)

            if not is_grounded:
                print("   -> ALUCINACIÓN detectada, reintentando...")
                continue

            # 5. Comprobación de utilidad
            print("5. Comprobando utilidad...")
            is_useful = check_answer_usefulness(question, generation)

            if not is_useful:
                print("   -> Respuesta NO ÚTIL, búsqueda web de respaldo...")
                web_docs = web_search_fallback(question)
                relevant_docs.extend(web_docs)
                continue

            # Éxito
            print("   -> ¡Respuesta validada!")
            return {
                "answer": generation,
                "attempts": attempt + 1,
                "grounded": True,
                "useful": True,
            }

        # Si fallan todos los intentos
        print("   -> Máximo de intentos alcanzado")
        return {
            "answer": generation,
            "attempts": self.max_retries + 1,
            "grounded": is_grounded,
            "useful": is_useful,
        }

# Uso
self_rag = SelfRAG(chunks, embeddings, index, max_retries=2)
result = self_rag.ask("¿Cuáles son las ventajas de RAG frente al fine-tuning?")

print(f"\nRespuesta: {result['answer']}")
print(f"Intentos: {result['attempts']}")
print(f"Fundamentada: {result['grounded']}, Útil: {result['useful']}")

El coste de la fiabilidad

Cada barrera de seguridad añade otra llamada al LLM, y el total suma rápidamente. La siguiente función lo hace explícito desglosando las llamadas por paso: una llamada de calificación por documento, luego generación, comprobación de fundamentación y comprobación de utilidad, repetidas en cada reintento. Con cuatro documentos y un solo reintento, llegas a diez llamadas para una única pregunta, mientras que el RAG básico requería dos. Ejecuta esta estimación con tus propios valores antes de establecer k y max_retries: este cálculo te indica si tu presupuesto y requisitos de latencia admiten Self-RAG para todo el tráfico o solo para las preguntas más sensibles.

def estimate_self_rag_cost(n_docs=4, n_retries=1):
    """Estima el número de llamadas al LLM para una pregunta Self-RAG."""
    calls = {
        "grading": n_docs,           # 1 llamada por documento
        "generation": 1 + n_retries, # 1 inicial + reintentos
        "hallucination_check": 1 + n_retries,
        "answer_check": 1 + n_retries,
    }
    total = sum(calls.values())
    print(f"Llamadas al LLM estimadas: {total}")
    for step, count in calls.items():
        print(f"  {step}: {count}")
    return total

estimate_self_rag_cost(n_docs=4, n_retries=1)
# Llamadas al LLM estimadas: 10

Puntos clave

  • Self-RAG añade dos comprobaciones posteriores a la generación: alucinaciones y utilidad
  • Si la respuesta no está fundamentada en los documentos, el sistema la regenera
  • Si la respuesta no es útil, el sistema realiza una búsqueda web y lo reintenta
  • El número de reintentos debe limitarse para controlar la latencia
  • Self-RAG es más costoso (más llamadas al LLM) pero más fiable