10 Técnicas de Ahorro de Tokens para Desarrolladores de IA

Eliminar Palabras de Relleno y Cortesías

Los modelos no necesitan "por favor", "amablemente", "como modelo de IA" ni "me gustaría que". Estas frases consumen tokens sin mejorar la calidad de la salida. Elimínalas sin piedad.

# ANTES — 52 tokens
Por favor analiza cuidadosamente los siguientes comentarios de
clientes y proporciona amablemente un análisis detallado de
sentimientos. Como asistente de IA útil, asegúrate de ser
exhaustivo.

# DESPUÉS — 18 tokens
Analiza comentarios de clientes. Retorna: sentimiento
(pos/neg/neutro), temas clave, confianza 0-1.

Usar Formatos Estructurados en Lugar de Prosa

Las instrucciones en prosa como "Por favor responde en formato JSON con los siguientes campos..." son verbosas. Mostrar el esquema directamente es más conciso y a menudo más efectivo.

# ANTES — 55 tokens
Por favor responde a la pregunta del usuario en formato JSON.
El JSON debe tener un campo "respuesta" con tu respuesta,
un campo "confianza" con un número entre 0 y 1, y un arreglo
"fuentes" si tienes fuentes relevantes.

# DESPUÉS — 18 tokens
Responde JSON: {"respuesta":"...","confianza":0.0-1.0,"fuentes":[]}

Usar Abreviaturas en Prompts del Sistema

En prompts del sistema largos, define abreviaturas una vez y úsalas en todo el texto. "IU" en lugar de "interfaz de usuario", "req" en lugar de "requisito", "BC" en lugar de "base de conocimiento". Los modelos entienden las abreviaturas perfectamente.

# ANTES — 42 tokens
Cuando el usuario envíe un ticket de soporte, consulta la base
de conocimiento para encontrar documentación relevante. Si la
base de conocimiento contiene una respuesta, proporciónala con
un enlace al artículo de la base de conocimiento.

# DESPUÉS — 24 tokens
Con ticket de soporte: consultar BC para docs relevantes.
Si hay coincidencia en BC: respuesta + enlace a artículo.

Comprimir Contexto con Resúmenes Progresivos

A medida que las conversaciones crecen, reenvías todo el historial en cada turno. Después de 6–8 turnos, reemplaza los mensajes más antiguos con un resumen compacto. Usa un modelo económico (Gemini Flash) para la síntesis y minimiza el costo de compresión.

async def comprimir_historial(mensajes, max_tokens=1500):
    if contar_tokens(mensajes) < max_tokens:
        return mensajes

    a_resumir = mensajes[1:-6]  # mantener sistema + últimos 3 turnos
    prompt_resumen = f"Resume esta conversación en ≤100 palabras: {a_resumir}"
    resumen = await llamar_llm(prompt_resumen, model="gemini-2.5-flash")

    return [
        mensajes[0],  # prompt del sistema
        {"role": "assistant", "content": f"[Contexto previo: {resumen}]"},
        *mensajes[-6:]
    ]

Usar Ejemplos Few-Shot de Forma Eficiente

Los ejemplos few-shot son poderosos pero costosos si están inflados. Usa los ejemplos más cortos que demuestren el patrón. El modelo infiere el patrón solo con los pares entrada/salida.

# ANTES — 82 tokens
Aquí hay algunos ejemplos de cómo clasificar mensajes de clientes:
Ejemplo 1: Cuando un cliente dice "Mi pedido no ha llegado todavía"
esto debe clasificarse como un problema de "entrega".
Ejemplo 2: Cuando dice "Me cobraron dos veces" → "facturación".

# DESPUÉS — 28 tokens
Clasifica el tipo de mensaje.
"Mi pedido no llegó" → entrega
"Me cobraron dos veces" → facturación
"{mensaje}" →

Dividir Prompts Complejos en Llamadas Más Pequeñas

Un solo prompt complejo que pide 5 cosas a menudo da peores resultados que 5 prompts enfocados. Más importante aún, puedes enrutar subtareas a modelos más económicos.

# En lugar de una llamada costosa que hace todo:
# "Extrae entidades, clasifica sentimiento, genera respuesta,
#  traduce al inglés y verifica política"

# Divídelo en llamadas enrutadas:
entidades  = await llamar(prompt_extrac, model="gemini-flash")  # barato
sentimiento = await llamar(prompt_clasif, model="gemini-flash") # barato
respuesta  = await llamar(prompt_genera, model="gpt-4o")        # costoso
traduccion = await llamar(prompt_traduc, model="gemini-flash")  # barato

Eliminar Espacios en Blanco y Líneas Vacías

Las líneas en blanco, los espacios finales y la sangría excesiva se tokenizan como tokens separados. Es un ahorro pequeño, pero no cuesta nada implementarlo y se acumula en millones de llamadas.

import re

def comprimir_espacios(prompt: str) -> str:
    # Eliminar espacios al final de cada línea
    prompt = re.sub(r'[ \t]+$', '', prompt, flags=re.MULTILINE)
    # Colapsar 2+ líneas vacías en una
    prompt = re.sub(r'\n{3,}', '\n\n', prompt)
    return prompt.strip()

Usar Optimizaciones Específicas de Cada Modelo

Cada modelo tiene características diseñadas para reducir la sobrecarga de tokens:

• OpenAI: Usa response_format: {"type": "json_object"} en lugar de pedir JSON en el prompt
• Anthropic: Usa etiquetas XML (<instrucciones>, <contexto>) para mayor claridad con menos palabras
• Gemini: Usa generationConfig.responseMimeType: "application/json" para salida JSON directa

Cachear Prompts del Sistema con la Caché de Anthropic

La caché de prompts de Anthropic marca parte de tu prompt como cacheable. En solicitudes subsiguientes, las porciones en caché se leen a $0.30/1M tokens en lugar de $3.00/1M — una reducción del 90%.

import anthropic

client = anthropic.Anthropic()
respuesta = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    system=[
        {
            "type": "text",
            "text": prompt_sistema_largo,  # ej. 4000 tokens
            "cache_control": {"type": "ephemeral"}  # caché 5 min
        }
    ],
    messages=[{"role": "user", "content": mensaje_usuario}]
)
# Primera llamada: escribe caché (precio completo)
# Llamadas 2-N: lee caché ($0.30/1M vs $3.00/1M)

Medir Antes y Después con un Contador de Tokens

Todas las técnicas anteriores solo son útiles si mides su efecto. Diferentes modelos tokenizan el texto de forma diferente — un prompt de 150 tokens para GPT-4o puede ser 180 tokens para Claude. Antes de desplegar cualquier optimización, verifica los recuentos de tokens reales con Tokenia.

import tiktoken

enc = tiktoken.encoding_for_model("gpt-4o")

tokens_antes = len(enc.encode(prompt_antes))
tokens_despues = len(enc.encode(prompt_despues))

print(f"Antes:  {tokens_antes} tokens")
print(f"Después: {tokens_despues} tokens")
print(f"Ahorro: {(tokens_antes - tokens_despues)/tokens_antes:.0%}")