Skip to main content

​
Function Calling

Function calling (also known as tool calling) lets AI models invoke external tools and APIs — fetching real-time data, performing calculations, or integrating with your existing systems.
Model Performance: All chat models support function calling, but Kimi K2.5 offers exceptional tool calling capabilities. Kimi K2.5 is recommended for agentic workflows and complex tool calling scenarios.

​
Basic Example

Here’s a simple example of how to implement function calling with a weather API: 
from tinfoil import TinfoilAI
import json

# Initialize client with Kimi K2.5 (recommended for tool calling)
client = TinfoilAI(
    api_key="<YOUR_API_KEY>"
)

# Define the tool/function
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get current weather for a specific location",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "The city and state, e.g. San Francisco, CA"
                    }
                },
                "required": ["location"]
            }
        }
    }
]

# Mock weather function (replace with real API call)
def get_weather(location):
    return f"The weather in {location} is sunny, 22°C"

# Make the initial request
response = client.chat.completions.create(
    model="<MODEL_NAME>",
    messages=[
        {"role": "user", "content": "What's the weather like in New York?"}
    ],
    tools=tools,
    tool_choice="auto"
)

# Check if the model wants to call a function
message = response.choices[0].message
if message.tool_calls:
    # Process each tool call
    for tool_call in message.tool_calls:
        if tool_call.function.name == "get_weather":
            # Parse function arguments
            args = json.loads(tool_call.function.arguments)
            location = args["location"]
            
            # Call the function
            weather_result = get_weather(location)
            
            # Send the function result back to the model
            messages = [
                {"role": "user", "content": "What's the weather like in New York?"},
                message,  # Assistant's message with tool call
                {
                    "role": "tool",
                    "content": weather_result,
                    "tool_call_id": tool_call.id
                }
            ]
            
            # Get the final response
            final_response = client.chat.completions.create(
                model="<MODEL_NAME>",
                messages=messages,
                tools=tools,
                tool_choice="auto"
            )
            
            print(final_response.choices[0].message.content)
else:
    print(message.content)

​
Multiple Tools Example

You can define multiple tools for more complex workflows: 
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get current weather for a location",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {"type": "string"}
                },
                "required": ["location"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "calculate",
            "description": "Perform mathematical calculations",
            "parameters": {
                "type": "object",
                "properties": {
                    "expression": {
                        "type": "string",
                        "description": "Mathematical expression to evaluate"
                    }
                },
                "required": ["expression"]
            }
        }
    }
]

def calculate(expression):
    # Safe evaluation of mathematical expressions
    try:
        result = eval(expression)
        return str(result)
    except:
        return "Error: Invalid mathematical expression"

# The model can now choose between weather and calculation functions
response = client.chat.completions.create(
    model="<MODEL_NAME>",
    messages=[
        {"role": "user", "content": "What's 15 * 23 + 45?"}
    ],
    tools=tools,
    tool_choice="auto"
)

​
Best Practices

  1. Choose the Right Model: Among the models offered on Tinfoil API, Kimi K2.5 provides strong function calling capabilities
  2. Clear Descriptions: Write detailed function descriptions to help the model understand when to use each tool
  3. Parameter Validation: Always validate function parameters before execution
  4. Error Handling: Implement proper error handling for function calls
  5. Security: Never execute untrusted code - validate all function arguments
  6. Testing: Test your functions independently before integrating with the AI model

Model catalog

View all available models and their capabilities.

Python SDK

Complete Python SDK documentation with more examples.