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

pip install anthropic
export ANTHROPIC_API_KEY="your-api-key-here"

import anthropic
import os

# Initialize the Anthropic client — it reads ANTHROPIC_API_KEY from environment automatically
client = anthropic.Anthropic()

# Quick connectivity test before we build the full agent
response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=256,
    messages=[
        {"role": "user", "content": "Say 'Agent initialized successfully' and nothing else."}
    ]
)

print(response.content[0].text)

import anthropic
import json
import math
import os
from datetime import datetime

# Initialize client — API key pulled from ANTHROPIC_API_KEY environment variable
client = anthropic.Anthropic()

MODEL = "claude-sonnet-4-6"
MAX_ITERATIONS = 10  # Safety limit to prevent infinite loops

# ─────────────────────────────────────────────
# TOOL DEFINITIONS
# ─────────────────────────────────────────────

tools = [
    {
        "name": "web_search",
        "description": (
            "Searches the web for current information on a given query. "
            "Use this when the user asks about recent events, facts you're unsure about, "
            "or anything that requires up-to-date information. Returns a simulated search result."
        ),
        "input_schema": {
            "type": "object",
            "properties": {
                "query": {
                    "type": "string",
                    "description": "The search query to look up. Be specific for better results."
                }
            },
            "required": ["query"]
        }
    },
    {
        "name": "calculator",
        "description": (
            "Evaluates a mathematical expression and returns the result. "
            "Use this for any arithmetic, algebra, or numerical computation. "
            "Supports standard Python math expressions including math module functions."
        ),
        "input_schema": {
            "type": "object",
            "properties": {
                "expression": {
                    "type": "string",
                    "description": (
                        "A valid Python math expression. Examples: '2 + 2', "
                        "'math.sqrt(144)', '(15 * 8) / 3'. Do not include variable assignments."
                    )
                }
            },
            "required": ["expression"]
        }
    },
    {
        "name": "write_file",
        "description": (
            "Writes text content to a file on the local filesystem. "
            "Use this when the user asks to save, export, or create a file with specific content. "
            "Returns confirmation with the file path and character count."
        ),
        "input_schema": {
            "type": "object",
            "properties": {
                "filename": {
                    "type": "string",
                    "description": "The filename including extension, e.g. 'report.txt' or 'output.md'."
                },
                "content": {
                    "type": "string",
                    "description": "The full text content to write into the file."
                }
            },
            "required": ["filename", "content"]
        }
    }
]


# ─────────────────────────────────────────────
# TOOL EXECUTION FUNCTIONS
# ─────────────────────────────────────────────

def run_web_search(query: str) -> str:
    """
    Simulates a web search result. In production, replace this with
    a real search API call (SerpAPI, Brave Search, Tavily, etc.).
    """
    simulated_results = {
        "Naples Florida weather": (
            "Current weather in Naples, FL: 88°F, partly cloudy, humidity 74%. "
            "Afternoon thunderstorms possible. 7-day forecast shows continued warm temperatures."
        ),
        "Anthropic Claude API pricing": (
            "Claude claude-sonnet-4-6 pricing as of 2026: input tokens $3/MTok, output tokens $15/MTok. "
            "Batch API offers 50% discount. Check console.anthropic.com for current rates."
        ),
    }
    # Return a matching result or a generic simulated response
    for key, value in simulated_results.items():
        if key.lower() in query.lower():
            return value

    return (
        f"Search results for '{query}': Found 10 relevant results. "
        f"Top result: According to multiple sources, this topic has been widely covered "
        f"as of {datetime.now().strftime('%B %Y')}. "
        f"Key finding: The information requested is available and current."
    )


def run_calculator(expression: str) -> str:
    """Safely evaluates a math expression using Python's math module."""
    try:
        # Restrict available names to math functions only — never use bare eval on user input
        allowed_names = {k: v for k, v in math.__dict__.items() if not k.startswith("_")}
        allowed_names["abs"] = abs
        allowed_names["round"] = round
        result = eval(expression, {"__builtins__": {}}, allowed_names)
        return f"Result: {result}"
    except Exception as e:
        return f"Calculator error: {str(e)}. Please check the expression syntax."


def run_write_file(filename: str, content: str) -> str:
    """Writes content to a file and returns a status message."""
    try:
        with open(filename, "w", encoding="utf-8") as f:
            f.write(content)
        return f"File '{filename}' written successfully. {len(content)} characters saved."
    except Exception as e:
        return f"File write error: {str(e)}"


def execute_tool(tool_name: str, tool_input: dict) -> str:
    """Routes a tool call to the correct execution function."""
    if tool_name == "web_search":
        return run_web_search(tool_input["query"])
    elif tool_name == "calculator":
        return run_calculator(tool_input["expression"])
    elif tool_name == "write_file":
        return run_write_file(tool_input["filename"], tool_input["content"])
    else:
        return f"Unknown tool: {tool_name}"


# ─────────────────────────────────────────────
# AGENT LOOP
# ─────────────────────────────────────────────

def run_agent(user_message: str) -> str:
    """
    Main agent loop. Sends the user message to Claude, handles tool calls,
    and continues until Claude returns a final text response.
    """
    print(f"\n{'='*60}")
    print(f"USER: {user_message}")
    print(f"{'='*60}\n")

    messages = [{"role": "user", "content": user_message}]
    iteration = 0

    while iteration < MAX_ITERATIONS:
        iteration += 1
        print(f"[Iteration {iteration}] Sending request to Claude...")

        # Call Claude with the current message history and tool definitions
        response = client.messages.create(
            model=MODEL,
            max_tokens=4096,
            tools=tools,
            messages=messages
        )

        print(f"[Iteration {iteration}] Stop reason: {response.stop_reason}")

        # If Claude is done thinking and has a final answer, return it
        if response.stop_reason == "end_turn":
            final_text = ""
            for block in response.content:
                if hasattr(block, "text"):
                    final_text += block.text
            print(f"\nAGENT RESPONSE:\n{final_text}")
            return final_text

        # If Claude wants to use a tool, process all tool calls in this response
        if response.stop_reason == "tool_use":
            # Add Claude's response (including tool use blocks) to message history
            messages.append({"role": "assistant", "content": response.content})

            # Collect results for all tool calls in this single response
            tool_results = []
            for block in response.content:
                if block.type == "tool_use":
                    print(f"[Tool Call] {block.name}({json.dumps(block.input)})")
                    result = execute_tool(block.name, block.input)
                    print(f"[Tool Result] {result}\n")

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

            # Send all tool results back to Claude in a single user message
            messages.append({"role": "user", "content": tool_results})
            continue

        # Safety fallback for unexpected stop reasons
        print(f"[Warning] Unexpected stop reason: {response.stop_reason}")
        break

    return "Agent reached maximum iterations without a final response."


# ─────────────────────────────────────────────
# MAIN — TEST SCENARIOS
# ─────────────────────────────────────────────

if __name__ == "__main__":
    # Scenario 1: Multi-step task using calculator and file writer
    run_agent(
        "Calculate the monthly payment for a $450,000 Naples home with a 7.2% annual interest rate "
        "over 30 years, then save the result to a file called 'mortgage_estimate.txt' with a "
        "short explanation of the calculation."
    )

    # Scenario 2: Search and summarize
    run_agent(
        "Search for the current Claude API pricing and tell me how much it would cost "
        "to process 1 million input tokens."
    )

import anthropic
import json

client = anthropic.Anthropic()

def agent_loop_example(tools: list, messages: list) -> str:
    """
    Isolated agent loop showing the core iteration pattern.
    In the full agent.py, this logic lives inside run_agent().
    """
    MAX_ITERATIONS = 10

    for iteration in range(MAX_ITERATIONS):
        response = client.messages.create(
            model="claude-sonnet-4-6",
            max_tokens=4096,
            tools=tools,
            messages=messages
        )

        # Terminal condition — Claude finished and has a text answer
        if response.stop_reason == "end_turn":
            return next(
                (block.text for block in response.content if hasattr(block, "text")),
                "No text response found."
            )

        # Tool use condition — Claude wants to call one or more tools
        if response.stop_reason == "tool_use":
            messages.append({"role": "assistant", "content": response.content})

            results = []
            for block in response.content:
                if block.type == "tool_use":
                    # YOUR tool execution logic goes here
                    tool_output = f"Simulated result for {block.name}"
                    results.append({
                        "type": "tool_result",
                        "tool_use_id": block.id,
                        "content": tool_output
                    })

            messages.append({"role": "user", "content": results})

    return "Max iterations reached."

import anthropic
import json
import math

client = anthropic.Anthropic()

# Minimal tool definition to show the schema pattern
sample_tools = [
    {
        "name": "get_business_hours",
        "description": (
            "Returns the operating hours for a given Naples-area business by name. "
            "Use this when a user asks when a business is open."
        ),
        "input_schema": {
            "type": "object",
            "properties": {
                "business_name": {
                    "type": "string",
                    "description": "The exact name of the business to look up."
                },
                "day_of_week": {
                    "type": "string",
                    "description": "Optional: specific day to check, e.g. 'Monday'. Omit for full week.",
                    "enum": ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"]
                }
            },
            "required": ["business_name"]
        }
    }
]


def handle_tool_call(tool_name: str, tool_input: dict) -> str:
    """
    Demonstrates how to route tool calls.
    Add elif branches here as you add more tools to your agent.
    """
    if tool_name == "get_business_hours":
        name = tool_input["business_name"]
        day = tool_input.get("day_of_week", "all days")
        # In production: query your database or external API here
        return f"{name} is open 9am–6pm on {day} (simulated result)."
    else:
        return f"Tool '{tool_name}' not recognized."


def demonstrate_tool_response_structure():
    """Shows exactly what a tool result message looks like in the conversation."""
    # This is the structure Claude expects when you return tool results
    tool_result_message = {
        "role": "user",
        "content": [
            {
                "type": "tool_result",
                "tool_use_id": "toolu_01XyZ",  # Must match the id from Claude's tool_use block
                "content": "The tool output goes here as a plain string."
            }
        ]
    }
    print("Tool result message structure:")
    print(json.dumps(tool_result_message, indent=2))


if __name__ == "__main__":
    demonstrate_tool_response_structure()