Cómo hacer que Claude dure más y ahorrar tokens

Antes de exprimir Claude necesitas el SDK oficial y tu clave. En España y LATAM lo habitual es exportar la variable de entorno para no hardcodear secretos en el repo. Crea la key en console.anthropic.com bajo Settings > API Keys. Guárdala como variable de entorno: en Linux/Mac usa export, en Windows usa set. El SDK la lee automáticamente. Verifica que todo funciona con una llamada mínima antes de complicarte. Fíjate que usamos claude-opus-4-8, el modelo por defecto actual, que tiene una ventana de contexto amplia y soporta caching.

pip install anthropic
export ANTHROPIC_API_KEY='tu-clave-aqui'

El primer factor que hace que Claude 'dure más' es no desperdiciar tokens en respuestas gigantes que nadie lee. El parámetro max_tokens limita la salida: si pones 4096 pero solo necesitas un resumen, estás reservando presupuesto innecesario. Ajústalo al caso de uso real. Además, un system prompt claro que pida concisión reduce tokens de salida drásticamente. Recuerda que pagas tanto por tokens de entrada como de salida, y los de salida suelen ser más caros. Medir la respuesta te da control sobre el gasto por conversación.

import anthropic

client = anthropic.Anthropic()

resp = client.messages.create(
    model="claude-opus-4-8",
    max_tokens=1024,
    system="Responde de forma concisa. Máximo 3 párrafos.",
    messages=[{"role": "user", "content": "Explica qué es prompt caching"}],
)

print(resp.content[0].text)
print("Tokens entrada:", resp.usage.input_tokens)
print("Tokens salida:", resp.usage.output_tokens)

Aquí está la clave para que Claude 'dure más' en presupuesto: el prompt caching. Si envías el mismo contexto grande (documentación, instrucciones extensas, ejemplos) en cada llamada, cachearlo reduce el coste hasta un 90% y acelera la respuesta. Marca el bloque estable con cache_control tipo ephemeral. Claude guarda ese prefijo durante 5 minutos y lo reutiliza en llamadas siguientes. El primer request escribe la caché (coste ligeramente mayor), los siguientes leen de ella (coste mínimo). Ideal para chatbots con instrucciones largas o análisis de documentos repetidos.

resp = client.messages.create(
    model="claude-opus-4-8",
    max_tokens=1024,
    system=[
        {
            "type": "text",
            "text": "Aquí va tu contexto extenso y estable..." * 200,
            "cache_control": {"type": "ephemeral"},
        }
    ],
    messages=[{"role": "user", "content": "Pregunta sobre el contexto"}],
)

print("Cache creación:", resp.usage.cache_creation_input_tokens)
print("Cache lectura:", resp.usage.cache_read_input_tokens)

En conversaciones largas la ventana de contexto se llena y cada turno cuesta más porque reenvías todo el historial. La técnica para que 'dure más' es resumir los mensajes antiguos periódicamente. Cuando el historial supera un umbral, pides a Claude que condense los turnos viejos en un resumen breve y reemplazas esos mensajes por el resumen. Así mantienes la memoria de la conversación gastando una fracción de los tokens. Es la estrategia que usan los asistentes de producción para chats interminables.

def resumir_historial(client, mensajes):
    texto = "\n".join(f"{m['role']}: {m['content']}" for m in mensajes)
    r = client.messages.create(
        model="claude-opus-4-8",
        max_tokens=512,
        system="Resume esta conversación en puntos clave, conservando datos importantes.",
        messages=[{"role": "user", "content": texto}],
    )
    return {"role": "user", "content": f"[Resumen previo]: {r.content[0].text}"}

# Si el historial es largo, comprime los primeros mensajes
if len(historial) > 20:
    resumen = resumir_historial(client, historial[:-6])
    historial = [resumen] + historial[-6:]

El streaming no reduce tokens, pero hace que Claude 'dure más' en la experiencia: evitas timeouts en respuestas largas y el usuario ve texto al instante. En lugar de esperar la respuesta completa, recibes fragmentos según se generan. Esto es crítico para apps con respuestas extensas donde una petición síncrona podría cortarse. Además permites que el usuario interrumpa si ya tiene lo que buscaba, ahorrando tokens de salida no consumidos.

with client.messages.stream(
    model="claude-opus-4-8",
    max_tokens=2048,
    messages=[{"role": "user", "content": "Escribe una guía detallada"}],
) as stream:
    for texto in stream.text_stream:
        print(texto, end="", flush=True)

    mensaje_final = stream.get_final_message()
    print("\nTokens usados:", mensaje_final.usage.output_tokens)

Para que tu presupuesto 'dure más' necesitas medir. Acumula el uso de cada llamada y calcula el coste estimado. Establece un límite por sesión que corte la conversación antes de sobrepasar tu presupuesto. En LATAM y España, donde el tipo de cambio afecta al coste en dólares, este control evita sorpresas en la factura. Construye un contador simple que sume input y output tokens por conversación y avise cuando se acerque al umbral.

class ControlUso:
    def __init__(self, limite_tokens=100_000):
        self.total = 0
        self.limite = limite_tokens

    def registrar(self, usage):
        self.total += usage.input_tokens + usage.output_tokens
        pct = (self.total / self.limite) * 100
        print(f"Uso: {self.total} tokens ({pct:.1f}%)")
        if self.total >= self.limite:
            raise RuntimeError("Límite de tokens alcanzado en esta sesión")

control = ControlUso()
control.registrar(resp.usage)