1 什么是Function Call

2023年6月13日，OpenAI正式推出Function Call（函数调用）功能。该功能支持开发者为GPT-4和GPT-3.5-turbo模型定义函数描述，模型将智能生成包含调用参数的JSON对象响应。这项创新显著提升了GPT模型与外部工具、API的对接可靠性。

那么 Function Call 可以解决大模型什么问题：

• 信息实时性：大模型训练时使用的数据集往往有时间限制，无法包含最新的信息，如最新的新闻、实时股价等。通过Function Call，模型可以实时获取最新数据，提供更加时效的服务。
• 数据局限性：模型的训练数据量庞大但有限，无法覆盖所有可能的查询，如医学、法律等领域的专业咨询。Function Call允许模型调用外部数据库或API，获取特定领域的详细信息。
• 功能扩展性：大模型虽然功能强大，但不可能内置所有需要的功能。通过Function Call，可以轻松扩展模型能力，如调用外部工具进行复杂计算、数据分析等。

GPT4 和 GPT-3.5-turbo 模型具备函数调用(Function Call)能力，这得益于它们的特殊训练。这些模型能够智能识别用户输入中需要调用函数的情况，并直接生成符合函数参数要求的JSON对象，而非输出普通文本内容。

2 Function Call 工作原理

接下来，我们通过举例分别对比有无Function Call功能时GPT模型工作流程的差异：

当没有函数调用(funciton call)时候，我们调用GPT构建AI应用的模式非常简

• 主要步骤：

  1. 用户(client)发请求给我们的服务(chat server)
  2. 我们的服务(chat server)给GPT提示词
  3. 重复执行

当有函数调用(funciton call)时候，我们调用GPT构建AI应用的模式比之前要复杂一些。

• 主要步骤：

  1. 用户(client)发请求提示词，chat server将提示词和可以调用的函数发送给大模型
  2. GPT模型根据用户的提示词，判断是用普通文本还是函数调用的格式响应我们的服务(chat server)
  3. 如果是函数调用格式，那么chat server就会执行这个函数，并且将结果返回给GPT
  4. 然后模型使用提供的数据，用连贯的文本回答

需特别说明：大模型的Function Call功能仅会返回调用函数所需的参数，而不会实际执行函数调用。开发者需自行根据模型输出的参数在应用程序中完成函数调用操作。

3 Function Call 的具体使用

3.1 导包

# 导入所需要的包
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage, ToolMessage

3.2 定义外部函数

# 第一步：定义工具函数
def add(a: int, b: int) -> int:
    """
    将数字a与数字b相加
    Args:
        a: 第一个数字
        b: 第二个数字
    """
    return a + b


def multiply(a: int, b: int) -> int:
    """
    将数字a与数字b相乘
    Args:
        a: 第一个数字
        b: 第二个数字
    """
    return a * b

 3.3 描述函数功能

需要在 tools 字段中传入可调用的函数列表，用于向模型描述外部函数库。具体参数如下表所示：

参数名称	类型	是否必填	参数说明
type	String	是	设置为function
function	Object	是
name	String	是	函数名称
description	String	是	用于描述函数的功能，模型会根据这段描述决定函数调用方式。
parameters	Object	是	parameters字段需要传入一个Json Schema对象，以准确地定义函数所接受的参数。若调用函数时不需要传入参数，省略该参数即可。
required		否	指定哪些属性在数据中必须被包含。

说明如下：

# 定义 JSON 格式的工具 schema
tools = [
    {
        "type": "function",
        "function": {
            "name": "add",
            "description": "将数字a与数字b相加",
            "parameters": {
                "type": "object",
                "properties": {
                    "a": {
                        "type": "integer",
                        "description": "第一个数字"
                    },
                    "b": {
                        "type": "integer",
                        "description": "第二个数字"
                    }
                },
                "required": ["a", "b"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "multiply",
            "description": "将数字a与数字b相乘",
            "parameters": {
                "type": "object",
                "properties": {
                    "a": {
                        "type": "integer",
                        "description": "第一个数字"
                    },
                    "b": {
                        "type": "integer",
                        "description": "第二个数字"
                    }
                },
                "required": ["a", "b"]
            }
        }
    }
]

3.4 模型实例化

为方便使用配置，需要创建Config类。

class Config:
    def __init__(self):
        self.base_url = 'xxxxxxxxxxx'
        self.api_key = 'xxxxxxxxx'
        self.model_name = 'qwen-plus'

# todo: 第二步：初始化模型
llm = ChatOpenAI(base_url=conf.base_url,
                 api_key=conf.api_key,
                 model=conf.model_name,
                 temperature=0.1)
# 绑定工具，允许模型自动选择工具
llm_with_tools = llm.bind_tools(tools, tool_choice="auto")

3.5 模型调用

# todo: 第三步：调用回复
query = "2+1等于多少？"
messages = [HumanMessage(query)]

try:
    # todo: 第一次调用
    ai_msg = llm_with_tools.invoke(messages)
    messages.append(ai_msg)
    print(f"\n第一轮调用后结果：\n{messages}")

    # 处理工具调用
    # 判断消息中是否有tool_calls，以判断工具是否被调用
    if hasattr(ai_msg, 'tool_calls') and ai_msg.tool_calls:
        for tool_call in ai_msg.tool_calls:
            # todo: 处理工具调用
            selected_tool = {"add": add, "multiply": multiply}[tool_call["name"].lower()]
            tool_output = selected_tool(**tool_call["args"])
            messages.append(ToolMessage(content=tool_output, tool_call_id=tool_call["id"]))
        print(f"\n第二轮  message中增加tool_output 之后：\n{messages}")

        # todo: 第二次调用，将工具结果传回模型以生成最终回答
        final_response = llm_with_tools.invoke(messages)
        print(f"\n最终模型响应：\n{final_response.content}")
    else:
        print("直接返回文本:")
        print(ai_msg.content)
except Exception as e:
    print(f"模型调用失败: {str(e)}")

3.6 完整代码

from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage, ToolMessage

from agent_learn.config import Config

conf = Config()


# 第一步：定义工具函数
def add(a: int, b: int) -> int:
    """
    将数字a与数字b相加
    Args:
        a: 第一个数字
        b: 第二个数字
    """
    return a + b


def multiply(a: int, b: int) -> int:
    """
    将数字a与数字b相乘
    Args:
        a: 第一个数字
        b: 第二个数字
    """
    return a * b


# 定义 JSON 格式的工具 schema
tools = [
    {
        "type": "function",
        "function": {
            "name": "add",
            "description": "将数字a与数字b相加",
            "parameters": {
                "type": "object",
                "properties": {
                    "a": {
                        "type": "integer",
                        "description": "第一个数字"
                    },
                    "b": {
                        "type": "integer",
                        "description": "第二个数字"
                    }
                },
                "required": ["a", "b"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "multiply",
            "description": "将数字a与数字b相乘",
            "parameters": {
                "type": "object",
                "properties": {
                    "a": {
                        "type": "integer",
                        "description": "第一个数字"
                    },
                    "b": {
                        "type": "integer",
                        "description": "第二个数字"
                    }
                },
                "required": ["a", "b"]
            }
        }
    }
]


# todo: 第二步：初始化模型
llm = ChatOpenAI(base_url=conf.base_url,
                 api_key=conf.api_key,
                 model=conf.model_name,
                 temperature=0.1)
# 绑定工具，允许模型自动选择工具
llm_with_tools = llm.bind_tools(tools, tool_choice="auto")

# todo: 第三步：调用回复
query = "2+1等于多少？"
messages = [HumanMessage(query)]

try:
    # todo: 第一次调用
    ai_msg = llm_with_tools.invoke(messages)
    messages.append(ai_msg)
    print(f"\n第一轮调用后结果：\n{messages}")

    # 处理工具调用
    # 判断消息中是否有tool_calls，以判断工具是否被调用
    if hasattr(ai_msg, 'tool_calls') and ai_msg.tool_calls:
        for tool_call in ai_msg.tool_calls:
            # todo: 处理工具调用
            selected_tool = {"add": add, "multiply": multiply}[tool_call["name"].lower()]
            tool_output = selected_tool(**tool_call["args"])
            messages.append(ToolMessage(content=tool_output, tool_call_id=tool_call["id"]))
        print(f"\n第二轮  message中增加tool_output 之后：\n{messages}")

        # todo: 第二次调用，将工具结果传回模型以生成最终回答
        final_response = llm_with_tools.invoke(messages)
        print(f"\n最终模型响应：\n{final_response.content}")
    else:
        print("直接返回文本:")
        print(ai_msg.content)
except Exception as e:
    print(f"模型调用失败: {str(e)}")

注意：

llm.invoke(messages, tools=tools, ...):
绑定方式:可以通过在 .invoke() 方法中直接传入 tools 参数来实现临时绑定，这种方式仅对当前调用有效。

调用方式: 如果你想再次调用模型并使用工具，你必须在下一次 .invoke() 调用中再次传递 tools 参数。

适用场景: 适用于简单、单次的工具调用需求，

3.2 装饰器tool方式

以下是代码通过装饰器@tool的方式进行工具定义：

定义方式：使用 @tool 装饰器可以轻松装饰普通的 Python 函数，例如 add 和 multiply 函数。

工作原理：@tool 装饰器能够自动解析函数签名（例如 a: int, b: int）及其文档字符串，并据此生成完整的工具定义（schema）。该定义包含工具名称、功能描述以及详细的参数结构信息。

优势：

• 简洁高效：这是最简单、最符合 Python 风格的方式，几乎无需额外样板代码。只需专注于核心函数逻辑的实现，框架会自动处理工具定义部分。
• 自动化：LangChain 的工具系统会自动封装和调用工具，并完成基础参数类型的校验工作。

代码如下：

from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage, ToolMessage
from langchain_core.tools import tool

from agent_learn.config import Config

conf = Config()


# 第一步：定义工具函数
@tool
def add(a: int, b: int) -> int:
    """
    将数字a与数字b相加
    Args:
        a: 第一个数字
        b: 第二个数字
    """
    return a + b

@tool
def multiply(a: int, b: int) -> int:
    """
    将数字a与数字b相乘
    Args:
        a: 第一个数字
        b: 第二个数字
    """
    return a * b

# 定义 JSON 格式的工具 schema
tools = [add, multiply]


# todo: 第二步：初始化模型
llm = ChatOpenAI(base_url=conf.base_url,
                 api_key=conf.api_key,
                 model=conf.model_name,
                 temperature=0.1)
# 绑定工具，允许模型自动选择工具
llm_with_tools = llm.bind_tools(tools, tool_choice="auto")

# todo: 第三步：调用回复
query = "2+1等于多少？"
messages = [HumanMessage(query)]

try:
    # todo: 第一次调用
    ai_msg = llm_with_tools.invoke(messages)
    messages.append(ai_msg)
    print(f"\n第一轮调用后结果：\n{messages}")

    # 处理工具调用
    # 判断消息中是否有tool_calls，以判断工具是否被调用
    if hasattr(ai_msg, 'tool_calls') and ai_msg.tool_calls:
        for tool_call in ai_msg.tool_calls:
            # todo: 处理工具调用
            selected_tool = {"add": add, "multiply": multiply}[tool_call["name"].lower()]
            tool_output = selected_tool.invoke(tool_call["args"])  # 需要使用invoke进行调用
            messages.append(ToolMessage(content=tool_output, tool_call_id=tool_call["id"]))
        print(f"\n第二轮  message中增加tool_output 之后：\n{messages}")

        # todo: 第二次调用，将工具结果传回模型以生成最终回答
        final_response = llm_with_tools.invoke(messages)
        print(f"\n最终模型响应：\n{final_response.content}")
    else:
        print("直接返回文本:")
        print(ai_msg.content)
except Exception as e:
    print(f"模型调用失败: {str(e)}")

3.3 pydantic的tool方式

定义方式：定义一个继承自 BaseModel 的类，通过类型注解结合 Field 声明工具参数。类中需实现 invoke 方法，用于处理工具的核心执行逻辑。

工作原理：

• 数据验证：Pydantic 具备强大的数据验证能力。在工具被调用时，它会自动检查传入参数是否符合 BaseModel 中定义的类型和约束条件。
• 手动实现：与 @tool 不同，Pydantic 本身并不包含工具执行逻辑。因此，你需要手动实现 invoke 方法来处理参数并返回结果。

优点：

• 强大的数据验证：Pydantic 具备比 @tool 更精细的参数验证能力，支持定义复杂的约束条件。
• 高度可控：通过手动实现invoke方法，你可以灵活掌控工具的执行流程，包括添加预处理步骤、错误处理机制或定制化逻辑等复杂操作。
• 清晰的结构：工具的参数定义与执行逻辑封装于类中，显著提升了代码结构的清晰度。

代码如下：

from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage, ToolMessage
from langchain_core.tools import tool
"""
Pydantic 是一个 Python 库，用于数据验证和序列化。
它通过使用 Python 类型注解（type hints）来定义数据模型，
并提供强大的数据验证功能。Pydantic 基于 Python 的 dataclasses 和 typing 模块，
允许开发者定义结构化的数据模型，并自动验证输入数据是否符合指定的类型和约束。
"""
from pydantic.v1 import BaseModel, Field

from agent_learn.config import Config

conf = Config()



# 第一步：定义工具函数
class Add(BaseModel):
    """
    将两个数字相加
    """
    a: int = Field(..., description="第一个数字")
    b: int = Field(..., description="第二个数字")

    def invoke(self, args):
        # 验证参数
        tool_instance = self.__class__(**args)  # 自动验证 a 和 b
        return tool_instance.a + tool_instance.b

class Multiply(BaseModel):
    """
    将两个数字相乘
    """
    a: int = Field(..., description="第一个数字")
    b: int = Field(..., description="第二个数字")

    def invoke(self, args):
        # 验证参数
        tool_instance = self.__class__(**args)  # 自动验证 a 和 b
        return tool_instance.a * tool_instance.b

# 定义 JSON 格式的工具 schema
tools = [Add, Multiply]


# todo: 第二步：初始化模型
llm = ChatOpenAI(base_url=conf.base_url,
                 api_key=conf.api_key,
                 model=conf.model_name,
                 temperature=0.1)
# 绑定工具，允许模型自动选择工具
llm_with_tools = llm.bind_tools(tools, tool_choice="auto")

# todo: 第三步：调用回复
query = "2+1等于多少？"
messages = [HumanMessage(query)]

try:
    # todo: 第一次调用
    ai_msg = llm_with_tools.invoke(messages)
    messages.append(ai_msg)
    print(f"\n第一轮调用后结果：\n{messages}")

    # 处理工具调用
    # 判断消息中是否有tool_calls，以判断工具是否被调用
    if hasattr(ai_msg, 'tool_calls') and ai_msg.tool_calls:
        for tool_call in ai_msg.tool_calls:
            # todo: 处理工具调用
            selected_tool = {"add": Add, "multiply": Multiply}[tool_call["name"].lower()]
            # 实例化工具类并调用 invoke
            tool_instance = selected_tool(**tool_call["args"])
            tool_output = tool_instance.invoke(tool_call["args"])
            messages.append(ToolMessage(content=tool_output, tool_call_id=tool_call["id"]))
        print(f"\n第二轮  message中增加tool_output 之后：\n{messages}")

        # todo: 第二次调用，将工具结果传回模型以生成最终回答
        final_response = llm_with_tools.invoke(messages)
        print(f"\n最终模型响应：\n{final_response.content}")
    else:
        print("直接返回文本:")
        print(ai_msg.content)
except Exception as e:
    print(f"模型调用失败: {str(e)}")

总结：

特性	JSON Schema	@tool 装饰器	Pydantic
定义方式	手动编写 Python 字典（JSON Schema）	装饰 Python 函数	继承 Pydantic BaseModel
自动化程度	低：完全手动定义和分发	高：自动生成 Schema 和调用逻辑	中等：自动验证数据，但需手动实现 invoke
数据验证	需要手动验证或依赖外部库	基础类型检查	强大：提供丰富的验证功能
适用场景	需要与其他系统集成、通用性和最大灵活性的场景	快速开发、简单工具、原型验证	需要复杂数据验证、清晰结构和自定义逻辑的场景

4 Agent 调用 tool

智能体（Agent）是一种具备环境感知、自主决策和行动执行能力的智能实体。从大语言模型视角来看，智能体本质上是通过大模型的语义理解与推理能力，使其获得处理复杂问题时的任务规划能力。这种智能体不仅能调用外部工具完成各类任务，还具备记忆存储功能。

Agent = 大模型 + 任务规划（Planning） + 使用外部工具执行任务（Tools&Action） + 记忆（Memory）

Agent的核心在于大模型，其工具调用通常通过Function Call实现。不过多数Agent框架会对内部调用过程进行封装，使其更易于使用。

代码如下：

from langchain.agents import initialize_agent, AgentType
from langchain_openai import ChatOpenAI
from langchain_core.tools import tool

from agent_learn.config import Config

conf = Config()


# todo: 第一步：定义工具函数
@tool
def add(a: int, b: int) -> int:
    """
    将数字a与数字b相加
    Args:
        a: 第一个数字
        b: 第二个数字
    """
    return a + b

@tool
def multiply(a: int, b: int) -> int:
    """
    将数字a与数字b相乘
    Args:
        a: 第一个数字
        b: 第二个数字
    """
    return a * b

# 加载工具
tools = [add, multiply]

# todo: 第二步：初始化模型
llm = ChatOpenAI(base_url=conf.base_url,
                 api_key=conf.api_key,
                 model=conf.model_name,
                 temperature=0.1)

# todo: 第三步：创建Agent
agent = initialize_agent(tools, llm, AgentType.STRUCTURED_CHAT_ZERO_SHOT_REACT_DESCRIPTION, verbose=True)

# todo: 第四步：调用Agent
query = "2+1等于多少？"
result = agent.invoke(query)
print(f'result: {result["output"]}')

目录

1 什么是Function Call

2 Function Call 工作原理

3 Function Call 的具体使用

3.1 导包

3.2 定义外部函数

 3.3 描述函数功能

3.4 模型实例化

3.5 模型调用

3.6 完整代码

3.2 装饰器tool方式

3.3 pydantic的tool方式

4 Agent 调用 tool

---