Compromisos entre coste y latencia
Presupuestos de tokens de razonamiento, costes de inferencia y estrategias de enrutamiento híbrido.
Compromisos entre coste y latencia es una lección gratuita de AI Prompt Engineering en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de AI Prompt Engineering, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de AI Prompt Engineering incluye 4 lecciones en total.
El triángulo de coste, calidad y latencia
En el diseño de sistemas LLM existe un triángulo fundamental: coste, calidad y latencia. En un momento dado, puede optimizar como máximo dos de los tres aspectos.
- Coste bajo + Calidad alta = Lento (modelos de razonamiento, generación lenta)
- Coste bajo + Latencia baja = Menor calidad (modelos pequeños y rápidos)
- Calidad alta + Latencia baja = Caro (modelo de razonamiento con streaming)
Cada decisión de arquitectura implica un compromiso dentro de este triángulo.
Precios de los modelos de razonamiento
Los tokens de razonamiento tienen un coste adicional al de los tokens estándar de entrada y salida. El coste de una llamada a un modelo de razonamiento incluye: tokens de entrada + tokens de razonamiento + tokens de salida.
En comparación con los modelos rápidos y pequeños: o3 es aproximadamente 20 veces más caro por token que GPT-4o-mini; Claude Opus con razonamiento extendido es aproximadamente entre 10 y 15 veces más caro por token de salida que Claude Haiku.
# Rough cost estimates (2025 pricing, may change)
# Source: provider pricing pages
PRICING = {
# (input $/1M tokens, output $/1M tokens)
'gpt-4o-mini': (0.15, 0.60),
'gpt-4o': (2.50, 10.00),
'o3-mini': (1.10, 4.40),
'o3': (10.0, 40.00),
'claude-haiku-4-5': (0.25, 1.25),
'claude-sonnet-4-5': (3.00, 15.00),
'claude-opus-4-5': (15.0, 75.00),
}
def estimate_cost(model, input_tokens, output_tokens, thinking_tokens=0):
inp_price, out_price = PRICING[model]
# Thinking tokens billed as output tokens
total_out = output_tokens + thinking_tokens
cost = (input_tokens / 1e6 * inp_price) + (total_out / 1e6 * out_price)
return cost
# A single hard question with 8000 thinking tokens:
cost = estimate_cost('claude-opus-4-5', 500, 300, thinking_tokens=8000)
print(f'Cost per call: ${cost:.4f}')Sobrecoste de los tokens de razonamiento
Los tokens de razonamiento suelen ser mucho más numerosos que los tokens de salida. Una respuesta concisa de 200 palabras puede estar respaldada por entre 5.000 y 15.000 tokens de razonamiento. Esos tokens de razonamiento cuestan lo mismo que los tokens de salida.
Por eso, el multiplicador de coste de los modelos de razonamiento depende principalmente de los tokens de razonamiento, no de la longitud de la respuesta.
import anthropic
client = anthropic.Anthropic(api_key='sk-ant-...')
def analyze_token_breakdown(question, budget_tokens):
response = client.messages.create(
model='claude-opus-4-5',
max_tokens=budget_tokens + 2000,
thinking={'type': 'enabled', 'budget_tokens': budget_tokens},
messages=[{'role': 'user', 'content': question}]
)
# Usage breakdown
usage = response.usage
print(f'Input tokens: {usage.input_tokens:,}')
print(f'Output tokens: {usage.output_tokens:,}')
# Thinking tokens are in cache_creation_input_tokens on some APIs
# or can be estimated from thinking block content length
thinking_blocks = [b for b in response.content if b.type == 'thinking']
est_thinking = sum(len(b.thinking.split()) * 1.3 for b in thinking_blocks)
print(f'Est. thinking tokens: {int(est_thinking):,}')
answer = next(b.text for b in response.content if b.type == 'text')
print(f'Answer words: {len(answer.split())}')
analyze_token_breakdown(
'Explain the trade-offs between REST and GraphQL APIs.',
budget_tokens=5000
)Latencia: qué esperar
Intervalos de latencia observados para distintas configuraciones de modelos (varían considerablemente según la carga y la dificultad del problema):
- Claude Haiku: 0.5-2 segundos
- Claude Sonnet: 2-8 segundos
- Claude Opus (no thinking): 5-15 segundos
- Claude Opus (thinking 5K): 15-40 segundos
- Claude Opus (thinking 16K): 40-90 segundos
- o3 (high effort): 30-120 segundos
import time
import anthropic
client = anthropic.Anthropic(api_key='sk-ant-...')
def benchmark_latency(prompt, model, budget_tokens=None):
kwargs = {
'model': model,
'max_tokens': 2000,
'messages': [{'role': 'user', 'content': prompt}]
}
if budget_tokens:
kwargs['thinking'] = {'type': 'enabled', 'budget_tokens': budget_tokens}
kwargs['max_tokens'] = budget_tokens + 2000
start = time.time()
response = client.messages.create(**kwargs)
elapsed = time.time() - start
answer = response.content[-1].text
print(f'{model} (budget={budget_tokens}): {elapsed:.1f}s')
return elapsed, answer
benchmark_latency('Name 3 planets', 'claude-haiku-4-5')
benchmark_latency('Solve x^2 - 5x + 6 = 0', 'claude-opus-4-5', 3000)
benchmark_latency('Design a fault-tolerant payment system', 'claude-opus-4-5', 10000)Tiempo hasta el primer token con streaming
Aunque la latencia total de los modelos de razonamiento es alta, el tiempo hasta el primer token (TTFT) con streaming puede ser mucho menor: el modelo empieza a transmitir la respuesta en cuanto termina de razonar. Muestre algo al usuario rápidamente mediante streaming.
import anthropic
import time
client = anthropic.Anthropic(api_key='sk-ant-...')
def stream_with_timing(prompt):
start = time.time()
first_token_time = None
full_text = ''
with client.messages.stream(
model='claude-opus-4-5',
max_tokens=10000,
thinking={'type': 'enabled', 'budget_tokens': 5000},
messages=[{'role': 'user', 'content': prompt}]
) as stream:
in_answer = False
for text_chunk in stream.text_stream:
if not in_answer:
in_answer = True
first_token_time = time.time() - start
print(f'Time to first answer token: {first_token_time:.1f}s')
full_text += text_chunk
print(text_chunk, end='', flush=True)
total_time = time.time() - start
print(f'\nTotal time: {total_time:.1f}s')
stream_with_timing('List 5 key benefits of microservices.')Patrón de arquitectura híbrida
Un patrón práctico para producción consiste en utilizar primero un modelo estándar rápido. Si el resultado es satisfactorio, compruébelo con su métrica de calidad y devuélvalo inmediatamente. Si no lo es, escale a un modelo de razonamiento. Así obtendrá una latencia y un coste medios bajos, con gran precisión en los casos difíciles.
import anthropic
client = anthropic.Anthropic(api_key='sk-ant-...')
def hybrid_query(question, quality_threshold=0.7):
# Step 1: Try fast model first
r_fast = client.messages.create(
model='claude-haiku-4-5',
max_tokens=300,
messages=[{'role': 'user', 'content': question}]
)
fast_answer = r_fast.content[0].text
# Step 2: Quick confidence check
confidence_check = client.messages.create(
model='claude-haiku-4-5',
max_tokens=20,
messages=[{
'role': 'user',
'content': (
f'Q: {question}\nA: {fast_answer}\n'
f'Rate answer quality 0.0-1.0. Number only:'
)
}]
)
try:
quality = float(confidence_check.content[0].text.strip())
except ValueError:
quality = 0.5
if quality >= quality_threshold:
return fast_answer, 'fast'
# Step 3: Escalate to reasoning model
r_slow = client.messages.create(
model='claude-opus-4-5',
max_tokens=8000,
thinking={'type': 'enabled', 'budget_tokens': 6000},
messages=[{'role': 'user', 'content': question}]
)
return next(b.text for b in r_slow.content if b.type == 'text'), 'reasoning'Costes a escala: haga cuentas
Los modelos de razonamiento que parecen asequibles durante las pruebas pueden representar costes importantes a escala. Proyecte siempre los costes antes de elegir una arquitectura.
def project_monthly_cost(daily_queries, model_config):
"""
Project monthly API costs for different configurations.
model_config: dict with 'cost_per_query' key
"""
monthly_queries = daily_queries * 30
monthly_cost = monthly_queries * model_config['cost_per_query']
print(f'Daily queries: {daily_queries:,}')
print(f'Monthly queries: {monthly_queries:,}')
print(f'Cost per query: ${model_config["cost_per_query"]:.4f}')
print(f'Monthly cost: ${monthly_cost:,.2f}')
return monthly_cost
# Compare configurations at 10,000 queries/day
configs = [
{'name': 'All Haiku', 'cost_per_query': 0.0005},
{'name': 'All Sonnet', 'cost_per_query': 0.015},
{'name': 'All Opus+Thinking', 'cost_per_query': 0.85},
{'name': 'Hybrid (90% Haiku, 10% Opus)', 'cost_per_query': 0.9*0.0005 + 0.1*0.85},
]
for config in configs:
print(f'\n--- {config["name"]} ---')
project_monthly_cost(10_000, config)Almacenamiento en caché de prompts para reducir costes
Para las llamadas a modelos de razonamiento con prompts del sistema o contextos largos y repetidos, utilice el almacenamiento en caché de prompts. Los tokens almacenados en caché cuestan un 90 % menos que los que no lo están. Esto resulta especialmente importante cuando se envía repetidamente el mismo contexto grande, como documentos o código.
import anthropic
client = anthropic.Anthropic(api_key='sk-ant-...')
LONG_CONTEXT = 'A' * 50000 # Simulated large document
# With prompt caching: mark large context as cacheable
response = client.messages.create(
model='claude-opus-4-5',
max_tokens=10000,
thinking={'type': 'enabled', 'budget_tokens': 6000},
system=[
{
'type': 'text',
'text': f'You are analyzing this document: {LONG_CONTEXT}',
'cache_control': {'type': 'ephemeral'} # Cache this prefix
}
],
messages=[{
'role': 'user',
'content': 'What are the main themes in this document?'
}]
)
usage = response.usage
print(f'Cache read tokens: {getattr(usage, "cache_read_input_tokens", 0):,}')
print(f'Cache creation tokens: {getattr(usage, "cache_creation_input_tokens", 0):,}')
# Second call with same system content costs ~90% less on cached tokensProcesamiento por lotes para ahorrar costes
OpenAI y Anthropic ofrecen API de procesamiento por lotes con descuentos del 50 % para solicitudes que no son sensibles al tiempo. Si tiene grandes volúmenes de consultas cuyos resultados pueden esperar varias horas, el procesamiento por lotes es la opción más rentable.
import anthropic
import json
client = anthropic.Anthropic(api_key='sk-ant-...')
# Batch API: 50% cheaper, 24-hour turnaround
requests = [
{
'custom_id': f'query_{i}',
'params': {
'model': 'claude-opus-4-5',
'max_tokens': 1024,
'messages': [{'role': 'user', 'content': f'Analyze dataset row {i}'}]
}
}
for i in range(100) # 100 queries in one batch
]
# Submit batch
batch = client.messages.batches.create(requests=requests)
print(f'Batch ID: {batch.id}')
print(f'Status: {batch.processing_status}')
print(f'Requests: {batch.request_counts}')
# Poll batch.id for results when processing_status == 'ended'Optimización del presupuesto de tokens
Ajuste budget_tokens al tamaño adecuado para cada tipo de problema. Utilizar un presupuesto de 16K en un problema sencillo desperdicia tokens y añade latencia. Cree una tabla de consulta de presupuestos basada en niveles de dificultad.
BUDGET_LOOKUP = {
'simple_math': 1000, # Arithmetic, basic algebra
'medium_code': 3000, # Function implementation, debugging
'complex_reasoning': 8000, # System design, complex analysis
'research_grade': 16000, # Proofs, research-level problems
}
def budget_for_query(query):
q_lower = query.lower()
if any(kw in q_lower for kw in ['calculate', 'what is', 'how many', 'convert']):
return BUDGET_LOOKUP['simple_math']
elif any(kw in q_lower for kw in ['code', 'function', 'bug', 'implement']):
return BUDGET_LOOKUP['medium_code']
elif any(kw in q_lower for kw in ['design', 'architecture', 'analyze', 'strategy']):
return BUDGET_LOOKUP['complex_reasoning']
else:
return BUDGET_LOOKUP['medium_code'] # Safe default
print(budget_for_query('What is 15% of 340?')) # 1000
print(budget_for_query('Implement a trie in Python')) # 3000
print(budget_for_query('Design a CDC pipeline')) # 8000Definición de SLA para aplicaciones LLM
Antes de elegir entre modelos estándar y modelos de razonamiento, defina los requisitos del Acuerdo de Nivel de Servicio (SLA) de su aplicación:
- Latencia P50: experiencia de usuario habitual
- Latencia P99: experiencia de usuario en el peor caso
- Presupuesto de tokens: coste máximo por consulta de usuario
- Umbral de calidad: precisión mínima aceptable en su conjunto de pruebas
Los modelos de razonamiento incumplen fácilmente los SLA de latencia P99 de las aplicaciones interactivas. Conozca sus limitaciones antes de tomar decisiones de arquitectura definitivas.
Compruebe sus conocimientos: costes de los modelos de razonamiento
¿Cuál es el principal factor que eleva los costes de los modelos de razonamiento en comparación con los modelos estándar?
Resumen: compensaciones entre coste y latencia
Los modelos de razonamiento son caros: los tokens de razonamiento se facturan como tokens de salida y pueden ser entre 10 y 50 veces más numerosos que la respuesta visible. La latencia oscila entre 15 y 120 segundos en los problemas difíciles. Para mitigar estos costes, utilice el patrón híbrido, con un modelo rápido primero y una ampliación únicamente cuando la confianza sea baja; el almacenamiento en caché de prompts para contextos grandes repetidos, con un descuento del 90 % en los tokens almacenados en caché; la API de procesamiento por lotes para cargas de trabajo sin conexión, con un descuento del 50 %; y un ajuste de budget_tokens adecuado a la dificultad del problema. A escala, incluso los pequeños costes por consulta se multiplican hasta generar facturas mensuales elevadas. Proyecte siempre los costes antes de comprometerse con una arquitectura.
Preguntas frecuentes
¿La lección «Compromisos entre coste y latencia» es gratis?
Sí — el texto completo de «Compromisos entre coste y latencia» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de AI Prompt Engineering, actualiza a CoddyKit PRO. El curso de AI Prompt Engineering incluye 4 lecciones en total.
¿Qué aprenderé en «Compromisos entre coste y latencia»?
Presupuestos de tokens de razonamiento, costes de inferencia y estrategias de enrutamiento híbrido. Practicas AI Prompt Engineering con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar AI Prompt Engineering?
No se requiere experiencia previa. AI Prompt Engineering en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.
¿Cuánto tiempo toma la lección «Compromisos entre coste y latencia»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de AI Prompt Engineering?
Sí. Cada lección de AI Prompt Engineering incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- En qué se diferencian los modelos de razonamiento
- Prompts eficaces para el razonamiento prolongado
- Cuándo usar modelos de razonamiento frente a modelos estándar
- Compromisos entre coste y latencia