¿Cuánto cuesta un sistema RAG? Embeddings, base de datos y LLM

Un sistema RAG parece caro porque tiene muchas piezas: modelo de embeddings, base de datos vectorial, LLM, servidor. En la práctica, la factura suele concentrarse en una sola, y saber cuál cambia las decisiones de diseño. Optimizar la base vectorial mientras envías 10 fragmentos enormes a un modelo caro es ahorrar en el lugar equivocado.

Los números de este artículo son hipotéticos, elegidos para facilitar la cuenta, en dólares estadounidenses y sin impuestos. No son precios de ningún proveedor; los valores reales están en las páginas oficiales de precios.

¿De qué está hecho el costo de un RAG?#

Un RAG tiene dos fases, cada una con sus costos:

• Indexación (una vez, y de nuevo en cada actualización): dividir los documentos en fragmentos, generar el embedding de cada fragmento y guardar los vectores en un índice.
• Consulta (en cada pregunta): generar el embedding de la pregunta, buscar los fragmentos más parecidos y enviar pregunta y fragmentos al LLM, que escribe la respuesta.

Eso da cuatro líneas en la factura: embeddings, almacenamiento y búsqueda de los vectores, generación en el LLM y hosting de la aplicación que lo une todo.

¿Cuánto cuestan los embeddings?#

Los modelos de embeddings cobran solo la entrada, por millón de tokens, y cuestan mucho menos que los de generación. Las cuentas de abajo usan tres gamas hipotéticas:

Algunos proveedores dan una cuota de tokens sin costo por cuenta, y otros hacen descuento en modo batch. Los valores actuales están en las páginas de precios de proveedores como OpenAI, Voyage AI y Google. El proveedor de los embeddings no tiene que ser el mismo de la generación: la documentación de embeddings de Anthropic, por ejemplo, recomienda Voyage AI.

La cuenta de la indexación es pequeña. Ejemplo hipotético: un acervo de 10.000 documentos de 2.000 tokens suma 20 millones de tokens: US$1 con el embedding pequeño, US$5 con el premium y cero mientras dure una cuota sin costo, si el proveedor la ofrece. Las preguntas también se convierten en embeddings, pero con unos 50 tokens cada una, mil preguntas al día suman 1,5 millones de tokens al mes: siete centavos y medio de dólar.

¿Cuánto cuesta guardar y buscar los vectores?#

El tamaño de cada vector depende de sus dimensiones: cada una ocupa 4 bytes en precisión simple (float32) y 2 bytes en media precisión (float16), más unos bytes de cabecera por vector. Con 20 millones de tokens en fragmentos de 500 tokens, son 40.000 fragmentos:

• 40.000 × (4 × 1.536 + 8) bytes ≈ 246 MB de vectores en precisión simple.
• La mitad, ≈ 123 MB, en media precisión.
• Suma el texto de los fragmentos (que guardas para enviarlo al LLM) y el índice de búsqueda, que ocupa su propio espacio.

Hay dos caminos para alojar esto:

1. Una extensión vectorial en una base que administras tú mismo. Algunas bases relacionales aceptan extensiones open source que guardan y buscan vectores. El costo es el del servidor de la base, y 40.000 fragmentos caben con holgura en un servidor pequeño.
2. Un servicio vectorial dedicado. Suele tener un plan sin cuota mensual, con límites de almacenamiento, de lecturas y escrituras al mes y de región, y planes de pago con un mínimo mensual, más un cobro por GB almacenado y por millón de operaciones de lectura y escritura. La página de precios de Pinecone es un ejemplo de cómo se arma esa tabla.

Para un acervo de este tamaño, el almacenamiento cuesta menos de un dólar en cualquier opción. Lo que pesa es el mínimo del plan. La comparación entre tipos de base está en qué es una base de datos vectorial.

¿Cuánto cuesta la generación en el LLM?#

Aquí está la mayor parte de la factura. Cada pregunta envía al modelo el prompt de sistema, los fragmentos recuperados y la pregunta. Con 5 fragmentos de 500 tokens, la entrada llega a 3.000 tokens aunque la pregunta tenga una línea.

Las cuentas usan las mismas tres gamas hipotéticas de precio por millón de tokens (entrada y salida) del artículo sobre la API de un LLM: un modelo pequeño a US$0,20 y US$1, otro pequeño con salida más cara a US$0,50 y US$4 y uno intermedio a US$4 y US$20. Los valores reales están en la página de precios de cada proveedor. Cómo funciona el cobro por token está explicado en cuánto cuesta usar la API de un LLM.

¿Cuánto cuesta un RAG con mil preguntas al día?#

Ejemplo hipotético: 10.000 documentos (20 millones de tokens), fragmentos de 500 tokens, mil preguntas al día (30.000 al mes), 5 fragmentos por pregunta, un prompt de sistema de 450 tokens, una pregunta de 50 y una respuesta de 400. El script de abajo hace la cuenta (cualquier versión actual de Python 3, sin dependencias):

"""costo_rag.py: ejecútalo con python costo_rag.py.
Precios en US$ por millón de tokens: valores hipotéticos, cámbialos por los actuales."""

EMBEDDING = 0.05  # embedding pequeño (hipotético)
MODELOS = {
    "pequeno-a": (0.20, 1.00),
    "pequeno-b": (0.50, 4.00),
    "intermedio": (4.00, 20.00),
}

tokens_acervo = 20_000_000  # indexación: 10.000 documentos de 2.000 tokens
tokens_por_fragmento = 500
dimensiones = 1536
fragmentos = tokens_acervo // tokens_por_fragmento
bytes_por_vector = 4 * dimensiones + 8  # float32 + cabecera

print(f"Indexación: US$ {tokens_acervo / 1e6 * EMBEDDING:.2f} (una vez)")
print(f"Fragmentos: {fragmentos}, vectores: {fragmentos * bytes_por_vector / 1e6:.0f} MB")

preguntas = 30_000  # mil preguntas al día
entrada = 450 + 5 * tokens_por_fragmento + 50  # sistema + 5 fragmentos + pregunta
salida = 400
emb_preguntas = preguntas * 50 / 1e6 * EMBEDDING

for nombre, (precio_in, precio_out) in MODELOS.items():
    llm = preguntas * (entrada * precio_in + salida * precio_out) / 1e6
    print(f"{nombre}: US$ {llm + emb_preguntas:.2f} al mes")

Resultado:

Cambiar el modelo de generación lleva la factura de US$30 a US$600 al mes; cambiar el modelo de embeddings solo la mueve unos pocos dólares. Suma además el hosting de la aplicación y de la base, que es un costo fijo al mes.

¿Qué costos ocultos aparecen?#

• Demasiados fragmentos. Pasar de 5 a 10 fragmentos casi duplica la entrada de cada pregunta. Prueba con cuántos fragmentos la respuesta sigue siendo buena.
• Reindexación. Cambiar el modelo de embeddings, el tamaño de los fragmentos o la forma de dividir los documentos obliga a generar todos los vectores otra vez. Barato para 20 millones de tokens, caro para miles de millones.
• Historial de conversación. En un chat, el historial se suma a los fragmentos en cada mensaje y la entrada crece rápido.
• Contexto largo. Algunos modelos cobran más por prompts por encima de cierto tamaño. Un RAG que mete documentos enteros en el prompt cae en esa franja.
• Reranker y evaluación. Un modelo de reranking mejora la búsqueda, pero es otra llamada pagada por pregunta. Ejecutar pruebas de calidad también gasta tokens.
• Extracción de documentos. Los PDF escaneados necesitan OCR antes de convertirse en texto, y eso puede costar más que los embeddings.
• Abuso. Un endpoint público sin límite por usuario se convierte en una API de LLM abierta. Mira qué es el prompt injection y pon límites en el código.

¿Cómo reducir el costo de un RAG?#

1. Empieza por el modelo de generación más pequeño y sube solo si las respuestas no sirven.
2. Recupera menos y mejor. Fragmentos más pequeños, menos fragmentos y un corte por similitud mínima reducen la entrada.
3. Limita la salida con max_tokens y pide respuestas cortas.
4. Usa caché de prompt para la parte fija (instrucciones y ejemplos). Los fragmentos cambian en cada pregunta, así que el ahorro está en el prompt de sistema.
5. Guarda las respuestas de preguntas repetidas. Un FAQ interno suele recibir las mismas dudas.
6. Usa batch en la indexación cuando el proveedor ofrece descuento en modo batch para embeddings.

Cómo hacerlo en Square Cloud#

La tabla de arriba muestra que casi toda la cuenta está en la generación. En Square Cloud alojas la aplicación RAG y, desde el Standard, puedes sacar esa línea de tu factura en dólares.

La aplicación (la API que recibe la pregunta, consulta el índice y llama al modelo) corre en un contenedor siempre encendido, sin cold start. Entre diversos runtimes, como Python, Node.js y Go, eliges el de tu stack; consulta los runtimes disponibles hoy en Runtimes. Las claves de los proveedores van en las variables de entorno de la aplicación.

Para la generación, el AI Gateway, desde el Standard (R$44,99 al mes), es una API compatible con la de OpenAI que sirve el modelo cubic. Apuntas el SDK de OpenAI a https://api.squarecloud.app/v2/ai, usas una clave de API de la cuenta con el alcance ai:chat y envías el prompt con los fragmentos recuperados, como harías con cualquier proveedor. El gateway está en beta, con acceso anticipado sin costo extra, y los límites y la disponibilidad pueden cambiar cuando termine la beta. El Standard permite hasta 2,5 millones de tokens y hasta 1.000 peticiones al día, con contexto de hasta 16 mil tokens; el Pro, hasta 5 millones de tokens y hasta 5.000 peticiones al día. Las mil preguntas diarias del ejemplo suman unos 3,4 millones de tokens: superan el Standard y caben en el Pro.

El gateway solo hace la generación. Los embeddings siguen en un proveedor como los de la tabla, que cuestan centavos, y el índice queda en un servicio vectorial externo: no hay base vectorial en la plataforma, y el PostgreSQL alojado es el nativo, sin extensiones (ni pgvector). El hosting de bases de datos, útil para los documentos y el historial, también empieza en el Standard, en el mismo datacenter que las aplicaciones, con una latencia media de alrededor de 1 ms. El Hobby, desde R$12,49, no incluye bases de datos ni el gateway y sirve para una API ligera que llama a proveedores externos. Un modelo de embeddings local, con las wheels de torch y transformers del runtime de Python, no cabe en el Hobby de 1 GB.

Mira los detalles en AI Gateway y cómo publicar la API en Hosting de APIs.