Cómo hacer que Claude cree un chatbot con la API

Empieza creando un entorno aislado para no ensuciar tu Python global. Crea una carpeta para el proyecto, monta un entorno virtual e instala el SDK oficial de Anthropic. Después guarda tu clave API en una variable de entorno para no hardcodearla en el código: es el error de seguridad más frecuente entre builders que empiezan. En España y LATAM puedes pagar la API con tarjeta normal desde la consola; recuerda añadir crédito inicial porque sin saldo las llamadas fallan con un error 400. La clave la obtienes en console.anthropic.com > API Keys. Cópiala una sola vez porque no vuelve a mostrarse.

python -m venv venv
source venv/bin/activate  # En Windows: venv\Scripts\activate
pip install anthropic
export ANTHROPIC_API_KEY='sk-ant-tu-clave-aqui'

Antes de montar el bucle conversacional, valida que la conexión funciona con una llamada mínima. El SDK lee la clave automáticamente desde la variable de entorno ANTHROPIC_API_KEY, así que no necesitas pasarla al cliente. El parámetro messages es una lista de turnos con rol user o assistant, y max_tokens limita la longitud de la respuesta (y por tanto el coste). Usamos el modelo claude-opus-4-8 por defecto. Si todo va bien verás el texto de la respuesta impreso en consola. Si obtienes un error de autenticación, revisa que exportaste bien la variable en la misma terminal donde ejecutas el script.

import anthropic

client = anthropic.Anthropic()

respuesta = client.messages.create(
    model="claude-opus-4-8",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "Hola, ¿funciona la conexión?"}
    ],
)

print(respuesta.content[0].text)

Un chatbot sin instrucciones responde de forma genérica. El system prompt define quién es tu bot, su tono y sus límites. A diferencia de los mensajes de usuario, va en el parámetro system separado, no dentro de messages. Aquí es donde defines si es un asistente de soporte, un tutor o un vendedor. Sé específico: indica idioma, longitud de respuesta y qué NO debe hacer. Un buen system prompt reduce respuestas fuera de tema y evita que el bot invente. Para casos de negocio en LATAM conviene fijar el idioma español neutro y aclarar que no debe dar consejos legales o médicos si no aplica a tu producto.

SYSTEM_PROMPT = """Eres SoporteBot, el asistente de una tienda online de electrónica.
Responde en español neutro, con tono cercano y profesional.
Sé conciso: máximo 3 frases salvo que pidan detalle.
Si no sabes algo, dilo claramente y ofrece contactar con un humano.
Nunca inventes precios ni plazos de envío."""

respuesta = client.messages.create(
    model="claude-opus-4-8",
    max_tokens=1024,
    system=SYSTEM_PROMPT,
    messages=[{"role": "user", "content": "¿Cuánto tarda un envío?"}],
)
print(respuesta.content[0].text)

El punto clave de un chatbot real es la memoria: Claude no recuerda turnos anteriores por sí solo, tú debes reenviar todo el historial en cada llamada. La estrategia es mantener una lista messages y, en cada turno, añadir el mensaje del usuario, llamar a la API, y añadir también la respuesta del asistente. Así el modelo tiene contexto completo de la conversación. Este patrón es el corazón de cualquier bot conversacional. Ten en cuenta que cada llamada envía todo el historial, por lo que los tokens (y el coste) crecen con la conversación: en el paso 6 veremos cómo acotarlo.

historial = []

def enviar_mensaje(texto_usuario):
    historial.append({"role": "user", "content": texto_usuario})
    respuesta = client.messages.create(
        model="claude-opus-4-8",
        max_tokens=1024,
        system=SYSTEM_PROMPT,
        messages=historial,
    )
    texto_bot = respuesta.content[0].text
    historial.append({"role": "assistant", "content": texto_bot})
    return texto_bot

print(enviar_mensaje("Me llamo Ana"))
print(enviar_mensaje("¿Cómo me llamo?"))  # Recordará Ana

Ahora unimos todo en un chat de consola funcional. Añadimos streaming para que las respuestas aparezcan token a token en lugar de esperar a la respuesta completa: mejora enormemente la percepción de velocidad, igual que en la app de Claude. Usamos client.messages.stream como context manager y iteramos sobre text_stream. El bucle while permite conversar hasta que el usuario escriba 'salir'. Acumulamos la respuesta completa para guardarla en el historial. Este es ya un chatbot usable que puedes conectar a un frontend web, WhatsApp o Telegram cambiando solo la capa de entrada/salida.

def chat():
    print("SoporteBot listo. Escribe 'salir' para terminar.\n")
    while True:
        entrada = input("Tú: ")
        if entrada.lower() == "salir":
            break
        historial.append({"role": "user", "content": entrada})
        print("Bot: ", end="", flush=True)
        texto_bot = ""
        with client.messages.stream(
            model="claude-opus-4-8",
            max_tokens=1024,
            system=SYSTEM_PROMPT,
            messages=historial,
        ) as stream:
            for fragmento in stream.text_stream:
                print(fragmento, end="", flush=True)
                texto_bot += fragmento
        print("\n")
        historial.append({"role": "assistant", "content": texto_bot})

chat()

En un bot real la conversación puede alargarse hasta consumir muchos tokens por llamada, lo que dispara el coste y puede superar la ventana de contexto. La solución más simple es mantener una ventana deslizante: conserva solo los últimos N turnos. Para bots que necesitan memoria larga, resume los turnos antiguos con una llamada aparte y guarda ese resumen. También conviene registrar respuesta.usage.input_tokens y output_tokens para vigilar el gasto y poner alertas. Con estos controles tienes un chatbot listo para escalar sin sorpresas en la factura a fin de mes.

MAX_TURNOS = 20  # 10 intercambios user+assistant

def recortar_historial(historial):
    if len(historial) > MAX_TURNOS:
        # Conserva los turnos más recientes
        return historial[-MAX_TURNOS:]
    return historial

# Uso dentro del bucle antes de llamar a la API:
# historial[:] = recortar_historial(historial)

# Monitorizar consumo tras una llamada no-streaming:
# print(f"Entrada: {respuesta.usage.input_tokens} tokens")
# print(f"Salida: {respuesta.usage.output_tokens} tokens")