Tool Use and Function Calling

Function calling works through a structured conversation loop. The model is given a list of tool schemas — descriptions of what each function does, what parameters it takes, and what types those parameters are. When the model decides a tool is needed, it emits a special response instead of plain prose. The decision loop can be described simply. At each step, the model scores whether to answer directly or invoke a tool:

Explanation: The model picks the action â (either "respond in text" or "call tool T with args") that has the highest probability given the user input x and the set of available tools 𝒯. Here, $\mathcal{A}$ is the set of all possible actions (one per tool plus the "just talk" option), $x$ is the conversation so far, and $\mathcal{T}$ is the tool schema list injected into the system prompt or a dedicated API field. After a tool is called and the result is returned, the model computes its next response conditioning on the augmented context:

Explanation: The final reply y is generated using not just the original input x, but also the tool call that was made and the result that came back. Here $t_{\text{call}}$ is the tool invocation (function name + arguments) and $r_{\text{result}}$ is the tool's return value, both appended as new messages before the model generates its answer. Here is the fundamental orchestration loop in Python: ```python import json import openai client = openai.OpenAI()

# 1. Define the tool schema tools = [ { "type": "function", "function": { "name": "get_weather", "description": "Get the current temperature for a city.", "parameters": { "type": "object", "properties": { "city": { "type": "string", "description": "The city name, e.g. 'London'" } }, "required": ["city"] } } } ]

# 2. The actual Python function the model wants to call def get_weather(city: str) -> dict:

# In a real app this would call a weather API return {"city": city, "temperature_c": 18, "condition": "Cloudy"}

# 3. First model call — model may request a tool messages = [{"role": "user", "content": "What's the weather in Paris?"}] response = client.chat.completions.create( model="gpt-4o", messages=messages, tools=tools, tool_choice="auto" # model decides whether to call a tool ) msg = response.choices[0].message

# 4. Check if the model wants to call a tool if msg.tool_calls: tool_call = msg.tool_calls[0] func_name = tool_call.function.name # "get_weather" func_args = json.loads(tool_call.function.arguments) # {"city": "Paris"}

# 5. WE run the function — not the model result = get_weather(**func_args)

# 6. Feed the result back as a new message messages.append(msg) # assistant's tool-call request messages.append({ "role": "tool", "tool_call_id": tool_call.id, "content": json.dumps(result) })

# 7. Second model call — now model has the data and writes a response final = client.chat.completions.create( model="gpt-4o", messages=messages, tools=tools ) print(final.choices[0].message.content)

# → "It's currently 18°C and cloudy in Paris." ``` A key structural piece is the tool schema — a JSON Schema object telling the model exactly what shape the arguments must take: ```python

# Richer schema example with multiple parameters and types weather_schema = { "name": "get_forecast", "description": "Get a multi-day weather forecast for a location.", "parameters": { "type": "object", "properties": { "city": {"type": "string"}, "days": {"type": "integer", "minimum": 1, "maximum": 7}, "units": {"type": "string", "enum": ["celsius", "fahrenheit"]} }, "required": ["city", "days"] } } ``` When multiple tools are available, the model can call them sequentially (one at a time, waiting for results) or — in systems that support it — in parallel, batching several tool calls in one response: ```python

# Parallel tool calls — model returns a list of tool_calls for tool_call in msg.tool_calls: # iterate over all requested calls name = tool_call.function.name args = json.loads(tool_call.function.arguments) result = dispatch(name, args) # your router function messages.append({ "role": "tool", "tool_call_id": tool_call.id, "content": json.dumps(result) }) ```

AI Agents and Agentic Loops · Retrieval-Augmented Generation · Prompt Engineering · Chain-of-Thought Prompting · Multi-Agent Frameworks