Function calling in LLMs in Agentic AI

Introduction

Function calling helps large language models (LLMs) use external tools or code to get precise answers or perform tasks beyond just text.

When you want the LLM to fetch real-time data like weather or stock prices.

When the LLM needs to perform calculations or access a database.

When you want the LLM to control smart devices or apps by calling specific functions.

When you want to keep answers accurate by letting the LLM ask a trusted function instead of guessing.

When building chatbots that can do tasks like booking tickets or setting reminders.

Syntax

Agentic AI

function_call = {
    "name": "function_name",
    "arguments": {
        "param1": "value1",
        "param2": "value2"
    }
}

response = llm.generate(prompt, function_call=function_call)

The function_call object tells the LLM which function to run and with what inputs.

The LLM can decide when to call a function based on the conversation or prompt.

Examples

This tells the LLM to call the 'get_current_weather' function with the location set to New York.

Agentic AI

function_call = {
    "name": "get_current_weather",
    "arguments": {
        "location": "New York"
    }
}

This instructs the LLM to call a function that sums numbers 5, 10, and 15.

Agentic AI

function_call = {
    "name": "calculate_sum",
    "arguments": {
        "numbers": [5, 10, 15]
    }
}

Sample Model

This simple example shows how an LLM can call a function named 'get_greeting' with a name argument to return a personalized greeting.

Agentic AI

class SimpleLLM:
    def generate(self, prompt, function_call=None):
        if function_call:
            name = function_call.get("name")
            args = function_call.get("arguments", {})
            if name == "get_greeting":
                name_arg = args.get("name", "there")
                return f"Hello, {name_arg}!"
            else:
                return "Function not found."
        return "No function called."

llm = SimpleLLM()

# Call the function 'get_greeting' with argument 'name' = 'Alice'
function_call = {
    "name": "get_greeting",
    "arguments": {
        "name": "Alice"
    }
}

response = llm.generate("Say hello", function_call=function_call)
print(response)

Important Notes

Function calling lets LLMs do more than just chat; they can run code or get data.

You need to define the functions the LLM can call and how to handle their inputs and outputs.

Always check that the function names and arguments match what the LLM expects.

Summary

Function calling connects LLMs to external tools or code for better answers.

It works by telling the LLM which function to run and with what inputs.

This helps build smarter apps like chatbots that can do real tasks.

Practice

1. What is the main purpose of function calling in large language models (LLMs)?

easy

A. To prevent the LLM from understanding user questions

B. To let the LLM run specific external functions and get precise results

C. To slow down the LLM's response time intentionally

D. To make the LLM generate random text without any control

Solution

1. Step 1: Understand function calling role

   Function calling lets LLMs connect to external code or tools to perform tasks.

2. Step 2: Identify the main benefit

   This connection helps LLMs provide accurate, task-specific answers by running real functions.

3. Final Answer:

   To let the LLM run specific external functions and get precise results -> Option B

4. Quick Check:

   Function calling purpose = precise external function use [OK]

Hint: Function calling means running real code from the LLM [OK]

Common Mistakes:

• Thinking function calling makes LLMs slower
• Believing it causes random text generation
• Assuming it blocks understanding questions

2. Which of the following is the correct way to specify a function call in an LLM prompt?

easy

A. {"name": "get_weather", "parameters": {"city": "Paris"}}

B. function_call: get_weather(city='Paris')

C. call_function('get_weather', city='Paris')

D. run get_weather with city=Paris

Solution

1. Step 1: Recognize JSON format for function calls

   LLMs use structured JSON to specify function names and parameters clearly.

2. Step 2: Match the correct JSON syntax

   {"name": "get_weather", "parameters": {"city": "Paris"}} shows a JSON object with "name" and "parameters", which is the standard format.

3. Final Answer:

   {"name": "get_weather", "parameters": {"city": "Paris"}} -> Option A

4. Quick Check:

   Function call format = JSON object [OK]

Hint: Function calls in LLMs use JSON with name and parameters [OK]

Common Mistakes:

• Using plain text instead of JSON
• Trying to call functions like regular code
• Missing quotes around keys or values

3. Given this function call JSON sent to an LLM:

{"name": "calculate_sum", "parameters": {"a": 5, "b": 3}}

What should the LLM do next?

medium

A. Return the sum 8 as the function output

B. Ignore the function call and generate unrelated text

C. Ask the user to provide values for a and b

D. Throw an error because parameters are missing

Solution

1. Step 1: Understand the function call content

   The JSON specifies a function named "calculate_sum" with parameters a=5 and b=3.

2. Step 2: Determine expected LLM behavior

   The LLM should run the function with these inputs and return the result, which is 8.

3. Final Answer:

   Return the sum 8 as the function output -> Option A

4. Quick Check:

   Function call with inputs = output sum 8 [OK]

Hint: LLM runs function with given inputs and returns result [OK]

Common Mistakes:

• Ignoring the function call and chatting instead
• Requesting inputs already provided
• Assuming missing parameters cause errors

4. You wrote this function call JSON for an LLM:

{"name": "get_user_info", "params": {"user_id": 42}}

Why might the LLM fail to execute this call?

medium

A. Because the function name must be uppercase

B. Because user_id must be a string, not a number

C. Because the key should be "parameters", not "params"

D. Because the JSON is missing a closing brace

Solution

1. Step 1: Check JSON keys for function calling

   The standard key for parameters is "parameters", not "params".

2. Step 2: Identify why LLM fails

   Using "params" means the LLM won't recognize the inputs and can't run the function.

3. Final Answer:

   Because the key should be "parameters", not "params" -> Option C

4. Quick Check:

   Correct key = "parameters" [OK]

Hint: Use "parameters" key exactly in function call JSON [OK]

Common Mistakes:

• Using "params" instead of "parameters"
• Assuming number types cause failure
• Thinking function names must be uppercase

5. You want to build a chatbot that can book appointments by calling an external scheduling function. Which approach best uses function calling in LLMs to achieve this?

hard

A. Ask the user to book appointments manually without automation

B. Make the LLM guess appointment times without calling any function

C. Hardcode all appointment slots inside the LLM prompt text

D. Define a function schema with name and parameters, let LLM call it with user inputs, then run the real scheduler

Solution

1. Step 1: Understand chatbot function calling design

   Function calling lets the LLM decide when to call the scheduler with user data.

2. Step 2: Choose best integration method

   Defining a function schema and letting the LLM call it dynamically is the correct approach.

3. Final Answer:

   Define a function schema with name and parameters, let LLM call it with user inputs, then run the real scheduler -> Option D

4. Quick Check:

   Function calling enables dynamic external task calls [OK]

Hint: Use function schema and let LLM call real scheduler [OK]

Common Mistakes:

• Ignoring function calling and guessing answers
• Hardcoding data inside prompt text
• Not automating booking at all