Function calling transforms large language models from passive text generators into active agents that can interact with external APIs, databases, and internal services. As agentic workflows become standard, developers need reliable patterns for defining tools, invoking them safely, and managing the resulting context loops without unpredictable costs or latency spikes.
The Mechanics of Tool Use
At its core, function calling is a structured output pattern. You provide the model with a list of available tools, each defined by a JSON Schema describing its name, parameters, and purpose. The model then decides whether to answer directly or emit a tool call containing the arguments needed to invoke an external function.
This requires three distinct components: the tool definitions fed into the system prompt, the model's reasoning about which tool to use, and your application's execution layer that runs the function and returns the result. Getting the boundary right between what the model decides and what your code enforces is the difference between a prototype and a production system.
Implementation with the OpenAI SDK
Because Oxlo.ai is fully OpenAI SDK compatible, you can adopt function calling without rewriting your client logic. The base URL is https://api.oxlo.ai/v1, and the chat.completions endpoint accepts the same tools and tool_choice parameters you already use.
Below is a minimal example using Python. It defines a single get_weather tool and points the client at Oxlo.ai.
from openai import OpenAI
import json
client = OpenAI(
api_key="YOUR_OXLO_API_KEY",
base_url="https://api.oxlo.ai/v1"
)
tools = [
{
"type": "function",
"function": {
"name": "get_weather",
"description": "Get current weather for a location",
"parameters": {
"type": "object",
"properties": {
"location": {
"type": "string",
"description": "City and country, e.g., Paris, France"
}
},
"required": ["location"]
}
}
}
]
messages = [
{"role":
Top comments (0)