Cuánto cuesta una pregunta RAG: cuántos fragmentos enviar

Tu chatbot de documentos funciona, llega la primera factura y es más grande de lo que las preguntas merecen. En casi todas las configuraciones de RAG el dinero se va a un solo sitio: los fragmentos recuperados que pegas delante de cada pregunta. Una pregunta RAG cuesta los tokens de la pregunta, tus instrucciones y N fragmentos en la entrada, más una respuesta corta en la salida. Los fragmentos son la parte que controlas, y cada uno añade el mismo número de tokens a cada petición.

Esta guía cuenta una petición, calcula el precio de 1.000 y 100.000 con precios en vivo, y muestra qué cambia cuando pasas el top-k de 3 a 10. La recuperación en sí (tu almacén vectorial, tu troceado) se queda de tu lado; solo la llamada final de generación va a la API del modelo. Si el facturado de entrada y salida es nuevo para ti, empieza por tokens de entrada vs salida.

Qué entra en una petición RAG#

Supón que tienes un bot de soporte sobre los documentos de la empresa. Un cliente pregunta: «¿Cómo restablezco el inicio de sesión en dos pasos?», tu recuperador devuelve los cinco mejores pasajes y envías esto al modelo:

• un prompt de sistema: «Responde solo con el contexto. Si no está ahí, dilo.» — unos 300 tokens una vez añades las reglas de formato;
• la pregunta con un poco de contexto de chat — unos 200 tokens;
• 5 fragmentos de unos 500 tokens cada uno — 5 × 500 = 2.500 tokens;
• la respuesta: dos o tres párrafos cortos — unos 300 tokens de salida.

La entrada son 2.500 + 300 + 200 = 3.000 tokens, la salida unos 300. Estas son las suposiciones del autor para un bot de soporte típico; sustituye por tus propios números. Todo lo que sigue usa esta petición como unidad.

La forma rápida de ver el reparto: los fragmentos son aproximadamente cinco sextos de toda la entrada, y la entrada es diez veces la respuesta. Prueba la estimación tú mismo:

Cuánto cuestan 1.000 preguntas#

Una petición es demasiado pequeña para notarla, así que escálala. Con 3.000 tokens de entrada y 300 de salida, 1.000 preguntas envían 3.000.000 de tokens de entrada y generan 300.000 de salida. Arrastra los deslizadores de abajo para ajustarlos a tu propio bot; el sitio recalcula con precios en vivo para cada modelo.

La tabla muestra la misma carga de trabajo para los tres modelos, con la referencia de OpenRouter al lado. Contado en total, con entrada y salida juntas, cada uno sale más barato que OpenRouter aquí.

¿Y con 100.000 preguntas? Eso son 300.000.000 de tokens de entrada y 30.000.000 de salida. En DeepSeek-V4-Flash son $7.50, en GLM-5.3-Flash $7.20, en MiniMax-M2.7 $19.50. Los precios son fijos por modelo, sin horas punta, así que un lote nocturno y un chat diurno cuestan lo mismo por token. Consulta la lista completa de precios en la página de precios.

Top-k: cada fragmento añade la misma cantidad#

Aquí está el segundo escenario: un asistente de wiki interna. Alguien sugiere: «Enviemos 10 fragmentos en vez de 3, por si acaso». La entrada crece en línea recta: cada fragmento son otros 500 tokens en cada petición.

2.000 frente a 5.500 tokens: la respuesta tiene la misma longitud, así que toda la diferencia en la factura del asistente de wiki es entrada. Si te compra una mejor respuesta es una cuestión de calidad: pasado el punto en que el pasaje correcto ya está en el contexto, los fragmentos extra sobre todo añaden ruido y coste. Una forma práctica de elegir k es tomar un conjunto de preguntas reales, comprobar en qué k aparece el pasaje correcto y parar un poco por encima de eso.

La ventana de contexto es el otro límite. Los tres modelos de aquí tienen espacio de sobra para un top-k normal: 180K tokens para MiniMax-M2.7, 380K para DeepSeek-V4-Flash y 390K para GLM-5.3-Flash. Los límites de salida difieren: hasta 8.192 tokens por respuesta para GLM-5.3-Flash y MiniMax-M2.7, hasta 32.768 para DeepSeek-V4-Flash, lo que importa si tus respuestas son informes largos en vez de réplicas cortas.

El documento entero en el prompt, o cuatro fragmentos#

Tercer escenario: preguntas y respuestas sobre contratos. La versión perezosa pega el PDF entero de 30.000 tokens en cada pregunta. La versión con recuperación envía la pregunta, las instrucciones y cuatro fragmentos relevantes de unos 650 tokens cada uno, unos 3.000 tokens en total. Las mismas 1.000 preguntas, las mismas respuestas de 300 tokens:

El documento completo envía diez veces la entrada, 30.000 ÷ 3.000 = 10, para la misma pregunta. Sigue teniendo sentido para una pregunta puntual sobre un documento que cabe en el contexto. Para un bot que responde todo el día, es la opción cara por defecto. Si gran parte de esa entrada es el mismo texto cada vez, lee sobre caché de prompts.

Envía la petición#

Abajo está el paso de generación. La parte de recuperación es tuya: chunks es lo que devolvió tu almacén vectorial. El mismo código funciona con el SDK de OpenAI o con curl simple.

from openai import OpenAI

client = OpenAI(
    base_url="https://api.cheaptokens.dev/v1",
    api_key="YOUR_CHEAPTOKENS_KEY",
)

chunks = ["Chunk 1 text...", "Chunk 2 text...", "Chunk 3 text..."]
context = "\n\n---\n\n".join(chunks)

resp = client.chat.completions.create(
    model="deepseek-ai/DeepSeek-V4-Flash-0731",
    max_tokens=400,
    messages=[
        {"role": "system", "content": "Answer only from the context. If the answer is not there, say so."},
        {"role": "user", "content": f"Context:\n{context}\n\nQuestion: How do I reset two-factor login?"},
    ],
)
print(resp.choices[0].message.content)
print(resp.usage.prompt_tokens, resp.usage.completion_tokens)

curl https://api.cheaptokens.dev/v1/chat/completions \
  -H "Authorization: Bearer YOUR_CHEAPTOKENS_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-ai/DeepSeek-V4-Flash-0731",
    "max_tokens": 400,
    "messages": [
      {"role": "system", "content": "Answer only from the context. If the answer is not there, say so."},
      {"role": "user", "content": "Context:\nChunk 1...\n\nQuestion: How do I reset two-factor login?"}
    ]
  }'

La última línea del ejemplo de Python es la útil. usage.prompt_tokens es tu entrada real por pregunta; compárala con la estimación de 3.000 y sustituye mis suposiciones por tus números. Usa el id completo del modelo, como en el ejemplo: deepseek-ai/DeepSeek-V4-Flash-0731. Los ids están listados en la documentación. La configuración completa está en la documentación, y si quieres ver cómo se acumulan los tokens de un bot a lo largo de un diálogo, por qué un chat largo cuesta más cubre la parte del historial.

Cuatro formas de reducir la entrada#

Empieza por max_tokens, que limita la respuesta y te protege de una réplica desbocada. Luego baja k al valor más pequeño que siga encontrando el pasaje correcto. Haz los fragmentos más ajustados, para que 500 tokens lleven 500 tokens de significado y no cabeceras y texto repetitivo. Elimina fragmentos duplicados antes de enviar: dos pasajes casi idénticos cuestan el doble y dicen lo mismo una vez. Y mide con usage sobre tráfico real, porque una suposición sobre fragmentos de 500 tokens es solo una suposición. Para una visión más amplia de a dónde van los tokens en una llamada a la API, consulta cuántos tokens usa una petición.

Pon tus propios tokens por petición en la calculadora de arriba para calcular el precio de tu bot en los tres modelos; si tus respuestas son largas, DeepSeek-V4-Flash es el primero que deberías mirar.