Function Calling

Function Calling

Enable LLMs to use external tools and return structured data.

Basic Tool Definition (2026 Best Practice)

# OpenAI format with strict mode (2026 recommended)
tools = [{
    "type": "function",
    "function": {
        "name": "search_documents",
        "description": "Search the document database for relevant content",
        "strict": True,  # ← 2026: Enables structured output validation
        "parameters": {
            "type": "object",
            "properties": {
                "query": {
                    "type": "string",
                    "description": "The search query"
                },
                "limit": {
                    "type": "integer",
                    "description": "Max results to return"
                }
            },
            "required": ["query", "limit"],  # All props required when strict
            "additionalProperties": False     # ← 2026: Required for strict mode
        }
    }
}]

# Note: With strict=True:
# - All properties must be listed in "required"
# - additionalProperties must be False
# - No "default" values (provide via code instead)

Tool Execution Loop

async def run_with_tools(messages: list, tools: list) -> str:
    """Execute tool calls until LLM returns final answer."""
    while True:
        response = await llm.chat(messages=messages, tools=tools)

        # Check if LLM wants to call tools
        if not response.tool_calls:
            return response.content

        # Execute each tool call
        for tool_call in response.tool_calls:
            result = await execute_tool(
                tool_call.function.name,
                json.loads(tool_call.function.arguments)
            )

            # Add tool result to conversation
            messages.append({
                "role": "tool",
                "tool_call_id": tool_call.id,
                "content": json.dumps(result)
            })

        # Continue loop (LLM will process tool results)

async def execute_tool(name: str, args: dict) -> any:
    """Route to appropriate tool implementation."""
    tools = {
        "search_documents": search_documents,
        "get_weather": get_weather,
        "calculate": calculate,
    }
    return await tools[name](**args)

Structured Output (Guaranteed JSON)

from pydantic import BaseModel

class Analysis(BaseModel):
    sentiment: str
    confidence: float
    key_points: list[str]

# OpenAI structured output
response = await client.beta.chat.completions.parse(
    model="gpt-5.2",
    messages=[{"role": "user", "content": "Analyze this text..."}],
    response_format=Analysis
)

analysis = response.choices[0].message.parsed  # Typed Analysis object

LangChain Tool Binding

from langchain_core.tools import tool
from pydantic import BaseModel, Field

@tool
def search_documents(query: str, limit: int = 5) -> list[dict]:
    """Search the document database.

    Args:
        query: Search query string
        limit: Maximum results to return
    """
    return db.search(query, limit=limit)

# Bind to model
llm_with_tools = llm.bind_tools([search_documents])

# Or with structured output
class SearchResult(BaseModel):
    query: str = Field(description="The search query used")
    results: list[str] = Field(description="Matching documents")

structured_llm = llm.with_structured_output(SearchResult)

Parallel Tool Calls

# OpenAI supports parallel tool calls
response = await llm.chat(
    messages=messages,
    tools=tools,
    parallel_tool_calls=True  # Default in GPT-5 series
)

# Handle multiple calls in parallel
if response.tool_calls:
    results = await asyncio.gather(*[
        execute_tool(tc.function.name, json.loads(tc.function.arguments))
        for tc in response.tool_calls
    ])

⚠️ 2026 Compatibility Note:

# Structured outputs with strict=True may not work with parallel_tool_calls
# If using strict mode schemas, disable parallel calls:
response = await llm.chat(
    messages=messages,
    tools=tools_with_strict_true,
    parallel_tool_calls=False  # Required for strict mode reliability
)

Key Decisions

Common Mistakes

• Vague tool descriptions (LLM won't know when to use)
• No input validation (LLM sends bad params)
• Missing error handling (crashes on tool failure)
• Too many tools (LLM gets confused)

Related Skills

• agent-loops - Multi-step tool use with reasoning
• llm-streaming - Streaming with tool calls
• structured-output - Complex output schemas

Capability Details

tool-definition

Keywords: tool, function, define tool, tool schema, function schema Solves:

• Define tools with clear descriptions
• Create JSON schemas for tool parameters
• Document tool behavior for LLM

tool-execution-loop

Keywords: execution loop, tool call, agent loop, run tool Solves:

• Implement tool execution loops
• Handle multiple tool calls
• Process tool results

structured-output

Keywords: structured output, JSON output, typed response, response schema Solves:

• Get structured JSON from LLM
• Enforce output schemas
• Parse and validate responses

parallel-tool-calls

Keywords: parallel, concurrent, multiple tools, batch tools Solves:

• Execute multiple tools in parallel
• Handle concurrent tool results
• Optimize tool call latency

strict-mode-schemas

Keywords: strict mode, strict schema, additionalProperties, required fields Solves:

• Enforce strict JSON schemas
• Prevent extra fields in output
• Ensure schema compliance

Function Calling Checklist

Tool Definition

• [ ] Clear, concise description (1-2 sentences)
• [ ] All parameters documented
• [ ] Use strict mode (strict: true) for reliability
• [ ] All properties in required (when strict)
• [ ] Set additionalProperties: false (when strict)

Schema Design

• [ ] Use specific types (not just string)
• [ ] Add enum constraints where applicable
• [ ] Provide examples in descriptions
• [ ] Limit to 5-15 tools per request

Tool Execution

• [ ] Validate input parameters (Pydantic/Zod)
• [ ] Handle errors gracefully
• [ ] Return errors as tool results (don't crash)
• [ ] Log tool calls for debugging

Execution Loop

• [ ] Check for tool calls in response
• [ ] Execute all requested tools
• [ ] Add results to conversation
• [ ] Continue until final answer

Parallel Tool Calls

• [ ] Disable parallel calls with strict mode
• [ ] Use asyncio.gather for parallel execution
• [ ] Handle partial failures

Structured Output

• [ ] Use Pydantic for type safety
• [ ] Validate output schema
• [ ] Handle parse errors
• [ ] Provide fallback behavior

Testing

• [ ] Test each tool independently
• [ ] Test tool selection (right tool for task)
• [ ] Test error handling
• [ ] Test with invalid inputs

Tool Schema Patterns

Define robust tool schemas for OpenAI and Anthropic function calling.

OpenAI Strict Mode Schema

from typing import Literal

def create_tool_schema(
    name: str,
    description: str,
    parameters: dict,
    strict: bool = True
) -> dict:
    """Create OpenAI-compatible tool schema with strict mode."""
    schema = {
        "type": "function",
        "function": {
            "name": name,
            "description": description,
            "strict": strict,
            "parameters": {
                "type": "object",
                "properties": parameters,
                "required": list(parameters.keys()),  # All required in strict
                "additionalProperties": False
            }
        }
    }
    return schema

# Example: Search tool
search_tool = create_tool_schema(
    name="search_documents",
    description="Search knowledge base for relevant documents",
    parameters={
        "query": {"type": "string", "description": "Search query"},
        "limit": {"type": "integer", "description": "Max results (1-100)"},
        "filters": {
            "type": "object",
            "properties": {
                "category": {"type": "string"},
                "date_from": {"type": "string", "format": "date"}
            },
            "required": ["category", "date_from"],
            "additionalProperties": False
        }
    }
)

Anthropic Tool Schema

def create_anthropic_tool(
    name: str,
    description: str,
    input_schema: dict
) -> dict:
    """Create Anthropic-compatible tool definition."""
    return {
        "name": name,
        "description": description,
        "input_schema": {
            "type": "object",
            "properties": input_schema,
            "required": list(input_schema.keys())
        }
    }

# Anthropic usage
tools = [create_anthropic_tool(
    name="get_weather",
    description="Get current weather for a location",
    input_schema={
        "location": {"type": "string", "description": "City name"},
        "units": {"type": "string", "enum": ["celsius", "fahrenheit"]}
    }
)]

Configuration

• strict: true - Enforces schema compliance (OpenAI)
• additionalProperties: false - No extra fields allowed
• All properties in required array for strict mode
• Use enum for fixed choices

Cost Optimization

• Shorter descriptions reduce prompt tokens
• Limit tools to 5-15 per request
• Cache tool schemas (they're static)
• Disable parallel_tool_calls with strict mode