返回专栏
· 20 分钟阅读

Function Calling 工具调用:大语言模型如何连接外部工具与真实世界?


一、什么是 Function Calling?

Function Calling,通常称为函数调用或工具调用,是一种让大语言模型能够请求外部函数执行特定任务的机制。

传统大语言模型主要通过生成文本来响应用户请求。它可以解释概念、编写代码、总结信息,但无法仅凭自身参数直接完成实时查询、数据库读写、发送邮件或调用业务系统等操作。

Function Calling 为模型提供了一种结构化的外部能力调用接口。

例如,用户提出:

帮我查询北京今天的天气。

模型可以判断需要调用天气查询工具,并生成结构化参数:

{
  "location": "北京",
  "date": "2026-11-19"
}

随后,应用程序根据这些参数执行真正的天气查询,将结果返回给模型,再由模型组织成自然语言回答。

需要明确一个核心概念:

Function Calling 本身通常不负责执行函数,而是让模型生成调用意图和参数,由外部应用程序负责执行。

从职责上看,它包含三个主体:

主体 核心职责
大语言模型 判断是否需要调用工具,生成调用参数
应用程序 解析调用请求、执行函数、管理调用流程
外部工具 完成实际操作,返回执行结果

二、Function Calling 的整体工作流程

Function Calling 并不是模型直接访问操作系统或外部服务,而是通过应用程序建立一条受控的调用链路。

典型流程如下:

flowchart TD
    A["用户提出请求"] --> B["应用程序接收请求"]
    B --> C["向模型提供工具定义"]
    C --> D["模型分析用户意图"]
    D --> E{"是否需要调用工具"}
    E -->|"不需要"| F["模型直接生成回答"]
    E -->|"需要"| G["模型生成工具调用请求"]
    G --> H["应用程序解析调用参数"]
    H --> I["参数校验与权限检查"]
    I --> J{"是否允许执行"}
    J -->|"否"| K["拒绝或要求补充授权"]
    J -->|"是"| L["执行外部函数"]
    L --> M["获取工具执行结果"]
    M --> N["将结果返回给模型"]
    N --> O["模型整合结果"]
    O --> P["返回最终回答"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#EAF3EC,stroke:#83A995,color:#315D49
    style C fill:#EAF3EC,stroke:#83A995,color:#315D49
    style D fill:#EAF3EC,stroke:#83A995,color:#315D49
    style E fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style F fill:#E5F0E9,stroke:#83A995,color:#315D49
    style G fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style H fill:#EAF3EC,stroke:#83A995,color:#315D49
    style I fill:#EAF3EC,stroke:#83A995,color:#315D49
    style J fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style K fill:#F7EAE7,stroke:#C98D7C,color:#754438
    style L fill:#EAF3EC,stroke:#83A995,color:#315D49
    style M fill:#EAF3EC,stroke:#83A995,color:#315D49
    style N fill:#EAF3EC,stroke:#83A995,color:#315D49
    style O fill:#EAF3EC,stroke:#83A995,color:#315D49
    style P fill:#DCEFE5,stroke:#4F8B70,color:#24563F

可以将整个过程拆分为六个阶段:

  1. 工具定义: 应用程序向模型提供可调用工具的名称、用途和参数结构。
  2. 意图识别: 模型判断用户请求是否需要外部能力。
  3. 参数生成: 模型根据工具定义生成结构化调用参数。
  4. 工具执行: 应用程序验证调用请求,并执行对应函数。
  5. 结果回传: 应用程序将工具执行结果提交给模型。
  6. 答案生成: 模型根据工具返回的数据生成最终回答。

这里有一个容易混淆的地方:

模型生成工具调用请求,并不代表工具已经执行成功。

例如,模型生成了一个发送邮件的调用请求,只能说明它提出了发送邮件的意图。只有应用程序真正执行邮件发送操作,并获得相应结果,才能确认邮件是否发送成功。

三、Function Calling 的核心组成

Function Calling 的实现通常围绕工具定义、参数结构、调用请求和执行结果展开。

1. Tool Definition:工具定义

工具定义用于告诉模型:

  • 有哪些工具可以使用。
  • 每个工具能够完成什么任务。
  • 工具需要接收哪些参数。
  • 参数的数据类型和约束是什么。

例如,定义一个天气查询工具:

{
  "type": "function",
  "name": "get_weather",
  "description": "查询指定城市的天气信息",
  "parameters": {
    "type": "object",
    "properties": {
      "location": {
        "type": "string",
        "description": "需要查询天气的城市"
      },
      "unit": {
        "type": "string",
        "enum": ["celsius", "fahrenheit"],
        "description": "温度单位"
      }
    },
    "required": ["location"],
    "additionalProperties": false
  },
  "strict": true
}

这里包含几个重要字段:

字段 含义
type 工具类型,这里是 function
name 工具名称
description 工具功能描述
parameters 参数定义
properties 参数名称和数据结构
required 必须提供的参数
enum 限制参数可选值
additionalProperties 是否允许未声明的额外参数
strict 是否启用严格结构约束,具体支持情况取决于 API

工具定义本质上是一份机器可读的接口契约。

模型根据这份契约生成调用参数,而应用程序可以根据相同的结构进行校验和执行。

2. Function Name:函数名称

函数名称用于标识具体的工具。

例如:

get_weather
search_database
calculate_tax
send_email
create_order

函数名称应该具有明确的业务含义。

不推荐使用:

tool1
function_a
process_data

因为名称过于模糊,会增加模型选择工具时的判断难度,也不利于开发人员维护。

3. Parameters:参数定义

参数定义决定模型需要提供什么数据。

例如,一个订单查询工具:

{
  "type": "object",
  "properties": {
    "order_id": {
      "type": "string",
      "description": "订单编号"
    },
    "include_items": {
      "type": "boolean",
      "description": "是否包含订单商品明细"
    }
  },
  "required": ["order_id"],
  "additionalProperties": false
}

用户提出:

查询订单 ORD20261119001 的商品明细。

模型可能生成:

{
  "order_id": "ORD20261119001",
  "include_items": true
}

需要注意,参数生成并不等于参数正确。

模型可能生成不存在的订单编号、错误的数据类型,甚至遗漏业务必需字段。

因此,应用程序不能只依赖模型的参数生成能力,还需要进行服务端校验。

4. Tool Call:工具调用请求

当模型决定调用工具时,会生成结构化调用请求。

不同模型厂商的 API 格式存在差异,但通常包含:

  • 工具调用 ID。
  • 函数名称。
  • 函数参数。
  • 调用类型。

抽象示例如下:

{
  "id": "call_001",
  "type": "function",
  "function": {
    "name": "get_weather",
    "arguments": {
      "location": "北京",
      "unit": "celsius"
    }
  }
}

实际 API 中,arguments 有时会以 JSON 字符串形式返回,而不是已经解析好的 JSON 对象。

开发时必须按照具体 API 的协议处理,不能假设所有厂商都采用完全相同的数据结构。

5. Tool Result:工具执行结果

工具执行后,应用程序需要将结果返回给模型。

例如:

{
  "location": "北京",
  "temperature": 12,
  "condition": "晴",
  "humidity": 35
}

模型收到结果后,可以将结构化数据组织为自然语言:

北京今天晴,气温 12℃,空气湿度为 35%。

需要区分三个不同阶段:

  • Tool Call:模型提出调用请求。
  • Tool Execution:应用程序执行实际操作。
  • Tool Result:工具返回执行结果。

这三个阶段不能混为一谈。

四、模型是如何决定调用哪个工具的?

Function Calling 最重要的能力之一,是让模型根据用户意图判断是否需要使用外部工具。

假设应用程序向模型提供三个工具:

工具 功能
get_weather 查询天气
search_flight 查询航班
calculate 执行数学计算

用户提出:

帮我查询明天北京到上海的航班,并估算飞行时间。

模型需要识别出:

  1. 用户需要查询航班信息。
  2. 航班查询需要外部实时数据。
  3. 飞行时间可以通过航班信息获得,也可以使用计算工具辅助处理。
  4. 应当优先调用 search_flight。

这个过程可以抽象为:

flowchart TD
    A["用户输入自然语言"] --> B["分析任务语义"]
    B --> C["提取任务目标"]
    C --> D["识别所需外部能力"]
    D --> E["匹配可用工具"]
    E --> F{"是否存在合适工具"}
    F -->|"否"| G["直接回答或说明能力限制"]
    F -->|"是"| H["选择工具"]
    H --> I["提取调用参数"]
    I --> J["生成结构化调用请求"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#EAF3EC,stroke:#83A995,color:#315D49
    style C fill:#EAF3EC,stroke:#83A995,color:#315D49
    style D fill:#EAF3EC,stroke:#83A995,color:#315D49
    style E fill:#EAF3EC,stroke:#83A995,color:#315D49
    style F fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style G fill:#F7EAE7,stroke:#C98D7C,color:#754438
    style H fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style I fill:#EAF3EC,stroke:#83A995,color:#315D49
    style J fill:#DCEFE5,stroke:#4F8B70,color:#24563F

从模型内部机制来看,Function Calling 并不是一个完全独立于语言模型的传统函数执行模块。

模型仍然基于上下文进行预测,只不过输出目标不再局限于普通文本,还可以是符合工具调用协议的结构化内容。

模型需要学习:

  • 工具描述与任务语义之间的对应关系。
  • 不同工具的适用场景。
  • 参数字段的含义。
  • 参数之间的约束关系。
  • 何时调用工具、何时直接回答。

因此,工具描述的质量会直接影响模型的工具选择效果。

五、Function Calling 与普通文本生成有什么区别?

两者的核心区别不在于是否使用大语言模型,而在于输出目标和后续处理方式不同。

对比维度 普通文本生成 Function Calling
输出形式 自然语言 结构化调用请求
主要目标 生成回答 请求外部能力
参数结构 不固定 按工具 Schema 组织
后续处理 展示给用户 应用程序解析并执行
外部系统交互 通常不直接发生 可以通过工具完成
执行结果 模型生成内容 由外部工具返回
可验证性 需要额外验证 可以结合工具执行结果验证

例如,用户提出:

计算 125 × 36。

普通文本生成可能直接回答:

125 × 36 = 4500。

Function Calling 则可能生成:

{
  "name": "calculate",
  "arguments": {
    "expression": "125 * 36"
  }
}

应用程序执行计算后,再把结果返回模型。

对于简单计算,模型可以直接回答;对于复杂计算、精确数据查询或需要访问外部系统的任务,工具调用通常更可靠。

六、Function Calling 的调用模式

不同任务对工具调用的控制程度不同。常见模式包括自动调用、指定工具、禁止工具调用等。

1. Auto:自动选择

由模型自行判断是否需要调用工具,以及选择哪个工具。

用户请求
   ↓
模型分析
   ↓
判断是否需要工具
   ↓
选择工具或直接回答

这是最常见的模式,适合通用 AI 助手。

2. Required:必须调用工具

要求模型必须发起工具调用,但具体选择哪个工具仍然可以由模型决定,具体语义以 API 定义为准。

适用于:

  • 必须通过外部系统获取数据的业务。
  • 不允许模型凭内部知识直接回答的场景。
  • 必须调用检索工具的流程。

需要注意,强制调用并不代表一定能获得有效结果。工具仍可能失败,参数也仍需要校验。

3. 指定工具:强制选择某个函数

应用程序明确要求模型调用指定工具。

例如,用户进入订单查询页面后,系统已经确定需要使用订单查询能力。

此时可以要求模型调用 get_order,而不是让模型在所有工具中自由选择。

4. None:禁止工具调用

禁止模型发起工具调用,只允许生成普通回答。

适用于:

  • 纯文本问答。
  • 不允许访问外部系统的场景。
  • 工具调用权限暂时关闭的情况。

不同 API 对工具选择参数的命名和行为可能不同,实际开发应以对应平台的文档为准。

七、一次工具调用与多次工具调用

实际业务往往不止一次工具调用。

1. 单次工具调用

用户提出一个明确任务,只需要调用一个工具。

例如:

查询北京今天的天气。

执行过程:

flowchart TD
    A["用户请求"] --> B["模型选择天气工具"]
    B --> C["生成天气查询参数"]
    C --> D["应用程序调用天气 API"]
    D --> E["返回天气数据"]
    E --> F["模型生成自然语言回答"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#EAF3EC,stroke:#83A995,color:#315D49
    style C fill:#EAF3EC,stroke:#83A995,color:#315D49
    style D fill:#EAF3EC,stroke:#83A995,color:#315D49
    style E fill:#EAF3EC,stroke:#83A995,color:#315D49
    style F fill:#DCEFE5,stroke:#4F8B70,color:#24563F

2. 多次顺序调用

有些任务需要先获得一个工具的执行结果,再决定下一步调用什么工具。

例如:

查询北京到上海的航班,并查询对应机场到市中心的交通路线。

模型可能需要:

  1. 调用航班查询工具。
  2. 获取出发机场和到达机场。
  3. 调用路线查询工具。
  4. 根据两个工具的结果生成完整回答。
flowchart TD
    A["用户提出复合任务"] --> B["调用航班查询工具"]
    B --> C["获取航班与机场信息"]
    C --> D["模型分析下一步任务"]
    D --> E["调用路线查询工具"]
    E --> F["获取交通路线"]
    F --> G["整合多个工具结果"]
    G --> H["生成最终回答"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#EAF3EC,stroke:#83A995,color:#315D49
    style C fill:#EAF3EC,stroke:#83A995,color:#315D49
    style D fill:#EAF3EC,stroke:#83A995,color:#315D49
    style E fill:#EAF3EC,stroke:#83A995,color:#315D49
    style F fill:#EAF3EC,stroke:#83A995,color:#315D49
    style G fill:#EAF3EC,stroke:#83A995,color:#315D49
    style H fill:#DCEFE5,stroke:#4F8B70,color:#24563F

这种方式的特点是:

后续工具的参数可能依赖前一个工具的返回结果。

因此,工具调用必须由应用程序持续编排,不能把所有步骤都视为一次简单的函数执行。

3. 多工具并行调用

如果多个工具之间没有依赖关系,可以并行执行。

例如:

分别查询北京、上海和深圳今天的天气。

模型可以同时生成多个天气查询请求,应用程序并行调用天气服务。

flowchart TD
    A["用户提出多个城市天气查询"] --> B["模型生成多个工具调用"]
    B --> C["北京天气查询"]
    B --> D["上海天气查询"]
    B --> E["深圳天气查询"]
    C --> F["汇总执行结果"]
    D --> F
    E --> F
    F --> G["模型生成汇总回答"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#EAF3EC,stroke:#83A995,color:#315D49
    style C fill:#EAF3EC,stroke:#83A995,color:#315D49
    style D fill:#EAF3EC,stroke:#83A995,color:#315D49
    style E fill:#EAF3EC,stroke:#83A995,color:#315D49
    style F fill:#EAF3EC,stroke:#83A995,color:#315D49
    style G fill:#DCEFE5,stroke:#4F8B70,color:#24563F

并行调用能够降低整体等待时间,但需要注意:

  • 并行工具之间不能存在未满足的数据依赖。
  • 应用程序需要正确处理多个调用 ID。
  • 需要考虑部分成功、部分失败的情况。
  • 多个工具的结果需要统一汇总。
  • 并行执行不意味着模型已经获得所有工具的最终结果。

八、Function Calling 的实际代码实现

理解 Function Calling,最重要的是区分模型调用和函数执行。

下面通过 Python 构建一个简化示例。

1. 定义业务函数

首先编写真正执行任务的 Python 函数:

def get_weather(location: str, unit: str = "celsius"):
    # 示例数据,实际项目中应调用天气服务
    weather_data = {
        "北京": {
            "temperature": 12,
            "condition": "晴"
        },
        "上海": {
            "temperature": 18,
            "condition": "多云"
        }
    }

    result = weather_data.get(location)

    if result is None:
        return {
            "success": False,
            "error": "暂不支持该城市"
        }

    temperature = result["temperature"]

    if unit == "fahrenheit":
        temperature = temperature * 9 / 5 + 32

    return {
        "success": True,
        "location": location,
        "temperature": temperature,
        "unit": unit,
        "condition": result["condition"]
    }

这里的 get_weather 才是真正执行天气查询的函数。

Function Calling 不会自动创建或执行这个 Python 函数。

2. 向模型提供工具定义

应用程序需要将工具的名称、用途和参数 Schema 发送给模型。

以下使用一种简化的工具定义格式:

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "查询指定城市的天气",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "城市名称"
                    },
                    "unit": {
                        "type": "string",
                        "enum": [
                            "celsius",
                            "fahrenheit"
                        ]
                    }
                },
                "required": ["location"]
            }
        }
    }
]

这一步只是向模型声明工具能力,并没有执行天气查询。

3. 模型生成工具调用请求

应用程序将用户消息和工具定义发送给模型。

messages = [
    {
        "role": "user",
        "content": "查询北京今天的天气"
    }
]

模型可能返回类似下面的调用请求:

{
  "name": "get_weather",
  "arguments": {
    "location": "北京",
    "unit": "celsius"
  }
}

注意:这是模型生成的调用请求示例,并不是已经执行的函数结果。

4. 应用程序执行工具

应用程序需要根据函数名称找到对应的本地函数,再传入模型生成的参数。

import json

function_map = {
    "get_weather": get_weather
}

def execute_tool(name: str, arguments):
    if name not in function_map:
        raise ValueError(f"未知工具:{name}")

    if isinstance(arguments, str):
        arguments = json.loads(arguments)

    if not isinstance(arguments, dict):
        raise ValueError("工具参数必须是 JSON 对象")

    allowed_keys = {"location", "unit"}

    if not set(arguments).issubset(allowed_keys):
        raise ValueError("存在未允许的参数")

    if "location" not in arguments:
        raise ValueError("缺少必需参数 location")

    return function_map[name](**arguments)

这里的 function_map 是工具注册表。

它将模型可以请求的函数名称映射到应用程序中真实存在的函数。

这种设计比直接使用 eval() 或 exec() 执行模型生成的代码安全得多。

5. 将结果返回给模型

工具执行成功后,应用程序将结果转换为 JSON,再提交给模型。

例如:

{
  "success": true,
  "location": "北京",
  "temperature": 12,
  "unit": "celsius",
  "condition": "晴"
}

模型可以基于工具结果组织最终回答。

整个调用关系如下: