Cómo hacer que Claude automatice tareas con la API

El primer paso es preparar tu entorno. Anthropic ofrece un SDK oficial de Python que simplifica las llamadas a la API. Instálalo con pip y guarda tu API key como variable de entorno para no exponerla en el código (buena práctica esencial si vas a subir el proyecto a Git). Crea tu API key en console.anthropic.com dentro de la sección API Keys. En España y LATAM el proceso es idéntico; solo necesitas una tarjeta para añadir crédito. Exporta la clave en tu terminal antes de ejecutar cualquier script. En Windows usa `set` en lugar de `export`. La automatización real empieza cuando Claude puede llamar a funciones de tu código: eso es tool use (o function calling). Pero antes verificamos que la conexión básica funcione con una llamada simple.

pip install anthropic

# En Linux/macOS (España/LATAM)
export ANTHROPIC_API_KEY="sk-ant-tu-clave-aqui"

# En Windows (PowerShell)
# $env:ANTHROPIC_API_KEY="sk-ant-tu-clave-aqui"

Antes de automatizar nada, confirma que el SDK y la key funcionan con una petición mínima. Esto te ahorra depurar problemas de red o autenticación más adelante, cuando el código sea complejo. Usamos el modelo claude-opus-4-8 por defecto. El parámetro `max_tokens` limita la longitud de la respuesta y `messages` contiene el historial de la conversación. Cada mensaje tiene un `role` (user o assistant) y un `content`. Si ves la respuesta impresa en consola, tu entorno está listo. Si recibes un error 401, la key es incorrecta o no está exportada; un 429 significa que has superado el límite de tasa o no tienes crédito.

import anthropic

client = anthropic.Anthropic()  # lee ANTHROPIC_API_KEY del entorno

response = client.messages.create(
    model="claude-opus-4-8",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "Responde solo con: conexión OK"}
    ],
)

print(response.content[0].text)

La automatización de tareas se basa en tool use: describes a Claude qué funciones tiene disponibles y él decide cuándo llamarlas. Cada herramienta se define con un nombre, una descripción clara y un esquema JSON de entrada (input_schema). La descripción es crítica: Claude decide cuándo usar cada herramienta basándose en ella, así que sé específico. Aquí definimos dos herramientas de ejemplo: una para consultar el tiempo y otra para guardar una nota en disco. En un caso real conectarías con APIs propias, bases de datos o servicios como Slack o Notion. El `input_schema` sigue el estándar JSON Schema. Marca como `required` los parámetros obligatorios para que Claude no los omita. Cuanto más precisa sea la descripción de cada parámetro, menos errores cometerá el modelo al invocar la función.

tools = [
    {
        "name": "consultar_tiempo",
        "description": "Devuelve la temperatura actual de una ciudad española o de LATAM.",
        "input_schema": {
            "type": "object",
            "properties": {
                "ciudad": {"type": "string", "description": "Nombre de la ciudad, p.ej. Madrid"}
            },
            "required": ["ciudad"],
        },
    },
    {
        "name": "guardar_nota",
        "description": "Guarda un texto en un archivo local para registro.",
        "input_schema": {
            "type": "object",
            "properties": {
                "contenido": {"type": "string", "description": "Texto a guardar"}
            },
            "required": ["contenido"],
        },
    },
]

Claude no ejecuta código por ti: solo te dice qué función llamar y con qué argumentos. Tú eres responsable de ejecutar la lógica real. Aquí implementamos las funciones que corresponden a las herramientas definidas. Para `consultar_tiempo` simulamos una respuesta, pero en producción harías una petición a una API real como AEMET (España) u OpenWeather. Para `guardar_nota` escribimos en un archivo local. Lo importante es crear un despachador (dispatcher) que reciba el nombre de la herramienta y sus argumentos, y devuelva el resultado como texto. Ese resultado se lo devolveremos a Claude en el siguiente paso para que continúe la tarea. Mantén cada función pequeña y con manejo de errores: si falla, devuelve un mensaje descriptivo en lugar de reventar el programa.

import json

def consultar_tiempo(ciudad):
    # En producción: llamada real a AEMET u OpenWeather
    datos = {"Madrid": 28, "Bogotá": 18, "Buenos Aires": 22}
    temp = datos.get(ciudad, 20)
    return f"En {ciudad} hay {temp}°C"

def guardar_nota(contenido):
    with open("notas.txt", "a", encoding="utf-8") as f:
        f.write(contenido + "\n")
    return "Nota guardada correctamente"

def ejecutar_herramienta(nombre, args):
    if nombre == "consultar_tiempo":
        return consultar_tiempo(args["ciudad"])
    if nombre == "guardar_nota":
        return guardar_nota(args["contenido"])
    return f"Herramienta desconocida: {nombre}"

Aquí está el corazón de la automatización. Cuando Claude decide usar una herramienta, la respuesta tiene `stop_reason == 'tool_use'`. Tú ejecutas la función, le devuelves el resultado, y Claude continúa hasta completar la tarea. Este ciclo se repite hasta que ya no necesita más herramientas. El bucle acumula todos los mensajes (los del usuario, los del assistant y los resultados de las herramientas) para mantener el contexto. Es fundamental enviar el `tool_use_id` correcto en cada resultado para que Claude sepa a qué llamada corresponde. Con este patrón, Claude puede encadenar varias acciones automáticamente: consultar el tiempo, decidir qué escribir y guardar una nota, todo con una sola instrucción tuya. Esto es lo que convierte a Claude en un agente autónomo.

messages = [
    {"role": "user", "content": "Consulta el tiempo en Madrid y guarda una nota con el resultado."}
]

while True:
    resp = client.messages.create(
        model="claude-opus-4-8",
        max_tokens=1024,
        tools=tools,
        messages=messages,
    )

    if resp.stop_reason != "tool_use":
        print(resp.content[0].text)
        break

    messages.append({"role": "assistant", "content": resp.content})
    resultados = []
    for bloque in resp.content:
        if bloque.type == "tool_use":
            salida = ejecutar_herramienta(bloque.name, bloque.input)
            resultados.append({
                "type": "tool_result",
                "tool_use_id": bloque.id,
                "content": salida,
            })
    messages.append({"role": "user", "content": resultados})

Ejecuta el script completo. Deberías ver cómo Claude consulta el tiempo, procesa el dato y guarda la nota sin que intervengas entre pasos. Revisa el archivo notas.txt para confirmar que la acción se ejecutó. A partir de aquí, la automatización crece conectando herramientas reales: enviar emails con SMTP, crear tickets en Jira, consultar tu base de datos PostgreSQL o publicar en redes. El patrón es siempre el mismo: describe la herramienta, implementa la función, deja que el bucle agéntico orqueste. Para casos avanzados con muchas integraciones, conviene explorar MCP (Model Context Protocol), el estándar de Anthropic para conectar Claude a fuentes de datos y servicios de forma reutilizable. También puedes añadir logging para auditar cada acción, algo imprescindible en entornos de producción con requisitos de cumplimiento como el RGPD europeo.

# Ejemplo de nueva herramienta: enviar email
# Añádela a la lista `tools` y a `ejecutar_herramienta`
import smtplib
from email.message import EmailMessage

def enviar_email(destino, asunto, cuerpo):
    msg = EmailMessage()
    msg["To"] = destino
    msg["Subject"] = asunto
    msg.set_content(cuerpo)
    # Configura tu servidor SMTP real aquí
    return f"Email enviado a {destino}"