Technical Tutorials

Large Language Models (LLMs) are powerful text generators, but they are fundamentally constrained by their training data. They cannot browse the live web, query your internal databases, or execute code in a secure sandbox without external assistance. This is where Tool Use (often referred to as function calling) becomes critical. By teaching models how to request specific actions from external systems, you transform them from passive chatbots into active agents capable of solving complex, multi-step problems.

What is Tool Use?

At its core, tool use is a structured way for an LLM to communicate with external APIs or scripts. Instead of generating a final natural language response, the model generates a structured data object (usually JSON) that indicates which tool it wants to call and with what arguments. The application developer then intercepts this request, executes the actual code, and feeds the result back to the model to formulate the final answer.

Defining Tools: The Contract

To make tool use work, you must define the "contract" between the model and your application. This is done via a schema that describes the tool's name, purpose, and expected input parameters. Clarity is paramount here; vague descriptions lead to hallucinated arguments.

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

The Execution Loop

The interaction follows a specific loop. First, the user asks a question. Second, the model decides it needs to fetch weather data and returns a `function_call` object. Third, your backend executes the `get_current_weather` logic. Finally, you append the result to the message history and ask the model to generate the final response.

# Pseudocode for the Agent Loop
messages = [user_query]
while True:
    response = llm.chat(messages, tools=tools)
    
    if response.tool_calls:
        for tool_call in response.tool_calls:
            # Execute the function
            result = execute_tool(tool_call)
            # Append result to history
            messages.append({"role": "tool", "content": result})
    else:
        # No tools needed, return final answer
        return response.content

Best Practices for Reliable Tool Use

Keep Descriptions Atomic: One tool should do one thing. Do not create a "do_everything" API. Granular tools allow the model to compose workflows more effectively.
Use Enumerations: Whenever possible, restrict string inputs using `enum` types. This drastically reduces the chance of the model inventing invalid parameter values.
Handle Errors Gracefully: If a tool call fails (e.g., network timeout), return a clear error message to the LLM. The model is often smart enough to retry or suggest an alternative path if it knows why the initial attempt failed.
Sanitize Outputs: Never blindly trust the LLM's generated arguments. Validate all inputs against your schema before executing any real-world code.

Conclusion

Tool use is the bridge between artificial intelligence and practical utility. By implementing robust function calling, you unlock the ability to automate workflows, retrieve real-time data, and interact with legacy systems. Start small with one or two well-defined tools, monitor how the model interprets your schemas, and iterate. As you refine your prompts and error handling, your LLM applications will evolve from static text completions into dynamic, autonomous agents.