OpenAI Plugins & Function Calling

Plugin Ai Function Calling

最后更新时间 (CST)：2023-09-16 05:11:23 +0800

接口（Interface）

两种常见接口：

人机交互接口，User Interface，简称 UI
应用程序编程接口，Application Programming Interface，简称 API

接口能「通」的关键，是两边都要遵守约定。

人要按照 UI 的设计来操作。UI 的设计要符合人的习惯
程序要按照 API 的设计来调用。API 的设计要符合程序惯例

我们经历过很多调接口的痛苦经历，比如：

文档坑
大小写坑
参数顺序坑
参数类型坑 ……

`UI` 接口

命令行，Command Line Interface，简称 CLI（DOS、Unix/Linux shell, Windows Power Shell）。
图形界面，Graphical User Interface，简称 GUI（Windows、MacOS、iOS、Android）。
语言界面，Conversational User Interface，简称 CUI，或 Natural-Language User Interface，简称 LUI。
脑机接口，Brain–Computer Interface，简称 BCI。

UI 进化的趋势是：越来越适应人的习惯，越来越自然

`API` 接口

从本地到远程，从同步到异步，媒介发生很多变化，但本质一直没变：程序员的约定。
自然语言接口，Natural-Language Interface，简称 NLI。

自然语言连接一切（Natural Language Interface）

NLI 是《以 ChatGPT 为代表的「大模型」会是多大的技术革命？》一文中提出的概念。

用户操作习惯的迁移，会逼所有软件，都得提供「自然语言界面（Natural Language Interface，简称 NLI）」。这是一个新词，指的是以自然语言为输入的接口。

不仅用户界面要 NLI，API 也要 NLI 化。这是因为用户发出的宏观指令，往往不会是一个独立软件能解决的，它需要很多软件、设备的配合。

一种实现思路是，入口 AI（比如 Siri、小爱同学，机器人管家）非常强大，能充分了解所有软件和设备的能力，且能准确地把用户任务拆解和分发下去。这对入口 AI 的要求非常高。

另一种实现思路是，入口 AI 收到自然语言指令，把指令通过 NLI 广播出去（也可以基于某些规则做有选择的广播，保护用户隐私），由各个软件自主决策接不接这个指令，接了要怎么做，该和谁配合。

当 NLI 成为事实标准，那么互联网上软件、服务的互通性会大幅提升，不再受各种协议、接口的限制。最自然的接口，就是自然语言接口。

以前因为计算机处理不对自然语言，所以有了那么多编程语言，那么多接口，那么多协议，那么多界面风格。而且，它们每一次进化，都是为了「更自然」。现在，终极的自然，到来了。

ChatGPT 让我们体验到 LUI 的美好。而 Plugins 和 Function Calling，让我们能直接进入 NLI 的过程。

`Plugins`

学习 plugin 之前，先要了解 ChatGPT 及所有大模型都有两大缺陷：

没有最新信息。大模型的训练周期很长，且更新一次耗资巨大，所以它的知识都是过去的。GPT-3.5 和 GPT-4 的知识截至 2021 年 9 月。
没有「真逻辑」。它表现出的逻辑、推理，是训练文本的统计规律，而不是真正的逻辑。

比如把 100 以内所有加法算式都训练给大模型，它就能回答 100 以内的加法算式。但如果问它更大数字的加法算式，它就不一定答对了。因为它并不懂「加法」，只是记住了 100 以内的加法算式的统计规律。它是用字面意义来做数学。

比如 Plugin 能一定程度解决这两个问题：

用天气插件查询天气
用 Wolfram Alpha 插件做数学题

如果你对 Wolfarm Alpha 做数学的能力感到惊讶，想了解它和 ChatGPT 原理的不同，推荐阅读这篇文章：《Wolfram|Alpha as the Way to Bring Computational Knowledge Superpowers to ChatGPT》。

Plugin 的原理

官方开发文档

可能是史上最容易开发的 plugin。只需要定义两个文件：

yourdomain.com/.well-known/ai-plugin.json，描述插件的基本信息
openai.yaml，描述插件的 API（Swagger 生成的文档）

而 OpenAI 那边，更简单，没有任何人和你对接。是 AI 和你对接！AI 阅读上面两个文件，就知道该怎么调用你了。

ai-plugin.json

例子

{
  "schema_version": "v1", //配置文件版本
  "name_for_human": "Sport Stats", //插件名字，给用户看的名字
  "name_for_model": "sportStats", //插件名字，给ChatGPT模型看的名字，需要唯一
  "description_for_human": "Get current and historical stats for sport players and games.", //描述插件的功能，这个字段是在插件市场展示给用户看的
  "description_for_model": "Get current and historical stats for sport players and games. Always display results using markdown tables.", //描述插件的功能，ChatGPT会分析这个字段，确定什么时候调用你的插件
  "auth": {
    "type": "none" //这个是API认证方式，none 代表不需要认证
  },
  "api": {
    "type": "openapi",
    "url": "PLUGIN_HOSTNAME/openapi.yaml" //这个是Swagger API文档地址，ChatGPT通过这个地址访问我们的api文档
  },
  "logo_url": "PLUGIN_HOSTNAME/logo.png", //插件logo地址
  "contact_email": "[email protected]", //插件官方联系邮件
  "legal_info_url": "https://example.com/legal" //与该插件相关的legal information
}

openapi.yaml

例子

openapi: 3.0.1
info:
  title: Sport Stats
  description: Get current and historical stats for sport players and games.
  version: "v1"
servers:
  - url: PLUGIN_HOSTNAME
paths:
  /players:
    get:
      operationId: getPlayers
      summary: Retrieves all players from all seasons whose names match the query string.
      parameters:
        - in: query
          name: query
          schema:
            type: string
          description: Used to filter players based on their name. For example, ?query=davis will return players that have 'davis' in their first or last name.
      responses:
        "200":
          description: OK
  /teams:
    get:
      operationId: getTeams
      summary: Retrieves all teams for the current season.
      responses:
        "200":
          description: OK
  /games:
    get:
      operationId: getGames
      summary: Retrieves all games that match the filters specified by the args. Display results using markdown tables.
      parameters:
        - in: query
          name: limit
          schema:
            type: string
          description: The max number of results to return.
        - in: query
          name: seasons
          schema:
            type: array
            items:
              type: string
          description: Filter by seasons. Seasons are represented by the year they began. For example, 2018 represents season 2018-2019.
        - in: query
          name: team_ids
          schema:
            type: array
            items:
              type: string
          description: Filter by team ids. Team ids can be determined using the getTeams function.
        - in: query
          name: start_date
          schema:
            type: string
          description: A single date in 'YYYY-MM-DD' format. This is used to select games that occur on or after this date.
        - in: query
          name: end_date
          schema:
            type: string
          description: A single date in 'YYYY-MM-DD' format. This is used to select games that occur on or before this date.
      responses:
        "200":
          description: OK
  /stats:
    get:
      operationId: getStats
      summary: Retrieves stats that match the filters specified by the args. Display results using markdown tables.
      parameters:
        - in: query
          name: limit
          schema:
            type: string
          description: The max number of results to return.
        - in: query
          name: player_ids
          schema:
            type: array
            items:
              type: string
          description: Filter by player ids. Player ids can be determined using the getPlayers function.
        - in: query
          name: game_ids
          schema:
            type: array
            items:
              type: string
          description: Filter by game ids. Game ids can be determined using the getGames function.
        - in: query
          name: start_date
          schema:
            type: string
          description: A single date in 'YYYY-MM-DD' format. This is used to select games that occur on or after this date.
        - in: query
          name: end_date
          schema:
            type: string
          description: A single date in 'YYYY-MM-DD' format. This is used to select games that occur on or before this date.
      responses:
        "200":
          description: OK
  /season_averages:
    get:
      operationId: getSeasonAverages
      summary: Retrieves regular season averages for the given players. Display results using markdown tables.
      parameters:
        - in: query
          name: season
          schema:
            type: string
          description: Defaults to the current season. A season is represented by the year it began. For example, 2018 represents season 2018-2019.
        - in: query
          name: player_ids
          schema:
            type: array
            items:
              type: string
          description: Filter by player ids. Player ids can be determined using the getPlayers function.
      responses:
        "200":
          description: OK

收起

注意：description 的内容非常重要，决定了 ChatGPT 会不会调用你的插件，调用得是否正确。

`Plugins` 的市场表现

时间线：

3 月 24 日发布，提供 11 个插件，可以申请加入 waitlist 获得使用权。
5 月 15 日开始向 Plus 用户全量开放插件和 Browsing，插件数 70 多个。
7 月 5 日因安全原因，关闭 Browsing（用户可通过此功能访问付费页面）。
7 月 11 日开始全量开放 Code Interpreter。插件数已超 400。

媒体将其类比为 App Store，获得鼓吹。

6 月 7 日（全面放开后三星期）一篇应 OpenAI 要求而被删除的帖子中透露，在一个闭门会中说:

插件的实际使用情况表明，除了 Browsing 以外，还没有达到理想的产品市场契合点。他表示，很多人认为 OpenAI 希望开发者的应用程序位于 ChatGPT 之内，但 OpenAI 真正想要的是 ChatGPT 存在于开发者的应用之中。

—— Sam Altman

更确切的说，他认为未来的应用趋势是将大模型的功能嵌入更多 APP 应用，而不是在 ChatGPT 上生长出更多插件。因为现实中大多数插件并没有呈现出产品与市场的匹配度。前者是 API 租赁业务，后者是插件业务。

被删内容这里见这里。

`Plugins` 失败分析

plugins 失败的主要原因：

缺少「强 Agent」调度，只能手工选三个 plugin，使用成本太高。（解决此问题，相当于 App Store + Siri，可挑战手机操作系统地位）
不在「场景」中，不能提供端到端一揽子服务。（解决此问题，就是全能私人助理了，人类唯一需要的软件）
开销大（至少两次 GPT-4 生成，和一次 Web API 调用）

做「智能应用」也会面对同样的问题。好在 OpenAI 很快推出了大杀器 Function Calling 功能，来帮助我们开发更好的智能应用。

`Function Calling`

Function Calling 完整的官方接口文档

示例 1：加法计算器

[1]:

# 加载环境变量
import openai
import os
import json

from dotenv import load_dotenv, find_dotenv
_ = load_dotenv(find_dotenv())  # 读取本地 .env 文件，里面定义了 OPENAI_API_KEY

openai.api_key = os.getenv('OPENAI_API_KEY')

[2]:

def get_completion(messages, model="gpt-3.5-turbo"):
    response = openai.ChatCompletion.create(
        model=model,
        messages=messages,
        temperature=0,  # 模型输出的随机性，0 表示随机性最小
        functions=[{  # 用 JSON 描述函数。可以定义多个，但是只有一个会被调用，也可能都不会被调用
            "name": "sum",
            "description": "计算一组数的加和",
            "parameters": {
                "type": "object",
                "properties": {
                    "numbers": {
                        "type": "array",
                        "items": {
                            "type": "number"
                        }
                    }
                }
            },
        }],
    )
    return response.choices[0].message

[3]:

from math import *

# prompt = "Tell me the sum of 1, 2, 3, 4, 5, 6, 7, 8, 9, 10."
# prompt = "桌上有 2 个苹果，四个桃子和 3 本书，一共有几个水果？"
prompt = "1+2+3...+99+100"

messages = [
    {"role": "system", "content": "你是一个小学数学老师，你要教学生加法"},
    {"role": "user", "content": prompt}
]
response = get_completion(messages)
messages.append(response)  # 把大模型的回复加入到对话中
print("=====GPT回复=====")
print(response)

# 如果返回的是函数调用结果，则打印出来
if (response.get("function_call")):
    # 是否要调用 sum
    if (response["function_call"]["name"] == "sum"):
        args = json.loads(response["function_call"]["arguments"])
        result = sum(args["numbers"])
        print("=====函数返回=====")
        print(result)
        messages.append(
            {"role": "function", "name": "sum",
                "content": str(result)}  # 数值result 必须转成字符串
        )
        print("=====最终回复=====")
        print(get_completion(messages).content)

[ ]:

=====GPT回复=====
{
  "role": "assistant",
  "content": null,
  "function_call": {
    "name": "sum",
    "arguments": "{\n  \"numbers\": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100]\n}"
  }
}
=====函数返回=====
5050
=====最终回复=====
1 + 2 + 3 + ... + 99 + 100 = 5050

收起

示例 2：计算数学表达式

[4]:

def get_completion(messages, model="gpt-3.5-turbo"):
    response = openai.ChatCompletion.create(
        model=model,
        messages=messages,
        temperature=0,  # 模型输出的随机性，0 表示随机性最小
        functions=[{  # 用 JSON 描述函数。可以定义多个，但是只有一个会被调用，也可能都不会被调用
            "name": "calculate",
            "description": "计算一个数学表达式的值",
            "parameters": {
                "type": "object",
                "properties": {
                    "expression": {
                        "type": "string",
                        "description": "a mathematical expression in python grammar.",
                    }
                }
            },
        }],
    )
    return response.choices[0].message

[5]:

from math import *

# prompt = "从1加到10"
prompt = "3的平方根乘以2再开平方"

messages = [
    {"role": "system", "content": "你是一个数学家，你可以计算任何算式。"},
    {"role": "user", "content": prompt}
]
response = get_completion(messages)
messages.append(response)  # 把大模型的回复加入到对话中
print("=====GPT回复=====")
print(response)

# 如果返回的是函数调用结果，则打印出来
if (response.get("function_call")):
    if (response["function_call"]["name"] == "calculate"):
        args = json.loads(response["function_call"]["arguments"])
        result = eval(args["expression"])
        print("=====函数返回=====")
        print(result)
        messages.append(
            {"role": "function", "name": "calculate",
                "content": str(result)}  # 数值result 必须转成字符串
        )
        print("=====最终回复=====")
        print(get_completion(messages).content)

[ ]:

=====GPT回复=====
{
  "role": "assistant",
  "content": null,
  "function_call": {
    "name": "calculate",
    "arguments": "{\n  \"expression\": \"((3 ** 0.5) * 2) ** 0.5\"\n}"
  }
}
=====函数返回=====
1.8612097182041991
=====最终回复=====
3的平方根乘以2再开平方的结果约为1.8612097182041991。

收起

划重点:

Function Calling 中的函数与参数的描述也是一种Prompt
这种 Prompt 也需要调优，否则会影响函数的召回、参数的准确性，甚至让 GPT 产生幻觉

[6]:

def get_completion(messages, model="gpt-3.5-turbo"):
    response = openai.ChatCompletion.create(
        model=model,
        messages=messages,
        temperature=0,  # 模型输出的随机性，0 表示随机性最小
        functions=[{  # 用 JSON 描述函数。可以定义多个，但是只有一个会被调用，也可能都不会被调用
            "name": "calculate",
            "description": "计算一个以Python形式表示的数学表达式的值",
            "parameters": {
                "type": "object",
                "properties": {
                    "expression": {
                        "type": "string",
                        "description": "a mathematical expression in python format. it must be evaluatable by Python's eval()",
                    }
                }
            },
        }],
    )
    return response.choices[0].message


prompt = "从1加到20"

messages = [
    {"role": "system", "content": "你是一个数学家，你可以计算任何算式。"},
    {"role": "user", "content": prompt}
]
response = get_completion(messages)
messages.append(response)  # 把大模型的回复加入到对话中
print("=====GPT回复=====")
print(response)

# 如果返回的是函数调用结果，则打印出来
if (response.get("function_call")):
    if (response["function_call"]["name"] == "calculate"):
        args = json.loads(response["function_call"]["arguments"])
        result = eval(args["expression"])
        print("=====函数返回=====")
        print(result)
        messages.append(
            {"role": "function", "name": "calculate",
                "content": str(result)}  # 数值result 必须转成字符串
        )
        print("=====最终回复=====")
        print(get_completion(messages).content)

[ ]:

=====GPT回复=====
{
  "role": "assistant",
  "content": null,
  "function_call": {
    "name": "python",
    "arguments": "sum(range(1, 21))"
  }
}

收起

示例 3：多 `Function` 调用

[7]:

def get_completion(messages, model="gpt-3.5-turbo"):
    response = openai.ChatCompletion.create(
        model=model,
        messages=messages,
        temperature=0,  # 模型输出的随机性，0 表示随机性最小
        function_call="auto",  # 默认值，由系统自动决定，返回function call还是返回文字回复
        functions=[{  # 用 JSON 描述函数。可以定义多个，但是只有一个会被调用，也可能都不会被调用
            "name": "get_location_coordinate",
            "description": "根据POI名称，获得POI的经纬度坐标",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "POI名称，必须是中文",
                    },
                    "city": {
                        "type": "string",
                        "description": "POI所在的城市名，必须是中文",
                    }
                },
                "required": ["location", "city"],
            },
        },
            {
            "name": "search_nearby_pois",
            "description": "搜索给定坐标附近的poi",
            "parameters": {
                "type": "object",
                "properties": {
                    "longitude": {
                        "type": "string",
                        "description": "中心点的经度",
                    },
                    "latitude": {
                        "type": "string",
                        "description": "中心点的纬度",
                    },
                    "keyword": {
                        "type": "string",
                        "description": "目标poi的关键字",
                    }
                },
                "required": ["longitude", "latitude", "keyword"],
            },
        }],
    )
    return response.choices[0].message

[8]:

import requests

amap_key = "******"


def get_location_coordinate(location, city="北京"):
    url = f"https://restapi.amap.com/v5/place/text?key={amap_key}&keywords={location}®ion={city}"
    print(url)
    r = requests.get(url)
    result = r.json()
    if "pois" in result and result["pois"]:
        return result["pois"][0]
    return None


def search_nearby_pois(longitude, latitude, keyword):
    url = f"https://restapi.amap.com/v5/place/around?key={amap_key}&keywords={keyword}&location={longitude},{latitude}"
    print(url)
    r = requests.get(url)
    result = r.json()
    ans = ""
    if "pois" in result and result["pois"]:
        for i in range(min(3, len(result["pois"]))):
            name = result["pois"][i]["name"]
            address = result["pois"][i]["address"]
            distance = result["pois"][i]["distance"]
            ans += f"{name}\n{address}\n距离：{distance}米\n\n"
    return ans

[9]:

prompt = "沈阳市太原街附近的咖啡"

messages = [
    {"role": "system", "content": "你是一个地图通，你可以找到任何地址。"},
    {"role": "user", "content": prompt}
]
response = get_completion(messages)
messages.append(response)  # 把大模型的回复加入到对话中
print("=====GPT回复=====")
print(response)

# 如果返回的是函数调用结果，则打印出来
while (response.get("function_call")):
    if (response["function_call"]["name"] == "get_location_coordinate"):
        args = json.loads(response["function_call"]["arguments"])
        print("Call: get_location_coordinate")
        result = get_location_coordinate(**args)
    elif (response["function_call"]["name"] == "search_nearby_pois"):
        args = json.loads(response["function_call"]["arguments"])
        print("Call: search_nearby_pois")
        result = search_nearby_pois(**args)
    print("=====函数返回=====")
    print(result)
    messages.append(
        {"role": "function", "name": response["function_call"]["name"], "content": str(
            result)}  # 数值result 必须转成字符串
    )
    response = get_completion(messages)

print("=====最终回复=====")
print(get_completion(messages).content)

[ ]:

=====GPT回复=====
{
  "role": "assistant",
  "content": null,
  "function_call": {
    "name": "get_location_coordinate",
    "arguments": "{\n  \"location\": \"\u592a\u539f\u8857\",\n  \"city\": \"\u6c88\u9633\u5e02\"\n}"
  }
}
Call: get_location_coordinate
https://restapi.amap.com/v5/place/text?key=6d672e6194caa3b639fccf2caf06c342&keywords=太原街®ion=沈阳市
=====函数返回=====
{'parent': '', 'address': '和平区', 'distance': '', 'pcode': '210000', 'adcode': '210102', 'pname': '辽宁省', 'cityname': '沈阳市', 'type': '地名地址信息;热点地名;热点地名', 'typecode': '190700', 'adname': '和平区', 'citycode': '024', 'name': '太原街', 'location': '123.405498,41.794275', 'id': 'B001817BZL'}
Call: search_nearby_pois
https://restapi.amap.com/v5/place/around?key=6d672e6194caa3b639fccf2caf06c342&keywords=咖啡&location=123.405498,41.794275
=====函数返回=====
库迪咖啡(医大一建国璞隐店)
同泽北街9号北联大厦A座
距离：155米

CAFE&CAKE(海润国际店)
南京北街268号海润国际
距离：168米

Coffee for Elephant象咖文化(华润·太原街广场店)
北一马路129号
距离：169米


=====最终回复=====
沈阳市太原街附近的咖啡店有以下几家：

1. 库迪咖啡(医大一建国璞隐店)
   地址：同泽北街9号北联大厦A座
   距离太原街155米

2. CAFE&CAKE(海润国际店)
   地址：南京北街268号海润国际
   距离太原街168米

3. Coffee for Elephant象咖文化(华润·太原街广场店)
   地址：北一马路129号
   距离太原街169米

希望对您有帮助！

收起

示例 4：用 `Function Calling` 实现信息抽取

[10]:

def get_completion(messages, model="gpt-3.5-turbo"):
    response = openai.ChatCompletion.create(
        model=model,
        messages=messages,
        temperature=0,  # 模型输出的随机性，0 表示随机性最小
        function_call="auto",
        functions=[{
            "name": "add_contact",
            "description": "添加联系人",
            "parameters": {
                "type": "object",
                "properties": {
                    "name": {
                        "type": "string",
                        "description": "联系人姓名"
                    },
                    "address": {
                        "type": "string",
                        "description": "联系人地址"
                    },
                    "tel": {
                        "type": "string",
                        "description": "联系人电话"
                    },
                }
            },
        }],
    )
    return response.choices[0].message


prompt = "帮我寄给张三，地址是北京市朝阳区亮马桥外交办公大楼，电话13012345678。"
messages = [
    {"role": "system", "content": "你是一个联系人录入员。"},
    {"role": "user", "content": prompt}
]
response = get_completion(messages)
print("====GPT回复====")
print(json.dumps(response, ensure_ascii=False, indent=2))
args = json.loads(response["function_call"]["arguments"])
print("====函数参数====")
print(args)

[ ]:

====GPT回复====
{
  "role": "assistant",
  "content": null,
  "function_call": {
    "name": "add_contact",
    "arguments": "{\n  \"name\": \"张三\",\n  \"address\": \"北京市朝阳区亮马桥外交办公大楼\",\n  \"tel\": \"13012345678\"\n}"
  }
}
====函数参数====
{'name': '张三', 'address': '北京市朝阳区亮马桥外交办公大楼', 'tel': '13012345678'}

收起

因为 Function Calling 能力是特别 fine-tune 在模型内的，所以输出更稳定，用来获取 JSON 更可靠。搞个假函数声明，就能拿到 JSON 了。

示例 5：通过 `Function Calling` 查询数据库

[11]:

import openai
import os
import json

from dotenv import load_dotenv, find_dotenv
_ = load_dotenv(find_dotenv())  # 读取本地 .env 文件，里面定义了 OPENAI_API_KEY

openai.api_key = os.getenv('OPENAI_API_KEY')


def get_sql_completion(messages, model="gpt-4"):
    response = openai.ChatCompletion.create(
        model=model,
        messages=messages,
        temperature=0,  # 模型输出的随机性，0 表示随机性最小
        function_call="auto",
        functions=[{  # 摘自 OpenAI 官方示例 https://github.com/openai/openai-cookbook/blob/main/examples/How_to_call_functions_with_chat_models.ipynb
            "name": "ask_database",
            "description": "Use this function to answer user questions about business. \
                            Output should be a fully formed SQL query.",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {
                        "type": "string",
                        "description": f"""
                            SQL query extracting info to answer the user's question.
                            SQL should be written using this database schema:
                            {database_schema_string}
                            The query should be returned in plain text, not in JSON.
                            The query should only contain grammars supported by SQLite.
                            """,
                    }
                },
                "required": ["query"],
            },
        }],
    )
    return response.choices[0].message

[12]:

# 描述数据库表结构
database_schema_string = """
CREATE TABLE orders (
    id INT PRIMARY KEY NOT NULL, -- 主键，不允许为空
    customer_id INT NOT NULL, -- 客户ID，不允许为空
    product_id STR NOT NULL, -- 产品ID，不允许为空
    price DECIMAL(10,2) NOT NULL, -- 价格，不允许为空
    status INT NOT NULL, -- 订单状态，整数类型，不允许为空。0代表待支付，1代表已支付，2代表已退款
    create_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP, -- 创建时间，默认为当前时间
    pay_time TIMESTAMP -- 支付时间，可以为空
);
"""

[13]:

import sqlite3

# 创建数据库连接
conn = sqlite3.connect(':memory:')
cursor = conn.cursor()

# 创建orders表
cursor.execute(database_schema_string)

# 插入5条明确的模拟记录
mock_data = [
    (1, 1001, 'TSHIRT_1', 50.00, 0, '2023-08-12 10:00:00', None),
    (2, 1001, 'TSHIRT_2', 75.50, 1, '2023-08-16 11:00:00', '2023-08-16 12:00:00'),
    (3, 1002, 'SHOES_X2', 25.25, 2, '2023-08-17 12:30:00', '2023-08-17 13:00:00'),
    (4, 1003, 'HAT_Z112', 60.75, 1, '2023-08-20 14:00:00', '2023-08-20 15:00:00'),
    (5, 1002, 'WATCH_X001', 90.00, 0, '2023-08-28 16:00:00', None)
]

for record in mock_data:
    cursor.execute('''
    INSERT INTO orders (id, customer_id, product_id, price, status, create_time, pay_time)
    VALUES (?, ?, ?, ?, ?, ?, ?)
    ''', record)

# 提交事务
conn.commit()

[14]:

def ask_database(query):
    cursor.execute(query)
    records = cursor.fetchall()
    return records


prompt = "上个月的销售额"
# prompt = "统计每月每件商品的销售额"
# prompt = "哪个用户消费最高？消费多少？"

messages = [
    {"role": "system", "content": "基于 order 表回答用户问题"},
    {"role": "user", "content": prompt}
]
response = get_sql_completion(messages)
print("====Function Calling====")
print(response)

if "function_call" in response:
    if response["function_call"]["name"] == "ask_database":
        arguments = response["function_call"]["arguments"]
        args = json.loads(arguments)
        print("====SQL====")
        print(args["query"])
        result = ask_database(args["query"])
        print("====DB Records====")
        print(result)

        messages.append({
            "role": "user", "content": f"用户问：{prompt}\n系统通过以下SQL查询后，返回:"+str(result)+"\n据此请回答："
        })
        response = get_sql_completion(messages)
        print("====最终回复====")
        print(get_completion(messages).content)

[ ]:

====Function Calling====
{
  "role": "assistant",
  "content": null,
  "function_call": {
    "name": "ask_database",
    "arguments": "{\n  \"query\": \"SELECT SUM(price) as total_sales FROM orders WHERE strftime('%Y-%m', create_time) = strftime('%Y-%m', 'now', '-1 month') AND status = 1\"\n}"
  }
}
====SQL====
SELECT SUM(price) as total_sales FROM orders WHERE strftime('%Y-%m', create_time) = strftime('%Y-%m', 'now', '-1 month') AND status = 1
====DB Records====
[(136.25,)]
====最终回复====
上个月的销售额为136.25。

收起

示例 6：用 `Function Calling` 实现多表查询

[15]:

#  描述数据库表结构
database_schema_string = """
CREATE TABLE customers (
    id INT PRIMARY KEY NOT NULL, -- 主键，不允许为空
    customer_name VARCHAR(255) NOT NULL, -- 客户名，不允许为空
    email VARCHAR(255) UNIQUE, -- 邮箱，唯一
    register_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP -- 注册时间，默认为当前时间
);
CREATE TABLE products (
    id INT PRIMARY KEY NOT NULL, -- 主键，不允许为空
    product_name VARCHAR(255) NOT NULL, -- 产品名称，不允许为空
    price DECIMAL(10,2) NOT NULL -- 价格，不允许为空
);
CREATE TABLE orders (
    id INT PRIMARY KEY NOT NULL, -- 主键，不允许为空
    customer_id INT NOT NULL, -- 客户ID，不允许为空
    product_id INT NOT NULL, -- 产品ID，不允许为空
    price DECIMAL(10,2) NOT NULL, -- 价格，不允许为空
    status INT NOT NULL, -- 订单状态，整数类型，不允许为空。0代表待支付，1代表已支付，2代表已退款
    create_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP, -- 创建时间，默认为当前时间
    pay_time TIMESTAMP -- 支付时间，可以为空
);
"""

prompt = "统计每月每件商品的销售额"
# prompt = "这星期消费最高的用户是谁？他买了哪些商品？ 每件商品买了几件？花费多少？"
messages = [
    {"role": "system", "content": "基于 order 表回答用户问题"},
    {"role": "user", "content": prompt}
]
response = get_sql_completion(messages)
print(response)

[ ]:

{
  "role": "assistant",
  "content": null,
  "function_call": {
    "name": "ask_database",
    "arguments": "{\n  \"query\": \"SELECT strftime('%Y-%m', orders.create_time) as month, products.product_name, SUM(orders.price) as total_sales FROM orders JOIN products ON orders.product_id = products.id WHERE orders.status = 1 GROUP BY month, products.product_name\"\n}"
  }
}

收起

示例 7：在 `Stream` 模式下使用 `Function Calling`

[16]:

def get_completion(messages, model="gpt-3.5-turbo"):
    response = openai.ChatCompletion.create(
        model=model,
        messages=messages,
        temperature=0,  # 模型输出的随机性，0 表示随机性最小
        functions=[{  # 用 JSON 描述函数。可以定义多个，但是只有一个会被调用，也可能都不会被调用
            "name": "sum",
            "description": "计算一组数的加和",
            "parameters": {
                "type": "object",
                "properties": {
                    "numbers": {
                        "type": "array",
                        "items": {
                            "type": "number"
                        }
                    }
                }
            },
        }],
        stream=True,
    )
    return response


prompt = "1+2+3"
# prompt = "你是谁"

messages = [
    {"role": "system", "content": "你是一个小学数学老师，你要教学生加法"},
    {"role": "user", "content": prompt}
]
response = get_completion(messages)

function_name, args, text = "", "", ""

print("====Streaming====")
for msg in response:
    if msg.get("choices", [{}])[0].get("delta", {}).get("function_call"):
        if not function_name:
            function_name = msg.get("choices", [{}])[0].get(
                "delta", {}).get("function_call", {}).get("name", "")
        delta = msg.get("choices", [{}])[0].get("delta", {}).get(
            "function_call", {}).get("arguments", "")
        print(delta)
        args = args + delta
    elif msg.get("choices", [{}])[0].get("delta", {}).get("content"):
        delta = msg.get("choices", [{}])[0].get("delta", {}).get("content")
        print(delta)
        text = text + delta

print("====done!====")

if function_name or args:
    print(function_name)
    print(args)
if text:
    print(text)

[ ]:

====Streaming====

{

 
 "
numbers
":
 [
1
,
 
2
,
 
3
]

}
====done!====
sum
{
  "numbers": [1, 2, 3]
}

收起

`Function Calling` 的注意事项

注意：

只有 gpt-3.5-turbo-0613 和 gpt-4-0613 可用。它俩针对 Function Calling 做了 fine-tuning，以尽可能保证正确率。
但不保证不出错，包括不保证 json 格式正确。所以官方强烈建议（原文：strongly recommend）如果有写操作，一定插入人工流程做确认。但比纯靠 prompt 控制，可靠性是大了很多的
函数声明是消耗 token 的。要在功能覆盖、省钱、节约上下文窗口之间找到最佳平衡
实战经验：把自己的函数调用结果用自然语言给到 OpenAI，效果有时更好。

`Function Calling` 的想象空间

想象你是下面产品的研发，怎样用 Function Calling 实现下面的功能？

用户对着微信说：「给我每个女性好友发一条情真意切的拜年消息，还要带点儿小幽默」
用户对着富途牛牛说：「人工智能相关股票，市盈率最低的是哪几个？最近交易量如何？都有哪些机构持有？」
用户对着京东说：「我想买一台 65 寸的电视，不要日货，价格在 5000 元左右」

基本上：

我们的任何功能都可以和大模型结合，提供更好的用户体验
通过大模型，完成内部功能的组合调用，完全 agent 化设计系统架构

遗憾的是，暂时国内还没有任何大模型支持 Function Calling。但应该很快都会陆续支持起来，因为太好用了。 OpenAI 再次定义了行业标准。

当然，「幻觉」仍然是存在的。如何尽量减少幻觉的影响，参考以下资料：

NLP算法工程师视角：：

模型砍大面，规则修细节
一个模型搞不定的问题，拆成多个解决
评估算法的准确率
评估badcase的影响面
算法的结果永远不是100%正确的，建立在这个假设基础上推敲产品的可行性

开源替代

可以关注 ToolBench

OpenAI Plugins & Function Calling

接口（Interface）

UI 接口

API 接口

自然语言连接一切（Natural Language Interface）

Plugins

Plugin 的原理

Plugins 的市场表现

Plugins 失败分析

Function Calling

示例 1：加法计算器

示例 2：计算数学表达式

示例 3：多 Function 调用

示例 4：用 Function Calling 实现信息抽取

示例 5：通过 Function Calling 查询数据库

示例 6：用 Function Calling 实现多表查询

示例 7：在 Stream 模式下使用 Function Calling

Function Calling 的注意事项

Function Calling 的想象空间

开源替代

欢迎使用 Cloud Shell

`UI` 接口

`API` 接口

`Plugins`

`Plugins` 的市场表现

`Plugins` 失败分析

`Function Calling`

示例 3：多 `Function` 调用

示例 4：用 `Function Calling` 实现信息抽取

示例 5：通过 `Function Calling` 查询数据库

示例 6：用 `Function Calling` 实现多表查询

示例 7：在 `Stream` 模式下使用 `Function Calling`

`Function Calling` 的注意事项

`Function Calling` 的想象空间