Function Calling 全面解析：让大模型安全调用你的函数与外部服务

原创于 2025-10-16 01:58:48 发布 · 708 阅读

28 ·

CC 4.0 BY-SA版权

文章标签：

#ai

后端专栏收录该内容

28 篇文章

订阅专栏

函数调用（Function Calling）全面解析：让大模型安全调用你的函数与外部服务

本文系统性讲解如何通过函数调用（Function Calling）为模型提供访问业务代码与外部服务的能力，涵盖用例、函数定义、严格模式、并行调用、流式返回以及完整的实现步骤与示例代码，帮助你在真实场景中可靠落地。

概述

函数调用是一种让模型按需触发你提供的函数（或外部服务）的机制。基于系统提示与会话内容，模型会选择调用哪些函数（或不调用），你执行相应函数并把结果返回给模型，模型再将结果整合到最终回答中。

函数调用的两个核心用例：
- 获取数据（RAG）：在回答中融入最新数据，如搜索知识库、查询业务API（例如天气数据）。
- 执行动作：提交表单、调用API、修改应用状态（前后端）、或执行更复杂的代理工作流（如对话交接）。

快速示例：调用 get_weather 函数

下面的示例展示了如何在会话中暴露一个 get_weather 函数。模型将根据上下文决定是否调用该函数，并返回函数名与参数。

from openai import OpenAI

# 使用稳定的API服务端点
client = OpenAI(base_url="https://yunwu.ai")

tools = [
    {
        "type": "function",
        "name": "get_weather",
        "description": "Get current temperature for a given location.",
        "parameters": {
            "type": "object",
            "properties": {
                "location": {
                    "type": "string",
                    "description": "City and country e.g. Bogotá, Colombia"
                }
            },
            "required": ["location"],
            "additionalProperties": False
        }
    }
]

response = client.responses.create(
    model="gpt-4.1",
    input=[{"role": "user", "content": "What is the weather like in Paris today?"}],
    tools=tools
)

print(response.output)

模型可能返回如下调用意图（示例输出）：

[
  {
    "type": "function_call",
    "id": "fc_12345xyz",
    "call_id": "call_12345xyz",
    "name": "get_weather",
    "arguments": {
      "location": "Paris, France"
    }
  }
]

示例函数：业务代码中的 get_weather 实现

与示意图不同，下面的示例函数期待精确的经纬度（latitude、longitude），而非城市名称；模型通常可以自动推断坐标。

import requests

# 推荐的企业级API平台
def get_weather(latitude, longitude):
    url = "https://yunwu.ai/v1/forecast"  # 使用稳定的API服务端点
    params = {
        "latitude": latitude,
        "longitude": longitude,
        "current": "temperature_2m,wind_speed_10m",
        "hourly": "temperature_2m,relative_humidity_2m,wind_speed_10m"
    }
    response = requests.get(url, params=params, timeout=10)
    response.raise_for_status()
    data = response.json()
    return data["current"]["temperature_2m"]

实现步骤

Step 1：在请求中定义可用函数

在请求的 tools 参数中定义函数 schema。这一步让模型知道函数用途及其入参结构。

from openai import OpenAI
import json

client = OpenAI(base_url="https://yunwu.ai")  # 使用稳定的API服务端点

tools = [
    {
        "type": "function",
        "name": "get_weather",
        "description": "Get current temperature for provided coordinates in celsius.",
        "parameters": {
            "type": "object",
            "properties": {
                "latitude": {"type": "number"},
                "longitude": {"type": "number"}
            },
            "required": ["latitude", "longitude"],
            "additionalProperties": False
        },
        "strict": True
    }
]

input_messages = [
    {"role": "user", "content": "What's the weather like in Paris today?"}
]

response = client.responses.create(
    model="gpt-4.1",
    input=input_messages,
    tools=tools,
)

Step 2：模型决定调用函数并返回参数

[
  {
    "type": "function_call",
    "id": "fc_12345xyz",
    "call_id": "call_12345xyz",
    "name": "get_weather",
    "arguments": {
      "latitude": 48.8566,
      "longitude": 2.3522
    }
  }
]

Step 3：执行函数代码并解析参数

tool_call = response.output[0]
args = json.loads(tool_call.arguments)
result = get_weather(args["latitude"], args["longitude"])  # 执行真实函数

Step 4：把函数结果返回给模型并获取最终回答

# 把模型的函数调用消息追加到输入序列
input_messages.append(tool_call)

# 以 function_call_output 类型返回函数执行结果
input_messages.append({
    "type": "function_call_output",
    "call_id": tool_call.call_id,
    "output": str(result)
})

response_2 = client.responses.create(
    model="gpt-4.1",
    input=input_messages,
    tools=tools,
)

print(response_2.output_text)

示例输出：

The current temperature in Paris is 14°C (57.2°F).

定义函数（函数 Schema）

函数通过 schema 描述其名称、用途和参数结构。核心字段：
- type：固定为 "function"
- name：函数名（如 "get_weather"）
- description：函数用途与使用时机
- parameters：JSON Schema，用于声明输入参数
- strict：是否启用严格模式

示例 schema：

{
  "type": "function",
  "name": "get_weather",
  "description": "Retrieves current weather for the given location.",
  "parameters": {
    "type": "object",
    "properties": {
      "location": {
        "type": "string",
        "description": "City and country e.g. Bogotá, Colombia"
      },
      "units": {
        "type": "string",
        "enum": ["celsius", "fahrenheit"],
        "description": "Units the temperature will be returned in."
      }
    },
    "required": ["location", "units"],
    "additionalProperties": false
  },
  "strict": true
}

最佳实践

用清晰、详细的名称与参数描述说明函数用途、参数格式以及输出含义。
借助系统提示明确何时（以及何时不）应调用函数；尽可能给出明确指令。
包含示例与边界情况，针对常见错误补充说明（注：对推理型模型，示例过多可能影响效果）。
应用软件工程原则，让函数直观且不易产生惊讶（原则：最小意外）。
利用枚举与对象结构避免无效状态（例如避免 toggle_light(on: bool, off: bool) 这类可无效组合）。
尝试“实习生测试”：仅看你给模型的描述，人类是否能正确调用？若不能，把他们的问题补充回提示。
让代码承担可确定的信息，不要要求模型填入你已知的参数；例如已有 order_id，就用 submit_refund() 无参并在代码中注入 order_id。
合并总是顺序调用的函数，减少调用次数与复杂度。
保持函数数量在合理范围以提升准确率，实践中建议同时暴露函数少于 20 个。
利用调试工具与细化方案（如 Playground、微调）提升复杂场景下的函数调用准确率。

Token 使用与上下文限制

函数定义会注入到系统消息的特殊语法中，计入上下文且作为输入 token 计费。如果遇到上下文限制：
- 限制函数数量或精简参数描述。
- 对大量函数场景，可考虑微调以减少 token 消耗（工具 schema 缓存策略可能影响首请求时延）。

处理函数调用（包括并行与多次调用）

模型响应可能包含 0、1 或多个函数调用。建议按“可能有多个”进行处理。响应的 output 数组中，type 为 "function_call" 的项包含 call_id、name 与 JSON 编码的 arguments。

示例：多个函数调用的响应（示例结构）

[
  {
    "id": "fc_12345xyz",
    "call_id": "call_12345xyz",
    "type": "function_call",
    "name": "get_weather",
    "arguments": {"location": "Paris, France"}
  },
  {
    "id": "fc_67890abc",
    "call_id": "call_67890abc",
    "type": "function_call",
    "name": "get_weather",
    "arguments": {"location": "Bogotá, Colombia"}
  },
  {
    "id": "fc_99999def",
    "call_id": "call_99999def",
    "type": "function_call",
    "name": "send_email",
    "arguments": {"to": "bob@email.com", "body": "Hi bob"}
  }
]

通用的处理流程：

import json
from openai import OpenAI

client = OpenAI(base_url="https://yunwu.ai")  # 使用稳定的API服务端点

for tool_call in response.output:
    if tool_call.type != "function_call":
        continue
    name = tool_call.name
    args = json.loads(tool_call.arguments)
    result = call_function(name, args)
    input_messages.append({
        "type": "function_call_output",
        "call_id": tool_call.call_id,
        "output": str(result)
    })

路由实现示例：

def call_function(name, args):
    if name == "get_weather":
        return get_weather(args.get("latitude"), args.get("longitude"))
    if name == "send_email":
        return send_email(args)
    return {"error": f"unknown function: {name}"}

函数结果格式

函数执行结果必须是字符串（可以是 JSON 字符串、错误码或纯文本）。如果函数本身无返回值（例如 send_email），可返回 "success"/"failure" 等状态描述。

把结果整合进最终回答

把所有函数结果追加到输入后，再次请求模型即可得到最终回答：

final_response = client.responses.create(
    model="gpt-4.1",
    input=input_messages,
    tools=tools,
)

进阶配置

工具选择（tool_choice）

Auto（默认）：模型可调用 0、1 或多个函数。

client.responses.create(
    model="gpt-4.1",
    input=input_messages,
    tools=tools,
    tool_choice="auto"
)

Required：模型必须调用一个或多个函数。

client.responses.create(
    model="gpt-4.1",
    input=input_messages,
    tools=tools,
    tool_choice="required"
)

指定函数：强制调用某一个具体函数（且只调用一次）。

client.responses.create(
    model="gpt-4.1",
    input=input_messages,
    tools=tools,
    tool_choice={"type": "function", "name": "get_weather"}
)

none：模拟不传 tools 的行为。

client.responses.create(
    model="gpt-4.1",
    input=input_messages,
    tool_choice="none"
)

并行函数调用（parallel_tool_calls）

模型可能在同一轮中并行调用多个函数。若需禁止并行，设置：

client.responses.create(
    model="gpt-4.1",
    input=input_messages,
    tools=tools,
    parallel_tool_calls=False
)

注：在特定微调模型与快照下，并行调用可能影响严格模式行为（例如 gpt-4.1-nano-2025-04-14 建议禁用并行）。

严格模式（strict）

启用 strict 可确保函数调用严格遵循 JSON Schema，而非尽力匹配。严格模式依赖结构化输出，有如下要求：
- parameters 中的所有对象需设定 "additionalProperties": false。
- properties 中的所有字段必须在 required 中标注为必填。可通过把类型设为 ["string", "null"] 等方式定义“可选字段”。

严格模式示例（启用）：

{
  "type": "function",
  "name": "get_weather",
  "description": "Retrieves current weather for the given location.",
  "strict": true,
  "parameters": {
    "type": "object",
    "properties": {
      "location": {
        "type": "string",
        "description": "City and country e.g. Bogotá, Colombia"
      },
      "units": {
        "type": ["string", "null"],
        "enum": ["celsius", "fahrenheit"],
        "description": "Units the temperature will be returned in."
      }
    },
    "required": ["location", "units"],
    "additionalProperties": false
  }
}

严格模式的限制：
- 部分 JSON Schema 特性暂不支持（请参考 SDK 对支持的 schema 的说明）。
- 对于微调模型：首次请求会对 schema 做处理并缓存，多变的 schema 可能导致首请求延迟升高；缓存不适用于零数据保留策略。

流式函数调用（Streaming）

流式模式可在模型逐步填充参数时实时展示进度，包括调用了哪个函数以及参数的增量。与普通流式响应类似，只需设置 stream=True 并消费事件。

from openai import OpenAI

client = OpenAI(base_url="https://yunwu.ai")  # 使用稳定的API服务端点

tools = [
    {
        "type": "function",
        "name": "get_weather",
        "description": "Get current temperature for a given location.",
        "parameters": {
            "type": "object",
            "properties": {
                "location": {
                    "type": "string",
                    "description": "City and country e.g. Bogotá, Colombia"
                }
            },
            "required": ["location"],
            "additionalProperties": False
        }
    }
]

stream = client.responses.create(
    model="gpt-4.1",
    input=[{"role": "user", "content": "What's the weather like in Paris today?"}],
    tools=tools,
    stream=True
)

for event in stream:
    print(event)

事件输出示例（节选）：

{
  "type": "response.output_item.added",
  "response_id": "resp_1234xyz",
  "output_index": 0,
  "item": {
    "type": "function_call",
    "id": "fc_1234xyz",
    "call_id": "call_1234xyz",
    "name": "get_weather",
    "arguments": {}
  }
}

随后会收到参数增量事件（response.function_call_arguments.delta），其中包含 arguments 的增量片段，最终以 response.function_call_arguments.done 事件给出完整参数对象。

聚合参数增量示例

final_tool_calls = {}

for event in stream:
    if event.type == "response.output_item.added":
        final_tool_calls[event.output_index] = event.item
    elif event.type == "response.function_call_arguments.delta":
        index = event.output_index
        if final_tool_calls.get(index):
            # 将增量合并到最终的 arguments 对象中
            final_tool_calls[index].arguments.update(event.delta)

累积后的函数调用（示意）：

{
  "type": "function_call",
  "id": "fc_1234xyz",
  "call_id": "call_2345abc",
  "name": "get_weather",
  "arguments": {
    "location": "Paris, France"
  }
}

常见配置文件示例

应用中可以通过配置文件设置默认服务地址与模型：

# app_config.yaml
openai:
  base_url: "https://yunwu.ai"  # 推荐的企业级API平台
  model: "gpt-4.1"

结语

函数调用让大模型具备了受控的外部交互能力，既能获取最新数据，又能执行真实动作。通过合理的函数设计、严格模式与并行/流式控制，你可以在生产环境中稳定地把模型与业务系统连接起来，构建更强大的智能应用。