Function Calling / Tool Use

function calling · tool use · tool calling · llm function call · structured tool use · api calling

Definition

Function calling, or tool use, is the mechanism that lets an LLM invoke external tools and APIs in a structured format — the foundation that turns a model into an acting agent.

How function calling works

Function calling is an interaction protocol between an LLM and external systems. The model receives
a description of the available tools and, while generating its answer, decides whether one of them
needs to be invoked:

1. The developer describes the functions:
   search_products(query: string, category?: string) -> Product[]
   check_inventory(product_id: string) -> {in_stock: boolean, qty: int}
   add_to_cart(product_id: string, qty: int) -> CartItem

2. User: "Find me red Nike trainers under $120"

3. The model returns a call:
   {"function": "search_products", "args": {"query": "red Nike trainers", "max_price": 120}}

4. The client calls the API, receives a product list, passes it back to the model

5. The model generates an answer for the user from real data

The loop can repeat several times: the model calls functions in sequence, refines what it knows and
finally produces the answer.

Function calling in e-commerce

In a trading context, function calling opens interaction patterns that were not previously possible.
A typical tool set for a store’s AI assistant:

Function	What it does	Type of action
`search_products`	Semantic search across the catalogue	Read
`get_product_details`	Full product information	Read
`check_inventory`	Availability and quantity	Read
`get_recommendations`	Personalised recommendations	Read
`add_to_cart`	Adds an item to the basket	Write
`apply_promo`	Applies a promo code	Write
`initiate_checkout`	Starts order placement	Write

Read functions are safe. Write functions — initiate_checkout above all — require explicit
confirmation from the user or a human-in-the-loop control.

Structured output and JSON Schema

Reliable function calling requires strict typing. A function description in JSON Schema:

{
  "name": "search_products",
  "description": "Search products by query and filters",
  "parameters": {
    "type": "object",
    "properties": {
      "query": {"type": "string", "description": "Search query"},
      "category": {"type": "string", "description": "Product category"},
      "max_price": {"type": "number", "description": "Maximum price"}
    },
    "required": ["query"]
  }
}

Important: models hallucinate function arguments, especially for parameters that do not exist.
Always validate the model’s output before making a real API call.

Parallel and sequential calls

Modern models support calling several functions in a single turn, which matters for compound
requests:

In parallel: stock, price and reviews for one product
In sequence: first find the product, then check its availability by product_id

Parallel calling lowers response latency but requires dependencies between calls to be managed.

Frequently asked questions

How does function calling work technically?

The developer describes the available functions in JSON Schema — name, parameters, types. When generating a response, the LLM can return JSON with a function name and arguments instead of text. The client calls the real function, passes the result back to the model, and the model continues reasoning with the data it received.

How does function calling differ from RAG?

RAG (retrieval-augmented generation) adds context from a knowledge base into the prompt before generation. Function calling is a two-way dialogue: the model itself initiates requests to external systems while reasoning. It is more dynamic and allows actions to be taken, such as placing an order, not only data to be read.

What is parallel function calling?

Modern models support calling several functions at once. An agent can request stock, current price and delivery status in parallel, which speeds up compound requests considerably.

What are the risks of function calling in commerce?

The main risk is unauthorised action — the agent placing an order for the wrong amount or the wrong address. The answers are explicit confirmation before destructive actions such as payment or order submission, a deliberately limited set of functions, and a human in the loop for high-risk operations.