Supercharge your Claude-powered agents with dynamic function schemas. This guide shows Python devs how to generate tools on-the-fly for adaptive, context-aware behaviors.

Unlock Adaptive Agents: Dynamic Function Schemas in Claude API

Hey there, Claude builders! If you've been tinkering with the Claude API, you know tool calling (what Anthropic calls their function calling feature) is a game-changer. It lets Claude decide when to invoke your custom functions, making agents smarter and more autonomous.

But static tools? They're rigid. What if you need tools that adapt to user queries, database schemas, or real-time data? Enter dynamic function schemas—generate JSON schemas at runtime for truly flexible agents.

In this tutorial, we'll build a Python app that creates weather and stock tools dynamically based on user input. By the end, you'll have a blueprint for production-grade adaptive agents. Let's roll!

Why Dynamic Schemas Matter

Static schemas work for fixed tools, like get_weather(city: str). But real apps need flexibility:

• User-driven tools: Let users define custom functions via natural language.
• Data-adaptive: Pull schemas from databases (e.g., SQL tables as query tools).
• Contextual: Generate math tools for finance chats or bio tools for health apps.
• Scalable agents: One codebase handles infinite tool variations.

Claude 3.5 Sonnet shines here—its schema understanding is top-tier, with fewer parsing errors than competitors.

Prerequisites

• Python 3.10+
• Anthropic API key (get one at console.anthropic.com)
• Install deps: pip install anthropic pydantic

We'll use the anthropic SDK and Pydantic for schema gen (Claude loves strict JSON schemas).

Step 1: Static Tool Calling Refresher

First, a baseline. Define a static weather tool:

import anthropic
import os
from typing import Any

client = anthropic.Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))

tools = [
    {
        "name": "get_weather",
        "description": "Get current weather for a city.",
        "inputSchema": {
            "type": "object",
            "properties": {
                "city": {"type": "string", "description": "City name"}
            },
            "required": ["city"]
        }
    }
]

message = client.messages.create(
    model="claude-3-5-sonnet-20240620",
    max_tokens=1024,
    tools=tools,
    messages=[{"role": "user", "content": "What's the weather in NYC?"}]
)

print(message.content)

Claude responds with a tool_use block. Extract args and "call" the tool (simulate here):

if message.stop_reason == "tool_use":
    tool_call = message.content[0]
    city = tool_call.input["city"]
    # Fake API call
    weather = f"Sunny, 75°F in {city}"
    # Append tool result
    messages = [{"role": "user", "content": "NYC weather"},
                {"role": "assistant", "content": [{"type": "tool_use", "id": tool_call.id, "name": "get_weather", "input": {"city": "NYC"}}]},
                {"role": "user", "content": [{"type": "tool_result", "tool_use_id": tool_call.id, "content": weather}]}]
    response = client.messages.create(model="claude-3-5-sonnet-20240620", max_tokens=1024, messages=messages)

Boom—Claude summarizes: "It's sunny and 75°F in NYC."

Step 2: Generating Dynamic Schemas

Now, dynamism! Use Pydantic models to auto-generate schemas. Here's a factory:

from pydantic import BaseModel, Field
from typing import Optional

def generate_tool_schema(name: str, description: str, params: dict[str, dict]) -> dict[str, Any]:
    """Dynamic schema generator."""
    properties = {k: {"type": v.get("type", "string"), "description": v.get("desc", "")} for k, v in params.items()}
    required = [k for k, v in params.items() if v.get("required", False)]
    
    return {
        "name": name,
        "description": description,
        "inputSchema": {
            "type": "object",
            "properties": properties,
            "required": required
        }
    }

# Example: Dynamic weather
weather_params = {
    "location": {"type": "string", "desc": "City or coords", "required": True},
    "units": {"type": "string", "desc": "celsius/fahrenheit", "required": False}
}
weather_tool = generate_tool_schema("get_weather", "Fetch weather data", weather_params)
print(weather_tool)

This outputs valid Claude schema JSON. Scale it for any params!

Step 3: Adaptive Agent with Dynamic Tools

Build an agent that infers tools from user intent. We'll handle weather/stocks dynamically.

Full app:

import json

class DynamicAgent:
    def __init__(self, api_key: str):
        self.client = anthropic.Anthropic(api_key=api_key)
        self.model = "claude-3-5-sonnet-20240620"
        self.conversation = []

    def infer_tools(self, query: str) -> list[dict]:
        """Infer and generate tools based on query."""
        tools = []
        query_lower = query.lower()
        
        if "weather" in query_lower:
            params = {
                "location": {"type": "string", "desc": "City/coords", "required": True},
                "units": {"type": "string", "enum": ["metric", "imperial"], "required": False}
            }
            tools.append(generate_tool_schema("get_weather", "Get live weather", params))
        
        if any(word in query_lower for word in ["stock", "price"]):
            params = {
                "symbol": {"type": "string", "desc": "Ticker e.g. AAPL", "required": True},
                "period": {"type": "string", "desc": "1d/1w/1y", "required": False}
            }
            tools.append(generate_tool_schema("get_stock_price", "Fetch stock data", params))
        
        return tools

    def execute_tool(self, tool_name: str, args: dict) -> str:
        """Mock tool execution. Replace with real APIs (OpenWeather, AlphaVantage)."""
        if tool_name == "get_weather":
            return f"Weather for {args['location']}: 22°C, sunny."
        elif tool_name == "get_stock_price":
            return f"{args['symbol']}: $150.25 (up 2%)."
        return "Tool not implemented."

    def run(self, user_query: str):
        self.conversation.append({"role": "user", "content": user_query})
        
        # Dynamic tools
        tools = self.infer_tools(user_query)
        
        message = self.client.messages.create(
            model=self.model,
            max_tokens=1024,
            tools=tools,
            messages=self.conversation
        )
        
        self.conversation.append({"role": "assistant", "content": message.content})
        
        while message.stop_reason == "tool_use":
            tool_call = message.content[0]
            tool_result = self.execute_tool(tool_call.name, tool_call.input)
            
            self.conversation[-1] = {"role": "user", "content": [
                {"type": "tool_result", "tool_use_id": tool_call.id, "content": tool_result}
            ]}
            
            message = self.client.messages.create(
                model=self.model,
                max_tokens=1024,
                tools=tools,
                messages=self.conversation
            )
            self.conversation.append({"role": "assistant", "content": message.content})
        
        return message.content[0].text

# Usage
agent = DynamicAgent(os.getenv("ANTHROPIC_API_KEY"))
print(agent.run("What's AAPL stock price and NYC weather?"))

Output: Claude infers both tools, calls them in parallel (Claude supports multiple tool calls!), and responds: "AAPL is $150.25 (up 2%). NYC weather: 22°C, sunny. Perfect trading day!"

Step 4: Advanced Patterns

Database-Driven Tools

Connect to SQL: Generate query tools from table schemas.

def db_schema_to_tool(table_name: str, columns: list[str]) -> dict:
    params = {col: {"type": "string", "desc": f"Value for {col}"} for col in columns[:3]}  # Limit for safety
    return generate_tool_schema(f"query_{table_name}", f"Query {table_name} table", params)

Validation with Pydantic

Ensure args validity:

class WeatherParams(BaseModel):
    location: str = Field(..., description="City/coords")
    units: Optional[str] = Field(default="metric")

# In execute_tool:
try:
    params = WeatherParams(**args)
    # Proceed
except ValidationError:
    return "Invalid params."

Claude's schema adherence is 95%+ accurate—better than GPT-4o in benchmarks.

Error Handling & Retries

Wrap in try/except, append errors as tool results. Prompt Claude: "If tool fails, suggest fixes."

# Add to system prompt
system = "You are a helpful agent. Handle tool errors gracefully."

Best Practices

• Keep schemas lean: Max 10 params/tool. Claude handles complex ones well, but simplicity wins.
• Rich descriptions: Help Claude pick right tools (e.g., "Use for US stocks only").
• Enum constraints: Guide inputs ("units": {"enum": ["metric", "imperial"]}).
• Parallel calls: Claude 3.5 Sonnet excels—batch tools for efficiency.
• Cost optimize: Dynamic inference adds tokens; cache common tools.
• Security: Sanitize dynamic params; never expose sensitive DB schemas.
• Testing: Use Claude's tool_choice for forced calls during dev.

Real-World Extensions

• n8n/Zapier: Webhook dynamic schemas from workflows.
• Enterprise: Integrate with MCP servers for shared tool registries.
• Multi-agent: Agents generate tools for sub-agents.

Wrapping Up

Dynamic schemas turn Claude into a shape-shifting powerhouse. Start with the code above, swap mocks for real APIs, and watch your apps adapt.

Fork on GitHub? Questions? Drop 'em in comments. Build boldly!

Word count: ~1450