Explorar guías rápidas · Ingeniería de IA para datos
Optimización de tokens en LLM
Reduce el consumo de tokens de un LLM en aplicaciones de datos sin perder el contexto ni la calidad que necesitas: mide primero, recorta prompts e historial, limita la recuperación, compacta la salida, usa caché y enruta.
En esta página
- Problema
- Respuesta rápida
- Fundamentos de los tokens
- Tokens de entrada y de salida
- Por qué el contexto repetido es caro
- Código / comandos
- 1. Medir antes de optimizar
- 2. Acortar y deduplicar instrucciones
- 3. Mantener estables las instrucciones estables
- 4. Resumir o recortar el historial de conversación
- 5. Limitar el contexto recuperado
- 6. Fragmentar solo cuando sea útil
- 7. Enviar el esquema relevante, no todo el catálogo
- 8. Pedir formatos de salida concisos
- 9. Salida estructurada frente a prosa extensa
- 10. Cachear el contexto estable y los resultados
- 11. Enrutar cada tarea al modelo adecuado, o a ninguno
- 12. Agrupar elementos pequeños cuando la tarea lo permita
- Tabla de decisión de técnicas
- Qué revisar
- Errores comunes
- 1. Optimizar sin una línea base
- 2. Usar el máximo de tokens de salida para acortar las respuestas
- 3. Perder identificadores al resumir
- 4. Recuperar un top-20 «por si acaso»
- 5. Datos volátiles al inicio del prompt
- 6. Enviar esquemas o catálogos completos
- 7. Contar caracteres o palabras
- 8. Suponer que menos tokens siempre es más barato
- 9. Ignorar los tokens de reintentos y de razonamiento
- Notas de producción
- Lista de comprobación
- Siguiente paso
- Para profundizar
Problema
Una funcionalidad con LLM funciona en pruebas. En producción:
- la factura crece más rápido que el uso
- la latencia aumenta a medida que las conversaciones se alargan
- algunas solicitudes alcanzan el límite de la ventana de contexto
- las mismas instrucciones y esquemas se reenvían en cada llamada
- las respuestas son largas cuando bastaría un resultado estructurado y corto
Los tokens determinan tres cosas a la vez: el costo, la latencia y lo que cabe en la ventana de contexto.
El objetivo no es el prompt más corto posible. Es enviar y generar solo lo que la tarea necesita, y demostrar que la calidad no bajó.
Respuesta rápida
- Mide el uso de tokens por funcionalidad, por modelo, de entrada y de salida.
- Elimina lo que el modelo no necesita: instrucciones duplicadas, esquemas completos, historial obsoleto, fragmentos poco relevantes.
- Restringe la salida: formato estructurado compacto, longitud explícita y un máximo de tokens de salida como límite de seguridad.
- Reutiliza lo que se repite: un prefijo de prompt estable (caché de prompts del proveedor, donde exista) y resultados en caché para solicitudes idénticas.
- Enruta las tareas simples a un modelo más pequeño, o a código normal.
- Vuelve a comprobar la calidad con un conjunto de evaluación después de cada cambio.
tokens de entrada = instrucciones del sistema + definiciones de herramientas + ejemplos
+ historial de conversación + contexto recuperado + resultados de herramientas + entrada del usuario
tokens de salida = respuesta generada (+ tokens de razonamiento, en los modelos que los cobran)
Fundamentos de los tokens
- Los modelos leen y escriben tokens, no caracteres ni palabras. Un token es un fragmento de texto producido por el tokenizador del modelo.
- El número de tokens depende del tokenizador: el mismo texto puede dar recuentos distintos en distintas familias de modelos.
- El código, el JSON, los identificadores largos, los números, los espacios y el texto que no está en inglés suelen tokenizarse de forma menos eficiente que la prosa en inglés.
- Las estimaciones basadas en caracteres sirven para planificar. Para cifras reales, usa el tokenizador del modelo o los campos de uso que devuelve la API.
- Todo lo que va en la solicitud cuenta: prompt del sistema, definiciones de herramientas/funciones, ejemplos, historial, documentos recuperados, resultados de herramientas.
- La ventana de contexto limita lo que cabe en una solicitud. Según el modelo, la entrada y la salida la comparten o la salida tiene su propio límite.
Tokens de entrada y de salida
| Tokens de entrada | Tokens de salida | |
|---|---|---|
| Qué son | Todo lo que envías | Todo lo que genera el modelo |
| Cómo los controlas | Diseño del prompt, límites de recuperación, política de historial | Formato de salida, instrucciones, máximo de tokens de salida |
| Precio | Normalmente se cobran por token | Normalmente se cobran por token, a menudo más caros que la entrada |
| Latencia | Añaden tiempo de procesamiento antes del primer token | El tiempo de generación crece con el número de tokens generados |
Los precios y la relación entrada/salida dependen del modelo y cambian con el tiempo. Consúltalos en la lista de precios actual del proveedor, nunca en una guía rápida.
Algunos modelos generan tokens de razonamiento internos que se cobran como salida aunque no se devuelvan. Revisa los campos de uso.
Por qué el contexto repetido es caro
Las API de LLM habituales no guardan estado: una «conversación» reenvía el historial en cada turno. El contexto fijo (instrucciones, esquema, ejemplos) se vuelve a pagar en cada llamada y el historial crece en cada turno.
def cumulative_input_tokens(base: int, per_turn: int, turns: int) -> int:
"""Tokens de entrada enviados en toda una conversación cuando se reenvía el historial completo en cada turno."""
return sum(base + per_turn * (turn - 1) for turn in range(1, turns + 1))
print(cumulative_input_tokens(base=2_000, per_turn=300, turns=20)) # 97000
Con un contexto fijo de 2.000 tokens y 300 tokens añadidos por turno, 20 turnos envían 97.000 tokens de entrada, de los cuales 40.000 son el mismo contexto fijo repetido. La parte del historial crece aproximadamente con el cuadrado del número de turnos.
La misma aritmética se aplica a los pipelines batch: una llamada al LLM por fila con un bloque de instrucciones de 1.500 tokens paga esas instrucciones en cada fila.
Código / comandos
1. Medir antes de optimizar
Registra el uso de cada llamada. Mapea los campos de uso del proveedor una sola vez, en tu wrapper.
import json
import logging
import time
log = logging.getLogger("llm.usage")
def record_usage(feature: str, model: str, prompt_version: str, usage: dict, started: float) -> None:
"""Registra el uso de tokens de una llamada. `usage` es el bloque de uso que devuelve la API del proveedor."""
log.info(json.dumps({
"feature": feature,
"model": model,
"prompt_version": prompt_version,
"input_tokens": usage.get("input_tokens"),
"output_tokens": usage.get("output_tokens"),
"cached_input_tokens": usage.get("cached_input_tokens", 0),
"latency_ms": round((time.monotonic() - started) * 1000),
}))
Registra recuentos, no el texto de los prompts: pueden contener datos sensibles.
Encuentra los mayores consumidores (T-SQL sobre una tabla de uso):
SELECT
feature,
model,
COUNT(*) AS requests,
AVG(input_tokens) AS avg_input_tokens,
AVG(output_tokens) AS avg_output_tokens,
SUM(input_tokens + output_tokens) AS total_tokens
FROM llm_usage_log
WHERE requested_at >= DATEADD(day, -7, SYSUTCDATETIME())
GROUP BY feature, model
ORDER BY total_tokens DESC;
Después, desglosa un prompt representativo por componente:
def prompt_breakdown(parts: dict[str, str], count_tokens) -> dict[str, int]:
"""Tokens por componente del prompt; `count_tokens` es la función del tokenizador de tu modelo."""
return {name: count_tokens(text) for name, text in parts.items()}
# {"system": 1850, "schema": 4200, "history": 6100, "retrieved": 3900, "question": 40}
Optimiza primero el componente más grande.
2. Acortar y deduplicar instrucciones
Los prompts de sistema largos acumulan reglas repetidas, fórmulas de cortesía y ejemplos que nadie volvió a probar.
Antes:
Eres un asistente muy útil, cuidadoso y preciso. Asegúrate siempre de responder
con exactitud. Es muy importante que seas exacto. Responde siempre en JSON.
Asegúrate de que la respuesta sea JSON. No incluyas nada más que JSON en tu respuesta.
Después:
Clasifica el ticket de soporte. Devuelve solo JSON que cumpla el esquema.
Conserva las instrucciones que cambian el comportamiento. Elimina las que se repiten y vuelve a ejecutar el conjunto de evaluación para confirmarlo.
3. Mantener estables las instrucciones estables
Pon el contenido fijo al principio y el variable al final:
[estable] rol, reglas, esquema de salida, ejemplos
[variable] contexto recuperado, entrada del usuario
Así los prompts son más fáciles de versionar y la caché de prompts/prefijos del proveedor puede funcionar donde se ofrezca (la longitud mínima y la caducidad dependen del proveedor).
No inyectes marcas de tiempo, ID de solicitud ni nombres de usuario en la parte estable: cualquier cambio al principio impide reutilizar el prefijo.
4. Resumir o recortar el historial de conversación
Opciones, de la más simple a la más elaborada:
- conservar los últimos N turnos
- conservar los últimos N turnos más un resumen continuo de los anteriores
- conservar hechos y decisiones extraídos en lugar de los turnos completos
- eliminar los resultados de herramientas una vez usados
def build_history(turns: list[dict], summary: str | None, keep_last: int = 4) -> list[dict]:
"""Conserva los últimos turnos tal cual y reemplaza los anteriores por un resumen continuo."""
recent = turns[-keep_last:]
if summary and len(turns) > keep_last:
return [{"role": "user", "content": f"Resumen de la conversación anterior:\n{summary}"}] + recent
return recent
Los resúmenes pierden detalle. Pide al resumidor que conserve literalmente identificadores, números, nombres de tablas y decisiones.
5. Limitar el contexto recuperado
Más fragmentos no significa más precisión. Los fragmentos poco relevantes cuestan tokens y pueden distraer al modelo.
def select_chunks(chunks: list[dict], budget_tokens: int, min_score: float) -> list[dict]:
"""Fragmentos con mejor puntuación, sin duplicados, que caben en un presupuesto de tokens."""
selected, seen, used = [], set(), 0
for chunk in sorted(chunks, key=lambda c: c["score"], reverse=True):
if chunk["score"] < min_score or chunk["text_hash"] in seen:
continue
if used + chunk["tokens"] > budget_tokens:
continue
selected.append(chunk)
seen.add(chunk["text_hash"])
used += chunk["tokens"]
return selected
Ajusta budget_tokens y min_score con un conjunto de evaluación; no existe un top-k universal.
6. Fragmentar solo cuando sea útil
La fragmentación (chunking) sirve para recuperar información en corpus grandes. No siempre hace falta:
- un documento corto y completamente relevante puede enviarse una vez
- los datos estructurados suelen funcionar mejor consultados (SQL, agregados) que convertidos en fragmentos de texto
- los fragmentos demasiado pequeños pierden contexto; los demasiado grandes desperdician tokens
7. Enviar el esquema relevante, no todo el catálogo
Para generar SQL, envía solo las tablas y columnas que necesita la pregunta, en forma compacta:
orders(order_id int pk, customer_id int fk->customers, order_date date,
status varchar -- 'open' | 'shipped' | 'cancelled', amount decimal(12,2))
customers(customer_id int pk, country char(2), segment varchar)
Preselecciona las tablas con búsqueda en metadatos o con un paso de recuperación a nivel de tabla. Añade descripciones solo donde un nombre sea ambiguo.
8. Pedir formatos de salida concisos
Indica el formato y la longitud que necesitas:
Devuelve solo JSON que cumpla el esquema. Sin explicación. "reason" debe tener como máximo 15 palabras.
Fija también un máximo de tokens de salida, pero como límite de seguridad, no como forma de acortar las respuestas: un límite demasiado bajo corta la salida a mitad del JSON.
9. Salida estructurada frente a prosa extensa
Prosa:
Tras revisar el ticket con atención, parece que lo más probable es que el cliente
tenga un problema de facturación, ya que menciona que se le cobró dos veces...
Estructurada:
{"label": "billing_issue", "confidence": 0.82, "evidence": "cobrado dos veces"}
La salida estructurada suele ser más corta, más fácil de validar y de almacenar. Las claves también cuestan tokens: mantenlas cortas pero legibles. Usa la función de salida estructurada / esquema JSON del proveedor cuando exista, y valida igualmente.
10. Cachear el contexto estable y los resultados
Dos mecanismos distintos:
- Caché de prompts/prefijos (función del proveedor, donde exista): los prefijos idénticos repetidos pueden cobrarse y procesarse a menor costo. Las condiciones varían.
- Caché de resultados de la aplicación: entradas idénticas devuelven una respuesta almacenada sin llamar al modelo.
import hashlib
import json
def cache_key(model: str, prompt_version: str, payload: dict) -> str:
"""Clave estable para una caché de resultados: mismo modelo, misma versión de prompt y entrada normalizada."""
raw = json.dumps({"m": model, "v": prompt_version, "p": payload}, sort_keys=True, ensure_ascii=False)
return hashlib.sha256(raw.encode("utf-8")).hexdigest()
Una caché de resultados solo ayuda cuando las entradas se repiten. Incluye la versión del prompt y el modelo en la clave, y define una caducidad cuando cambian los datos subyacentes.
11. Enrutar cada tarea al modelo adecuado, o a ninguno
def route(task: str, text: str) -> str:
if task in {"parse_date", "extract_email"}:
return "code" # parser determinista: sin llamada al LLM
if task in {"classify_ticket", "extract_fields"} and len(text) < 4_000:
return "small-model"
return "large-model"
El enrutamiento no reduce tokens; hace que cada token sea más barato y a menudo más rápido. Escala a un modelo más grande cuando falle la validación, en lugar de enviarlo todo al más grande.
12. Agrupar elementos pequeños cuando la tarea lo permita
Varios registros por llamada comparten una sola copia de las instrucciones:
{"records": [
{"id": "t-101", "text": "Reembolso no recibido"},
{"id": "t-102", "text": "No puedo iniciar sesión tras restablecer la contraseña"}
]}
Exige los ID en la salida y comprueba que cada ID de entrada vuelve exactamente una vez. Los lotes grandes pueden bajar la calidad y hacer que un fallo afecte a muchos registros.
Tabla de decisión de técnicas
| Técnica | Ahorra tokens de entrada | Ahorra tokens de salida | Riesgo principal |
|---|---|---|---|
| Acortar / deduplicar el prompt del sistema | Sí | — | Quitar una instrucción de la que dependía el modelo |
| Resumir el historial | Sí | — | Perder hechos, ID o decisiones |
| Reducir los fragmentos recuperados | Sí | — | Descartar el fragmento que tenía la respuesta |
| Enviar solo el esquema relevante | Sí | — | Preselección de tablas errónea, SQL incorrecto |
| Pedir JSON compacto | — | Sí | Menos explicación para lectores humanos |
| Fijar un máximo de tokens de salida | — | Acota el peor caso | Salida truncada o no válida |
| Caché de prompts/prefijos | Reduce el costo de la entrada repetida, donde exista | — | Cualquier cambio de prefijo la anula; reglas propias de cada proveedor |
| Cachear resultados repetidos | Se evita toda la solicitud | Se evita toda la solicitud | Respuestas obsoletas, clave de caché incorrecta |
| Enrutar tareas simples a un modelo más pequeño | Mismos tokens, más baratos | Mismos tokens, más baratos | Menor calidad en casos difíciles |
| Agrupar registros por llamada | Sí, instrucciones compartidas | Ligeramente | Fallos parciales, ID que no cuadran |
El ahorro depende de la carga de trabajo. Mídelo; no supongas un porcentaje.
Qué revisar
- Qué componente domina la entrada: instrucciones, esquema, historial, recuperación o resultados de herramientas.
- La relación salida/entrada por funcionalidad.
- Tokens por solicitud en p50 y p95, no solo el promedio.
- Solicitudes cercanas al límite de la ventana de contexto.
- Reintentos: una validación fallida hace pagar la solicitud dos veces.
- La tasa de aciertos de la caché, si la usas.
- En bucles de agentes o herramientas, los resultados de herramientas reinyectados en cada paso.
Errores comunes
1. Optimizar sin una línea base
Sin un conjunto de evaluación no puedes saber si un prompt más corto es más barato y sigue siendo correcto.
2. Usar el máximo de tokens de salida para acortar las respuestas
El modelo no planifica en función del límite; la salida se corta. Pide brevedad en las instrucciones y deja el límite como seguridad.
3. Perder identificadores al resumir
«El usuario preguntó por una tabla» no sirve. Conserva sales.orders, el rango de fechas y la decisión tomada.
4. Recuperar un top-20 «por si acaso»
Los fragmentos de más cuestan tokens y pueden llevar al modelo hacia la fuente equivocada.
5. Datos volátiles al inicio del prompt
Marcas de tiempo o ID de usuario en las primeras líneas anulan la caché de prefijos y hacen ruidosas las comparaciones de prompts.
6. Enviar esquemas o catálogos completos
Miles de columnas para una pregunta sobre dos tablas.
7. Contar caracteres o palabras
Las estimaciones se desvían, sobre todo con código, JSON y texto que no está en inglés. Usa el tokenizador o los campos de uso de la API.
8. Suponer que menos tokens siempre es más barato
Un prompt más corto que provoca reintentos, escalados o respuestas incorrectas puede costar más por tarea completada.
9. Ignorar los tokens de reintentos y de razonamiento
Aparecen en la factura, no en tu prompt.
Notas de producción
- Versiona los prompts y registra la versión junto al uso, para relacionar un cambio de costo con un cambio de prompt.
- Define presupuestos de tokens por funcionalidad, con alertas.
- Vuelve a ejecutar la evaluación de calidad después de cada optimización.
- Los tokenizadores y los precios dependen del modelo: vuelve a medir al cambiar de modelo.
- Deja margen en la ventana de contexto para la salida.
- Registra recuentos de tokens, no prompts completos, cuando los prompts puedan contener datos de clientes o sensibles.
Lista de comprobación
- El uso se registra por funcionalidad, modelo y versión de prompt.
- Se conoce el componente más grande del prompt.
- Las instrucciones están deduplicadas y probadas.
- El contenido estable va primero; el volátil, al final.
- El historial tiene una política de retención o resumen.
- La recuperación tiene un presupuesto de tokens y un umbral de relevancia.
- Solo se envía el esquema relevante.
- El formato de salida es compacto y se valida.
- El máximo de tokens de salida se usa como límite de seguridad.
- La caché se usa solo donde las entradas o los prefijos se repiten de verdad.
- Las tareas simples se enrutan a modelos más baratos o a código.
- La calidad se vuelve a comprobar tras cada cambio.
¿Te resultó útil este contenido?
¿Qué podríamos mejorar?
Gracias — esto me ayuda a mejorar Javi Builds.
Mantente al día
Recibe solo las novedades de Javi Builds que realmente te interesan.
Revisa tu bandeja de entrada
Te he enviado un enlace de confirmación. Tu suscripción se activará cuando la confirmes.