Arquitectura RAG completa
En esta página
Lección actualizada el 3 de noviembre de 2026 según la documentación de OpenAI:
temperatureytop_psolo se aceptan con un esfuerzo de razonamiento denone, mientras que los modelos GPT-5.6 razonan por defecto (medium). Por tanto, las llamadas que establezcan estos parámetros deben especificarreasoning={"effort": "none"}(API Responses) oreasoning_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.
| Paso | Optimizaciones posibles |
|---|---|
| Fragmentación | Tamaño del fragmento, solapamiento, fragmentación semántica |
| Incrustación | Elección del modelo, dimensiones, enriquecimiento del texto |
| Búsqueda | Híbrida, reordenación (reranking), filtros de metadatos |
| Prompt | Instrucciones de sistema, formato del contexto, pocos ejemplos (few-shot) |
| Generación | Modelo, 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