多个Tool Calling实现

上一节我们已经实现了大模型调用乘法函数，这一节我们实现其他运算法则以便大模型调用。

## 1 JSON Schema的实现

```json
tools = [
    {
        "type": "function",
        "function": {
            "name": "multiply",
            "description": "用于运算乘法的函数，可以支持2个a和b数相乘",
            "parameters": {
                "properties": {
                    "a": {
                        "type": "number",
                        "description": "第一个数"
                    },
                    "b": {
                        "type": "number",
                        "description": "第二个数"
                    }
                },
                "type": "object"
            }
        }
    },
        {
        "type": "function",
        "function": {
            "name": "divide",
            "description": "用于运算除法的函数，可以支持2个a和b数相除",
            "parameters": {
                "properties": {
                    "a": {
                        "type": "number",
                        "description": "第一个数"
                    },
                    "b": {
                        "type": "number",
                        "description": "第二个数"
                    }
                },
                "type": "object"
            }
        }
    },
        {
        "type": "function",
        "function": {
            "name": "plus",
            "description": "用于运算加法的函数，可以支持2个a和b数相加",
            "parameters": {
                "properties": {
                    "a": {
                        "type": "number",
                        "description": "第一个数"
                    },
                    "b": {
                        "type": "number",
                        "description": "第二个数"
                    }
                },
                "type": "object"
            }
        }
    },
        {
        "type": "function",
        "function": {
            "name": "minus",
            "description": "用于运算减法的函数，可以支持2个a和b数相减",
            "parameters": {
                "properties": {
                    "a": {
                        "type": "number",
                        "description": "第一个数"
                    },
                    "b": {
                        "type": "number",
                        "description": "第二个数"
                    }
                },
                "type": "object"
            }
        }
    },
]
```

## 2 函数的定义

```python
def multiply(a,b):
    return a * b

def divide(a,b):
    return a / b

def plus(a,b):
    return a + b

def minus(a,b):
    return a - b
```

## 3 分支判断

```python
messages = [
    {"role": "system", "content": "你是一名优秀的助手"},
    {"role": "user", "content": "68457-784等于多少？"}
]

completion = client.chat.completions.create(
    model="Qwen/Qwen2.5-7B-Instruct",
    messages=messages,
    temperature=0.3,
    tools=tools,
)

choice = completion.choices[0]
finish_reason = choice.finish_reason

if finish_reason == "tool_calls":
    messages.append(choice.message)
    tool_call = choice.message.tool_calls[0]
    tool_call_id = tool_call.id
    tool_call_name = tool_call.function.name
    tool_result = 0
    tool_call_arguments = json.loads(tool_call.function.arguments)
    a = tool_call_arguments["a"]
    b = tool_call_arguments["b"]
    if tool_call_name == "multiply":     
        print("调用了multiply")       
        tool_result = multiply(a, b)
    elif tool_call_name == "divide":
        print("调用了divide") 
        tool_result = divide(a, b)
    elif tool_call_name == "plus":
        print("调用了plus") 
        tool_result = plus(a, b)
    elif tool_call_name == "minus":
        print("调用了minus") 
        tool_result = minus(a, b)

    messages.append({
        "role": "tool",
        "tool_call_id": tool_call.id,
        "name": tool_call_name,
        "content": json.dumps(tool_result)
    })

completion = client.chat.completions.create(
    model="Qwen/Qwen2.5-7B-Instruct",
    messages=messages,
    temperature=0.3,
    tools=tools,
)

print(completion.choices[0].message.content)
```

在案例中，我们将问题变成了68457-784等于多少？

结果如下：

```
调用了minus
68457 - 784 等于 67673。
```

我们使用`print("调用了minus")` 表示哪个分支激活了则打印哪个分支中的函数的名称。

可以试试其他运算。

## 4 多元运算

以上的实现只能进行二元运算，比如68457 - 784、68457 * 784、68457 + 784、68457 / 784这种。

但是，如果要计算68457 * 784 + 178789，它就无法计算。

这是因为我们实现的函数只能接收2个参数。

并且我们只会调用2次大模型，一次向大模型发送问题，一次向大模型发送Tool Calling的结果。

但是其实我们可以这样，就是让大模型先调用multiply函数计算68457乘784，得到结果后再调用plus函数计算68457乘784的值加上178789。

因此，我们可以让大模型逐步计算，每一次请求只调用一个函数，然后通过循环调用函数最终得到结果。

要实现这个过程，我们只需要加一个循环结果，判断finish_reason是否为tool_calls，如果是，则进入循环，否则跳出循环。

```python
messages = [
    {"role": "system", "content": "你是一名优秀的助手"},
    {"role": "user", "content": "68457 * 784 + 178789等于多少？请一步一步计算，每一次请求只调用一个函数。"}
]

finish_reason = None

while finish_reason is None or finish_reason == "tool_calls":
    completion = client.chat.completions.create(
        model="Qwen/Qwen2.5-7B-Instruct",
        messages=messages,
        temperature=0.3,
        tools=tools,
    )

    choice = completion.choices[0]
    finish_reason = choice.finish_reason

    if finish_reason == "tool_calls":
        messages.append(choice.message)
        tool_call = choice.message.tool_calls[0]
        tool_call_id = tool_call.id
        tool_call_name = tool_call.function.name
        tool_result = 0
        tool_call_arguments = json.loads(tool_call.function.arguments)
        a = tool_call_arguments["a"]
        b = tool_call_arguments["b"]
        if tool_call_name == "multiply":     
            print("调用了multiply")       
            tool_result = multiply(a, b)
        elif tool_call_name == "divide":
            print("调用了divide") 
            tool_result = divide(a, b)
        elif tool_call_name == "plus":
            print("调用了plus") 
            tool_result = plus(a, b)
        elif tool_call_name == "minus":
            print("调用了minus") 
            tool_result = minus(a, b)

        messages.append({
            "role": "tool",
            "tool_call_id": tool_call.id,
            "name": tool_call_name,
            "content": json.dumps(tool_result)
        })

    print(choice.message.content)
```

结果如下：

```
调用了multiply
首先，我们先计算乘法部分，即 \(68457 \times 784\)。


调用了plus
乘法计算结果是 \(53670288\)。接下来，我们将这个结果加上 \(178789\)。

现在我们调用加法函数进行计算：



最终计算结果是 \(53849077\)。
```

多个Tool Calling实现