Implement Tool Use and Function Calling in Claude API

Anthropic's Claude API now supports robust tool use and function calling capabilities, enabling developers to build AI agents that interact with external services, databases, and APIs in real time. This feature transforms Claude from a text-generation model into an actionable AI system capable of executing multi-step workflows — and understanding how to implement it properly is essential for any developer building production-grade AI applications in 2025.

Key Takeaways for Developers

• Tool use allows Claude to generate structured JSON requests to call external functions you define
• Claude supports up to 128 tools per API request, far exceeding OpenAI's initial 20-tool limit at launch
• Function calling works across Claude 3.5 Sonnet, Claude 3.5 Haiku, and Claude 3 Opus models
• The feature uses a structured tool definition schema based on JSON Schema for input validation
• Developers control tool execution entirely — Claude never directly calls external services
• Pricing follows standard token rates, with tool definitions counting toward input tokens

Understanding How Claude's Tool Use Architecture Works

Tool use in Claude follows a human-in-the-loop design philosophy that differs from some competing implementations. Unlike systems where the AI autonomously executes functions, Claude's approach keeps developers firmly in control of the execution pipeline.

The process follows a 4-step cycle. First, you send a message to Claude along with tool definitions describing available functions. Second, Claude analyzes the user's request and decides whether a tool call is needed. Third, if Claude determines a tool is relevant, it returns a structured tool_use response containing the function name and parameters. Fourth, your application executes the function and sends the results back to Claude via a tool_result message.

This architecture ensures security and reliability. Claude never has direct access to your systems — it simply suggests which tool to call and with what parameters.

Setting Up Your First Tool Definition

Every tool definition requires 3 components: a name, a description, and an input_schema. The input schema follows standard JSON Schema format, making it familiar to most web developers.

Here is a practical example of defining a weather lookup tool:

• name: 'get_current_weather' — must be alphanumeric with underscores, max 64 characters
• description: 'Retrieves the current weather for a given city. Returns temperature, humidity, and conditions.' — the more detailed, the better Claude performs
• input_schema: A JSON Schema object specifying required parameters like 'city' (string) and 'unit' (enum of 'celsius' or 'fahrenheit')

The description field is arguably the most critical component. Claude uses it to determine when and how to invoke the tool. Vague descriptions lead to poor tool selection, while detailed descriptions with examples dramatically improve accuracy.

Compared to OpenAI's function calling in GPT-4, Claude's tool definitions use a nearly identical JSON Schema approach, making migration between platforms relatively straightforward for developers already familiar with the pattern.

Crafting the API Request With Tools

Sending a tool-enabled request to the Claude API requires including a tools array alongside your standard messages payload. The API endpoint remains the same — POST to 'https://api.anthropic.com/v1/messages' — with your standard headers including the x-api-key and anthropic-version fields.

The request body structure includes these essential fields:

• model: Specify 'claude-sonnet-4-20250514' or your preferred model variant
• max_tokens: Set your token budget (1024 is a reasonable starting point for tool use)
• tools: An array of tool definition objects
• messages: Your conversation history including the user's query
• tool_choice: Optional parameter to control tool selection behavior

The tool_choice parameter deserves special attention. Setting it to 'auto' lets Claude decide whether to use a tool. Setting it to 'any' forces Claude to use at least 1 tool. You can also specify a particular tool name to force a specific function call — useful for testing and deterministic workflows.

Handling the Tool Use Response Cycle

When Claude decides to call a tool, the API response contains a stop_reason of 'tool_use' instead of the typical 'end_turn'. The response content array includes a block with type: 'tool_use', containing an auto-generated id, the name of the tool, and the structured input parameters.

Your application must then execute the actual function using those parameters. This is where your business logic lives — querying databases, calling third-party APIs, performing calculations, or any other operation your tool represents.

After execution, you send the results back by appending 2 messages to the conversation. First, an assistant message containing the original tool_use block. Second, a user message with a tool_result content block that includes the tool_use_id and the content of the result.

Claude then processes the tool result and generates a natural language response for the end user, incorporating the data returned by your function. This round-trip typically adds 1-3 seconds of latency depending on your external function's execution time.

Advanced Patterns: Chaining Multiple Tool Calls

Sequential tool chaining is where Claude's tool use truly shines. Claude can request multiple tool calls in a single response, or chain tools across multiple turns to accomplish complex tasks.

Consider a travel booking scenario. Claude might first call 'search_flights' to find available options, then call 'check_hotel_availability' for the destination city, and finally call 'calculate_total_cost' to provide a complete trip estimate. Each tool result feeds into Claude's reasoning for the next step.

Best practices for multi-tool workflows include:

• Design tools with single responsibilities — 1 function per task
• Keep input schemas simple — complex nested objects increase error rates by up to 15%
• Include error handling in your tool results so Claude can gracefully recover
• Use the system prompt to provide Claude with instructions about tool usage order and preferences
• Implement timeout logic on your side — do not let tool execution run indefinitely
• Log all tool interactions for debugging and optimization

Anthropic's documentation suggests that Claude 3.5 Sonnet achieves roughly 90% accuracy on complex multi-tool benchmarks, making it one of the most reliable models for agentic workflows available today.

Error Handling and Production Best Practices

Production deployments require robust error handling at every stage of the tool use cycle. When a tool execution fails, you should return an is_error: true flag in the tool_result block along with a descriptive error message. Claude will then attempt to recover, retry with different parameters, or inform the user about the issue.

Rate limiting is another critical consideration. Each tool definition consumes approximately 150-300 input tokens depending on schema complexity. With 128 tools defined, you could consume over 30,000 tokens on definitions alone before processing any user content. At Anthropic's current pricing of $3 per million input tokens for Claude 3.5 Sonnet, this adds roughly $0.09 per request — a cost that scales quickly at high volumes.

Several strategies help optimize costs:

• Only include tools relevant to the current conversation context
• Cache tool definitions on the client side using Anthropic's prompt caching feature, which reduces input token costs by up to 90%
• Use Claude 3.5 Haiku ($0.25 per million input tokens) for simpler tool routing tasks
• Implement a tool selection layer that pre-filters available tools based on user intent

Industry Context: The Rise of Agentic AI

Tool use and function calling have become the foundation of the agentic AI movement sweeping the industry in 2025. OpenAI, Google DeepMind, and Anthropic are all racing to make their models more capable of autonomous action through structured tool interactions.

Anthropic's implementation stands out for its emphasis on safety and developer control. The human-in-the-loop design means Claude never autonomously executes code or accesses external systems without explicit developer mediation. This aligns with Anthropic's broader mission of building safe, steerable AI systems.

The market for AI agent frameworks — including LangChain, CrewAI, and Anthropic's own tool use infrastructure — is projected to exceed $5 billion by 2027, according to recent industry estimates.

Looking Ahead: What Comes Next

Anthropic continues to expand Claude's tool use capabilities at a rapid pace. Recent updates have introduced streaming support for tool use responses, allowing developers to display partial results as Claude processes multi-step workflows. The company has also hinted at deeper integration with its computer use capabilities, potentially allowing Claude to interact with desktop applications through tool definitions.

For developers starting today, the recommendation is clear: begin with 2-3 simple tools, validate your error handling pipeline, and gradually expand to more complex multi-tool workflows. The Claude API documentation at docs.anthropic.com provides interactive examples and a dedicated tool use cookbook that covers edge cases and advanced patterns.

Mastering tool use is no longer optional for AI developers. It is the gateway to building AI systems that do not just generate text — but take meaningful action in the real world.