Programming &
Frameworks

mkdir agent-lab && cd agent-lab
python -m venv .venv
source .venv/bin/activate    # Windows: .venv\Scripts\activate
pip install anthropic python-dotenv

# Create .env with your API key
echo "ANTHROPIC_API_KEY=your_key_here" > .env

import os
import json
import anthropic
from dotenv import load_dotenv

load_dotenv()

client = anthropic.Anthropic()

# Tool definition — JSON Schema for inputs
TOOLS = [
    {
        "name": "calculator",
        "description": (
            "Performs arithmetic: add, subtract, multiply, divide. "
            "Use this whenever the user asks for a calculation."
        ),
        "input_schema": {
            "type": "object",
            "properties": {
                "operation": {
                    "type": "string",
                    "enum": ["add", "subtract", "multiply", "divide"],
                    "description": "The arithmetic operation"
                },
                "a": {"type": "number", "description": "First operand"},
                "b": {"type": "number", "description": "Second operand"}
            },
            "required": ["operation", "a", "b"]
        }
    }
]

def run_calculator(operation: str, a: float, b: float) -> str:
    """Execute the calculator tool and return result as string."""
    if operation == "add":
        result = a + b
    elif operation == "subtract":
        result = a - b
    elif operation == "multiply":
        result = a * b
    elif operation == "divide":
        if b == 0:
            return "Error: division by zero"
        result = a / b
    else:
        return f"Unknown operation: {operation}"
    return str(result)


def execute_tool(tool_name: str, tool_input: dict) -> str:
    """Route tool calls to the correct executor function."""
    if tool_name == "calculator":
        return run_calculator(
            tool_input["operation"],
            tool_input["a"],
            tool_input["b"]
        )
    raise ValueError(f"Unknown tool: {tool_name}")

def run_agent(user_message: str) -> str:
    """Run the agent loop until end_turn or max iterations."""
    messages = [
        {"role": "user", "content": user_message}
    ]
    max_iterations = 10  # guard against infinite loops

    for iteration in range(max_iterations):
        print(f"\n[iteration {iteration + 1}] calling API...")

        response = client.messages.create(
            model="claude-opus-4-6",  # use a current model from docs.anthropic.com
            max_tokens=1024,
            tools=TOOLS,
            messages=messages
        )

        # Append the assistant's response to history
        messages.append({
            "role": "assistant",
            "content": response.content
        })

        print(f"  stop_reason: {response.stop_reason}")

        # Done — extract and return the final text
        if response.stop_reason == "end_turn":
            for block in response.content:
                if hasattr(block, "text"):
                    return block.text
            return "(no text response)"

        # Model wants to call tools — execute each one
        if response.stop_reason == "tool_use":
            tool_results = []
            for block in response.content:
                if block.type == "tool_use":
                    print(f"  tool call: {block.name}({block.input})")
                    result = execute_tool(block.name, block.input)
                    print(f"  tool result: {result}")
                    tool_results.append({
                        "type": "tool_result",
                        "tool_use_id": block.id,
                        "content": result
                    })
            # Send tool results back as a user message
            messages.append({
                "role": "user",
                "content": tool_results
            })

    return "Max iterations reached without end_turn."


if __name__ == "__main__":
    answer = run_agent("What is 1234 multiplied by 5678?")
    print(f"\nAgent: {answer}")

python agent.py

[iteration 1] calling API...
  stop_reason: tool_use
  tool call: calculator({'operation': 'multiply', 'a': 1234, 'b': 5678})
  tool result: 7006652.0

[iteration 2] calling API...
  stop_reason: end_turn

Agent: 1234 multiplied by 5678 equals 7,006,652.

{
    "name": "get_today",
    "description": "Returns today's date as a string (YYYY-MM-DD).",
    "input_schema": {
        "type": "object",
        "properties": {},
        "required": []
    }
}

from datetime import date

if tool_name == "get_today":
    return str(date.today())