¿Enviaste un prompt de 12,000 tokens a Claude y recibiste una respuesta cortada a mitad de frase? ¿O creaste un sistema que funcionaba bien en pruebas, pero empezó a fallar en producción porque la entrada real del usuario superó el límite? Los límites de tokens no son casos extremos: son restricciones estructurales para las que debes diseñar.
Los tokens no son palabras. Eso es lo primero que rompe la intuición de la gente.
Qué Son Realmente los Tokens
Un token es un fragmento de texto que un modelo de lenguaje procesa como una unidad. Un token puede ser un solo carácter, parte de una palabra, una palabra completa o puntuación. El desglose exacto depende del tokenizador — el algoritmo que divide el texto en piezas antes de que el modelo lo vea.
El texto en inglés tiene un promedio de aproximadamente 1.3 tokens por palabra, pero eso es solo un promedio. El código es más denso — a menudo 1.7+ tokens por palabra porque los operadores y corchetes se tokenizan por separado. El JSON es aún peor. Un solo espacio o salto de línea puede ser su propio token.
Esto es importante porque se te cobra por token, y tu ventana de contexto se mide en tokens, no en palabras. Si crees que tienes 128K tokens de espacio y estás almacenando texto a 1.5 tokens por palabra, en realidad tienes unas 85,000 palabras, no 128,000.
La mayoría de los modelos publican sus límites de tokens como entrada + salida. Claude 3.5 Sonnet tiene una ventana de contexto de 200K tokens. Eso significa que tu prompt (tokens de entrada) más la respuesta del modelo (tokens de salida) juntos no pueden exceder los 200,000. Si tu prompt tiene 150K tokens, te quedan aproximadamente 50K tokens para la respuesta antes de que el modelo se corte.
Por Qué Esto Rompe Tus Planes Reales
La falla más común: diseñas un sistema que funciona con un prompt de 10K tokens de forma aislada, luego agregas recuperación RAG, historial de conversación, instrucciones del sistema y entrada del usuario, todo apilado. Ahora estás en 45K tokens por solicitud, y o bien alcanzas los límites o tus costos se disparan 4-5 veces más de lo que estimaste.
La segunda falla: metes todo en el contexto porque puedes, y luego la calidad de la salida del modelo disminuye. Los contextos largos perjudican el razonamiento. Eso no es hipérbole, es medible. El rendimiento de Claude en tareas se degrada notablemente más allá de unos 100K tokens, aunque pueda manejar 200K.
La tercera falla: no tienes en cuenta los tokens de salida. Calculas el costo de entrada, implementas el sistema y luego descubres que las respuestas del modelo son más largas de lo esperado. Un prompt de 100 tokens podría generar una respuesta de 800 tokens si estás pidiendo un análisis detallado. De repente, tu costo por solicitud es de 900 tokens, no de 100.
Calculando Tu Uso Real de Tokens
Deja de adivinar. Mídelo.
Usa la biblioteca tokenizadora del proveedor antes de implementar nada. Para Claude, usa el tokenizador en el paquete anthropic. Para los modelos GPT, usa tiktoken. Ejecuta tus prompts reales a través de estos y registra el recuento de tokens.
from anthropic import Anthropic, messages
import anthropic
client = Anthropic()
# Tu prompt
system_prompt = """Eres un analista. Extrae métricas clave de los datos proporcionados.
Sé conciso. Formato como JSON."""
user_input = """Aquí están los datos financieros del Q3 para Acme Corp...
[4000 palabras de datos reales]
"""
# Cuenta los tokens ANTES de llamar a la API
token_count = len(client.beta.messages.count_tokens(
model="claude-3-5-sonnet-20241022",
system=system_prompt,
messages=[{"role": "user", "content": user_input}]
).input_tokens)
print(f"Tu prompt: {token_count} tokens")
# Ahora haz la llamada
response = client.messages.create(
model="claude-3-5-sonnet-20241022",
max_tokens=1000,
system=system_prompt,
messages=[{"role": "user", "content": user_input}]
)
output_tokens = response.usage.output_tokens
print(f"Respuesta del modelo: {output_tokens} tokens")
print(f"Costo total: {token_count + output_tokens} tokens")Esto no es opcional. Necesitas los números reales antes de diseñar la arquitectura del sistema.
Enfoques Estructurales para Mantenerse Dentro de los Límites
Comprime tu prompt del sistema. Las instrucciones innecesarias añaden tokens sin añadir valor. Compara:
# Prompt del sistema malo (287 tokens)
Eres un representante de servicio al cliente servicial. Trabajas para TechCorp,
una empresa de software. Cuando los clientes te contactan, es importante que
seas educado, profesional y servicial. Debes intentar comprender sus
problemas y ayudarles a encontrar soluciones. Sé siempre respetuoso y paciente.
Nunca seas grosero. Puedes proporcionar información técnica sobre nuestros productos.
Asegúrate de hacer preguntas aclaratorias cuando sea necesario. Si no sabes la
respuesta, dile al cliente que lo investigarás.
# Buen prompt del sistema (89 tokens)
Eres soporte al cliente de TechCorp. Sé directo y profesional.
Haz preguntas aclaratorias. Si no lo sabes, dilo.
Proporciona información técnica de productos. Enfócate en resolver el problema.Ambos transmiten la misma instrucción. El segundo es un 68% más pequeño.
Usa paginación para documentos grandes. No cargues las 50 páginas de un documento en un solo prompt. Divídelo en secciones, recupera solo los fragmentos relevantes mediante búsqueda o coincidencia semántica, y pásalos. Para eso existen los sistemas RAG: son eficientes en tokens por diseño.
Limita el historial de conversación. Guarda los últimos 5-10 mensajes en una conversación de varios turnos, no todo el chat. Para la mayoría de las aplicaciones, el contexto antiguo añade ruido, no señal, y consume tokens que no necesitas gastar.
Estructura el formato de salida desde el principio. Si quieres JSON, dílo en el prompt del sistema, no en el mensaje del usuario. Si quieres exactamente 3 puntos, especifícalo. El formato explícito evita que el modelo genere relleno, lo que reduce los tokens de salida.
Qué Hacer Ahora Mismo
Elige uno de tus prompts activos — algo que uses en producción o pruebas regularmente. Mide su recuento real de tokens usando el tokenizador del proveedor. Incluye el prompt del sistema, la entrada del usuario y estima la longitud de la respuesta.
Calcula tu total: tokens de entrada + salida. Ahora multiplícalo por tu volumen de uso durante un mes. Si ese número te sorprende, comprime tu prompt del sistema usando los patrones anteriores y vuelve a medir. A menudo encontrarás ahorros de tokens del 20-30% al eliminar instrucciones redundantes.
