Technical Tutorials

Large Language Models (LLMs) possess remarkable generative capabilities, but they are inherently static. They cannot check live inventory, fetch real-time weather, or query internal corporate databases without assistance. This limitation is where Function Calling (or Tool Use) becomes essential. For intermediate to advanced developers, moving beyond simple chat interfaces to building agents that interact with the world is the next critical step in AI application development.

Why Tool Use is Critical for Production Apps

Relying solely on the model's training data leads to hallucinations, especially when precision is required. By exposing specific tools—such as a REST API endpoint, a SQL query generator, or a calculator—you constrain the model's output space. This not only improves accuracy but also adds a layer of security and control. The model acts as a router, deciding when and what tool to use based on user intent, rather than attempting to guess facts it may not know.

Selecting the Right Tool Schema

One of the most common pitfalls in integrating APIs with LLMs is poorly defined schemas. When you define a tool for the LLM, you are essentially writing a prompt for the model itself. If your schema is ambiguous, the model will fail to parse arguments correctly or will call the wrong endpoint.

Best practices include:

Explicit Types: Use strict JSON schema definitions for all parameters. Avoid loosely typed strings where integers or booleans are expected.
Descriptive Names: Tool names should be verb-object pairs (e.g., get_weather_forecast rather than just weather).
Concise Descriptions: The description field is what the LLM reads to decide if it should use the tool. Keep it clear and action-oriented.

Implementing Tool Execution: A Python Example

Let's look at a practical implementation using Python and a hypothetical weather API. We will define the tool, pass it to the LLM, and handle the function call response.

import openai
import json

# Define the tool schema
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": "The city and state, e.g., San Francisco, CA"
                    },
                    "unit": {
                        "type": "string",
                        "enum": ["celsius", "fahrenheit"]
                    }
                },
                "required": ["location"],
            },
        }
    }
]

# Simulate user input
user_message = "What is the weather in Tokyo today in celsius?"

# 1. Send request to LLM with tools
response = openai.ChatCompletion.create(
    model="gpt-4",
    messages=[{"role": "user", "content": user_message}],
    tools=tools
)

# 2. Check if the model wants to call a tool
message = response.choices[0].message
if hasattr(message, 'tool_calls') and message.tool_calls:
    # 3. Execute the actual Python function
    tool_call = message.tool_calls[0]
    args = json.loads(tool_call.function.arguments)
    
    # In a real app, this would be an HTTP request
    def get_current_weather(location, unit='fahrenheit'):
        return {"temperature": 22, "unit": unit}
        
    result = get_current_weather(args['location'], args.get('unit', 'celsius'))
    
    # 4. Send the result back to the LLM to generate a natural language response
    messages = [
        {"role": "user", "content": user_message},
        message, # The model's initial response with tool call
        {
            "role": "tool",
            "tool_call_id": tool_call.id,
            "content": str(result) # The output of the function
        }
    ]
    
    final_response = openai.ChatCompletion.create(
        model="gpt-4",
        messages=messages
    )
    print(final_response.choices[0].message.content)

Handling Errors and Edge Cases

In production, API calls will fail. Network timeouts, rate limits, and invalid authentication tokens are inevitable. A robust agent architecture must catch these errors and feed them back to the LLM. By providing the error message as the content of the tool response, you allow the model to decide if it should retry with different parameters, ask the user for clarification, or explain the failure to the end-user.

Conclusion

Integrating external APIs transforms LLMs from conversational partners into functional assistants. By carefully designing tool schemas, handling responses systematically, and implementing robust error handling, developers can build applications that are not only intelligent but also reliable and grounded in real-world data. As the ecosystem evolves, mastering this pattern will be a fundamental skill for any AI engineer.