Function Calling LLM Best Practices: The Complete 2026 Guide Function calling (also called tool use or plugin capabilities) transforms LLMs from chat interfaces into action-taking agents. Instead of just generating text, function-calling LLMs can query databases, call APIs, send emails, and interact with external systems. But with this power comes complexity—poorly designed function calling systems are slow, unreliable, and expensive. In this guide, we'll explore function calling LLM best practices that lead to robust production systems. ## What is Function Calling in LLMs? Function calling allows LLMs to invoke external tools by generating structured requests. The typical flow: 1. User query: "What's the weather in Lagos?" 2. LLM determines: Need to call get_weather(city="Lagos") 3. System executes: Calls actual weather API 4. Result returned: Temperature, conditions, etc. 5. LLM synthesizes: "It's currently 28°C and sunny in Lagos" Modern LLMs (GPT-4, Claude, Gemini) have native function calling support, but implementation quality varies widely. ## Why Function Calling Matters Without function calling: - LLMs can only use knowledge from training data - No access to real-time information - Can't take actions in external systems - Limited to text generation With function calling: - Access live data (stock prices, weather, inventory) - Take actions (send emails, create tasks, update databases) - Implement complex workflows (research → analysis → reporting) - Build true AI agents Our guide on AI agent tools for developers covers the frameworks that make function calling practical at scale. ## Function Calling Best Practices ### 1. Write Clear Function Descriptions The LLM relies entirely on your function description to decide when and how to call it: Bad: python def get_user(user_id): """Gets a user""" pass Good: python def get_user(user_id: str) -> Dict: """Retrieve detailed user information by user ID. Use this when you need to look up user details like email, name, subscription status, or account creation date. Args: user_id: The unique identifier for the user (e.g., "usr_123abc") Returns: Dict containing user details: id, email, name, created_at, subscription_tier, account_status Example: get_user("usr_123") → {"id": "usr_123", "email": "user@example.com", ...} """ pass Key elements: - Clear when to use the function - Detailed parameter descriptions with examples - Expected return value structure - Edge case handling ### 2. Design Atomic Functions Each function should do one thing well: Bad - Too broad: python def manage_order(action, order_id, updates): """Create, update, cancel, or query orders""" pass Good - Atomic: python def create_order(items: List[str], customer_id: str) -> str: """Create a new order""" pass def cancel_order(order_id: str, reason: str) -> bool: """Cancel an existing order""" pass def get_order_status(order_id: str) -> Dict: """Query the current status of an order""" pass Benefits: - LLM makes fewer mistakes selecting the right function - Easier to test and debug - Better error handling - Clearer audit logs ### 3. Implement Robust Error Handling Functions will fail. Handle it gracefully: python from typing import Dict, Optional import logging def get_stock_price(symbol: str) -> Dict: """Get current stock price for a given symbol. Args: symbol: Stock ticker symbol (e.g., "AAPL", "GOOGL") Returns: {"success": bool, "price": float, "error": Optional[str]} """ try: # Validate input if not symbol or not symbol.isalpha(): return { "success": False, "error": "Invalid stock symbol format" } # Call external API response = stock_api.get_price(symbol.upper()) if response.status_code == 404: return { "success": False, "error": f"Stock symbol '{symbol}' not found" } return { "success": True, "price": response.data["price"], "timestamp": response.data["timestamp"] } except Exception as e: logging.error(f"Stock API error: {e}") return { "success": False, "error": "Unable to fetch stock price. Please try again." } Always return structured responses that indicate success/failure—don't raise exceptions that crash the agent. ### 4. Add Confirmation for Destructive Actions Don't let the LLM delete data or send emails without human approval: python def send_email(to: str, subject: str, body: str) -> Dict: """Send an email message. ⚠️ REQUIRES USER CONFIRMATION before execution. Args: to: Recipient email address subject: Email subject line body: Email body content Returns: {"requires_confirmation": true, "preview": Dict} """ return { "requires_confirmation": True, "preview": { "to": to, "subject": subject, "body": body }, "message": "Email ready to send. User must confirm." } Implement a confirmation flow: python if result.get("requires_confirmation"): await show_confirmation_ui(result["preview"]) if await wait_for_user_approval(): execute_confirmed_action(result) ### 5. Limit Function Scope with Permissions Not all users should access all functions: python class FunctionRegistry: def __init__(self, user_role: str): self.user_role = user_role def get_available_functions(self) -> List: all_functions = [ (get_user, ["admin", "support", "user"]), (update_user, ["admin", "support"]), (delete_user, ["admin"]), (refund_order, ["admin", "finance"]), ] return [ func for func, allowed_roles in all_functions if self.user_role in allowed_roles ] Only pass role-appropriate functions to the LLM. ### 6. Optimize for Performance Function calls add latency. Minimize it: Parallel Execution: python # If the LLM requests multiple independent function calls calls = [ get_weather("London"), get_weather("Paris"), get_weather("Berlin") ] # Execute in parallel, not sequentially results = await asyncio.gather(*calls) Caching: python from functools import lru_cache from datetime import datetime, timedelta @lru_cache(maxsize=1000) def get_weather(city: str, _cache_key: str = None): """Cached for 30 minutes""" return weather_api.fetch(city) # Call with cache key based on time cache_key = datetime.now().replace(minute=datetime.now().minute // 30 * 30) result = get_weather("Lagos", str(cache_key)) Early Returns: python def search_documents(query: str, max_results: int = 10): """Search document database. Optimized to return as soon as we have enough results. """ results = [] for doc in document_stream: if len(results) >= max_results: break # Don't process more than needed if query.lower() in doc.content.lower(): results.append(doc) return results See our guide on AI agent cost optimization strategies for more performance tips. ### 7. Provide Rich Context in Results Help the LLM synthesize better responses: Bad: python def get_order_status(order_id: str) -> str: return "shipped" # Just the status Good: python def get_order_status(order_id: str) -> Dict: return { "order_id": order_id, "status": "shipped", "status_details": "Out for delivery", "tracking_number": "1Z999AA10123456784", "carrier": "UPS", "estimated_delivery": "2026-03-22", "last_update": "2026-03-20T14:30:00Z", "location": "Local distribution center - Lagos" } The LLM can now say: "Your order is out for delivery with UPS (tracking: 1Z999AA10123456784) and should arrive by March 22nd. It's currently at the Lagos distribution center." ### 8. Handle Multi-Step Function Sequences Complex tasks require multiple function calls. Design for this: python # User: "Find all high-priority bugs assigned to me and update their status to 'in progress'" # Step 1: LLM calls get_current_user() user = get_current_user() # Step 2: LLM calls search_bugs(assignee=user.id, priority="high") bugs = search_bugs(assignee=user["id"], priority="high") # Step 3: LLM calls update_bug_status() for each bug for bug in bugs["results"]: update_bug_status(bug_id=bug["id"], status="in_progress") # Step 4: LLM synthesizes final response "Updated 7 high-priority bugs to 'in progress'" Enable this by: - Returning structured data the LLM can iterate over - Allowing functions to be called multiple times - Implementing proper state management between calls ### 9. Version Your Function Schemas As your system evolves, function signatures change. Manage this carefully: python # v1 def create_user(email: str, name: str): pass # v2 - added optional phone parameter def create_user(email: str, name: str, phone: Optional[str] = None): """Create a new user account. Version: 2.0 Added in v2: phone parameter Args: email: User's email address (required) name: User's full name (required) phone: User's phone number (optional, added in v2.0) """ pass Track which version each agent instance uses and migrate gradually. ### 10. Log Everything Function calls are critical decision points. Capture them: python import logging from datetime import datetime def log_function_call(func_name: str, args: Dict, result: Any, duration: float): logging.info({ "event": "function_call", "timestamp": datetime.utcnow().isoformat(), "function": func_name, "arguments": args, "result_summary": str(result)[:200], # Truncate long results "duration_ms": duration * 1000, "user_id": get_current_user_id(), "session_id": get_session_id() }) This enables: - Debugging ("Why did the agent call this function?") - Audit trails (compliance requirements) - Performance analysis (which functions are slow?) - Usage analytics (which functions are actually used?) ## Advanced Function Calling Patterns ### Conditional Function Availability Make functions available only when contextually appropriate: python def get_available_tools(conversation_history: List) -> List: tools = [get_user, search_documents] # Always available # Only offer refund if we're discussing an order if any("order" in msg.lower() for msg in conversation_history): tools.append(refund_order) # Only offer escalation if customer is frustrated if detect_negative_sentiment(conversation_history): tools.append(escalate_to_human) return tools ### Fallback Functions Provide alternatives when primary functions fail: python def search_knowledge_base(query: str) -> Dict: """Search internal knowledge base. Falls back to web search if needed.""" results = internal_search(query) if not results or len(results) < 3: # Internal search didn't find much, try web web_results = web_search(query, site="docs.company.com") return { "source": "web_fallback", "results": web_results, "note": "Internal search returned limited results; using web search" } return { "source": "internal", "results": results } ### Hierarchical Function Calling Complex workflows with decision trees: python # High-level function def handle_customer_request(request: str) -> Dict: """Route customer request to appropriate handler. This function determines the request type and calls the appropriate specialized function. """ request_type = classify_request(request) if request_type == "refund": return process_refund_request(request) elif request_type == "technical_support": return create_support_ticket(request) elif request_type == "billing": return handle_billing_inquiry(request) else: return escalate_to_human(request) ## Testing Function Calling Systems ### Unit Testing Functions Test each function independently: python def test_get_stock_price(): # Valid input result = get_stock_price("AAPL") assert result["success"] == True assert "price" in result # Invalid input result = get_stock_price("INVALID123") assert result["success"] == False assert "error" in result # Edge cases result = get_stock_price("") assert result["success"] == False ### Integration Testing LLM Function Selection Test that the LLM selects the right functions: python test_cases = [ { "query": "What's the weather in Paris?", "expected_function": "get_weather", "expected_args": {"city": "Paris"} }, { "query": "Send an email to john@example.com", "expected_function": "send_email", "expected_args": {"to": "john@example.com"} } ] for test in test_cases: response = agent.invoke(test["query"]) assert response.function_calls[0]["name"] == test["expected_function"] ### Load Testing Ensure function calls scale: python import asyncio async def load_test(): tasks = [] for i in range(1000): tasks.append(agent.invoke(f"Get weather for city_{i}")) results = await asyncio.gather(*tasks) # Measure latency latencies = [r.duration for r in results] print(f"P50: {np.percentile(latencies, 50)}ms") print(f"P95: {np.percentile(latencies, 95)}ms") print(f"P99: {np.percentile(latencies, 99)}ms") ## Common Function Calling Mistakes Overly complex functions — Functions that try to do too much confuse the LLM. Keep them atomic. Poor error messages — Return human-readable errors. "Database error 0x8000FFFF" is useless. "User not found for email user@example.com" is helpful. Ignoring rate limits — External APIs have limits. Implement backoff and queueing. No validation — Always validate inputs. Never trust the LLM to pass perfectly formatted data. Forgetting about costs — Every function call adds latency and potentially costs money. Profile your workflows. For more on building production-ready systems, see our guide on handling AI agent hallucinations. ## Measuring Function Calling Success Key Metrics: Function Call Accuracy — % of queries where the correct function(s) were called Target: >95% Function Execution Success Rate — % of function calls that complete without errors Target: >98% Average Functions Per Query — Measure workflow complexity Typical: 1.5-3.0 for complex agents Function Call Latency — p95 latency for function execution Target: <500ms for most functions User Satisfaction — When function calling works, users get their goals accomplished Target: >85% task completion rate ## The Future of Function Calling 2026 is seeing exciting developments: Autonomous function discovery — Agents that can discover and learn to use new APIs from documentation Multi-modal function calling — Functions that accept images, audio, or video as inputs Federated function execution — Agents calling functions across distributed systems securely Learning from function results — Agents that improve function selection based on success/failure history ## Conclusion Function calling LLM best practices boil down to clarity, robustness, and monitoring. Write clear function descriptions, handle errors gracefully, implement confirmations for destructive actions, and log everything. The difference between a brittle demo and a production-ready agent often comes down to how well you've designed your function calling layer. Start simple—even 3-5 well-designed functions can power incredibly useful agents. Add complexity only as needed, and always prioritize reliability over feature breadth. The best function calling systems feel invisible to users; they just get their work done. --- ## Build AI That Works For Your Business At AI Agents Plus, we help companies move from AI experiments to production systems that deliver real ROI. Whether you need: - Custom AI Agents — Autonomous systems that handle complex workflows, from customer service to operations - Rapid AI Prototyping — Go from idea to working demo in days using vibe coding and modern AI frameworks - Voice AI Solutions — Natural conversational interfaces for your products and services We've built AI systems for startups and enterprises across Africa and beyond. Ready to explore what AI can do for your business? Let's talk →