How to implement tool calling on Claude

Install the Anthropic Python SDK using pip install anthropic. Initialize the client with your API key:

import anthropic

client = anthropic.Anthropic(
    api_key="your-api-key-here"
)

Alternatively, set your API key as an environment variable ANTHROPIC_API_KEY.

Create the actual functions that Claude will call. Each function should have clear parameters and return structured data:

def get_weather(location: str) -> dict:
    # Your weather API logic here
    return {
        "location": location,
        "temperature": "22°C",
        "condition": "sunny"
    }

def calculate_sum(a: float, b: float) -> float:
    return a + b

Define tool schemas that describe your functions to Claude using JSON schema format:

tools = [
    {
        "name": "get_weather",
        "description": "Get current weather for a location",
        "input_schema": {
            "type": "object",
            "properties": {
                "location": {
                    "type": "string",
                    "description": "City name or location"
                }
            },
            "required": ["location"]
        }
    }
]

Make an API call to Claude including your tools array and a message:

response = client.messages.create(
    model="claude-3-5-sonnet-20241022",
    max_tokens=1024,
    tools=tools,
    messages=[
        {
            "role": "user",
            "content": "What's the weather like in Paris?"
        }
    ]
)

Claude will analyze your message and determine if any tools should be used.

Check if Claude wants to use a tool by examining the response content:

if response.content[0].type == "tool_use":
    tool_use = response.content[0]
    tool_name = tool_use.name
    tool_input = tool_use.input
    tool_use_id = tool_use.id
    
    # Execute the corresponding function
    if tool_name == "get_weather":
        result = get_weather(**tool_input)
    
    print(f"Tool {tool_name} called with: {tool_input}")
    print(f"Result: {result}")

Create a follow-up message containing the tool results so Claude can provide a final response:

follow_up = client.messages.create(
    model="claude-3-5-sonnet-20241022",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "What's the weather like in Paris?"},
        {"role": "assistant", "content": response.content},
        {
            "role": "user",
            "content": [
                {
                    "type": "tool_result",
                    "tool_use_id": tool_use_id,
                    "content": str(result)
                }
            ]
        }
    ],
    tools=tools
)

Create a loop to handle multiple tool calls in a single conversation:

def chat_with_tools(user_message):
    messages = [{"role": "user", "content": user_message}]
    
    while True:
        response = client.messages.create(
            model="claude-3-5-sonnet-20241022",
            max_tokens=1024,
            tools=tools,
            messages=messages
        )
        
        if response.content[0].type == "text":
            return response.content[0].text
            
        # Handle tool use and continue loop
        # ... tool execution logic ...

Implement comprehensive error handling for API calls and tool execution:

import logging

try:
    response = client.messages.create(
        model="claude-3-5-sonnet-20241022",
        max_tokens=1024,
        tools=tools,
        messages=messages
    )
except anthropic.APIError as e:
    logging.error(f"Claude API error: {e}")
    return "Sorry, I encountered an error."
except Exception as e:
    logging.error(f"Tool execution error: {e}")
    return "Tool execution failed."