Adding a Calculator Tool to Your AI Agent

def calculate(expression: str) -> dict:
    """
    Evaluate a mathematical expression and return the result.
    
    Args:
        expression: A math expression like "1234 * 5678" or "100 + 50 - 25"
    
    Returns:
        Dictionary with 'result' or 'error'
    """
    try:
        # Evaluate the expression
        result = eval(expression)
        return {
            "success": True,
            "result": result,
            "expression": expression
        }
    except Exception as e:
        return {
            "success": False,
            "error": str(e),
            "expression": expression
        }

## Test the calculator
print(calculate("1234 * 5678"))
print(calculate("100 + 50 - 25"))
print(calculate("10 / 3"))

calculator_tool = {
    "name": "calculate",
    "description": "Perform precise mathematical calculations. Use this for any arithmetic operations including addition, subtraction, multiplication, division, and exponentiation.",
    "input_schema": {
        "type": "object",
        "properties": {
            "expression": {
                "type": "string",
                "description": "The mathematical expression to evaluate. Use standard operators: + (add), - (subtract), * (multiply), / (divide), ** (power). Examples: '1234 * 5678', '100 + 50 - 25', '2 ** 8'"
            }
        },
        "required": ["expression"]
    }
}

import os
from anthropic import Anthropic

## Using Claude Sonnet 4.5 for its excellent tool use and agent reasoning
client = Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))

def run_agent_with_calculator(user_message: str) -> str:
    """
    Run the agent with calculator tool support.
    
    Args:
        user_message: The user's question or request
    
    Returns:
        The agent's response
    """
    # Tool registry maps tool names to functions
    tool_registry = {
        "calculate": calculate
    }
    
    # Start the conversation
    messages = [{"role": "user", "content": user_message}]
    
    # Initial agent call with tool description
    response = client.messages.create(
        model="claude-sonnet-4-5",
        max_tokens=1024,
        tools=[calculator_tool],
        messages=messages
    )
    
    # Check if the agent wants to use a tool
    if response.stop_reason == "tool_use":
        # Extract tool use information
        tool_use_block = next(
            block for block in response.content 
            if block.type == "tool_use"
        )
        
        tool_name = tool_use_block.name
        tool_input = tool_use_block.input
        
        print(f"Agent is using tool: {tool_name}")
        print(f"Tool input: {tool_input}")
        
        # Call the tool
        tool_result = tool_registry[tool_name](**tool_input)
        print(f"Tool result: {tool_result}")
        
        # Send the tool result back to the agent
        messages.append({"role": "assistant", "content": response.content})
        messages.append({
            "role": "user",
            "content": [{
                "type": "tool_result",
                "tool_use_id": tool_use_block.id,
                "content": str(tool_result)
            }]
        })
        
        # Get the agent's final response
        final_response = client.messages.create(
            model="claude-sonnet-4-5",
            max_tokens=1024,
            tools=[calculator_tool],
            messages=messages
        )
        
        return final_response.content[0].text
    
    # No tool needed, return direct response
    return response.content[0].text

## Test 1: The original problem
print("Test 1: Large multiplication")
print(run_agent_with_calculator("What's 1234 times 5678?"))
print()

## Test 2: Multiple operations
print("Test 2: Multiple operations")
print(run_agent_with_calculator("If I have $\$100$ and spend $\$23.50$ on lunch and $\$15.75$ on coffee, how much do I have left?"))
print()

## Test 3: Complex calculation
print("Test 3: Complex calculation")
print(run_agent_with_calculator("What's 2 to the power of 16?"))

## Test 4: Simple math the agent can handle
print("Test 4: Simple math")
print(run_agent_with_calculator("What's 2 plus 2?"))
print()

## Test 5: General knowledge
print("Test 5: General knowledge")
print(run_agent_with_calculator("What's the capital of France?"))

## Test 6: Invalid expression
print("Test 6: Invalid expression")
print(run_agent_with_calculator("What's the square root of -1?"))

## Test 7: Syntax error
print("Test 7: Syntax error")
print(run_agent_with_calculator("Calculate 5 + + 3"))

{
    "stop_reason": "tool_use",
    "content": [
        {
            "type": "tool_use",
            "name": "calculate",
            "input": {"expression": "1234 * 5678"}
        }
    ]
}

calculate(expression="1234 * 5678")

{'success': True, 'result': 7006652, 'expression': '1234 * 5678'}

messages.append({
    "role": "user",
    "content": [{
        "type": "tool_result",
        "tool_use_id": "...",
        "content": "{'success': True, 'result': 7006652, 'expression': '1234 * 5678'}"
    }]
})

import re

def calculate_enhanced(expression: str) -> dict:
    """
    Enhanced calculator with better error handling and formatting.
    
    Args:
        expression: A math expression
    
    Returns:
        Dictionary with result or error
    """
    try:
        # Clean the expression
        # Remove common words that might appear
        expression = expression.lower()
        expression = re.sub(r'\b(what is|calculate|compute|equals?)\b', '', expression)
        expression = expression.strip()
        
        # Replace common word operators
        expression = expression.replace('times', '*')
        expression = expression.replace('divided by', '/')
        expression = expression.replace('plus', '+')
        expression = expression.replace('minus', '-')
        expression = expression.replace('to the power of', '**')
        
        # Evaluate
        result = eval(expression)
        
        # Format the result nicely
        if isinstance(result, float):
            # Round to reasonable precision
            if result.is_integer():
                result = int(result)
            else:
                result = round(result, 6)
        
        return {
            "success": True,
            "result": result,
            "expression": expression
        }
    except Exception as e:
        return {
            "success": False,
            "error": f"Could not evaluate '{expression}': {str(e)}",
            "expression": expression
        }

tool_registry = {
    "calculate": calculate_enhanced
}

def convert_temperature(value: float, from_unit: str, to_unit: str) -> dict:
    """Convert temperature between Celsius, Fahrenheit, and Kelvin."""
    try:
        # Convert to Celsius first
        if from_unit.lower() == "fahrenheit":
            celsius = (value - 32) * 5/9
        elif from_unit.lower() == "kelvin":
            celsius = value - 273.15
        else:  # Already Celsius
            celsius = value
        
        # Convert from Celsius to target
        if to_unit.lower() == "fahrenheit":
            result = celsius * 9/5 + 32
        elif to_unit.lower() == "kelvin":
            result = celsius + 273.15
        else:  # Stay in Celsius
            result = celsius
        
        return {
            "success": True,
            "result": round(result, 2),
            "from_value": value,
            "from_unit": from_unit,
            "to_unit": to_unit
        }
    except Exception as e:
        return {
            "success": False,
            "error": str(e)
        }

## Tool description
temperature_tool = {
    "name": "convert_temperature",
    "description": "Convert temperature between Celsius, Fahrenheit, and Kelvin",
    "input_schema": {
        "type": "object",
        "properties": {
            "value": {
                "type": "number",
                "description": "The temperature value to convert"
            },
            "from_unit": {
                "type": "string",
                "description": "The unit to convert from: 'celsius', 'fahrenheit', or 'kelvin'"
            },
            "to_unit": {
                "type": "string",
                "description": "The unit to convert to: 'celsius', 'fahrenheit', or 'kelvin'"
            }
        },
        "required": ["value", "from_unit", "to_unit"]
    }
}

## Update the agent to include both tools
def run_agent_with_tools(user_message: str) -> str:
    """Run agent with calculator and temperature converter."""
    tool_registry = {
        "calculate": calculate,
        "convert_temperature": convert_temperature
    }
    
    messages = [{"role": "user", "content": user_message}]
    
    response = client.messages.create(
        model="claude-sonnet-4-5",
        max_tokens=1024,
        tools=[calculator_tool, temperature_tool],
        messages=messages
    )
    
    # Same tool use logic as before...
    # (Full implementation omitted for brevity)

print(run_agent_with_tools("What's 100 Celsius in Fahrenheit?"))
print(run_agent_with_tools("If I buy 15 items at $\$12.99$ each, what's my total?"))