RAG tiene una explicación de una frase: en lugar de esperar que el modelo sepa la respuesta, le buscas la respuesta y se la pegas en el prompt.
Eso es todo. No hay reentrenamiento, no hay fine-tuning, no hay nada que el modelo "aprenda". Hay una búsqueda, un texto que se concatena y una pregunta. El resto de este artículo es sobre por qué esa cosa tan simple falla en producción, y qué hacer al respecto.
Primero, el malentendido que más dinero cuesta
Antes de cualquier código, hay que desarmar algo que se repite mucho, incluso en guías sobre RAG: que para que un modelo conozca tus datos tienes que reentrenarlo o actualizarlo.
No. Esa es exactamente la cosa que RAG existe para evitar.
Reentrenar o hacer fine-tuning cuesta tiempo, dinero y datos etiquetados, y no resuelve el problema que crees: el fine-tuning ajusta el estilo y el formato de las respuestas, no inyecta conocimiento factual de forma confiable. Y cada vez que tus datos cambian —un precio, una política, un documento nuevo— tendrías que volver a hacerlo.
RAG lo resuelve en el momento de la consulta. Tus datos viven en una base que puedes actualizar en un segundo, y el modelo los lee como contexto. Si lo que necesitas es que responda con información tuya y actual, no reentrenes nada.
Los embeddings, sin misticismo
Un embedding es una lista de números que representa un texto. Textos con significado parecido quedan cerca en ese espacio; textos distintos quedan lejos.
Eso es útil por una razón concreta: permite buscar por significado en lugar de por palabras exactas. La pregunta "¿cuánto tarda el envío?" encuentra un documento que dice "los pedidos se entregan en 3 a 5 días hábiles", aunque no comparta ni una palabra con la pregunta.
"Cerca" se mide normalmente con similitud cosenoidal: el ángulo entre dos vectores. Y hay un truco que simplifica todo: si normalizas los vectores a longitud 1, el coseno es simplemente el producto punto. Una multiplicación de matrices.
Eso lleva a lo siguiente, que es la parte que casi nadie dice.
No necesitas una base de datos vectorial
Con unos miles de documentos, una base vectorial es complejidad que no estás usando. Esto es un sistema de recuperación completo, sin servidor, sin servicio y sin dependencias más allá de numpy:
import numpy as np
from sentence_transformers import SentenceTransformer
modelo = SentenceTransformer("all-MiniLM-L6-v2")
fragmentos = [
"Los pedidos nacionales se entregan en 3 a 5 días hábiles.",
"Aceptamos devoluciones dentro de los 30 días posteriores a la compra.",
"El envío es gratuito en compras mayores a $999 MXN.",
"Atención a clientes opera de lunes a viernes, de 9 a 18 horas.",
]
# normalize_embeddings=True hace que el producto punto sea el coseno
indice = modelo.encode(fragmentos, normalize_embeddings=True)
def buscar(pregunta, k=3):
v = modelo.encode(pregunta, normalize_embeddings=True)
similitudes = indice @ v
mejores = np.argsort(-similitudes)[:k]
return [(fragmentos[i], float(similitudes[i])) for i in mejores]
for texto, score in buscar("¿cuánto tarda en llegar mi paquete?"):
print(f"{score:.3f} {texto}")
Eso corre, y es el 90% de lo que hace una base vectorial. El cálculo es una multiplicación de matrices: con 10,000 fragmentos tarda milisegundos.
Cuándo sí necesitas una base vectorial (Pinecone, Qdrant, Weaviate, o pgvector sobre el Postgres que probablemente ya tienes): cuando el índice no cabe en memoria, cuando necesitas filtrar por metadatos a escala, cuando varios procesos deben compartir el índice, o cuando actualizas documentos todo el tiempo y no quieres recalcular todo.
Antes de eso, estás operando un servicio más sin obtener nada. Y pgvector suele ser el siguiente paso correcto justamente porque no agrega un sistema nuevo.
La parte que decide si funciona: el troceado
Aquí está el verdadero trabajo de RAG, y es la decisión de la que menos se habla.
Tus documentos no se indexan completos. Se parten en fragmentos, y el tamaño del fragmento determina la calidad de todo el sistema:
-
Fragmentos muy chicos (una o dos oraciones) recuperan con precisión pero pierden contexto. Recuperas "no aplica en productos de temporada" sin saber a qué no aplica.
-
Fragmentos muy grandes (páginas enteras) traen el contexto pero diluyen la señal: el embedding de una página que habla de cinco temas no se parece mucho a ninguna pregunta específica.
Lo que funciona en la práctica:
Trocea por estructura, no por conteo de caracteres. Un fragmento por sección, por entrada de FAQ, por artículo de política. El documento ya tiene una estructura semántica — úsala en lugar de cortar cada 500 caracteres a ciegas.
Usa traslape cuando tengas que cortar por longitud. Un 10–20% de solapamiento evita que una respuesta quede partida exactamente en la frontera entre dos fragmentos.
Agrega el encabezado a cada fragmento. Si el texto es "3 a 5 días hábiles", indexa "Política de envíos — Tiempos de entrega: 3 a 5 días hábiles". Es barato y mejora la recuperación muchísimo, porque el fragmento ahora contiene las palabras que la gente usa al preguntar.
Guarda de dónde vino cada fragmento. Sin eso no puedes citar fuentes, y sin citas no puedes verificar las respuestas ni depurar los errores.
Dónde falla la búsqueda semántica
La búsqueda por significado es mala justo donde más importa: identificadores exactos.
Números de parte, códigos de error, SKUs, nombres propios, versiones. Para un modelo de embeddings, ERR_4021 y ERR_4210 son casi el mismo vector — y son problemas totalmente distintos.
La solución estándar es búsqueda híbrida: corres en paralelo la búsqueda vectorial y una búsqueda léxica clásica tipo BM25 —que tu Postgres o tu Elasticsearch ya hacen— y combinas los resultados. La léxica atrapa los códigos exactos; la semántica atrapa las preguntas parafraseadas.
Si tu dominio tiene identificadores, la búsqueda híbrida no es una optimización avanzada. Es un requisito, y es la causa más común de un RAG que "funciona en las pruebas" y falla con usuarios reales.
¿Quieres un RAG que de verdad responda con tus datos?
En DevChefs construimos sistemas de recuperación con citas verificables, evaluación y límites de costo. Cuéntanos qué documentación quieres consultar.
La generación, con los dos controles que importan
Con los fragmentos recuperados, la parte de generación es corta — pero tiene dos detalles que separan un demo de algo usable:
UMBRAL = 0.35
PLANTILLA = """Responde la pregunta usando ÚNICAMENTE el contexto de abajo.
Si el contexto no contiene la respuesta, di exactamente:
"No tengo esa información."
No uses conocimiento externo. Cita el número de fuente que usaste.
Contexto:
{contexto}
Pregunta: {pregunta}"""
def responder(pregunta, cliente):
resultados = buscar(pregunta, k=3)
# Control 1: si nada se parece, no llames al modelo
if not resultados or resultados[0][1] < UMBRAL:
return "No tengo esa información.", []
contexto = "\n\n".join(
f"[{i + 1}] {texto}" for i, (texto, _) in enumerate(resultados)
)
respuesta = cliente.chat.completions.create(
model="...", # el modelo de tu proveedor
messages=[
{
"role": "user",
"content": PLANTILLA.format(contexto=contexto, pregunta=pregunta),
}
],
)
return respuesta.choices[0].message.content, resultados
Control 1: el umbral de similitud. Si el mejor resultado no se parece lo suficiente a la pregunta, responde "no sé" sin gastar una llamada al modelo. Sin esto, le estás pasando cuatro fragmentos irrelevantes y pidiéndole que responda — y va a responder, con algo inventado que suena bien. El valor exacto del umbral lo calibras con tus propios datos; 0.35 es un punto de partida, no una constante universal.
Control 2: la instrucción de abstenerse. Decirle explícitamente qué responder cuando no sabe, y pedirle que cite. Las citas no son un adorno de interfaz: son tu herramienta de depuración. Cuando una respuesta esté mal, la cita te dice si falló la recuperación —trajo el fragmento equivocado— o la generación —tenía el fragmento correcto y lo ignoró. Son dos problemas distintos con dos arreglos distintos, y sin citas no puedes distinguirlos.
Qué no arregla RAG
La parte "sin hype" del título:
No elimina las alucinaciones. Las reduce bastante y las hace detectables. Pero el modelo puede ignorar el contexto y responder de memoria, sobre todo si el contexto contradice algo que "cree" firmemente.
No arregla documentación mala. Si tu política de devoluciones es ambigua para un humano, es ambigua para el modelo. RAG expone la calidad de tu documentación; no la mejora. Más de un proyecto de RAG termina siendo, correctamente, un proyecto de reescribir documentación.
No razona sobre todo el corpus. Preguntas como "¿cuántos clientes mencionaron el problema X?" o "¿cuál es la tendencia en estos informes?" requieren leer todo, no recuperar tres fragmentos. RAG responde preguntas puntuales; no hace agregaciones. Para eso necesitas una consulta a base de datos, no recuperación semántica.
No es barato por default. Cada respuesta manda tus fragmentos como tokens de entrada. Tres fragmentos grandes en cada consulta, multiplicados por el volumen, es la línea que crece sin que nadie la mire. Cachea el prompt del sistema y mide tokens por consulta desde el primer día.
Cómo saber si funciona
Esto es lo que casi nadie hace y es lo que separa un proyecto que mejora de uno que sólo cambia.
Arma un archivo con 30 a 50 preguntas reales —de tu soporte, de tu equipo de ventas, de tus usuarios— y para cada una, cuál fragmento debería recuperar. Mide dos cosas por separado:
-
Recuperación: ¿el fragmento correcto apareció entre los primeros k? Esto se mide sin llamar al modelo, es gratis y rápido, y es donde está la mayoría de tus fallas.
-
Respuesta: dado el fragmento correcto, ¿la respuesta fue correcta?
Separarlas es el punto. Casi siempre el problema está en el paso 1, y casi siempre la gente pasa semanas ajustando el prompt del paso 2.
Corre ese conjunto cada vez que cambies el troceado, el modelo de embeddings, el umbral o el prompt. Sin él, "mejoró" es una impresión.
Cierre
RAG es búsqueda más concatenación de texto. La magia que parece tener viene de los embeddings, y los embeddings son una multiplicación de matrices.
El trabajo real está en los lugares poco glamorosos: cómo partes tus documentos, qué haces cuando la búsqueda no encuentra nada, cómo manejas los códigos exactos, y si tienes 40 preguntas con las que verificar que un cambio mejoró las cosas.
Empieza con numpy y cuatro fragmentos. Cuando eso funcione y entiendas por qué falla cuando falla, cambia una pieza a la vez.
