Tool Use: Function Calling in LLM Applications (2026)

When to Use

• ✓The LLM needs real-time data it wasn't trained on (current prices, weather, live database records)
• ✓Tasks require executing code, running calculations, or performing actions with side effects
• ✓Structured output is required and you want the model to fill in fields from retrieved data
• ✓Building agents that can take actions in the world (send emails, create tickets, update records)
• ✓Replacing few-shot prompting for data extraction — tool use produces more reliable structured output

How It Works

1. 1Define tools as JSON schemas: each tool has a name, description (explain when to use it), and parameters (input_schema with types and descriptions). The description is critical — it guides the model's tool selection.
2. 2Pass tool definitions to the API with the user message. The model reads the tool descriptions and decides whether to call a tool or respond directly.
3. 3When the model decides to call a tool, it returns a tool_use block (Anthropic) or function_call (OpenAI) with the tool name and JSON arguments. It stops generating and waits for the result.
4. 4Execute the function with the provided arguments and return the result as a tool_result message. The model continues the conversation, now informed by the tool result.
5. 5Implement validation on tool inputs — don't blindly execute whatever arguments the model provides. Validate types, ranges, and permissions before calling external systems.

Examples

import anthropic

client = anthropic.Anthropic()

tools = [{
    'name': 'get_stock_price',
    'description': 'Get the current stock price for a ticker symbol. Use when the user asks about stock prices.',
    'input_schema': {
        'type': 'object',
        'properties': {
            'ticker': {
                'type': 'string',
                'description': 'Stock ticker symbol (e.g., AAPL, NVDA)'
            }
        },
        'required': ['ticker']
    }
}]

response = client.messages.create(
    model='claude-3-5-sonnet-20241022',
    max_tokens=1024,
    tools=tools,
    messages=[{'role': 'user', 'content': 'What is Nvidia stock trading at today?'}]
)

# Check if model wants to use a tool
if response.stop_reason == 'tool_use':
    tool_use = next(b for b in response.content if b.type == 'tool_use')
    print(f'Tool: {tool_use.name}, Args: {tool_use.input}')

def run_agent(user_message: str, tools: list, max_turns: int = 10):
    messages = [{'role': 'user', 'content': user_message}]
    
    for _ in range(max_turns):
        response = client.messages.create(
            model='claude-3-5-sonnet-20241022',
            max_tokens=1024,
            tools=tools,
            messages=messages
        )
        
        if response.stop_reason == 'end_turn':
            return response.content[0].text
        
        # Process all tool calls in this response
        tool_results = []
        for block in response.content:
            if block.type == 'tool_use':
                result = execute_tool(block.name, block.input)
                tool_results.append({
                    'type': 'tool_result',
                    'tool_use_id': block.id,
                    'content': str(result)
                })
        
        messages.extend([
            {'role': 'assistant', 'content': response.content},
            {'role': 'user', 'content': tool_results}
        ])
    
    return 'Max turns reached'

Common Mistakes

• ✗Poor tool descriptions — the model selects tools based on descriptions, not names. 'Get data' is useless; 'Retrieve the current inventory count for a product SKU from the warehouse database' is actionable. Write descriptions that tell the model exactly when to use the tool.
• ✗Not validating tool inputs before execution — LLMs can hallucinate argument values (wrong types, out-of-range numbers, non-existent IDs). Always validate inputs server-side before calling downstream APIs.
• ✗Exposing too many tools at once — beyond ~20 tools, model accuracy on tool selection degrades. Group related tools, use tool namespacing, or dynamically include only relevant tools based on the user's query.
• ✗Not handling tool errors gracefully — if a tool call fails, return a clear error message as the tool_result. Don't return empty results or Python tracebacks — the model can recover from meaningful error messages but not from cryptic failures.

FAQ