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

RAG adaptativo

Lección 17 de 18 Actualizado el 2 de noviembre de 2026 Desarrollador
En esta página
  1. Enruta las preguntas de forma inteligente
  2. Implementa el enrutador
  3. El pipeline completo
  4. Puntos clave

Enruta las preguntas de forma inteligente

Self-RAG aplica el mismo tratamiento a todas las preguntas, y ese es precisamente su defecto. Pregúntale cuánto es dos más dos: codificará la consulta, rastreará el índice, evaluará cuatro documentos irrelevantes, cambiará a la web, generará y verificará. Eso supone una docena de llamadas al LLM para una pregunta que el modelo resuelve al instante. No todas las preguntas tienen la misma complejidad, y una pregunta factual simple no requiere el mismo tratamiento que una que exige sintetizar información de múltiples documentos. El RAG adaptativo añade, por tanto, un enrutador inteligente aguas arriba del pipeline: analiza la pregunta y selecciona la estrategia óptima antes de iniciar cualquier procesamiento costoso.

El enrutador tiene tres destinos. Las preguntas sobre temas realmente cubiertos por tus documentos van al almacén vectorial; esta es la ruta completa de RAG. Las preguntas sobre actualidad o fuera del alcance indexado van a la búsqueda web, ya que consultar el índice solo devolvería ruido. Por último, las preguntas simples o de cultura general reciben una respuesta directa del modelo, sin recuperación alguna.

Implementa el enrutador

La parte delicada es que el enrutador debe conocer el alcance de tu índice para tomar una decisión. La solución elegida es tan simple como efectiva: se le pasa la lista de temas cubiertos, indexed_topics, que compara con la pregunta. Las tres reglas se establecen explícitamente en el prompt, y el formato JSON restringido garantiza un valor utilizable. La expresión result.get("route", "vectorstore") merece atención: en caso de una salida inesperada, el valor por defecto recurre al almacén vectorial. Este es el comportamiento más seguro, confiando en tus datos en lugar de en la web o en la memoria del modelo.

import json
from mistralai.client import Mistral

client = Mistral(api_key=api_key)

def route_question(question, indexed_topics):
    """Enruta una pregunta a la mejor estrategia."""
    topics_str = ", ".join(indexed_topics)

    prompt = f"""Eres un enrutador de preguntas. Dada una pregunta,
determina la mejor fuente de información.

Tus documentos indexados cubren los siguientes temas: {topics_str}

Reglas:
- Si la pregunta trata sobre temas indexados -> "vectorstore"
- Si la pregunta trata sobre actualidad o un tema no cubierto -> "websearch"
- Si la pregunta es muy simple o de cultura general -> "direct"

Responde ÚNICAMENTE con un objeto JSON: {{"route": "vectorstore"}} o {{"route": "websearch"}} o {{"route": "direct"}}

Pregunta: {question}

JSON de ruta:"""

    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("route", "vectorstore")

# Prueba del enrutador
topics = ["embeddings", "RAG", "Mistral AI", "vector search", "FAISS"]

tests = [
    "How does mistral-embed work?",          # -> vectorstore
    "What is Apple's stock price today?",  # -> websearch
    "How much is 2 + 2?",                        # -> direct
    "What are the steps of RAG?",             # -> vectorstore
    "Who won the 2026 World Cup?",         # -> websearch
]

for q in tests:
    route = route_question(q, topics)
    print(f"  [{route:12s}] {q}")

El conjunto de pruebas ilustra cada escenario y servirá como tu salvaguarda. Una pregunta sobre mistral-embed entra de lleno en los temas declarados, por lo que va al almacén vectorial. Los precios de las acciones o los resultados de competiciones cambian a diario: ningún índice estático puede contenerlos, así que van a la web. Dos más dos no requiere ni un corpus ni búsqueda. Reutiliza este bloque con tus propios temas y unas quince preguntas representativas de tu tráfico real: esta es la forma más económica de verificar que la lista topics es lo suficientemente precisa. Un enrutador que lo envíe todo al almacén vectorial no aporta valor, y un enrutador que responda directamente sobre tus temas de negocio es francamente peligroso.

El pipeline completo

AdaptiveRAG reúne todo lo que has construido en las últimas tres lecciones. Cada ruta tiene su propio método de ejecución, y el método ask se lee como una instrucción switch. La ruta direct devuelve inmediatamente, con una temperatura de 0,3 ya que no hay contexto al que atenerse, y una lista de fuentes vacía que indica honestamente al usuario que nada respalda esta respuesta. La ruta websearch genera únicamente a partir de resultados web. La ruta vectorstore, sin embargo, despliega toda la artillería: evaluación de documentos al estilo de Corrective RAG, recurso a la web si no sobrevive ninguno, y luego un bucle de generación con comprobaciones de fundamentación y utilidad heredadas de Self-RAG, agrupadas aquí en grade_and_correct.

Cabe destacar una diferencia de umbral respecto a la lección de Corrective RAG. El recurso a la web ya no se activa tan pronto como se descarta un documento, sino solo si relevant_docs está vacío. Esta elección es más tolerante: cuando dos de cuatro fragmentos siguen siendo relevantes, es razonable generar con ellos en lugar de ir a la web, lo que ahorra una llamada y reduce la latencia. Debes arbitrar en función de los requisitos de tu dominio.

import numpy as np

class AdaptiveRAG:
    """Pipeline de RAG adaptativo con enrutamiento inteligente."""

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

    def route(self, question):
        """Determina la estrategia óptima."""
        return route_question(question, self.topics)

    def retrieve_from_vectorstore(self, question, k=4):
        """Recuperación desde el almacén vectorial local."""
        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": "vectorstore"}
            for dist, idx in zip(distances[0], indices[0]) if idx >= 0
        ]

    def search_web(self, question):
        """Búsqueda web para preguntas fuera de alcance."""
        return web_search_fallback(question)

    def direct_answer(self, question):
        """Respuesta directa sin recuperación."""
        response = client.chat.complete(
            model="mistral-large-latest",
            messages=[{"role": "user", "content": question}],
            temperature=0.3,
        )
        return response.choices[0].message.content

    def generate_with_context(self, question, documents):
        """Generación con contexto (RAG clásico)."""
        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 proporcionado."},
                {"role": "user", "content": prompt},
            ],
            temperature=0.1,
        )
        return response.choices[0].message.content

    def grade_and_correct(self, question, documents, generation):
        """Comprobaciones de Self-RAG (alucinaciones + utilidad)."""
        is_grounded = check_hallucination(documents, generation)
        if not is_grounded:
            return None, "hallucination"

        is_useful = check_answer_usefulness(question, generation)
        if not is_useful:
            return None, "not_useful"

        return generation, "ok"

    def ask(self, question, max_retries=2):
        """Pipeline completo de RAG adaptativo."""
        print(f"\n{'='*60}")
        print(f"Pregunta: {question}")

        # 1. Enrutamiento
        route = self.route(question)
        print(f"Ruta elegida: {route}")

        # 2. Ejecución según la ruta
        if route == "direct":
            answer = self.direct_answer(question)
            return {"answer": answer, "route": "direct", "sources": []}

        elif route == "websearch":
            docs = self.search_web(question)
            answer = self.generate_with_context(question, docs)
            return {"answer": answer, "route": "websearch", "sources": ["web"]}

        else:  # vectorstore
            docs = self.retrieve_from_vectorstore(question)

            # Evaluación de documentos
            relevant_docs = []
            for doc in docs:
                if grade_document(question, doc["text"]):
                    relevant_docs.append(doc)

            # Recurso a la web si no hay suficientes documentos relevantes
            if not relevant_docs:
                print("  No hay documentos relevantes, recurriendo a la web...")
                relevant_docs = self.search_web(question)

            # Bucle de generación con verificación
            for attempt in range(max_retries + 1):
                generation = self.generate_with_context(question, relevant_docs)
                answer, status = self.grade_and_correct(
                    question, relevant_docs, generation
                )

                if status == "ok":
                    return {
                        "answer": answer,
                        "route": "vectorstore",
                        "attempts": attempt + 1,
                        "sources": [d.get("source", "") for d in relevant_docs],
                    }
                elif status == "not_useful":
                    web_docs = self.search_web(question)
                    relevant_docs.extend(web_docs)

            # Devolver la última generación aunque sea imperfecta
            return {
                "answer": generation,
                "route": "vectorstore",
                "attempts": max_retries + 1,
                "sources": [d.get("source", "") for d in relevant_docs],
            }

# Uso
adaptive_rag = AdaptiveRAG(chunks, embeddings, index, topics=topics)

questions = [
    "How do I create a FAISS index with mistral-embed?",
    "What is the weather in Paris tomorrow?",
    "How many dimensions does codestral-embed have?",
]

for q in questions:
    result = adaptive_rag.ask(q)
    print(f"\nRuta: {result['route']}")
    print(f"Respuesta: {result['answer'][:200]}...")

Las tres preguntas de ejemplo recorren todas las rutas en una sola ejecución, y el campo route del resultado te indica cuál se ha tomado. Este es el valor que debes registrar en producción: la distribución de rutas en tu tráfico real es el mejor indicador de salud de tu sistema, revelando tanto un índice demasiado estrecho como un enrutador mal calibrado.

Puntos clave

  • El RAG adaptativo enruta cada pregunta a la estrategia óptima (vectorstore, web, direct)
  • El enrutador utiliza un LLM con salida estructurada para clasificar las preguntas
  • Las preguntas sobre temas indexados van al almacén vectorial; el resto, a la web
  • El enrutamiento reduce la latencia y los costes al evitar el RAG completo para preguntas simples
  • El RAG adaptativo combina ideas de Corrective RAG y Self-RAG con enrutamiento