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

Arquitectura RAG completa

Lección 11 de 22 Actualizado el 3 de noviembre de 2026 Desarrollador
En esta página
  1. Objetivos
  2. ¿Qué es RAG?
  3. Fases de la canalización
  4. Implementación completa
  5. Uso
  6. Puntos de optimización
  7. Resumen

Lección actualizada el 3 de noviembre de 2026 según la documentación de OpenAI: temperature y top_p solo se aceptan con un esfuerzo de razonamiento de none, mientras que los modelos GPT-5.6 razonan por defecto (medium). Por tanto, las llamadas que establezcan estos parámetros deben especificar reasoning={"effort": "none"} (API Responses) o reasoning_effort="none" (Chat Completions). Fuentes: Uso de GPT-6 · GPT-5.6 Terra.

Objetivos

  • Comprender la arquitectura RAG de extremo a extremo
  • Implementar una canalización RAG funcional
  • Identificar los componentes susceptibles de optimización

¿Qué es RAG?

RAG (Generación Aumentada por Recuperación, Retrieval-Augmented Generation) combina la búsqueda de documentos con la generación de texto por parte de un LLM. En lugar de depender únicamente de su conocimiento interno, el modelo recibe documentos relevantes como contexto y redacta su respuesta basándose en ellos. Todo lo que has construido desde el inicio de este curso —incrustaciones, indexación, búsqueda, evaluación— se convierte aquí en la mitad aguas arriba de un sistema completo.

¿Por qué RAG?

Cuatro razones lo justifican, y sus efectos se acumulan. Primero, los datos propietarios: tu política de teletrabajo, tus procedimientos internos y tu catálogo de productos nunca aparecieron en los datos de entrenamiento del modelo, y ningún prompt logrará que aparezcan allí. Segundo, la información reciente: cualquier dato posterior a la fecha de entrenamiento es invisible para el modelo, mientras que un índice puede actualizarse el mismo día. La verificabilidad es igual de importante, ya que cada respuesta se ancla en fuentes identificables que el usuario puede abrir y comprobar, transformando así la naturaleza de la confianza depositada en el sistema. Por último, el coste juega a su favor: añadir conocimiento mediante RAG cuesta mucho menos que el ajuste fino (fine-tuning), y las correcciones se realizan eliminando un documento en lugar de volver a entrenar un modelo.

Fases de la canalización

Debes leer RAG en dos fases distintas que no debes confundir. La ingesta ocurre fuera de línea (offline), una única vez o cada vez que se actualiza el corpus:

Documentos → Fragmentación → Incrustaciones → Almacenamiento vectorial

La consulta ocurre en línea (online), para cada pregunta formulada, y debe ser rápida:

Pregunta → Incrustación → Búsqueda → Contexto + Pregunta → LLM → Respuesta

Esta separación tiene una consecuencia práctica: los costes de ingesta se pagan una sola vez y pueden ser elevados, mientras que los costes de consulta se pagan por llamada y dictan la experiencia del usuario. Por tanto, puedes permitirte un procesamiento de ingesta sofisticado, pero debes mantener la fase de consulta ligera.

Implementación completa

La siguiente clase materializa las tres fases en tres métodos distintos, más un cuarto que los encadena. Esta separación no es cosmética: te permite probar la búsqueda sin consumir tokens de generación y volver a ejecutar la generación sobre un contexto fijo para comparar dos prompts.

from openai import OpenAI
import numpy as np

client = OpenAI()

class PipelineRAG:
    def __init__(
        self,
        model_embedding: str = "text-embedding-3-large",
        model_generation: str = "gpt-5.6-terra"
    ):
        self.client = OpenAI()
        self.model_embedding = model_embedding
        self.model_generation = model_generation
        self.chunks: list[dict] = []
        self.embeddings: np.ndarray | None = None

    # --- Fase de ingesta ---

    def ingest(self, documents: list[dict]):
        """Ingesta documentos {id, text, metadata}."""
        self.chunks = documents
        texts = [d["text"] for d in documents]

        # Generar incrustaciones por lotes
        all_emb = []
        for i in range(0, len(texts), 100):
            batch = texts[i:i + 100]
            resp = self.client.embeddings.create(
                input=batch, model=self.model_embedding
            )
            batch_emb = sorted(resp.data, key=lambda x: x.index)
            all_emb.extend([e.embedding for e in batch_emb])

        self.embeddings = np.array(all_emb, dtype=np.float32)
        print(f"Ingesta completada: {len(self.chunks)} fragmentos indexados")

    # --- Fase de recuperación ---

    def search(self, question: str, k: int = 5) -> list[dict]:
        """Encuentra los k fragmentos más relevantes."""
        query_emb = self.client.embeddings.create(
            input=question, model=self.model_embedding
        ).data[0].embedding

        scores = self.embeddings @ np.array(query_emb)
        top_k = np.argsort(scores)[-k:][::-1]

        return [
            {**self.chunks[i], "score": float(scores[i])}
            for i in top_k
        ]

    # --- Fase de generación ---

    def generate(self, question: str, contexts: list[dict]) -> str:
        """Genera una respuesta basada en los contextos recuperados."""
        # Construir el prompt
        formatted_context = "\n\n---\n\n".join(
            f"[Fuente: {c.get('id', 'desconocida')}]\n{c['text']}"
            for c in contexts
        )

        messages = [
            {
                "role": "system",
                "content": (
                    "Eres un asistente que responde preguntas "
                    "basándose exclusivamente en los documentos proporcionados. "
                    "Si la información no está en los documentos, "
                    "indícalo claramente. Cita tus fuentes."
                )
            },
            {
                "role": "user",
                "content": (
                    f"Documentos de referencia:\n\n{formatted_context}\n\n"
                    f"---\n\nPregunta: {question}"
                )
            }
        ]

        response = self.client.chat.completions.create(
            model=self.model_generation,
            reasoning_effort="none",  # temperature requiere effort none
            messages=messages,
            temperature=0.2
        )

        return response.choices[0].message.content

    # --- Canalización completa ---

    def answer(self, question: str, k: int = 5) -> dict:
        """Canalización RAG completa: búsqueda → generación."""
        contexts = self.search(question, k=k)
        response = self.generate(question, contexts)

        return {
            "question": question,
            "response": response,
            "sources": [
                {"id": c["id"], "score": c["score"],
                 "excerpt": c["text"][:150]}
                for c in contexts
            ]
        }

Tres detalles en la fase de generación determinan la mayor parte de la calidad. El mensaje de sistema exige responder únicamente a partir de los documentos proporcionados y admitir cuando falta información: sin esta instrucción, el modelo rellenará los huecos con su conocimiento general, ofreciendo una respuesta plausible pero inventada. El prefijo [Fuente: id] antes de cada extracto proporciona al modelo algo específico que citar, en lugar de un vago «según los documentos». Por último, una temperature de 0,2 reduce la variabilidad: para preguntas factuales contra una base documental, buscas consistencia, no creatividad.

Uso

Probemos la canalización con un caso de uso empresarial mínimo: tres políticas internas y una pregunta que no copia ninguna de sus formulaciones exactas.

# Preparar documentos
documents = [
    {
        "id": "leave-policy",
        "text": "Los empleados reciben 25 días de vacaciones pagadas "
                 "al año. Las vacaciones deben solicitarse con al menos 2 semanas "
                 "de antelación a través del portal de RR. HH.",
        "metadata": {"type": "hr", "date": "2026-01"}
    },
    {
        "id": "remote-work-policy",
        "text": "El teletrabajo está autorizado hasta 3 días por semana. "
                 "Los martes y jueves son días obligatorios en la oficina. "
                 "Se requiere un acuerdo por escrito con el responsable.",
        "metadata": {"type": "hr", "date": "2026-01"}
    },
    {
        "id": "reimbursement-procedure",
        "text": "Los informes de gastos deben presentarse dentro de los 30 días "
                 "posteriores al gasto. Adjunte el recibo original. "
                 "Se requiere validación por el supervisor directo para importes superiores a 200 euros.",
        "metadata": {"type": "finance", "date": "2026-01"}
    },
]

# Crear la canalización
rag = PipelineRAG()
rag.ingest(documents)

# Formular una pregunta
result = rag.answer("¿Cuántos días de teletrabajo hay por semana?")
print(result["response"])
print("\nFuentes utilizadas:")
for s in result["sources"]:
    print(f"  [{s['score']:.3f}] {s['id']}: {s['excerpt']}")

Lleva el ejercicio un paso más allá formulando una pregunta que ningún documento responda, como una sobre el plan de salud de la empresa. La canalización devolverá aún tres fuentes —la búsqueda siempre devuelve sus k mejores candidatos— y será el mensaje de sistema el que deba impedir que el modelo invente una respuesta. Verificar este comportamiento antes de pasar a producción es preferible a descubrirlo mediante una reclamación.

Puntos de optimización

Cada paso de la canalización puede mejorarse de forma independiente, lo que permite avanzar mediante pequeños ajustes medibles.

PasoOptimizaciones posibles
FragmentaciónTamaño del fragmento, solapamiento, fragmentación semántica
IncrustaciónElección del modelo, dimensiones, enriquecimiento del texto
BúsquedaHíbrida, reordenación (reranking), filtros de metadatos
PromptInstrucciones de sistema, formato del contexto, pocos ejemplos (few-shot)
GeneraciónModelo, temperatura, citas

Las siguientes lecciones detallan cada una de estas optimizaciones. Abórdalas en este orden: la fragmentación determina qué se puede recuperar, y ninguna reordenación arreglará un documento mal fragmentado.

Resumen

  • RAG = Búsqueda + Contexto + Generación con LLM
  • La canalización se divide en ingesta (fuera de línea) y consulta (en línea)
  • Cada componente (fragmentación, incrustación, búsqueda, prompt, generación) puede optimizarse independientemente
  • RAG es más flexible y menos costoso que el ajuste fino para añadir conocimiento