Cómo hacer un agente de IA en Claude

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"

tools = [
    {
        "name": "calcular",
        "description": "Evalúa una expresión matemática y devuelve el resultado numérico. Úsala siempre que necesites hacer cálculos precisos.",
        "input_schema": {
            "type": "object",
            "properties": {
                "expresion": {
                    "type": "string",
                    "description": "Expresión matemática, ej: '2500 * 1.21'"
                }
            },
            "required": ["expresion"]
        }
    },
    {
        "name": "obtener_clima",
        "description": "Devuelve la temperatura actual de una ciudad. Úsala para preguntas sobre el tiempo.",
        "input_schema": {
            "type": "object",
            "properties": {
                "ciudad": {"type": "string", "description": "Nombre de la ciudad"}
            },
            "required": ["ciudad"]
        }
    }
]

def calcular(expresion: str) -> str:
    try:
        # En producción usa numexpr o un parser seguro, no eval crudo
        resultado = eval(expresion, {"__builtins__": {}}, {})
        return str(resultado)
    except Exception as e:
        return f"Error al calcular: {e}"

def obtener_clima(ciudad: str) -> str:
    # Simulado. Aquí llamarías a una API real (ej. OpenWeather)
    datos = {"Madrid": "28°C", "Bogotá": "18°C", "Buenos Aires": "22°C"}
    return datos.get(ciudad, "Ciudad no encontrada")

def ejecutar_tool(nombre: str, args: dict) -> str:
    if nombre == "calcular":
        return calcular(args["expresion"])
    elif nombre == "obtener_clima":
        return obtener_clima(args["ciudad"])
    return "Herramienta desconocida"

import anthropic

cliente = anthropic.Anthropic()

def ejecutar_agente(pregunta: str, max_iteraciones: int = 8):
    messages = [{"role": "user", "content": pregunta}]

    for i in range(max_iteraciones):
        respuesta = cliente.messages.create(
            model="claude-opus-4-8",
            max_tokens=1024,
            tools=tools,
            messages=messages,
        )
        messages.append({"role": "assistant", "content": respuesta.content})

        if respuesta.stop_reason != "tool_use":
            # Claude terminó: devolvemos el texto final
            return "".join(b.text for b in respuesta.content if b.type == "text")

        # Ejecutamos cada tool que Claude pidió
        resultados = []
        for bloque in respuesta.content:
            if bloque.type == "tool_use":
                salida = ejecutar_tool(bloque.name, bloque.input)
                resultados.append({
                    "type": "tool_result",
                    "tool_use_id": bloque.id,
                    "content": salida,
                })
        messages.append({"role": "user", "content": resultados})

    return "Se alcanzó el límite de iteraciones sin respuesta final."

SYSTEM = """Eres un asistente experto que resuelve tareas usando herramientas.
Reglas:
- Usa la herramienta 'calcular' para cualquier operación matemática, nunca calcules mentalmente.
- Usa 'obtener_clima' para preguntas sobre el tiempo.
- Responde siempre en español, de forma clara y concisa.
- Si te falta información, pídela antes de actuar."""

# Dentro de ejecutar_agente, añade system al create:
respuesta = cliente.messages.create(
    model="claude-opus-4-8",
    max_tokens=1024,
    system=SYSTEM,
    tools=tools,
    messages=messages,
)

if __name__ == "__main__":
    pregunta = (
        "Tengo una factura de 2500 euros sin IVA. "
        "Calcula el total con el IVA español del 21% "
        "y dime qué temperatura hace en Madrid."
    )
    resultado = ejecutar_agente(pregunta)
    print("\n=== RESPUESTA DEL AGENTE ===")
    print(resultado)

# Salida esperada (aprox):
# El total con el 21% de IVA es 3025 euros.
# En Madrid la temperatura actual es de 28°C.

def ejecutar_agente_seguro(pregunta, max_iteraciones=8):
    messages = [{"role": "user", "content": pregunta}]
    tokens_totales = 0
    for i in range(max_iteraciones):
        try:
            r = cliente.messages.create(
                model="claude-opus-4-8",
                max_tokens=1024,
                system=SYSTEM,
                tools=tools,
                messages=messages,
            )
        except anthropic.APIError as e:
            return f"Error de API: {e}"
        tokens_totales += r.usage.input_tokens + r.usage.output_tokens
        messages.append({"role": "assistant", "content": r.content})
        if r.stop_reason != "tool_use":
            print(f"Tokens usados: {tokens_totales}")
            return "".join(b.text for b in r.content if b.type == "text")
        resultados = [
            {"type": "tool_result", "tool_use_id": b.id,
             "content": ejecutar_tool(b.name, b.input)}
            for b in r.content if b.type == "tool_use"
        ]
        messages.append({"role": "user", "content": resultados})
    return "Límite de iteraciones alcanzado."