想象一下，你对 AI 助手说一句话，它就能自动帮你查天气、买机票、发邮件、填表格——整个过程一气呵成，你只需要等待最终结果。这就是 Function Calling（函数调用） 能实现的神奇效果。

作为一名深耕 AI 工程领域多年的开发者，我在 2024 年接触 Function Calling 时，就被它的潜力深深震撼。当时我在为一家电商公司构建智能客服系统，最初的做法是让 AI 生成文字回复，然后用正则表达式解析意图——这种方式既脆弱又容易出错。直到我掌握了 Function Calling，才真正实现了"AI 指挥多个工具自动协作"的工作流，开发效率提升了 300%。今天我要把这段实战经验完整分享给你。

一、什么是 Function Calling？用大白话解释

传统的 AI 对话就像你和一个人聊天：你问"北京今天热吗"，他回答你"今天 32 度，有点热"。但 Function Calling 不一样——它让 AI 变成了一个能调用工具的指挥官。

类比理解：外卖平台的工作方式

你可以把 Function Calling 想象成外卖平台：

当你点"我要一份退烧药和一瓶矿泉水"时，平台自动识别：你需要药店服务 + 超市服务，然后分配不同骑手同时取货、合并配送。Function Calling 就是这个原理——AI 自动判断需要调用哪些工具，并按正确顺序执行。

Function Calling 能做什么？

二、实战准备：注册 HolySheheep AI 并获取 API Key

在开始之前，你需要有一个能调用 Function Calling 的 AI 接口。这里我强烈推荐使用 立即注册 HolySheheep AI，原因有三：

第一步：注册账号

（文字模拟截图提示：打开浏览器访问 holysheep.ai，点击右上角"注册"按钮，填写邮箱和密码）

访问 https://www.holysheep.ai/register，使用邮箱完成注册。注册后自动获得免费试用额度。

第二步：创建 API Key

（文字模拟截图提示：登录后进入"控制台" → 点击"API Keys" → 点击"Create New Key"）

在控制台左侧菜单找到"API Keys"，点击创建新密钥。复制并妥善保存你的 Key（格式类似 sk-holysheep-xxxxxxxxxx）。

第三步：查看支持的模型

HolySheheep AI 聚合了多家主流模型，2026 年主流模型 output 价格参考：

对于 Function Calling 场景，我建议初学者从 DeepSeek V3.2 开始——价格最低（$0.42/MTok），性能足够学习使用。

三、第一个 Function Calling 示例

让我们从最简单的例子开始：让 AI 判断是否需要调用"获取天气"的工具。

核心概念：Function 的定义格式

在调用 API 之前，你需要告诉 AI："你可以调用哪些工具"。这通过 tools 参数实现：

import requests


API 配置

url = "https://api.holysheep.ai/v1/chat/completions"
api_key = "YOUR_HOLYSHEEP_API_KEY"  # 替换为你的实际 Key


定义可以调用的函数

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "查询指定城市的天气信息",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {
                        "type": "string",
                        "description": "城市名称，如：北京、上海"
                    },
                    "unit": {
                        "type": "string",
                        "enum": ["celsius", "fahrenheit"],
                        "description": "温度单位"
                    }
                },
                "required": ["city"]
            }
        }
    }
]


构造请求

headers = {
    "Authorization": f"Bearer {api_key}",
    "Content-Type": "application/json"
}

payload = {
    "model": "deepseek-v3.2",
    "messages": [
        {"role": "user", "content": "北京今天多少度？需要带伞吗？"}
    ],
    "tools": tools,
    "tool_choice": "auto"
}


发送请求

response = requests.post(url, headers=headers, json=payload)
print(response.json())

运行结果解析

运行上述代码后，你会得到类似这样的响应：

{
  "id": "chatcmpl-xxx",
  "choices": [{
    "message": {
      "role": "assistant",
      "content": null,
      "tool_calls": [{
        "id": "call_abc123",
        "type": "function",
        "function": {
          "name": "get_weather",
          "arguments": "{\"city\": \"北京\", \"unit\": \"celsius\"}"
        }
      }]
    }
  }]
}

注意！content 是 null，而 tool_calls 里有具体的函数调用信息。这就是 Function Calling 的精髓——AI 没有直接回答问题，而是告诉你"需要先查天气"。

手动执行工具并返回结果

现在你需要真正执行这个函数，然后把结果传回给 AI：

# 假设这是你实现的天气查询函数
def get_weather(city, unit="celsius"):
    # 这里调用真实的天气 API
    weather_data = {
        "北京": {"temp": 28, "condition": "晴", "humidity": 65},
        "上海": {"temp": 25, "condition": "多云", "humidity": 72}
    }
    return weather_data.get(city, {"temp": 20, "condition": "未知", "humidity": 50})


从响应中提取工具调用信息

tool_call = response.json()["choices"][0]["message"]["tool_calls"][0]
function_name = tool_call["function"]["name"]
arguments = json.loads(tool_call["function"]["arguments"])

print(f"AI 想要调用: {function_name}")
print(f"参数: {arguments}")


执行函数

if function_name == "get_weather":
    result = get_weather(**arguments)
    print(f"天气结果: {result}")


把执行结果返回给 AI

second_response = requests.post(url, headers=headers, json={
    "model": "deepseek-v3.2",
    "messages": [
        {"role": "user", "content": "北京今天多少度？需要带伞吗？"},
        {"role": "assistant", "content": None, "tool_calls": [tool_call]},
        {"role": "tool", "tool_call_id": tool_call["id"], "content": json.dumps(result)}
    ],
    "tools": tools
})

print("AI 最终回复:", second_response.json()["choices"][0]["message"]["content"])

现在 AI 会结合天气数据，给出完整的回答："北京今天 28 度，晴天，不需要带伞。"

四、实战：构建多工具协同工作流

单工具调用只是开始，真正强大的是多工具串联。让我展示一个电商场景的完整工作流：

用户需求：帮我查一下 iPhone 15 的价格，看看有没有库存，如果有的话帮我计算优惠后实付金额（使用满 1000 减 100 的优惠券）。

这个需求需要 3 个工具协作：

  1. get_product_info：查询商品信息（价格、名称）
  2. check_inventory：查询库存状态
  3. calculate_discount：计算优惠后价格

完整代码实现

import requests
import json

url = "https://api.holysheep.ai/v1/chat/completions"
api_key = "YOUR_HOLYSHEEP_API_KEY"

headers = {
    "Authorization": f"Bearer {api_key}",
    "Content-Type": "application/json"
}


定义三个工具

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_product_info",
            "description": "查询商品信息",
            "parameters": {
                "type": "object",
                "properties": {
                    "product_name": {"type": "string", "description": "商品名称"}
                },
                "required": ["product_name"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "check_inventory",
            "description": "检查商品库存",
            "parameters": {
                "type": "object",
                "properties": {
                    "product_id": {"type": "string", "description": "商品ID"},
                    "warehouse": {"type": "string", "description": "仓库位置"}
                },
                "required": ["product_id"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "calculate_discount",
            "description": "计算优惠后的价格",
            "parameters": {
                "type": "object",
                "properties": {
                    "original_price": {"type": "number", "description": "原价"},
                    "discount_rule": {"type": "string", "description": "优惠规则"}
                },
                "required": ["original_price", "discount_rule"]
            }
        }
    }
]


模拟的工具实现

def get_product_info(product_name):
    products = {
        "iPhone 15": {"id": "SKU001", "price": 5999, "spec": "128GB 黑色"},
        "MacBook Pro": {"id": "SKU002", "price": 12999, "spec": "M3 芯片 14寸"}
    }
    return products.get(product_name, {"error": "商品未找到"})

def check_inventory(product_id, warehouse="北京仓"):
    inventory = {"SKU001": {"stock": 50, "warehouse": "北京仓"}}
    return inventory.get(product_id, {"stock": 0, "warehouse": warehouse})

def calculate_discount(original_price, discount_rule):
    if "满1000减100" in discount_rule:
        discount_count = original_price // 1000
        discount_amount = discount_count * 100
        return {
            "original_price": original_price,
            "discount_amount": discount_amount,
            "final_price": original_price - discount_amount
        }
    return {"original_price": original_price, "final_price": original_price}


多轮对话处理

def chat_with_tools(user_message, max_turns=5):
    messages = [{"role": "user", "content": user_message}]
    
    for turn in range(max_turns):
        response = requests.post(url, headers=headers, json={
            "model": "deepseek-v3.2",
            "messages": messages,
            "tools": tools,
            "tool_choice": "auto"
        })
        
        assistant_msg = response.json()["choices"][0]["message"]
        messages.append(assistant_msg)
        
        # 如果没有工具调用，说明 AI 已经完成，直接返回
        if not assistant_msg.get("tool_calls"):
            return assistant_msg["content"]
        
        # 执行所有工具调用
        for tool_call in assistant_msg["tool_calls"]:
            func_name = tool_call["function"]["name"]
            args = json.loads(tool_call["function"]["arguments"])
            tool_call_id = tool_call["id"]
            
            # 根据函数名执行对应功能
            if func_name == "get_product_info":
                result = get_product_info(**args)
            elif func_name == "check_inventory":
                result = check_inventory(**args)
            elif func_name == "calculate_discount":
                result = calculate_discount(**args)
            else:
                result = {"error": f"未知函数: {func_name}"}
            
            # 将工具执行结果返回给 AI
            messages.append({
                "role": "tool",
                "tool_call_id": tool_call_id,
                "content": json.dumps(result)
            })
    
    return "对话轮次过多，请重试"


测试完整工作流

user_request = "帮我查一下 iPhone 15 的价格，看看有没有库存，如果有的话帮我计算优惠后实付金额（使用满 1000 减 100 的优惠券）"
result = chat_with_tools(user_request)
print("最终回复:", result)

工作流执行日志

运行上述代码，你会看到完整的执行过程：

[第一轮] AI 分析需求，决定先查询商品信息
  → 调用 get_product_info(product_name="iPhone 15")
  → 返回: {"id": "SKU001", "price": 5999, "spec": "128GB 黑色"}

[第二轮] AI 获取到价格后，决定查询库存
  → 调用 check_inventory(product_id="SKU001")
  → 返回: {"stock": 50, "warehouse": "北京仓"}

[第三轮] AI 获取到库存充足后，进行价格计算
  → 调用 calculate_discount(original_price=5999, discount_rule="满1000减100")
  → 返回: {"original_price": 5999, "discount_amount": 500, "final_price": 5499}

[第四轮] AI 整合所有信息，给出最终回答
最终回复: iPhone 15 (128GB) 原价 ¥5999，北京仓有库存 50 件。
使用满 1000 减 100 优惠券(可减 5 次)，立省 ¥500，实付 ¥5499。

整个过程完全自动化，你只需要描述需求，AI 会自动规划调用顺序、执行每个工具、整合结果。

五、进阶技巧：并行工具调用

有时候多个工具之间没有依赖关系，可以并行执行以提升速度。例如查询天气和查询股票——这两个查询互不影响：

# 并行执行多个独立工具
import concurrent.futures

def execute_tools_parallel(tool_calls):
    """并行执行多个工具调用"""
    results = {}
    
    def run_single_tool(tool_call):
        func_name = tool_call["function"]["name"]
        args = json.loads(tool_call["function"]["arguments"])
        
        if func_name == "get_weather":
            return func_name, get_weather(**args)
        elif func_name == "get_stock_price":
            return func_name, get_stock_price(**args)
        return func_name, {"error": "未实现"}
    
    # 使用线程池并行执行
    with concurrent.futures.ThreadPoolExecutor() as executor:
        futures = {executor.submit(run_single_tool, tc): tc for tc in tool_calls}
        for future in concurrent.futures.as_completed(futures):
            func_name, result = future.result()
            results[func_name] = result
    
    return results


当 AI 返回多个工具调用时


tool_calls = [{"function": {"name": "get_weather", ...}}, 


              {"function": {"name": "get_stock_price", ...}}]


parallel_results = execute_tools_parallel(tool_calls)


print(parallel_results)

并行调用可以显著减少总响应时间，特别是当每个工具调用延迟在 200-500ms 时。

常见错误与解决方案

我在实际开发中踩过无数坑，下面分享 3 个最常见的错误及解决方案。

错误 1：tool_choice 设置不当导致死循环

错误描述：AI 反复调用同一个工具，陷入死循环。

# ❌ 错误写法：强制使用特定工具
"tool_choice": {"type": "function", "function": {"name": "get_weather"}}


✅ 正确写法：让 AI 自动判断

"tool_choice": "auto"


✅ 或者完全不设置，默认为 auto

新手常犯的错误是手动指定工具，导致 AI 无法根据上下文灵活决策。

错误 2：tool_calls 嵌套导致消息格式错误

错误描述：报错 Invalid parameter: messages 或 tool_calls format error。

# ❌ 错误写法：tool_calls 放在 content 字段里
{
    "role": "assistant",
    "content": "正在查询天气",
    "tool_calls": [...]  # 错误：同时有 content 和 tool_calls
}


✅ 正确写法：content 必须为 null 或不传

{
    "role": "assistant",
    "content": null,  # 必须为 null，不能是空字符串
    "tool_calls": [...]
}


✅ 或者完全省略 content

{
    "role": "assistant",
    "tool_calls": [...]
}

关键点：当存在 tool_calls 时，content 必须为 null。

错误 3：tool_call_id 不匹配

错误描述：报错 tool_call_id not found。

# ❌ 错误写法：使用自定义 ID
{
    "role": "tool",
    "tool_call_id": "my_custom_id",  # 错误：必须使用 AI 返回的原始 ID
    "content": "..."
}


✅ 正确写法：使用 response 中返回的原始 tool_call_id

tool_call = response["choices"][0]["message"]["tool_calls"][0]
original_id = tool_call["id"]  # 格式如 "call_abc123xyz"


返回结果时必须使用这个原始 ID

{
    "role": "tool",
    "tool_call_id": original_id,  # 使用 AI 生成的原始 ID
    "content": "天气查询结果: 28度 晴"
}

常见报错排查

报错 1：401 Unauthorized

错误信息：{"error": {"message": "Incorrect API key provided", "type": "invalid_request_error"}}

原因：API Key 错误或未正确传入。

# ✅ 检查方式 1：确认 Key 格式正确（以 sk-holysheep- 开头）
print(f"你的 Key: {api_key}")  # 应该是 sk-holysheep-xxx 格式


✅ 检查方式 2：确认 Authorization header 格式

headers = {
    "Authorization": f"Bearer {api_key}",  # 注意是 "Bearer " 不是 "bearer "
    "Content-Type": "application/json"
}


✅ 检查方式 3：确认 URL 正确（使用 HolyShe


相关资源
相关文章