Function Calling and Tool Use: How AIs Execute Real Actions

Introduction

Imagine asking an AI to book a flight, send an email, or update a database, and it actually does it. That's the power of function calling and tool use—a paradigm shift from passive conversation to active task execution. In this post, we'll explore how AI models like GPT-4, Claude, and open-source alternatives can call external tools, APIs, and functions to perform real actions. We'll cover the underlying mechanisms, practical implementation, and key considerations for developers.

What is Function Calling?

Function calling (also known as tool use) allows an LLM to output structured data that specifies which function to call and with what parameters, rather than just generating text. The model doesn't execute the function; it returns a JSON object describing the desired invocation. The application then runs the function and feeds the result back to the model.

For example, a user says: "What's the weather in Tokyo?" The model might output:

{
  "function": "get_weather",
  "parameters": {
    "location": "Tokyo",
    "units": "celsius"
  }
}

Your code intercepts this, calls your weather API, and returns the result to the model, which then formulates a natural language response.

How It Works: The Loop

1. User query -> LLM
2. LLM decides whether to call a function. If yes, it outputs a special JSON block.
3. Application parses the JSON, calls the appropriate function with provided parameters.
4. Function result (typically JSON) is sent back to the LLM as a tool response.
5. LLM uses the result to generate a final answer in natural language.

This loop can be chained: the model can call multiple tools in sequence based on previous results.

Practical Example with OpenAI

OpenAI's API supports function calling natively. Here's a minimal example using Python:

import openai

# Define the tool you want the model to use
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_current_weather",
            "description": "Get the current weather in a given location",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {"type": "string", "description": "City name"},
                    "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]}
                },
                "required": ["location"]
            }
        }
    }
]

response = openai.chat.completions.create(
    model="gpt-4",
    messages=[{"role": "user", "content": "What's the weather in London?"}],
    tools=tools,
    tool_choice="auto"
)

# Extract the tool call
message = response.choices[0].message
tool_calls = message.tool_calls
if tool_calls:
    function_name = tool_calls[0].function.name
    arguments = tool_calls[0].function.arguments
    print(f"Function to call: {function_name}, Arguments: {arguments}")
    # Now call your actual weather API with these arguments
    # Then send the result back as a tool response

The model returns a special tool_calls field instead of content. Your application must handle this and subsequently call the model again with the function result.

Tool Use in Other Models

Anthropic's Claude, Google's Gemini, and open-source models like Llama 3 also support tool use. For example, Claude uses a similar structure but calls them "tools". Here's a snippet for Claude:

import anthropic

client = anthropic.Anthropic()
response = client.messages.create(
    model="claude-opus-4",
    max_tokens=1024,
    tools=[
        {
            "name": "get_weather",
            "description": "Get weather",
            "input_schema": {
                "type": "object",
                "properties": {
                    "location": {"type": "string"}
                },
                "required": ["location"]
            }
        }
    ],
    messages=[{"role": "user", "content": "Weather in Paris?"}]
)
if response.stop_reason == "tool_use":
    tool_block = response.content[-1]
    print(tool_block.name, tool_block.input)

Best Practices

1. Clear function descriptions: The model relies on your description fields to decide when to call a function. Be explicit about what the function does and when to use it.
2. Robust parameter handling: Validate parameters client-side; the model can hallucinate.
3. Error handling: If the function fails, return a clear error message so the model can apologize or ask for clarification.
4. Limit tool access: Only expose functions that are safe for the AI to invoke, especially if they modify data or cost money.
5. Use tool_choice wisely: auto lets the model decide; required forces a tool call; none disables tools.

Real-World Applications

• Customer support: AI can check order status, initiate refunds, or escalate tickets.
• Data analysis: Connect to databases to query and visualize data.
• Automation: Trigger CI/CD pipelines, send Slack messages, or create calendar events.
• Research: Scrape web pages, search the internet, or query APIs like Wikipedia.

Security Considerations

Because function calling gives the AI power to act, security is paramount:

• Never expose destructive functions like delete_database.
• Add human-in-the-loop for sensitive actions (e.g., financial transactions).
• Sanitize all inputs before executing functions to prevent injection.
• Rate-limit and monitor API calls to avoid abuse.

Conclusion

Function calling and tool use transform AI from a chatbot into a capable agent. By defining tools and managing the conversational loop, you can build assistants that truly get things done. As models improve, the line between conversation and action will blur further—making now the perfect time to experiment.

For more details, check OpenAI's function calling documentation and Anthropic's tool use guide.