Explorar guías rápidas · Ingeniería de IA para datos

Tecnología: Ingeniería de IA para datosCategoría: Optimización de tokensNivel: IntermedioActualizado

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
  1. Problema
  2. Respuesta rápida
  3. Fundamentos de los tokens
  4. Tokens de entrada y de salida
  5. Por qué el contexto repetido es caro
  6. Código / comandos
  7. 1. Medir antes de optimizar
  8. 2. Acortar y deduplicar instrucciones
  9. 3. Mantener estables las instrucciones estables
  10. 4. Resumir o recortar el historial de conversación
  11. 5. Limitar el contexto recuperado
  12. 6. Fragmentar solo cuando sea útil
  13. 7. Enviar el esquema relevante, no todo el catálogo
  14. 8. Pedir formatos de salida concisos
  15. 9. Salida estructurada frente a prosa extensa
  16. 10. Cachear el contexto estable y los resultados
  17. 11. Enrutar cada tarea al modelo adecuado, o a ninguno
  18. 12. Agrupar elementos pequeños cuando la tarea lo permita
  19. Tabla de decisión de técnicas
  20. Qué revisar
  21. Errores comunes
  22. 1. Optimizar sin una línea base
  23. 2. Usar el máximo de tokens de salida para acortar las respuestas
  24. 3. Perder identificadores al resumir
  25. 4. Recuperar un top-20 «por si acaso»
  26. 5. Datos volátiles al inicio del prompt
  27. 6. Enviar esquemas o catálogos completos
  28. 7. Contar caracteres o palabras
  29. 8. Suponer que menos tokens siempre es más barato
  30. 9. Ignorar los tokens de reintentos y de razonamiento
  31. Notas de producción
  32. Lista de comprobación
  33. Siguiente paso
  34. 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

  1. Mide el uso de tokens por funcionalidad, por modelo, de entrada y de salida.
  2. Elimina lo que el modelo no necesita: instrucciones duplicadas, esquemas completos, historial obsoleto, fragmentos poco relevantes.
  3. Restringe la salida: formato estructurado compacto, longitud explícita y un máximo de tokens de salida como límite de seguridad.
  4. 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.
  5. Enruta las tareas simples a un modelo más pequeño, o a código normal.
  6. 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

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.

Siguiente paso

  • Necesitas estimar el gasto mensual → Costo de LLM y presupuesto de tokens.
  • La mayoría de los tokens vienen del historial o de la recuperación → Ingeniería de contexto para LLM.
  • Un modelo más pequeño podría bastar → Elegir el modelo de IA adecuado.
  • Los prompts son largos porque las instrucciones son vagas → Patrones de prompts para ingeniería de datos.

← Todas las guías rápidas