Function calling in LLMs in Agentic AI - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

How does function calling improve LLM responses?

Large Language Models (LLMs) can call external functions during a conversation. What is the main benefit of this feature?

A It prevents the LLM from making any mistakes in grammar.

B It allows the LLM to access real-time or external data beyond its training.

C It makes the LLM generate longer text outputs automatically.

D It reduces the model size by offloading computations to the function.

💡 Hint

Think about how LLMs can get information they don't know internally.

Function calling lets LLMs request data or perform actions outside their training, like fetching current weather or database info, improving response accuracy.

❓ Predict Output

intermediate

Output of LLM function call simulation

Given the following Python simulation of an LLM calling a function, what is the printed output?

Agentic AI

def get_temperature(city):
    return f"The temperature in {city} is 22°C."

user_input = "What's the temperature in Paris?"

# Simulate LLM detecting function call
if "temperature" in user_input:
    city = user_input.split()[-1].strip('?')
    response = get_temperature(city)
else:
    response = "I don't know."

print(response)

A The temperature in Paris is 22°C.

B I don't know.

C The temperature in Paris is 22F.

D SyntaxError

💡 Hint

Look at how the city name is extracted and passed to the function.

The code extracts 'Paris' from the input and calls get_temperature('Paris'), which returns the temperature string with 22°C.

❓ Model Choice

advanced

Choosing the best LLM model for function calling

You want to build a chatbot that uses function calling to fetch live stock prices. Which model type is best suited for this?

A A large LLM trained only on static text data without function calling.

B A small LLM without function calling support but fine-tuned on finance data.

C A rule-based chatbot with no machine learning.

D A large LLM with built-in function calling and API integration capabilities.

💡 Hint

Consider which model can dynamically call external APIs for live data.

A large LLM with function calling and API integration can request live stock prices dynamically, making it the best choice.

❓ Hyperparameter

advanced

Effect of temperature setting on function calling outputs

When using an LLM with function calling, how does increasing the temperature hyperparameter affect the function call behavior?

A It makes the LLM more likely to call functions randomly, even when not needed.

B It makes the LLM more deterministic and less creative in calling functions.

C It has no effect on function calling decisions, only on text generation style.

D It disables function calling entirely.

💡 Hint

Think about how temperature affects randomness in LLM outputs.

Higher temperature increases randomness, so the LLM might call functions more freely, sometimes unnecessarily.

🔧 Debug

expert

Why does this LLM function call fail to execute?

Consider this snippet where an LLM is supposed to call a function to get current time, but it never executes the function. What is the likely cause?

Agentic AI

def get_current_time():
    from datetime import datetime
    return datetime.now().strftime('%H:%M:%S')

llm_response = '{"function_call": {"name": "get_current_time"}}'

# Code to parse and execute function call
import json
response_dict = json.loads(llm_response)

if response_dict.get('function_call'):
    func_name = response_dict['function_call']['name']
    if func_name == 'get_current_time':
        result = get_current_time()
    else:
        result = None
else:
    result = None

print(result)

A The JSON string is malformed and causes a parsing error.

B The function get_current_time is not defined in the code.

C The function get_current_time is assigned but not called, so result is the function object, not its output.

D The print statement is missing parentheses causing a syntax error.

💡 Hint

Check if the function is called or just referenced.

The code assigns the function object to result without calling it (missing parentheses), so printing result shows the function object, not the time string.

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