Function calling in LLMs in Agentic AI - Deep Dive

Overview - Function calling in LLMs

What is it?

Function calling in large language models (LLMs) is a way for the model to decide when and how to use external functions or tools during a conversation. Instead of just generating text, the LLM can request specific actions or data by calling predefined functions. This helps the model interact with real-world systems, like databases or calculators, making its responses more useful and accurate.

Why it matters

Without function calling, LLMs can only guess answers based on their training data, which might be outdated or incomplete. Function calling lets the model get fresh, precise information or perform tasks it cannot do alone. This makes AI assistants more reliable and practical for everyday use, like booking tickets or checking weather, improving user trust and experience.

Where it fits

Before learning function calling, you should understand how LLMs generate text and the basics of APIs or functions in programming. After mastering function calling, you can explore building agentic AI systems that combine multiple tools and reasoning steps for complex tasks.

Mental Model

Core Idea

Function calling lets an LLM ask for help by triggering specific external actions during a conversation to get accurate or updated results.

Think of it like...

It's like talking to a smart assistant who knows when to pick up the phone and call a friend to get the right answer instead of guessing.

┌───────────────┐      ┌───────────────┐
│   User Input  │─────▶│     LLM Text  │
│ (Question)    │      │ Generation    │
└───────────────┘      └──────┬────────┘
                                │
                                ▼
                      ┌───────────────────┐
                      │ Function Call?    │
                      │ (Yes/No Decision) │
                      └─────────┬─────────┘
                                │Yes
                                ▼
                      ┌───────────────────┐
                      │ Call External      │
                      │ Function/Tool      │
                      └─────────┬─────────┘
                                │
                                ▼
                      ┌───────────────────┐
                      │ Receive Function   │
                      │ Output             │
                      └─────────┬─────────┘
                                │
                                ▼
                      ┌───────────────────┐
                      │ Generate Final     │
                      │ Response to User   │
                      └───────────────────┘

Build-Up - 7 Steps

1

Foundation

What is a function call in AI

Concept: Introduce the idea of a function as a named action that can be triggered to perform a task or get data.

In programming, a function is like a small machine that takes input, does something, and gives output. In AI, function calling means the AI can ask to run one of these machines to help answer questions or do tasks. For example, a function might check the weather or do math calculations.

Result

You understand that function calling means asking for help from a specific tool or action during AI conversations.

Knowing that functions are external helpers clarifies how AI can go beyond just guessing answers.

2

Foundation

How LLMs generate text responses

Concept: Explain that LLMs predict the next word based on patterns learned from huge text data.

Large language models read lots of text and learn how words usually follow each other. When you ask a question, the model guesses the best next words to form an answer. But it only uses what it learned before; it can't do new calculations or check live data by itself.

Result

You see that LLMs alone can only generate text based on past knowledge, not real-time facts or actions.

Understanding this limitation shows why function calling is needed to extend LLM abilities.

3

Intermediate

Why LLMs need function calling

🤔Before reading on: do you think LLMs can always answer questions accurately without external help? Commit to yes or no.

Concept: Show the gap between LLM text generation and real-world tasks requiring up-to-date or precise information.

LLMs can make mistakes or hallucinate facts because they only predict text patterns. For example, they can't check today's weather or do exact math reliably. Function calling lets the model ask an external tool to do these tasks, improving accuracy and usefulness.

Result

You realize that function calling fixes key weaknesses of LLMs by connecting them to real tools.

Knowing this gap helps you appreciate function calling as a bridge between AI and real-world actions.

4

Intermediate

How function calling works in LLMs

🤔Before reading on: do you think the LLM decides itself when to call a function, or is it told explicitly? Commit to your answer.

Concept: Explain the process where the LLM generates a special signal or token to trigger a function call during text generation.

When the LLM thinks a function can help, it outputs a special message describing which function to call and with what inputs. The system then runs that function and sends the result back to the LLM. The LLM uses this result to continue the conversation with accurate info.

Result

You understand the interactive loop where the LLM and external functions work together.

Seeing this interaction clarifies how AI can dynamically use tools during conversations.

5

Intermediate

Defining functions for LLMs

🤔Before reading on: do you think functions for LLMs need to be described in a special way? Commit to yes or no.

Concept: Introduce the idea that functions must be described with names, inputs, and outputs so the LLM can understand and call them correctly.

To use function calling, developers define functions with clear names and input parameters. They also provide descriptions so the LLM knows what each function does and how to use it. This helps the model pick the right function and fill in the inputs properly.

Result

You see that function calling requires careful setup so the LLM can interact with external tools smoothly.

Knowing this setup prevents confusion and errors in AI-tool communication.

6

Advanced

Handling multiple function calls in conversations

🤔Before reading on: do you think LLMs can call multiple functions in one conversation seamlessly? Commit to yes or no.

Concept: Explain how LLMs manage calling several functions in sequence or based on previous results during a chat.

In complex tasks, the LLM might call one function, get results, then decide to call another function using that data. This requires keeping track of conversation state and function outputs. The system manages this flow so the AI can chain actions and provide coherent answers.

Result

You understand that function calling supports multi-step reasoning and tool use in AI dialogs.

Recognizing this flow shows how AI can handle real-world tasks that need several steps.

7

Expert

Challenges and surprises in function calling

🤔Before reading on: do you think LLMs always call the correct function with perfect inputs? Commit to yes or no.

Concept: Reveal common pitfalls like incorrect function selection, input errors, and how models can hallucinate calls or outputs.

Sometimes, the LLM might pick the wrong function or provide wrong inputs, causing errors. Also, the model can hallucinate function calls that don't exist or ignore function outputs. Handling these requires careful prompt design, validation, and fallback strategies in production.

Result

You see that function calling is powerful but needs robust engineering to avoid failures.

Understanding these challenges prepares you to build reliable AI systems that use function calling effectively.

Under the Hood

Function calling works by extending the LLM's text generation with a structured output format that signals a function call. Internally, the model predicts a special token sequence that encodes the function name and arguments. The system intercepts this output, executes the corresponding external function, and feeds the result back into the model's context. This loop allows the LLM to incorporate dynamic, real-time data or actions into its responses.

Why designed this way?

This design leverages the LLM's natural text generation ability while enabling precise control over external actions. Earlier approaches tried to hard-code logic or rely solely on text prompts, which led to errors and hallucinations. Function calling provides a clear interface between AI and tools, improving reliability and flexibility. It balances the creativity of language models with the precision of software functions.

┌───────────────┐       ┌───────────────┐       ┌───────────────┐
│  User Query   │──────▶│  LLM Generates│──────▶│ Function Call │
│ (Text Input)  │       │  Text + Call  │       │ (Name + Args) │
└───────────────┘       └───────┬───────┘       └───────┬───────┘
                                    │                       │
                                    ▼                       ▼
                          ┌─────────────────┐       ┌───────────────┐
                          │ Function Runner │◀──────│ External Tool │
                          │ Executes Call   │       │ (API, Script) │
                          └────────┬────────┘       └───────────────┘
                                   │
                                   ▼
                          ┌─────────────────┐
                          │ Return Output to │
                          │ LLM Context      │
                          └────────┬────────┘
                                   │
                                   ▼
                          ┌─────────────────┐
                          │ LLM Generates   │
                          │ Final Response  │
                          └─────────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Do you think function calling means the LLM writes code to run functions itself? Commit to yes or no.

Common Belief: Function calling means the LLM writes and runs code internally to perform tasks.

Reality: The LLM only generates a structured request to call an external function; it does not execute code itself.

Why it matters: Believing the LLM runs code can lead to security risks or misunderstandings about AI capabilities and limitations.

Quick: Do you think function calling guarantees 100% accurate answers? Commit to yes or no.

Common Belief: Using function calling means the AI always gives correct and up-to-date answers.

Reality: Function calling improves accuracy but depends on correct function definitions, inputs, and external tool reliability.

Why it matters: Overtrusting function calling can cause unnoticed errors or failures in critical applications.

Quick: Do you think LLMs can call any function without prior setup? Commit to yes or no.

Common Belief: LLMs can call any function dynamically without needing descriptions or definitions.

Reality: Functions must be predefined and described so the LLM knows how to call them properly.

Why it matters: Assuming dynamic calling without setup leads to failed calls and broken user experiences.

Quick: Do you think function calling replaces the need for prompt engineering? Commit to yes or no.

Common Belief: Function calling removes the need to carefully design prompts for LLMs.

Reality: Prompt design remains crucial to guide the LLM when and how to call functions effectively.

Why it matters: Ignoring prompt engineering can cause incorrect or missed function calls, reducing system reliability.

Expert Zone

1

Function calling requires balancing between giving the LLM enough freedom to decide when to call functions and constraining it to avoid hallucinations.

2

The timing of feeding function outputs back into the LLM context affects how well the model integrates external data into its reasoning.

3

Complex multi-function workflows need state management outside the LLM to track previous calls and results, which is often overlooked.

When NOT to use

Function calling is not ideal when the task requires deep reasoning without external data or when the external functions are unreliable or slow. In such cases, pure LLM generation or specialized models may be better.

Production Patterns

In production, function calling is used in AI assistants to fetch live data (weather, news), perform transactions (booking, payments), or run calculations. Systems often combine function calling with fallback prompts and error handling to ensure robustness.

Connections

API Integration

Function calling in LLMs builds on the idea of APIs as interfaces to external services.

Understanding APIs helps grasp how LLMs use function calling to interact with real-world tools and data.

Human-in-the-loop Systems

Function calling complements human oversight by automating routine tasks while allowing humans to intervene on errors.

Knowing human-in-the-loop concepts clarifies how function calling fits into reliable AI workflows.

Cognitive Offloading (Psychology)

Function calling is like cognitive offloading where the brain delegates tasks to external tools to reduce mental load.

Recognizing this parallel shows how AI mimics human strategies to handle complex tasks efficiently.

Common Pitfalls

#1 LLM calls a function with wrong or missing inputs.

Wrong approach:

{"function_call": {"name": "getWeather", "arguments": "{}"}}

Correct approach:

{"function_call": {"name": "getWeather", "arguments": "{\"location\": \"New York\"}"}}

Root cause:

The model did not receive clear guidance on required inputs or failed to extract them from the conversation.

#2 Ignoring function outputs and continuing with hallucinated answers.

Wrong approach:

LLM generates answer ignoring the returned data from the function call.

Correct approach:

LLM incorporates the function output into its next response to provide accurate information.

Root cause:

Lack of proper integration of function results into the model's context or prompt.

#3 Defining functions without clear descriptions or parameter types.

Wrong approach:

Function defined as {"name": "doTask", "parameters": {}} without details.

Correct approach:

Function defined as {"name": "doTask", "parameters": {"type": "object", "properties": {"taskId": {"type": "string", "description": "ID of the task"}}}}

Root cause:

Insufficient metadata causes the LLM to misunderstand how to call the function.

Key Takeaways

Function calling enables LLMs to extend their capabilities by interacting with external tools during conversations.

LLMs generate structured signals to request function calls, which are executed outside the model and fed back as context.

Careful definition and description of functions are essential for reliable and accurate AI-tool communication.

Function calling improves AI usefulness but requires robust design to handle errors, input validation, and multi-step workflows.

Understanding function calling bridges the gap between language models and practical, real-world applications.

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