Function Calling: Enabling LLMs to Use External Tools and APIs

Introduction

Large language models are remarkably capable at generating text, but they have fundamental limitations: they cannot access real-time information, perform calculations with perfect accuracy, or execute actions in the real world. Function Calling bridges this gap by enabling LLMs to invoke external functions, APIs, and tools—transforming them from passive text generators into active agents that can interact with the world.

This article explores how Function Calling works, its implementation patterns, and how it’s powering the next generation of AI applications.

The Need for Function Calling

LLM Limitations

llm_limitations = {
    'knowledge_cutoff': 'Training data has a cutoff date',
    'no_real_time_data': 'Cannot access current information',
    'math_accuracy': 'Struggle with precise arithmetic',
    'no_actions': 'Cannot execute real-world actions',
    'hallucinations': 'Can make up facts',
    
    # Example failures
    'example': {
        'query': 'What is the current price of Bitcoin?',
        'llm_response': 'As of my knowledge cutoff, Bitcoin was around $45,000',
        'actual': 'The model cannot know current prices'
    }
}

How Function Calling Solves This

# Without function calling: model guesses
query = "What's the weather in Tokyo?"
response = llm.generate(f"User asked: {query}")  
# Response: "I believe it's probably around 20°C"

# With function calling: model uses real data
tools = [{
    "name": "get_weather",
    "description": "Get current weather for a location",
    "parameters": {
        "type": "object",
        "properties": {
            "location": {"type": "string", "description": "City name"}
        },
        "required": ["location"]
    }
}]

# Model recognizes need for tool
response = llm.generate(query, tools=tools)
# Model outputs: {"name": "get_weather", "arguments": {"location": "Tokyo"}}

# Execute function
weather = get_weather(location="Tokyo")
# Result: {"temperature": 18, "condition": "Sunny", "humidity": 65}

# Generate final response with real data
final_response = llm.generate(query, context=weather)
# Response: "The current weather in Tokyo is 18°C and sunny."

How Function Calling Works

The Function Calling Pipeline

class FunctionCallingPipeline:
    """
    Complete function calling pipeline
    """
    
    def __init__(self, llm, tools):
        self.llm = llm
        self.tools = tools  # Tool definitions
    
    def process(self, user_message):
        """
        Complete function calling workflow
        """
        
        # Step 1: Send message + tools to LLM
        response = self.llm.chat(
            messages=[{"role": "user", "content": user_message}],
            tools=self.tools
        )
        
        # Step 2: Check if LLM wants to call a function
        if response.tool_calls:
            results = []
            
            for tool_call in response.tool_calls:
                # Parse function name and arguments
                function_name = tool_call.function.name
                arguments = json.loads(tool_call.function.arguments)
                
                # Execute function
                result = self.execute_function(function_name, arguments)
                results.append({
                    "tool_call_id": tool_call.id,
                    "result": result
                })
            
            # Step 3: Send results back to LLM
            final_response = self.llm.chat(
                messages=[
                    {"role": "user", "content": user_message},
                    {"role": "assistant", "tool_calls": response.tool_calls},
                    # Tool results as messages
                    *[{"role": "tool", 
                       "tool_call_id": r["tool_call_id"],
                       "content": json.dumps(r["result"])} 
                      for r in results]
                ]
            )
            
            return final_response.content
        
        # No function call needed
        return response.content
    
    def execute_function(self, name, args):
        """Execute a registered function"""
        function = self.available_functions[name]
        return function(**args)

Tool Definition Format

# OpenAI-style function calling tool definition
weather_tool = {
    "type": "function",
    "function": {
        "name": "get_current_weather",
        "description": "Get the current weather in a given location",
        "parameters": {
            "type": "object",
            "properties": {
                "location": {
                    "type": "string",
                    "description": "The city and state, e.g. San Francisco, CA"
                },
                "unit": {
                    "type": "string",
                    "enum": ["celsius", "fahrenheit"],
                    "description": "The unit of temperature to return"
                }
            },
            "required": ["location"]
        }
    }
}

# Code execution tool
code_execution_tool = {
    "type": "function",
    "function": {
        "name": "execute_python",
        "description": """Execute Python code and return the result.
        Use this for any calculations or data processing.""",
        "parameters": {
            "type": "object",
            "properties": {
                "code": {
                    "type": "string",
                    "description": "The Python code to execute"
                }
            },
            "required": ["code"]
        }
    }
}

# Database query tool
database_tool = {
    "type": "function",
    "function": {
        "name": "query_database",
        "description": "Query the company's database for information",
        "parameters": {
            "type": "object",
            "properties": {
                "sql": {
                    "type": "string",
                    "description": "SQL query to execute"
                }
            },
            "required": ["sql"]
        }
    }
}

Implementation Patterns

Basic Implementation

import json
from typing import List, Dict, Any

class FunctionCallingLLM:
    """
    Basic function calling implementation
    """
    
    def __init__(self, model, functions: List[Dict]):
        self.model = model
        self.functions = functions
        self.available_functions = {}
    
    def register_function(self, name: str, func: callable):
        """Register a function that can be called"""
        self.available_functions[name] = func
    
    def chat(self, messages: List[Dict], functions=None):
        """Send request to LLM with function definitions"""
        payload = {
            "model": self.model,
            "messages": messages,
        }
        
        if functions or self.functions:
            payload["tools"] = functions or self.functions
        
        response = self.openai_api_call(payload)
        return self.parse_response(response)
    
    def parse_response(self, response):
        """Parse LLM response, handle function calls"""
        choice = response['choices'][0]
        
        if 'tool_calls' in choice['message']:
            return ToolCallResponse(
                content=choice['message'].get('content'),
                tool_calls=choice['message']['tool_calls']
            )
        
        return TextResponse(content=choice['message']['content'])


# Usage example
llm = FunctionCallingLLM("gpt-4-turbo", [weather_tool, calculator_tool])

llm.register_function("get_current_weather", get_weather)
llm.register_function("calculate", calculate)

response = llm.chat([
    {"role": "user", "content": "What's 15% of 200?"}
])

print(response.content)  # "15% of 200 is 30"

Multi-Function Calling

class MultiFunctionCaller:
    """
    Handle multiple function calls in sequence
    """
    
    def __init__(self, llm):
        self.llm = llm
    
    def process_with_functions(self, query, tools):
        """
        Allow LLM to call multiple functions as needed
        """
        messages = [{"role": "user", "content": query}]
        
        max_turns = 5
        for turn in range(max_turns):
            # Get LLM response
            response = self.llm.chat(messages, tools=tools)
            
            if not response.tool_calls:
                # No more function calls, return final response
                return response.content
            
            # Execute all function calls
            for call in response.tool_calls:
                func_name = call.function.name
                args = json.loads(call.function.arguments)
                
                # Execute function
                result = self.execute(func_name, args)
                
                # Add to conversation
                messages.append({
                    "role": "assistant",
                    "tool_calls": [call]
                })
                messages.append({
                    "role": "tool",
                    "tool_call_id": call.id,
                    "content": json.dumps(result)
                })
        
        # Max turns reached
        return "I need more time to process your request."
    
    def execute(self, name, args):
        """Execute function and return result"""
        # Implementation depends on registered functions
        pass


# Example: Book recommendation with multiple data sources
query = """I want to read a book about machine learning.
Can you:
1. Search for popular ML books
2. Check which ones are available in the library
3. Tell me the average rating"""

tools = [search_books, check_library, get_ratings]

result = multi_function_caller.process_with_functions(query, tools)

Parallel Function Execution

class ParallelFunctionCaller:
    """
    Execute independent functions in parallel
    """
    
    def __init__(self, llm):
        self.llm = llm
    
    async def process(self, query, tools):
        """
        Execute multiple function calls concurrently
        """
        # Get initial response
        response = await self.llm.chat_async(query, tools=tools)
        
        if not response.tool_calls:
            return response.content
        
        # Group independent calls
        calls = response.tool_calls
        independent_groups = self.identify_independent_calls(calls)
        
        results = []
        for group in independent_groups:
            # Execute group in parallel
            group_results = await asyncio.gather([
                self.execute_call(call) for call in group
            ])
            results.extend(group_results)
        
        # Continue conversation with results
        return await self.continue_conversation(query, results)
    
    def identify_independent_calls(self, calls):
        """
        Identify which function calls can run in parallel
        """
        # Functions are independent if they don't depend on each other's output
        # Simple heuristic: different function names = potentially independent
        groups = {}
        for call in calls:
            func_name = call.function.name
            if func_name not in groups:
                groups[func_name] = []
            groups[func_name].append(call)
        
        return list(groups.values())

Real-World Applications

E-commerce Assistant

ecommerce_tools = [
    {
        "name": "search_products",
        "description": "Search product catalog",
        "parameters": {
            "type": "object",
            "properties": {
                "query": {"type": "string"},
                "category": {"type": "string"},
                "max_price": {"type": "number"}
            }
        }
    },
    {
        "name": "get_product_details",
        "description": "Get detailed information about a product",
        "parameters": {
            "type": "object",
            "properties": {
                "product_id": {"type": "string"}
            }
        }
    },
    {
        "name": "check_inventory",
        "description": "Check if product is in stock",
        "parameters": {
            "type": "object",
            "properties": {
                "product_id": {"type": "string"},
                "location": {"type": "string"}
            }
        }
    },
    {
        "name": "place_order",
        "description": "Place an order for a product",
        "parameters": {
            "type": "object",
            "properties": {
                "product_id": {"type": "string"},
                "quantity": {"type": "integer"}
            }
        }
    }
]

# Example conversation:
# User: "I want to buy a laptop for video editing under $2000"
# 1. search_products(query="laptop video editing", max_price=2000)
# 2. get_product_details(product_id=returned_id)
# 3. check_inventory(product_id=id, location=user_zip)
# 4. place_order(product_id=id, quantity=1)

Data Analysis Assistant

data_analysis_tools = [
    {
        "name": "load_data",
        "description": "Load data from a file or database",
        "parameters": {
            "type": "object",
            "properties": {
                "source": {"type": "string"},
                "query": {"type": "string"}
            }
        }
    },
    {
        "name": "analyze_data",
        "description": "Perform statistical analysis on data",
        "parameters": {
            "type": "object",
            "properties": {
                "data_id": {"type": "string"},
                "analysis_type": {"type": "string", "enum": ["descriptive", "correlation", "regression"]}
            }
        }
    },
    {
        "name": "visualize",
        "description": "Create visualizations",
        "parameters": {
            "type": "object",
            "properties": {
                "data_id": {"type": "string"},
                "chart_type": {"type": "string"}
            }
        }
    }
]

Calendar and Scheduling

calendar_tools = [
    {
        "name": "get_availability",
        "description": "Check available time slots",
        "parameters": {
            "type": "object",
            "properties": {
                "date": {"type": "string"},
                "duration_minutes": {"type": "integer"}
            }
        }
    },
    {
        "name": "book_meeting",
        "description": "Schedule a meeting",
        "parameters": {
            "type": "object",
            "properties": {
                "title": {"type": "string"},
                "date_time": {"type": "string"},
                "duration": {"type": "integer"},
                "attendees": {"type": "array", "items": {"type": "string"}}
            }
        }
    },
    {
        "name": "send_invite",
        "description": "Send calendar invitation",
        "parameters": {
            "type": "object",
            "properties": {
                "meeting_id": {"type": "string"},
                "recipients": {"type": "array", "items": {"type": "string"}}
            }
        }
    }
]

Advanced Patterns

Function Calling with Memory

class StatefulFunctionCaller:
    """
    Maintain conversation state across function calls
    """
    
    def __init__(self, llm):
        self.llm = llm
        self.state = {
            'context': {},
            'pending_actions': [],
            'history': []
        }
    
    def process(self, message):
        """Process message with state management"""
        
        # Add to history
        self.state['history'].append(message)
        
        # Get LLM response with context
        response = self.llm.chat(
            messages=self.state['history'],
            tools=self.tools,
            tool_context=self.state['context']
        )
        
        # Process any tool calls
        if response.tool_calls:
            results = []
            for call in response.tool_calls:
                result = self.execute_with_state(call)
                results.append(result)
                self.update_state(call, result)
        
        # Add response to history
        self.state['history'].append(response)
        
        return response
    
    def update_state(self, call, result):
        """Update state based on function results"""
        func_name = call.function.name
        
        if func_name == "get_user_preferences":
            self.state['context']['preferences'] = result
        elif func_name == "get_user_history":
            self.state['context']['history'] = result

Error Handling and Recovery

class RobustFunctionCaller:
    """
    Handle errors in function calling gracefully
    """
    
    def __init__(self, llm):
        self.llm = llm
        self.max_retries = 3
    
    def process_with_retry(self, message, tools):
        """Process with error handling"""
        
        for attempt in range(self.max_retries):
            try:
                response = self.llm.chat(message, tools=tools)
                
                if response.tool_calls:
                    results = []
                    for call in response.tool_calls:
                        try:
                            result = self.execute_safely(call)
                            results.append(result)
                        except FunctionExecutionError as e:
                            # Function failed, inform LLM
                            results.append({
                                "error": str(e),
                                "recovery_suggestion": e.suggestion
                            })
                    
                    # Check if all functions succeeded
                    if all('error' not in r for r in results):
                        # Success, continue
                        message = self.add_results(message, results)
                    else:
                        # Some failed, ask LLM to handle
                        message = self.handle_errors(message, results)
                        
                else:
                    return response.content
                    
            except Exception as e:
                if attempt == self.max_retries - 1:
                    return f"I encountered an error: {str(e)}"
        
        return "Unable to complete your request after multiple attempts."
    
    def execute_safely(self, call):
        """Execute function with error handling"""
        try:
            return self.execute(call)
        except Exception as e:
            raise FunctionExecutionError(
                str(e),
                suggestion=self.get_suggestion(call, e)
            )

Best Practices

Tool Design

tool_design_best_practices = {
    'descriptions': {
        'be_clear': 'Describe what the function does in plain language',
        'include_edge_cases': 'Mention limitations and error conditions',
        'use_examples': 'Give examples of when to use the function'
    },
    
    'parameters': {
        'required_fields': 'Mark required parameters clearly',
        'type_hints': 'Use proper JSON Schema types',
        'descriptions': 'Describe what each parameter means',
        'defaults': 'Provide sensible defaults when possible'
    },
    
    'naming': {
        'clear_names': 'Use descriptive function names',
        'verb_noun': 'Start with verb: get_weather, calculate_total',
        'consistent': 'Follow consistent naming convention'
    }
}

Integration Guidelines

integration_guidelines = {
    'security': {
        'input_validation': 'Validate all function inputs',
        'authentication': 'Use proper auth for sensitive functions',
        'rate_limiting': 'Implement rate limits to prevent abuse',
        'logging': 'Log all function calls for debugging'
    },
    
    'performance': {
        'caching': 'Cache results when appropriate',
        'async': 'Use async for I/O-bound functions',
        'timeouts': 'Set appropriate timeouts',
        'parallel': 'Execute independent calls in parallel'
    },
    
    'reliability': {
        'error_handling': 'Handle errors gracefully',
        'retry_logic': 'Implement retry for transient failures',
        'fallbacks': 'Provide fallback options',
        'monitoring': 'Monitor function call success rates'
    }
}

Comparison

Feature	Basic LLM	With Function Calling
Real-time Data	No	Yes
Calculations	Approximate	Exact
External Actions	No	Yes
Knowledge Cutoff	Limited	Bypassed
Hallucinations	Higher	Lower
Use Cases	Text generation	Task completion

Conclusion

Function Calling is transforming LLMs into powerful task-completing agents:

Real-World Integration: Connect to APIs, databases, and services
Accuracy: Precise calculations and real-time data
Automation: Execute actions beyond text generation
Reliability: Reduce hallucinations by using verified data
Agents: Foundation for autonomous AI agents

As models improve at understanding when and how to use tools, Function Calling will enable increasingly sophisticated AI applications.