How to Build an AI Agent with Claude API (Step-by-Step)

import os
import anthropic

# Verify the SDK is installed and the key is loaded
api_key = os.environ.get("ANTHROPIC_API_KEY")
if not api_key:
    raise EnvironmentError("ANTHROPIC_API_KEY environment variable is not set.")

client = anthropic.Anthropic(api_key=api_key)

# Quick sanity check — send a minimal message
response = client.messages.create(
    model="claude-sonnet-4-5",
    max_tokens=64,
    messages=[{"role": "user", "content": "Say hello in one word."}]
)

print(response.content[0].text)
# Expected output: Hello

import json
import math

# Tool schemas tell Claude what each tool does and what inputs it expects.
# These get passed directly into the API call.
TOOL_DEFINITIONS = [
    {
        "name": "get_weather",
        "description": (
            "Returns the current weather for a given city. "
            "Use this when the user asks about weather conditions in a specific location."
        ),
        "input_schema": {
            "type": "object",
            "properties": {
                "city": {
                    "type": "string",
                    "description": "The name of the city to get weather for, e.g. 'Naples, FL'"
                }
            },
            "required": ["city"]
        }
    },
    {
        "name": "calculate",
        "description": (
            "Evaluates a mathematical expression and returns the numeric result. "
            "Use this for any arithmetic, percentages, or unit conversions."
        ),
        "input_schema": {
            "type": "object",
            "properties": {
                "expression": {
                    "type": "string",
                    "description": "A valid Python math expression, e.g. '(98.6 - 32) * 5/9'"
                }
            },
            "required": ["expression"]
        }
    }
]


def get_weather(city: str) -> str:
    """
    Simulated weather lookup. In production, replace this with a
    real API call to OpenWeatherMap, WeatherAPI, or similar.
    """
    mock_data = {
        "naples, fl": {"temp_f": 84, "condition": "Sunny", "humidity": 72},
        "miami, fl": {"temp_f": 88, "condition": "Partly Cloudy", "humidity": 78},
        "new york, ny": {"temp_f": 55, "condition": "Overcast", "humidity": 60},
    }
    key = city.lower().strip()
    weather = mock_data.get(key, {"temp_f": 70, "condition": "Clear", "humidity": 50})
    return json.dumps({
        "city": city,
        "temperature_f": weather["temp_f"],
        "condition": weather["condition"],
        "humidity_percent": weather["humidity"]
    })


def calculate(expression: str) -> str:
    """
    Safely evaluates a math expression using Python's math module.
    Only allows numeric operations — no builtins, no exec tricks.
    """
    try:
        # Restrict eval to math functions only for safety
        allowed_names = {k: v for k, v in math.__dict__.items() if not k.startswith("_")}
        result = eval(expression, {"__builtins__": {}}, allowed_names)
        return json.dumps({"result": result, "expression": expression})
    except Exception as e:
        return json.dumps({"error": str(e), "expression": expression})


def execute_tool(tool_name: str, tool_input: dict) -> str:
    """Routes a tool call from Claude to the correct Python function."""
    if tool_name == "get_weather":
        return get_weather(tool_input["city"])
    elif tool_name == "calculate":
        return calculate(tool_input["expression"])
    else:
        return json.dumps({"error": f"Unknown tool: {tool_name}"})

import os
import anthropic
from tools import TOOL_DEFINITIONS, execute_tool

class ClaudeAgent:
    """
    A simple autonomous agent built on top of the Claude API.
    Supports multi-step tool use via an agentic loop.
    """

    def __init__(self, max_iterations: int = 10):
        self.client = anthropic.Anthropic(api_key=os.environ.get("ANTHROPIC_API_KEY"))
        self.model = "claude-sonnet-4-5"
        self.max_iterations = max_iterations
        self.conversation_history = []

    def run(self, user_message: str) -> str:
        """
        Entry point. Takes a user message and returns the agent's final answer
        after completing any necessary tool calls.
        """
        print(f"\n{'='*60}")
        print(f"USER: {user_message}")
        print(f"{'='*60}")

        # Add the user's message to the conversation history
        self.conversation_history.append({
            "role": "user",
            "content": user_message
        })

        # Run the agentic loop
        for iteration in range(self.max_iterations):
            print(f"\n[Iteration {iteration + 1}]")

            response = self.client.messages.create(
                model=self.model,
                max_tokens=4096,
                tools=TOOL_DEFINITIONS,
                messages=self.conversation_history
            )

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

            # Append Claude's response to history so the loop stays coherent
            self.conversation_history.append({
                "role": "assistant",
                "content": response.content
            })

            # If Claude is done, extract and return the final text response
            if response.stop_reason == "end_turn":
                final_text = self._extract_text(response.content)
                print(f"\nAGENT FINAL ANSWER:\n{final_text}")
                return final_text

            # If Claude wants to use tools, handle each tool call
            if response.stop_reason == "tool_use":
                tool_results = self._handle_tool_calls(response.content)

                # Feed the tool results back into the conversation
                self.conversation_history.append({
                    "role": "user",
                    "content": tool_results
                })
            else:
                # Unexpected stop reason — break to avoid infinite loop
                print(f"Unexpected stop reason: {response.stop_reason}")
                break

        return "Agent reached maximum iterations without completing the task."

    def _handle_tool_calls(self, content_blocks: list) -> list:
        """
        Finds all tool_use blocks in Claude's response, runs each tool,
        and returns a list of tool_result blocks to send back.
        """
        tool_results = []

        for block in content_blocks:
            if block.type == "tool_use":
                print(f"\n  TOOL CALL: {block.name}")
                print(f"  INPUT: {block.input}")

                # Execute the tool and get the result
                result = execute_tool(block.name, block.input)
                print(f"  RESULT: {result}")

                # Format the result as Claude expects it
                tool_results.append({
                    "type": "tool_result",
                    "tool_use_id": block.id,
                    "content": result
                })

        return tool_results

    def _extract_text(self, content_blocks: list) -> str:
        """Pulls the text content out of Claude's final response."""
        texts = []
        for block in content_blocks:
            if hasattr(block, "text"):
                texts.append(block.text)
        return "\n".join(texts)

from agent import ClaudeAgent

def main():
    # Create the agent with a safety limit of 10 loop iterations
    agent = ClaudeAgent(max_iterations=10)

    # This question requires two tool calls: weather lookup + unit conversion
    result = agent.run(
        "What's the weather like in Naples, FL right now? "
        "Also convert the temperature to Celsius for me."
    )

    print("\n" + "="*60)
    print("DONE")
    print("="*60)

if __name__ == "__main__":
    main()

============================================================
USER: What's the weather like in Naples, FL right now? Also convert the temperature to Celsius for me.
============================================================

[Iteration 1]
Stop reason: tool_use

  TOOL CALL: get_weather
  INPUT: {'city': 'Naples, FL'}
  RESULT: {"city": "Naples, FL", "temperature_f": 84, "condition": "Sunny", "humidity_percent": 72}

[Iteration 2]
Stop reason: tool_use

  TOOL CALL: calculate
  INPUT: {'expression': '(84 - 32) * 5/9'}
  RESULT: {"result": 28.88888888888889, "expression": "(84 - 32) * 5/9"}

[Iteration 3]
Stop reason: end_turn

AGENT FINAL ANSWER:
The current weather in Naples, FL is sunny with a temperature of 84°F (approximately 28.9°C)
and humidity at 72%. It's a warm, beautiful day on the Gulf Coast!

============================================================
DONE
============================================================