Qué es RAG y cómo hacer que la IA responda con tus documentos

RAG (del inglés retrieval-augmented generation, generación aumentada por recuperación) es una técnica que hace que un modelo de lenguaje busque primero en tus documentos los fragmentos relacionados con la pregunta y los lea antes de responder. Así puede contestar con información que no estaba en su entrenamiento, como el manual de tu producto o los contratos de tu empresa, y decir de dónde la ha sacado. El modelo no cambia: cambia lo que tiene delante cuando responde.

A partir de aquí va cómo funciona por dentro, cuándo compensa (en octubre de 2026, con modelos que leen un millón de tokens de una vez, no siempre) y un ejemplo corto en Python.

Qué es RAG, sin tecnicismos

Piensa en un examen a libro abierto. Un modelo como ChatGPT, Claude o Gemini responde de memoria: sabe lo que aprendió durante el entrenamiento, hasta una fecha de corte, y nada de tus documentos privados. Si le preguntas por la política de devoluciones de tu tienda, o se disculpa o se la inventa (el porqué está en por qué la IA se inventa cosas).

Con RAG, antes de responder, un buscador saca de tu biblioteca los párrafos que importan y se los pone delante al modelo junto con la pregunta. El modelo ya no tiene que recordar: tiene que leer y redactar, que es lo que mejor hace.

La idea tiene nombre y fecha. Viene de un artículo de investigadores de Facebook AI Research, University College London y la Universidad de Nueva York, publicado en mayo de 2020 y presentado en NeurIPS. Combinaban dos memorias: la paramétrica (lo que el modelo lleva dentro) y una no paramétrica, un índice vectorial de la Wikipedia en el que el sistema buscaba antes de generar. En el resumen ya señalaban los dos problemas que RAG ataca: poder decir de dónde sale una respuesta y poder actualizar lo que el modelo sabe sin reentrenarlo.

Cómo funciona un sistema RAG, paso a paso

Un RAG tiene dos fases. La indexación se hace una vez (y cada vez que cambian los documentos). La consulta ocurre con cada pregunta.

1. Trocear los documentos

Un manual de 300 páginas no cabe entero en cada consulta, ni conviene. Se parte en fragmentos (chunks) de unos cientos de tokens, a ser posible respetando la estructura: por apartados, por párrafos, sin cortar una tabla por la mitad. Es habitual que cada trozo repita un poco del anterior para no perder frases en el corte.

Aquí está el primer problema serio. Anthropic lo explica con un ejemplo en su artículo sobre recuperación contextual (septiembre de 2024): un trozo que dice «Los ingresos de la empresa crecieron un 3 % respecto al trimestre anterior» no dice qué empresa ni qué trimestre. Suelto, no sirve para responder «¿cuánto crecieron los ingresos de ACME en el segundo trimestre de 2023?».

2. Convertir cada trozo en un embedding

Un embedding es una lista de números (un vector) que representa el significado de un texto. Dos frases que dicen lo mismo con palabras distintas («plazo de devolución» y «cuántos días tengo para devolver algo») acaban con vectores parecidos. Lo calcula un modelo de embeddings, que es distinto del modelo que conversa.

La regla de oro: los documentos y las preguntas se convierten con el mismo modelo. Si un día cambias de modelo de embeddings, toca volver a indexar todo.

3. Guardarlos en una base de datos vectorial

Los vectores se guardan en una base de datos preparada para buscar «los más parecidos a este» entre millones en milisegundos. Puede ser una extensión de tu base de siempre, como pgvector para PostgreSQL, o una base específica como Chroma o Qdrant. Junto al vector se guarda el texto original y metadatos útiles: documento de origen, página, fecha, quién puede verlo.

4. Recuperar los trozos relevantes

Cuando llega una pregunta, se convierte en embedding y se buscan los trozos con vectores más cercanos. Se piden los K mejores (el famoso top-k). La búsqueda semántica falla con lo literal: un código de producto, una referencia de factura, un apellido raro. Por eso los sistemas serios combinan dos búsquedas, la semántica y una clásica por palabras clave (BM25, la de los buscadores de toda la vida), y mezclan los resultados. Es lo que se llama búsqueda híbrida.

5. Reordenar los resultados

Un reranker es un modelo que recibe la pregunta y, por ejemplo, 150 candidatos, y los ordena de nuevo con más cuidado que la búsqueda vectorial. Es más lento, así que se aplica solo a los candidatos.

Las cifras de Anthropic dan una idea de lo que aporta cada mejora. En sus pruebas, con los 20 mejores fragmentos, el sistema básico no encontraba el fragmento correcto el 5,7 % de las veces. Añadir contexto a cada trozo antes de indexarlo bajó los fallos un 35 %; sumarle la búsqueda BM25 con el mismo truco, un 49 %; y con reranking encima, un 67 % (del 5,7 % al 1,9 %).

6. Meter los fragmentos en el prompt

Los trozos elegidos se pegan en el prompt junto con la pregunta y unas instrucciones claras. Una plantilla que funciona como punto de partida:

Responde a la pregunta usando solo los documentos que hay entre las etiquetas.
Cita entre corchetes el número del documento en el que te apoyas.
Si la respuesta no está en los documentos, di «No lo encuentro en la documentación».

<documentos>
[1] (faq-devoluciones.md) Tienes 30 días desde la entrega para devolver un pedido...
[2] (condiciones.pdf, p. 4) Los gastos de envío de la devolución corren a cargo...
</documentos>

Pregunta: ¿Cuánto tiempo tengo para devolver un pedido?

Pedir la cita sirve para dos cosas: el usuario puede comprobar la respuesta y tú puedes detectar cuándo el modelo responde sin apoyo.

RAG, contexto largo o ajuste fino: cuál usar

En 2020 los modelos leían unas pocas páginas. A 8 de octubre de 2026, los modelos principales de las tres grandes leen alrededor de un millón de tokens de una vez: Claude Opus 5.5 y Sonnet 5.5, 1 millón; GPT-6 Astra, Sol y Luna, 1,05 millones; Gemini 3.8 Flash, 1.048.576. Eso cambia la pregunta: muchas veces ya no hace falta RAG.

Hay tres formas de darle tus datos a un modelo, y cada una encaja en un caso distinto.

Contexto largo: meterlo todo en el prompt

El modelo lee toda la documentación en cada pregunta, y actualizarla es inmediato: cambias el texto y ya está. La propia Anthropic lo recomienda en el artículo citado: si tu base de conocimiento ocupa menos de 200.000 tokens, puedes meterla entera en el prompt y usar la caché de prompts para que salga más rápido y barato. Encaja cuando la documentación es pequeña y las preguntas llegan seguidas, porque así la caché se aprovecha.

Pero meterlo todo tiene dos pegas. La primera es la calidad: el estudio Lost in the Middle (Stanford y otros, 2023) vio que los modelos aciertan más cuando el dato está al principio o al final del texto y peor cuando está en medio, y el informe Context Rot de Chroma (julio de 2025) comprobó en 18 modelos que el rendimiento no se mantiene igual a medida que crece la entrada, incluso en tareas sencillas. La segunda es el coste, que vemos enseguida con números.

RAG: leer solo lo relevante

Con RAG, el modelo solo lee los fragmentos que tienen que ver con cada pregunta. Es la opción cuando hay mucha documentación, cuando cambia a menudo y cuando necesitas citar de dónde sale cada respuesta. Actualizar los datos significa volver a indexar solo lo que ha cambiado.

Cuánto cuesta cada opción

Un ejemplo: una documentación de 500.000 tokens, con Claude Opus 5.5 a precios oficiales del 8 de octubre de 2026 (4 dólares por millón de tokens de entrada, 0,20 la lectura de caché, 5 la escritura en caché de 5 minutos). Esto es lo que cuesta la entrada de cada pregunta:

La caché de 5 minutos caduca, y cada vez que hay que reescribirla son esos 2,50 dólares. La salida cuesta lo mismo en los tres casos. Indexar los 500.000 tokens con text-embedding-3-small de OpenAI (0,02 dólares por millón) cuesta un céntimo, una sola vez. Con preguntas seguidas y caché caliente, el contexto largo se acerca mucho a RAG; con preguntas sueltas a lo largo del día, RAG sale decenas de veces más barato. Y si tus documentos pasan del millón de tokens, la discusión se acaba: no caben.

Ajuste fino: cambiar cómo responde el modelo

El ajuste fino (fine-tuning) es otra cosa: reentrenar un poco el modelo con tus ejemplos. Sirve para cambiar su comportamiento: un formato fijo, un estilo o un tono muy concretos, una tarea repetitiva. No es la forma práctica de enseñarle datos que cambian, porque cada actualización exige volver a entrenar y el modelo no puede decirte de qué documento saca cada cosa.

Un ejemplo de RAG en Python

Este ejemplo, basado en la documentación oficial de Chroma y de la API de Claude, hace todo el recorrido: guarda unos fragmentos, busca los dos más parecidos a la pregunta y se los pasa al modelo. Los embeddings se calculan en tu ordenador con un modelo abierto multilingüe; solo la última llamada sale a la API.

# pip install chromadb sentence-transformers anthropic
import anthropic
import chromadb
from chromadb.utils.embedding_functions import SentenceTransformerEmbeddingFunction

# 1. Base vectorial local, guardada en la carpeta ./rag_db
db = chromadb.PersistentClient(path="./rag_db")
modelo_embeddings = SentenceTransformerEmbeddingFunction(
    model_name="sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2"
)
coleccion = db.get_or_create_collection(
    name="ayuda", embedding_function=modelo_embeddings
)

# 2. Indexar: en un caso real, aquí van los trozos de tus documentos
trozos = [
    "Devoluciones: tienes 30 días desde la entrega para devolver un pedido.",
    "Si el producto llegó defectuoso, el envío de la devolución es gratuito.",
    "El teléfono de atención funciona de lunes a viernes, de 9:00 a 18:00.",
]
coleccion.upsert(
    ids=[f"faq-{i}" for i in range(len(trozos))],
    documents=trozos,
    metadatas=[{"fuente": "faq.md"} for _ in trozos],
)

# 3. Recuperar los dos trozos más parecidos a la pregunta
pregunta = "¿Cuánto tiempo tengo para devolver algo?"
resultado = coleccion.query(query_texts=[pregunta], n_results=2)
contexto = "\n".join(resultado["documents"][0])

# 4. Generar la respuesta con esos trozos delante
cliente = anthropic.Anthropic()  # lee la clave de la variable ANTHROPIC_API_KEY
respuesta = cliente.messages.create(
    model="claude-opus-5-5",
    max_tokens=16000,
    system="Responde solo con la información de los documentos. "
           "Si no está en ellos, di que no lo sabes.",
    messages=[{
        "role": "user",
        "content": f"<documentos>\n{contexto}\n</documentos>\n\nPregunta: {pregunta}",
    }],
)
for bloque in respuesta.content:
    if bloque.type == "text":
        print(bloque.text)

Tres detalles que no son obvios:

• El modelo de embeddings importa. El que Chroma usa por defecto, all-MiniLM-L6-v2, está etiquetado como modelo en inglés. Para documentos en español conviene uno multilingüe, como el del ejemplo, que según la documentación de Sentence Transformers se entrenó con más de 50 idiomas, español incluido.
• Ese modelo corta a los 128 tokens (ficha en Hugging Face): lo que pase de ahí no cuenta para la búsqueda. El tamaño de tus trozos lo marca el modelo de embeddings que elijas.
• Se recorre respuesta.content en lugar de leer el primer bloque, porque los modelos actuales de Claude razonan antes de responder y la respuesta puede traer bloques de razonamiento además del texto.

Si es tu primera vez con la API, empieza por los primeros pasos con la API de Claude y de OpenAI, y guarda la clave en una variable de entorno, nunca en el código.

Herramientas para hacer RAG, con y sin código

Sin programar

Si lo que quieres es preguntar a tus PDF, no hace falta montar nada:

• Gemini Notebook, el antiguo NotebookLM (Google lo renombró el 16 de julio de 2026), responde citando tus fuentes. En el plan gratuito admite 50 fuentes por cuaderno (100 en Plus, 300 en Pro, hasta 600 en Ultra) y 500.000 palabras o 200 MB por fuente. Lo explicamos a fondo en nuestra guía de NotebookLM.
• Los proyectos de Claude: en los planes de pago, cuando el conocimiento del proyecto se acerca al límite de contexto, se activa solo un modo RAG que, según Anthropic, multiplica hasta por diez la capacidad del proyecto.
• Los proyectos de ChatGPT también admiten archivos de referencia; los límites dependen del plan.

Para resúmenes de documentos sueltos, más que preguntas sobre una biblioteca, mira qué IA usar para resumir PDF.

Con código, pieza a pieza

Si montas tu propio RAG, cada pieza tiene varias opciones. Precios a 8 de octubre de 2026.

Para los embeddings por API, OpenAI cobra 0,02 dólares por millón de tokens con text-embedding-3-small y 0,13 con text-embedding-3-large, y Google, 0,20 con Gemini Embedding 2, que tiene nivel gratuito. Anthropic no tiene modelo de embeddings propio y recomienda Voyage, cuya familia actual es Voyage 4. Si prefieres modelos abiertos que funcionan en tu máquina, tienes los de Sentence Transformers, como el del ejemplo, o voyage-4-nano, con pesos abiertos bajo licencia Apache 2.0.

La base vectorial puede ser pgvector, si ya usas PostgreSQL; Chroma, Qdrant o Milvus, de código abierto con licencia Apache 2.0; Weaviate; FAISS, una biblioteca de Meta con licencia MIT; o Pinecone, que es un servicio gestionado.

Para reordenar resultados, Cohere tiene rerank-v4.0-pro y rerank-v4.0-fast, multilingües, y Voyage, rerank-3. Y si quieres un framework que junte todas las piezas, tienes LangChain y LlamaIndex (licencia MIT) y Haystack (Apache 2.0).

Con código, todo gestionado

Si no quieres mantener la base vectorial, los proveedores ofrecen RAG como servicio. La herramienta file search de OpenAI cobra 0,10 dólares por GB y día de almacenamiento (el primer GB gratis) y 2,50 dólares por cada 1.000 búsquedas. La File Search de la API de Gemini no cobra el almacenamiento ni los embeddings de las preguntas: solo los de la indexación, más los tokens recuperados como contexto normal. A cambio, controlas menos cómo se trocea y se busca.

Los errores habituales al montar un RAG

1. Trozos huérfanos. Fragmentos que no dicen de qué documento, producto o fecha hablan. Arreglo barato: anteponer a cada trozo el título del documento y del apartado. Arreglo serio: la recuperación contextual de Anthropic, que genera con un modelo una frase de contexto para cada trozo.
2. Solo búsqueda semántica. Falla con códigos, referencias y nombres propios. Añade BM25.
3. Un modelo de embeddings en inglés para textos en español. Busca peor sin avisar.
4. Recuperar muy poco. En las pruebas de Anthropic, pasar 20 fragmentos al modelo funcionó mejor que pasar 5 o 10. Con modelos de contexto largo, quedarte corto suele salir más caro que pasarte.
5. No medir. Prepara 30 o 50 preguntas reales con su respuesta y comprueba dos cosas por separado: si el fragmento correcto aparece entre los recuperados y si la respuesta final es correcta. Sin eso, cada cambio es a ojo.
6. Documentos viejos y duplicados. Si conviven la política de 2024 y la de 2026, el sistema puede citar la vieja. La limpieza de la biblioteca es parte del proyecto.
7. Permisos y texto hostil. Un RAG sobre los documentos de la empresa puede enseñar a un empleado lo que no debería ver: filtra por permisos con los metadatos antes de buscar. Y un documento puede llevar instrucciones escondidas para el modelo (la inyección de prompts, que explicamos en qué es un agente de IA).

Por dónde seguir

• RAG es una de las herramientas típicas de un agente: el contexto completo está en qué es un agente de IA.
• Para conectar un asistente con tus documentos, bases de datos o aplicaciones sin programar cada integración, mira MCP explicado.
• Para montar un asistente que use tus datos sin escribir código, tu primer agente de IA con n8n.