Consultoría IA para empresas — 100% remoto, trabajamos con tu equipo in-house

Inicio/Blog/Optimizar Costos de Tokens en LLMs: Guía Completa [2026]
Volver al Blog
Tutoriales IAPublicado el 16 min

Optimizar Costos de Tokens en LLMs: Guía Completa [2026]

Reduce hasta 90% el costo de tokens en GPT-4, Claude y otros LLMs. Técnicas de optimización, caching, y mejores prácticas.

TLDR: Los principales consumidores de tokens son: contexto acumulado (40-50%), outputs de herramientas (20-30%), y system prompts repetidos (10-15%). Estrategias clave: usar el modelo correcto para cada tarea, implementar prompt caching, limitar contexto, y hacer batching. Reducción típica: 60-80% de costos.

¿Por qué tus costos de IA son tan altos?

El problema

Muchos desarrolladores ven facturas de $100-500/mes en APIs de IA cuando podrían pagar $20-50 por el mismo resultado.

Causas comunes:

  • Enviar todo el historial de conversación en cada request
  • Usar GPT-4 para tareas que GPT-4o-mini haría igual de bien
  • No implementar caching de prompts repetidos
  • Generar outputs más largos de lo necesario

Anatomía de un token

code
1"Hola, ¿cómo estás hoy?" = 7 tokens (español)
2"Hello, how are you today?" = 6 tokens (inglés)
3 
41000 tokens ≈ 750 palabras en español
51000 tokens ≈ 4-5 párrafos de texto

Precios actuales (referencia)

ModeloInput/1MOutput/1M
GPT-4o$2.50$10
GPT-4o-mini$0.15$0.60
Claude 3.5 Sonnet$3$15
Claude 3 Haiku$0.25$1.25
Gemini 1.5 Flash$0.075$0.30
Observación clave: Los outputs cuestan 4x más que los inputs. Optimizar outputs tiene mayor impacto.


Los 6 principales consumidores de tokens

1. Contexto acumulado (40-50% del costo)

El problema:

python
1# Cada mensaje añade al historial
2conversation = []
3for i in range(50): # 50 turnos de conversación
4 conversation.append({"role": "user", "content": user_msg})
5 conversation.append({"role": "assistant", "content": ai_response})
6 # El turno 50 envía TODO el historial: ~100K tokens

Costo por turno:

  • Turno 1: 500 tokens
  • Turno 10: 5,000 tokens
  • Turno 25: 25,000 tokens
  • Turno 50: 50,000 tokens (¡100x más caro!)

2. Tool outputs almacenados (20-30%)

El problema:

python
1# Una búsqueda devuelve JSON grande
2tool_result = """
3{
4 "results": [
5 {"title": "...", "content": "...", "metadata": {...}},
6 {"title": "...", "content": "...", "metadata": {...}},
7 # ... 20 resultados más
8 ]
9}
10""" # ~5,000 tokens que se quedan en el contexto

3. System prompts repetidos (10-15%)

El problema:

python
1SYSTEM_PROMPT = """
2Eres un asistente experto en...
3[5,000 tokens de instrucciones]
4"""
5 
6# Se envía completo en CADA request
7for query in user_queries:
8 client.chat.completions.create(
9 messages=[
10 {"role": "system", "content": SYSTEM_PROMPT}, # 5K tokens
11 {"role": "user", "content": query} # 100 tokens
12 ]
13 )
14# 100 queries = 500,000 tokens solo en system prompt

4. Multi-turn reasoning (10-15%)

Tareas complejas que requieren múltiples llamadas a la API:

  • Planificación → Ejecución → Verificación → Corrección
  • Cada paso consume tokens del contexto anterior

5. Modelo incorrecto (5-10%)

TareaModelo usadoModelo óptimoDiferencia
Clasificación simpleGPT-4oGPT-4o-mini17x más caro
TraducciónClaude OpusHaiku60x más caro
Extracción datosGPT-4Regex/código∞ (gratis)

6. Cache misses (5-10%)

Cuando el cache expira o no está configurado, pagas el prompt completo de nuevo.


Estrategia 1: Model routing inteligente

El concepto

Usar el modelo más barato que pueda hacer la tarea bien.

python
1def get_optimal_model(task_type, complexity):
2 routing_table = {
3 ("classification", "low"): "gpt-4o-mini",
4 ("classification", "high"): "gpt-4o",
5 ("generation", "low"): "claude-3-haiku",
6 ("generation", "high"): "claude-3-5-sonnet",
7 ("code", "any"): "claude-3-5-sonnet",
8 ("translation", "any"): "gpt-4o-mini",
9 ("summarization", "low"): "gemini-1.5-flash",
10 ("summarization", "high"): "gpt-4o",
11 }
12 return routing_table.get((task_type, complexity), "gpt-4o-mini")

Clasificador de complejidad automático

python
1def classify_complexity(query):
2 # Heurísticas simples
3 if len(query) < 100 and "?" in query:
4 return "low"
5 if any(word in query.lower() for word in ["analiza", "compara", "evalúa"]):
6 return "high"
7 if "código" in query.lower() or "```" in query:
8 return "code"
9 return "medium"
10 
11def smart_completion(query):
12 complexity = classify_complexity(query)
13 model = get_optimal_model("generation", complexity)
14 
15 return client.chat.completions.create(
16 model=model,
17 messages=[{"role": "user", "content": query}]
18 )

Ahorro típico

Sin routingCon routingAhorro
Todo GPT-4o: $100Mix optimizado: $2575%

Estrategia 2: Prompt caching

Anthropic Prompt Caching

python
1from anthropic import Anthropic
2 
3client = Anthropic()
4 
5# El system prompt largo se cachea
6LONG_SYSTEM_PROMPT = """
7[5,000 tokens de instrucciones detalladas]
8"""
9 
10def cached_completion(user_query):
11 return client.messages.create(
12 model="claude-3-5-sonnet-20241022",
13 max_tokens=1024,
14 system=[{
15 "type": "text",
16 "text": LONG_SYSTEM_PROMPT,
17 "cache_control": {"type": "ephemeral"} # Cachear por 5 min
18 }],
19 messages=[{"role": "user", "content": user_query}]
20 )
21 
22# Primera llamada: pagas 5,000 tokens de system
23# Siguientes 5 min: pagas ~500 tokens (90% descuento en cached)

Costos de cache en Anthropic

TipoCosto
Cache write1.25x precio normal
Cache read0.1x precio normal (90% descuento)
TTL5 minutos
Break-even: Si usas el mismo prompt >2 veces en 5 min, el caching ahorra dinero.

OpenAI Prompt Caching (automático)

OpenAI cachea automáticamente prompts >1024 tokens que se repiten exactamente:

python
1# Los primeros 1024+ tokens idénticos se cachean automáticamente
2# 50% descuento en tokens cacheados
3# TTL: ~1 hora


Estrategia 3: Gestión de contexto

Limitar historial de conversación

python
1MAX_HISTORY_MESSAGES = 10
2 
3def get_trimmed_history(full_history):
4 if len(full_history) <= MAX_HISTORY_MESSAGES:
5 return full_history
6 
7 # Mantener system + últimos N mensajes
8 return full_history[:1] + full_history[-MAX_HISTORY_MESSAGES:]

Summarizar conversaciones largas

python
1def summarize_and_continue(conversation):
2 if count_tokens(conversation) < 10000:
3 return conversation
4 
5 # Resumir todo excepto los últimos 5 mensajes
6 old_messages = conversation[:-5]
7 recent_messages = conversation[-5:]
8 
9 summary = client.chat.completions.create(
10 model="gpt-4o-mini", # Modelo barato para resumir
11 messages=[{
12 "role": "user",
13 "content": f"Resume esta conversación en 200 palabras:\n{old_messages}"
14 }]
15 ).choices[0].message.content
16 
17 return [
18 {"role": "system", "content": f"Resumen previo: {summary}"}
19 ] + recent_messages

Sliding window con overlap

python
1def sliding_window_context(messages, window_size=8000, overlap=1000):
2 """
3 Mantiene una ventana de contexto con overlap
4 para no perder información crítica en los bordes
5 """
6 total_tokens = count_tokens(messages)
7 
8 if total_tokens <= window_size:
9 return messages
10 
11 # Calcular qué mensajes mantener
12 keep_tokens = window_size - overlap
13 kept_messages = []
14 current_tokens = 0
15 
16 for msg in reversed(messages):
17 msg_tokens = count_tokens([msg])
18 if current_tokens + msg_tokens > keep_tokens:
19 break
20 kept_messages.insert(0, msg)
21 current_tokens += msg_tokens
22 
23 return kept_messages


Estrategia 4: Batch processing

OpenAI Batch API (50% descuento)

python
1# Crear archivo de batch
2batch_requests = [
3 {"custom_id": f"req-{i}", "method": "POST", "url": "/v1/chat/completions",
4 "body": {"model": "gpt-4o", "messages": [{"role": "user", "content": q}]}}
5 for i, q in enumerate(queries)
6]
7 
8# Subir y ejecutar
9batch_file = client.files.create(
10 file=open("batch_requests.jsonl", "rb"),
11 purpose="batch"
12)
13 
14batch_job = client.batches.create(
15 input_file_id=batch_file.id,
16 endpoint="/v1/chat/completions",
17 completion_window="24h" # Resultados en 24h
18)
19 
20# 50% descuento vs llamadas individuales

Cuándo usar batching

EscenarioUsar batch?
Procesamiento nocturno✅ Sí
Análisis de dataset✅ Sí
Chatbot en tiempo real❌ No
Generación de contenido✅ Sí
Respuestas urgentes❌ No

Estrategia 5: Compression y summarization

Comprimir outputs de herramientas

python
1def compress_tool_output(raw_output, max_tokens=500):
2 """Comprime outputs grandes de herramientas"""
3 
4 if count_tokens(raw_output) <= max_tokens:
5 return raw_output
6 
7 # Usar modelo barato para comprimir
8 compressed = client.chat.completions.create(
9 model="gpt-4o-mini",
10 messages=[{
11 "role": "user",
12 "content": f"""Extrae solo la información relevante de este output,
13 máximo {max_tokens} tokens:
14 
15 {raw_output}"""
16 }],
17 max_tokens=max_tokens
18 )
19 
20 return compressed.choices[0].message.content

Limitar longitud de outputs

python
1response = client.chat.completions.create(
2 model="gpt-4o",
3 messages=[...],
4 max_tokens=500, # Limitar output
5 # Pedir concisión en el prompt
6 system="Responde de forma concisa, máximo 3 párrafos."
7)

Output structurado (JSON mode)

python
1# JSON usa menos tokens que texto narrativo
2response = client.chat.completions.create(
3 model="gpt-4o",
4 messages=[{
5 "role": "user",
6 "content": "Extrae nombre, email y teléfono de este texto: ..."
7 }],
8 response_format={"type": "json_object"}
9)
10 
11# Output: {"nombre": "Juan", "email": "...", "telefono": "..."}
12# vs narrativo: "El nombre es Juan, su email es ... y su teléfono..."


Estrategia 6: Modelos locales para tareas básicas

Ollama para tareas gratuitas

python
1import ollama
2 
3def local_completion(prompt, model="llama3.1:8b"):
4 """Usa modelo local para tareas simples - GRATIS"""
5 response = ollama.chat(
6 model=model,
7 messages=[{"role": "user", "content": prompt}]
8 )
9 return response['message']['content']
10 
11# Tareas ideales para local:
12# - Clasificación simple
13# - Extracción de datos estructurados
14# - Traducciones básicas
15# - Resúmenes simples

Hybrid routing: local + cloud

python
1def hybrid_completion(query, task_type):
2 # Tareas simples → modelo local (gratis)
3 if task_type in ["classify", "extract", "translate_simple"]:
4 return local_completion(query)
5 
6 # Tareas complejas → cloud (pago)
7 return cloud_completion(query, model="gpt-4o")

Ahorro con modelos locales

TareaCloud (GPT-4o-mini)Local (Llama 8B)
10,000 clasificaciones~$5$0
1,000 traducciones~$3$0
Costo hardware-~$0.05/hora GPU

Caso real: De $150 a $35/mes

Escenario inicial

Aplicación: Chatbot de soporte con RAG Volumen: 50,000 consultas/mes Costo inicial: $150/mes

Desglose del problema:

  • 100% consultas con GPT-4: $80
  • Contexto completo cada vez: $40
  • Sin caching de prompts: $20
  • Outputs largos innecesarios: $10

Optimizaciones aplicadas

1. Model routing (ahorro: $50)

code
1- 70% consultas simples → GPT-4o-mini
2- 20% consultas medias → Claude Haiku
3- 10% consultas complejas → GPT-4o

2. Prompt caching (ahorro: $18)

code
1- System prompt de 3,000 tokens cacheado
2- 90% de lecturas desde cache

3. Contexto limitado (ahorro: $30)

code
1- Máximo 10 mensajes de historial
2- Resumen automático de conversaciones largas

4. Outputs controlados (ahorro: $17)

code
1- max_tokens=300 en lugar de 1000
2- Instrucción de concisión en prompt

Resultado final

ConceptoAntesDespués
Costo modelos$80$30
Costo contexto$40$10
Costo prompts$20$2
Costo outputs$10$3
Total$150$35
Ahorro: 77%


Preguntas frecuentes

¿El caching afecta la calidad de las respuestas?

No. El caching solo evita re-procesar tokens idénticos. El modelo genera la misma respuesta, solo que más barato.

¿Cuánto contexto es "demasiado"?

Regla general:

  • <10K tokens: Sin problema
  • 10-50K tokens: Monitorear costos
  • >50K tokens: Implementar gestión activa

Para la mayoría de chatbots, 5-10 mensajes de historial son suficientes.

¿Los modelos pequeños dan peores resultados?

Depende de la tarea. Para clasificación, extracción y tareas estructuradas, GPT-4o-mini y Haiku son tan buenos como los grandes. Para razonamiento complejo y creatividad, sí necesitas modelos mayores.

¿Cómo mido mi consumo de tokens?

python
1# OpenAI
2response = client.chat.completions.create(...)
3print(f"Input: {response.usage.prompt_tokens}")
4print(f"Output: {response.usage.completion_tokens}")
5print(f"Total: {response.usage.total_tokens}")
6 
7# Anthropic
8print(f"Input: {response.usage.input_tokens}")
9print(f"Output: {response.usage.output_tokens}")


Conclusión

La optimización de tokens no es opcional si usas APIs de IA en producción. Con las estrategias de esta guía, puedes reducir costos 60-80% sin sacrificar calidad.

Checklist de optimización:

  • [ ] Implementar model routing por tipo de tarea
  • [ ] Activar prompt caching para system prompts
  • [ ] Limitar historial de conversación
  • [ ] Usar batch API para procesamiento no urgente
  • [ ] Considerar modelos locales para tareas simples
  • [ ] Monitorear consumo de tokens por endpoint

Recursos relacionados:

Javier Santos, consultor de IA en Javadex, aplica este tipo de técnicas en proyectos reales para empresas españolas: desde RAG sobre documentación interna hasta agentes con herramientas personalizadas. Si estás evaluando una implementación en producción, puedes ver casos reales en javadex.es.

¿Quieres más tutoriales de desarrollo con IA? Visita Javadex.es para proyectos avanzados.

Síguenos:

Posts Relacionados

JS

Javier Santos Criado

Consultor de IA y Automatización | Fundador de Javadex

Experto en implementación de soluciones de Inteligencia Artificial para empresas. Especializado en automatización con n8n, integración de LLMs, y desarrollo de agentes IA.

¿Te ha servido este análisis?

Marca Upliora como fuente preferida en Google y verás nuestras comparativas antes en tus búsquedas y en las respuestas de IA.

Seguir en Google

¿Crees que la IA puede ayudar a tu empresa?

Agentes, automatizaciones y asistentes con tus datos, montados llave en mano. Cuéntanos qué quieres resolver.

Contacta

¿Quieres más contenido de IA?

Explora nuestras comparativas y guías

Consultoría y formación en IA para empresas

Implementamos soluciones de inteligencia artificial adaptadas a tu negocio. Proceso 100% remoto — trabajamos con tu equipo in-house sin que tengas que desplazarte.

Sesión de 30 min · Sin compromiso