M05: Function Calling Fundamentals

# pip install "anthropic>=0.39.0"
import anthropic
import json

client = anthropic.Anthropic()

# Define tools
tools = [
    {
        "name": "get_weather",
        "description": "Get current weather for a city. Returns temp (Celsius), condition, humidity.",
        "input_schema": {
            "type": "object",
            "properties": {
                "city": {"type": "string", "description": "City name, e.g. 'Tokyo'"}
            },
            "required": ["city"]
        }
    },
    {
        "name": "calculate",
        "description": "Evaluate a mathematical expression. Use for any math computation.",
        "input_schema": {
            "type": "object",
            "properties": {
                "expression": {"type": "string", "description": "Math expression, e.g. '15 * 3 + 7'"}
            },
            "required": ["expression"]
        }
    }
]

# Mock tool implementations
def get_weather(city: str) -> dict:
    """Mock weather API."""
    data = {"Tokyo": {"temp": 22, "condition": "sunny", "humidity": 65},
            "London": {"temp": 14, "condition": "cloudy", "humidity": 80},
            "New York": {"temp": 28, "condition": "partly cloudy", "humidity": 70}}
    return data.get(city, {"error": f"No data for {city}"})

def calculate(expression: str) -> dict:
    """Safe math evaluator."""
    try:
        # Only allow safe math operations
        allowed = set("0123456789+-*/.() ")
        if not all(c in allowed for c in expression):
            return {"error": "Invalid characters in expression"}
        result = eval(expression)  # Safe: only math chars allowed
        return {"result": result}
    except Exception as e:
        return {"error": str(e)}

# Tool dispatcher
tool_functions = {"get_weather": get_weather, "calculate": calculate}

def run_agent(user_message: str) -> str:
    """Run the agent loop until Claude produces a final response."""
    messages = [{"role": "user", "content": user_message}]

    while True:
        try:
            response = client.messages.create(
                model="claude-sonnet-4-6",
                max_tokens=1024,
                tools=tools,
                messages=messages,
            )
        except anthropic.APIError as e:
            return f"API error: {e.status_code} - {e.message}"

        # Check if Claude wants to use a tool
        if response.stop_reason == "tool_use":
            # Process each tool_use block
            tool_results = []
            for block in response.content:
                if block.type == "tool_use":
                    func = tool_functions.get(block.name)
                    if func:
                        result = func(**block.input)
                    else:
                        result = {"error": f"Unknown tool: {block.name}"}

                    tool_results.append({
                        "type": "tool_result",
                        "tool_use_id": block.id,
                        "content": json.dumps(result),
                    })

            # Add Claude's response and tool results to conversation
            messages.append({"role": "assistant", "content": response.content})
            messages.append({"role": "user", "content": tool_results})

        else:
            # stop_reason == "end_turn" — Claude is done
            for block in response.content:
                if hasattr(block, "text"):
                    return block.text
            return "No text response from Claude."

# Test it!
print(run_agent("What's the weather in Tokyo?"))
print()
print(run_agent("What's 15% of 850?"))
print()
print(run_agent("What's the capital of France?"))  # No tool needed

mkdir m05-lab && cd m05-lab
python -m venv venv && source venv/bin/activate   # Windows: venv\Scripts\activate
pip install "anthropic>=0.39.0"
export ANTHROPIC_API_KEY="your-key-here"           # Windows: set ANTHROPIC_API_KEY=your-key-here

import anthropic
import json

client = anthropic.Anthropic()

# --- Tool definitions (what Claude sees) ---
TOOLS = [
    {
        "name": "get_weather",
        "description": "Get current weather for a city. Returns temperature (Celsius), condition, and humidity.",
        "input_schema": {
            "type": "object",
            "properties": {
                "city": {"type": "string", "description": "City name, e.g. 'Tokyo' or 'New York'"}
            },
            "required": ["city"],
        },
    },
    {
        "name": "calculate",
        "description": "Evaluate a mathematical expression. Supports +, -, *, /, **, parentheses.",
        "input_schema": {
            "type": "object",
            "properties": {
                "expression": {"type": "string", "description": "Math expression, e.g. '(15 * 7) + 23'"}
            },
            "required": ["expression"],
        },
    },
    {
        "name": "get_time",
        "description": "Get the current time in a specific timezone. Returns time in HH:MM format.",
        "input_schema": {
            "type": "object",
            "properties": {
                "timezone": {"type": "string", "description": "Timezone, e.g. 'US/Eastern', 'Asia/Tokyo', 'Europe/London'"}
            },
            "required": ["timezone"],
        },
    },
]

# --- Mock implementations (what your code runs) ---
MOCK_WEATHER = {
    "tokyo": {"temp": 22, "condition": "sunny", "humidity": 45},
    "london": {"temp": 14, "condition": "cloudy", "humidity": 72},
    "new york": {"temp": 28, "condition": "partly cloudy", "humidity": 60},
}

def run_tool(name: str, args: dict) -> str:
    """Execute a tool and return the result as a JSON string."""
    if name == "get_weather":
        city = args.get("city", "").lower()
        data = MOCK_WEATHER.get(city)
        if data:
            return json.dumps(data)
        return json.dumps({"error": f"City '{args.get('city')}' not found. Available: Tokyo, London, New York"})

    elif name == "calculate":
        expr = args.get("expression", "")
        try:
            # Safe eval: only allow math operations
            allowed = set("0123456789+-*/.()**% ")
            if not all(c in allowed for c in expr):
                return json.dumps({"error": f"Invalid characters in expression: {expr}"})
            result = eval(expr)  # Safe because we validated characters
            return json.dumps({"result": result})
        except Exception as e:
            return json.dumps({"error": f"Calculation failed: {str(e)}"})

    elif name == "get_time":
        tz = args.get("timezone", "")
        # Mock: return a fixed time
        times = {"us/eastern": "14:30", "asia/tokyo": "03:30", "europe/london": "19:30"}
        time_str = times.get(tz.lower(), "12:00")
        return json.dumps({"timezone": tz, "time": time_str})

    return json.dumps({"error": f"Unknown tool: {name}"})

print(f"Defined {len(TOOLS)} tools: {[t['name'] for t in TOOLS]}")
print(f"Test: {run_tool('get_weather', {'city': 'Tokyo'})}")

def agent_chat(user_message: str) -> str:
    """Run the full agent loop: send message, handle tool calls, return final answer."""
    messages = [{"role": "user", "content": user_message}]

    while True:
        response = client.messages.create(
            model="claude-sonnet-4-6",
            max_tokens=1024,
            tools=TOOLS,
            messages=messages,
        )

        # If Claude is done, return the text
        if response.stop_reason == "end_turn":
            for block in response.content:
                if hasattr(block, "text"):
                    return block.text
            return "(no text response)"

        # If Claude wants to use a tool, execute it
        if response.stop_reason == "tool_use":
            # Append Claude's full response (including tool_use blocks)
            messages.append({"role": "assistant", "content": response.content})

            # Process each tool_use block
            tool_results = []
            for block in response.content:
                if block.type == "tool_use":
                    print(f"  🔧 Tool call: {block.name}({json.dumps(block.input)})")
                    result = run_tool(block.name, block.input)
                    print(f"  📦 Result: {result[:80]}")
                    tool_results.append({
                        "type": "tool_result",
                        "tool_use_id": block.id,
                        "content": result,
                    })

            # Send all results back
            messages.append({"role": "user", "content": tool_results})
        else:
            return f"(unexpected stop_reason: {response.stop_reason})"

# Test with single-tool questions
test_questions = [
    "What's the weather like in Tokyo?",
    "What is (15 * 7) + 23?",
    "What time is it in London?",
    "What's the capital of France?",  # No tool needed!
]

for q in test_questions:
    print(f"\n{'='*50}")
    print(f"User: {q}")
    answer = agent_chat(q)
    print(f"Agent: {answer[:150]}")