GPT-5 函数调用教程

随着GPT-5 的发布，OpenAI 在 API 中扩展了工具/函数调用，新增了自由格式的工具调用（原始文本、无需 JSON）、通过 Lark/CFG 的语法约束、工具允许列表，以及改进的工具使用推理。它们共同让 GPT-5 成为真正的代理型模型；您可以将 API、数据库和自定义工具连接到 Responses API，生成有据可依的答案，甚至自动化工作流。

在本教程中，我将讲解函数工具、自定义工具、语法约束、工具允许列表以及前言（Preamble），并配以代码示例，清晰说明其工作原理及使用场景。

GPT-5 中的函数调用：是什么与为何

GPT-5 的函数调用允许您用应用的数据与动作增强模型。模型可以自行判断何时调用某个工具，而您负责处理逻辑并返回结果，以生成最终且有依据的回复。

函数调用类型：

函数工具（JSON Schema）：提供结构化的输入输出，模型可以精确调用。
自定义工具（自由格式）：为非结构化集成提供灵活的文本输入输出。

什么是函数调用？

GPT-5 同时支持使用 JSON Schema 的结构化函数工具，以及接收自由格式文本负载（如 SQL、脚本或配置）的自定义工具，以便与外部运行时无缝集成。

函数工具由 JSON Schema 定义，确保模型精确理解应传递的参数，并允许严格的输入校验。您可在我们的OpenAI 函数调用教程中了解更多。

为什么要使用函数调用？

灵活性：自由格式工具让模型可生成系统所需的精准文本，不受刚性 JSON 的限制，非常适合代码、查询或配置。
可靠性与可控性：函数工具强制使用结构化参数，提升可预测性并减少解析错误。
代理式工作流： GPT-5 专为复杂的多步工具使用与编码任务设计，使工具调用成为核心功能。

函数调用如何工作？

发送包含所有可用工具的提示。
模型发出工具调用（带参数或自由格式文本）。
您的应用执行工具（运行 Python 函数）。
将工具输出返回给模型。
模型随后回复，或可能调用更多工具。

来源：函数调用 - OpenAI API

何时使用函数工具与自定义工具

使用函数工具，当您希望通过 JSON Schema 获得严格校验与可预测、带类型的参数。
使用自定义工具（自由格式），当您的运行时需要原始文本（如脚本、SQL 或配置），或当您需要在无 Schema 的情况下快速迭代。

函数工具（JSON Schema）：发送结构化数据

结合 JSON Schema 使用函数工具可从模型获得可预测、结构化的结果。模型会评估您声明的工具，决定何时使用某个工具，提出通过 JSON 校验的参数，然后在您的代码中执行相应函数。

之后，您可以要求模型仅基于工具返回的数据生成回复，确保输出有据可依、机器可读、便于集成。

下面的示例展示了几个关键概念：

工具发现与参数生成：模型会选择合适的工具并自动填充其 JSON 类型化参数。
工具执行循环：您的应用执行所请求的工具，并将结果回传给模型。
按 Schema 形状的最终答案：最终响应严格基于工具输出，从而最大程度减少不准确信息并确保可靠性。

1. 环境准备

创建 OpenAI 账户并在平台控制台生成 API 密钥。在控制台中打开 API 部分，点击“View API keys”，再点击“Create new secret key”。
为您的账户添加支付方式或充值，以便运行 API 调用；使用量会在请求时从预付余额中扣除。
在启动应用前，将您的 API 密钥保存为名为 OPENAI_API_KEY 的环境变量。
使用 pip install openai 安装官方 OpenAI Python SDK。

2. 定义工具

您需要提供工具列表，包括名称、描述和参数的 JSON Schema。该 Schema 可帮助模型提供格式良好的参数。

make_coffee 期望一个字符串参数：coffee_type。
random_coffee_fact 不带参数（空对象）。这些定义通过 API 调用中的 tools 参数传递，让模型知道可用的工具。

import os
from openai import OpenAI
import json

client = OpenAI(api_key = os.environ["OPENAI_API_KEY"])

tools = [
    {
        "type": "function",
        "name": "make_coffee",
        "description": "Gives a simple recipe for making a coffee drink.",
        "parameters": {
            "type": "object",
            "properties": {
                "coffee_type": {
                    "type": "string",
                    "description": "The coffee drink, e.g. espresso, cappuccino, latte"
                }
            },
            "required": ["coffee_type"],
        },
    },
    {
        "type": "function",
        "name": "random_coffee_fact",
        "description": "Returns a fun fact about coffee.",
        "parameters": {"type": "object","properties":{}}
    }
]
技术支持

3. 实现工具

您需要实现实际执行工作的 Python 函数：

make_coffee(coffee_type) 根据请求的饮品返回简明配方字符串。
random_coffee_fact() 返回一条简短的咖啡小知识。

两者均返回可 JSON 序列化的字典，便于回传给模型。

def make_coffee(coffee_type):
    recipes = {
        "espresso": "Grind fine, 18g coffee → 36g espresso in ~28s.",
        "cappuccino": "Brew 1 espresso shot, steam 150ml milk, pour and top with foam.",
        "latte": "Brew 1 espresso shot, steam 250ml milk, pour for silky texture.",
    }
    return {"coffee_type": coffee_type, "recipe": recipes.get(coffee_type.lower(), "Unknown coffee type!")}

def random_coffee_fact():
    return {"fact": "Coffee is the second most traded commodity in the world, after oil."}技术支持

4. 开始对话

用用户问题开启对话：{"role": "user", "content": "How do I make a latte?"}

模型可能返回包含 function_call 项的消息，例如 make_coffee，并带有{"coffee_type":"latte"}。随后您应将模型消息追加回 input_list: input_list += response.output。这有助于在下一轮中维护对话状态。

# Track used tools
used_tools = []

input_list = [{"role": "user", "content": "How do I make a latte?"}]

response = client.responses.create(
    model="gpt-5",
    tools=tools,
    input=input_list,
)
input_list += response.output技术支持

5. 执行工具调用并附加输出

您应遍历 response.output，识别 item.type 等于 "function_call" 的条目。对于这些条目，解析 item.arguments，并将请求分发至您的 Python 函数。

对于 make_coffee 函数，使用 make_coffee(args["coffee_type"]) 调用。对于 random_coffee_fact，直接调用 random_coffee_fact() 即可。

执行函数后，追加一条包含以下内容的 function_call_output 消息：

call_id（用于将该输出与模型请求关联）
output（您的函数结果的 JSON 字符串）。

for item in response.output:
    if getattr(item, "type", "") == "function_call":
        used_tools.append(item.name)
        args = json.loads(item.arguments or "{}")

        if item.name == "make_coffee":
            result = make_coffee(args["coffee_type"])
        elif item.name == "random_coffee_fact":
            result = random_coffee_fact()
        else:
            result = {"error": f"Unknown tool {item.name}"}

        input_list.append({
            "type": "function_call_output",
            "call_id": item.call_id,
            "output": json.dumps(result)
        })技术支持

6. 生成最终答案

进行第二次 client.responses.create 调用，传入已包含工具输出的更新后 input_list。

used_tools 变量记录了模型函数调用中出现的工具名称。我们将用它来展示哪些工具被使用。

final = client.responses.create(
    model="gpt-5",
    tools=tools,
    input=input_list,
    instructions="Answer using only the tool results."
)

print("Final output:\n", final.output_text)

print("\n--- Tool Usage ---")
for t in tools:
    status = "USED ✅" if t["name"] in used_tools else "NOT USED ❌"
    print(f"{t['name']}: {status}")技术支持

由于用户询问拿铁，模型选择了 make_coffee，并设置 coffee_type = "latte"；您的代码执行了该函数，最终响应完全由该工具结果构建。

Final output:
 {"coffee_type":"latte","recipe":"Brew 1 espresso shot, steam 250ml milk, pour for silky texture."}

--- Tool Usage ---
make_coffee: USED ✅
random_coffee_fact: NOT USED ❌技术支持

自定义工具（自由格式）：发送原始文本

使用 GPT-5 的自由格式自定义工具，可让模型将原始文本直接发送给您的工具，例如代码、SQL、Shell 命令，或简单的 CSV，而无需 JSON Schema。

此能力超越了以往仅限 JSON 的函数调用，为与执行器、查询引擎或领域特定语言（DSL）解释器的集成提供了更大的灵活性。

在自由格式模式下，模型会生成包含非结构化文本负载的自定义工具调用，您可以将其路由到运行时。然后您返回结果，供模型用来完善面向用户的最终回答。

接下来我们将编写代码，使模型能选择合适的工具，并以非结构化原始文本作为输出。该输出随后将传递给一个 Python 函数生成结果。这样，用户可以提供手头食材，模型将生成贴合需求的食谱。

在本示例代码中，我们：

初始化 OpenAI 客户端，并定义了一个名为 meal_planner 的自定义工具，接受原始文本输入。
创建 Python 函数 plan_meal，接收以逗号分隔的食材字符串并返回晚餐创意。
以用户列出可用食材的信息开启对话。
进行首次模型调用，指示 GPT-5 仅用干净的食材列表来调用该工具，并将模型输出追加到对话历史。
定位发出的自定义工具调用，并提取原始的逗号分隔输入字符串。
通过将列表传递给 plan_meal 来执行工具，然后将结果作为通过 call_id 关联的 function_call_output 返回给模型。
进行最后一次模型调用，将工具输出的原始创意转化为简明的分步食谱，并打印工具调用详情与最终输出。

from openai import OpenAI
import json
import random

client = OpenAI()

# --- Custom tool ---
tools = [
    {
        "type": "custom",
        "name": "meal_planner",
        "description": "Takes ONLY a comma-separated list of ingredients and suggests a meal idea."
    }
]

# --- Fake meal planner ---
def plan_meal(ingredients: str) -> str:
    ideas = [
        f"Stir-fry: {ingredients} with garlic & soy sauce.",
        f"One-pot rice: cook {ingredients} together in broth until fluffy.",
        f"Soup: simmer {ingredients} in stock with herbs.",
        f"Sheet-pan bake: roast {ingredients} at 200°C for ~20 min."
    ]
    return random.choice(ideas)

# --- Start conversation ---
messages = [
    {"role": "user", "content": "I only have chicken, rice, and broccoli. Any dinner ideas?"}
]

# 1) Ask model with clear instruction
resp = client.responses.create(
    model="gpt-5",
    tools=tools,
    input=messages,
    instructions="If the user mentions ingredients, call the meal_planner tool with ONLY a comma-separated list like 'chicken, rice, broccoli'."
)

messages += resp.output

# 2) Find the tool call
tool_call = next((x for x in resp.output if getattr(x, "type", "") == "custom_tool_call"), None)
assert tool_call, "No tool call found!"

# Get clean CSV input
ingredients_csv = tool_call.input.strip()

# 3) Run the tool
meal_result = plan_meal(ingredients_csv)

# 4) Send tool output back
messages.append({
    "type": "function_call_output",
    "call_id": tool_call.call_id,
    "output": meal_result
})

# 5) Final model response
final = client.responses.create(
    model="gpt-5",
    tools=tools,
    input=messages,
    instructions="Turn the meal idea into a short recipe with 3-4 steps."
)

print("\n--- Tool Call ---")
print("Name:", tool_call.name)
print("Input:", ingredients_csv)
print("Output:", meal_result)


print("\n--- Final Output ---\n", final.output_text)技术支持

由此，我们获得了所用工具的统计信息，包括安装、输入和输出。此外，最终输出给出了完整的烹饪步骤。

--- Tool Call ---
Name: meal_planner
Input: chicken, rice, broccoli
Output: One-pot rice: cook chicken, rice, broccoli together in broth until fluffy.

--- Final Output ---
 One-Pot Chicken, Rice & Broccoli

- Season bite-size chicken pieces with salt and pepper; sear in a little oil in a pot until lightly browned.
- Add 1 cup rinsed rice and 2 cups broth (or water + salt). Bring to a boil, then cover and simmer on low for 12 minutes.
- Scatter 2 cups small broccoli florets on top, cover, and cook 5-7 more minutes until rice is fluffy and broccoli is tender.
- Rest 5 minutes off heat, fluff, and adjust seasoning. Optional: stir in a knob of butter or a splash of soy.技术支持

语法约束（Lark）：约束工具输出

GPT-5 现已支持上下文无关语法（CFG），以确保输出格式受到严格控制。

通过对响应应用语法（例如 SQL 或领域特定语言 DSL），GPT-5 能保证输出始终遵循所需结构。CFG 对自动化流程和高风险工作流尤为重要。

GPT-5 可以使用 Lark 等格式定义的语法，在生成过程中限制工具输出。这种受约束的解码方式通过防止格式漂移并确保结构一致性来提升可靠性。

接下来我们将编写代码，让模型选择一个工具并仅输出一个符合语法的算术表达式；然后在 Python 中对该表达式求值，将结果返回到对话，并最终以自然语言清晰呈现。

在本示例代码中，我们：

初始化 OpenAI 客户端，并定义自定义工具 math_solver，其输出必须仅为符合语法的算术表达式（Lark CFG）。
由用户的自然语言数学问题开启对话。
进行第一次模型调用，指示 GPT-5 使用符合语法的表达式来调用 math_solver。
定位发出的工具调用，并从工具负载中提取原始表达式字符串。
在受限环境中本地求值该表达式，得到具体结果。
将工具执行结果回传到对话，并通过原始 call_id 进行关联。
进行最后一次模型调用，以自然语言清晰呈现求值结果。

from openai import OpenAI
import json

client = OpenAI()

# --- Local fake evaluator ---
def eval_expression(expr: str) -> str:
    try:
        # Evaluate safely using Python's eval on restricted globals
        result = eval(expr, {"__builtins__": {}}, {})
        return f"{expr} = {result}"
    except Exception as e:
        return f"Error evaluating expression: {e}"

# --- Custom tool with grammar constraint ---
tools = [
    {
        "type": "custom",
        "name": "math_solver",
        "description": "Solve a math problem by outputting ONLY a valid arithmetic expression.",
        "format": {
            "type": "grammar",
            "syntax": "lark",
            "definition": r"""
start: expr

?expr: term
     | expr "+" term   -> add
     | expr "-" term   -> sub

?term: factor
     | term "*" factor -> mul
     | term "/" factor -> div

?factor: NUMBER
       | "(" expr ")"

%import common.NUMBER
%ignore " "
"""
        },
    }
]

# --- User asks ---
msgs = [
    {"role": "user", "content": "What is (12 + 8) * 3 minus 5 divided by 5?"}
]

# 1) First model call: GPT-5 must emit a grammar-valid expression
resp = client.responses.create(
    model="gpt-5",
    tools=tools,
    input=msgs,
    instructions="Always call the math_solver tool with a grammar-valid arithmetic expression like '(12 + 8) * 3 - 5 / 5'."
)

msgs += resp.output

tool_call = next(
    x for x in resp.output
    if getattr(x, "type", "") in ("custom_tool_call", "tool_call", "function_call")
)

expr = getattr(tool_call, "input", "") or getattr(tool_call, "arguments", "")
print("\n=== Grammar-Constrained Expression ===")
print(expr)

# 2) Run the local evaluator
tool_result = eval_expression(expr)
print("\n=== Tool Execution Result ===")
print(tool_result)

# 3) Return tool output
msgs.append({
    "type": "function_call_output",
    "call_id": tool_call.call_id,
    "output": tool_result
})

# 4) Final pass: GPT-5 presents answer nicely
final = client.responses.create(
    model="gpt-5",
    input=msgs,
    tools=tools,
    instructions="Present the evaluated result clearly in natural language."
)

print("\n=== Final Output ===")
print(final.output_text)技术支持

如您所见，模型选择了工具并生成了受语法约束的表达式。随后通过 Python 函数得到答案，最终以自然语言给出清晰的结果。

=== Grammar-Constrained Expression ===
(12 + 8) * 3 - 5 / 5

=== Tool Execution Result ===
(12 + 8) * 3 - 5 / 5 = 59.0

=== Final Output ===
59技术支持

工具允许列表：安全限制模型可用工具

allowed_tools 设置可将模型限制在您的完整工具集中的安全子集内。这提升了可预测性并防止意外的工具调用，同时仍在允许范围内给予模型灵活性。

您可以让模型在允许的工具中自由选择，或要求其必须使用其中一个，这与其他技术栈中的“强制工具”行为一致，并符合工具调用编排的一般最佳实践。

接下来我们将编写代码，只允许一个工具，让模型仅调用该工具，运行它，将结果回传，然后生成简明的用户可读摘要。

注意：请创建一个免费的 Firecrawl 账户，生成 API 密钥，保存为环境变量 FIRECRAWL_API_KEY，并使用 pip install firecrawl-py 安装 Firecrawl Python SDK。

在本示例代码中，我们：

定义了完整工具集，包含 dummy_web_search 与 firecrawl_search。
通过 tool_choice = { type: "allowed_tools", mode: "required", tools: [...] } 将模型限制为仅可使用 firecrawl_search。
发起首次模型调用，捕获工具调用名称与参数，并打印以便查看。
当调用 firecrawl_search 时，反序列化参数，执行 Firecrawl，将其响应转换为可 JSON 序列化的字典，并提取安全的数据负载。
将工具结果以 function_call_output（通过 call_id 关联）回传到对话，然后进行最后一次模型调用，将结果总结为 3–4 个要点并包含 Markdown 链接。
包含一个回退分支以运行虚拟工具（尽管在本次运行中允许列表会阻止它）。
打印最终的自然语言答案。

from openai import OpenAI
from firecrawl import Firecrawl
import json
import os

client = OpenAI()
firecrawl = Firecrawl(api_key=os.environ["FIRECRAWL_API_KEY"])

# --- Full toolset ---
tools = [
    {
        "type": "function",
        "name": "dummy_web_search",
        "description": "A fake web search that always returns static dummy results.",
        "parameters": {
            "type": "object",
            "properties": {
                "query": {"type": "string"},
                "limit": {"type": "integer"}
            },
            "required": ["query"]
        },
    },
    {
        "type": "function",
        "name": "firecrawl_search",
        "description": "Perform a real web search using Firecrawl.",
        "parameters": {
            "type": "object",
            "properties": {
                "query": {"type": "string"},
                "limit": {"type": "integer"}
            },
            "required": ["query"]
        },
    },
]

# --- Dummy implementation ---
def dummy_web_search(query, limit=3):
    return {
        "query": query,
        "results": [f"[Dummy] Result {i+1} for '{query}'" for i in range(limit)]
    }

# --- User asks ---
messages = [
    {"role": "user", "content": "Find me the latest info about the stock market."}
]

# --- Restrict to Firecrawl only ---
resp = client.responses.create(
    model="gpt-5",
    tools=tools,
    input=messages,
    instructions="Only the firecrawl_search tool is allowed. Do not use dummy_web_search.",
    tool_choice={
        "type": "allowed_tools",
        "mode": "required",  # force Firecrawl
        "tools": [{"type": "function", "name": "firecrawl_search"}],
    },
)

for item in resp.output:
    if getattr(item, "type", "") in ("function_call", "tool_call"):
        print("\n--- Tool Call ---")
        print("Tool name:", item.name)
        print("Arguments:", item.arguments)

        if item.name == "firecrawl_search":
            args = json.loads(item.arguments)

            # Firecrawl returns a SearchData object → convert it
            results_obj = firecrawl.search(
                query=args["query"],
                limit=args.get("limit", 3),
            )

            # 🔥 Convert to JSON-serializable dict
            if hasattr(results_obj, "to_dict"):
                results = results_obj.to_dict()
            elif hasattr(results_obj, "dict"):
                results = results_obj.dict()
            else:
                results = json.loads(results_obj.json()) if hasattr(results_obj, "json") else results_obj

            print("\n--- Firecrawl Raw Results ---")
            print(json.dumps(results, indent=2)[:500])

            # ✅ Extract only the data portion for summarization
            safe_results = results.get("data", results)

            # Feed back to GPT
            messages += resp.output
            messages.append({
                "type": "function_call_output",
                "call_id": item.call_id,
                "output": json.dumps(safe_results)  # now safe
            })

            # Final pass
            final = client.responses.create(
                model="gpt-5",
                tools=tools,
                input=messages,
                instructions="Summarize the Firecrawl search results into 3-4 bullet points with clickable [Title](URL) links."
            )

            print("\n--- Final Natural Language Answer ---")
            print(final.output_text)

        elif item.name == "dummy_web_search":
            args = json.loads(item.arguments)
            results = dummy_web_search(args["query"], args.get("limit", 3))
            print("\n--- Dummy Web Search Results ---")
            print(json.dumps(results, indent=2))技术支持

它选择了 Firecrawl 搜索，并据此以 Markdown 格式生成了最终响应。

前言（Preamble）：告知模型如何调用工具

前言是模型在调用工具前生成的简短说明，用于阐明调用原因。它能提升透明度、建立用户信任，并在复杂工作流中改进调试清晰度。您可以通过类似“在调用工具前先解释”的简洁指令启用它，通常不会显著增加延迟。

接下来我们将编写代码，让模型先生成一行以“Preamble:”开头的简短说明，解释为何调用某工具，然后调用工具，您在本地执行，返回结果，最后模型给出清晰的最终答案。

在本示例代码中，我们：

初始化 OpenAI 客户端，并用 JSON Schema 定义一个严格类型的函数工具（medical_advice）。
添加系统指令，要求模型在任何工具调用前输出一行以 “Preamble:” 开头的说明。
以用户的症状问题初始化对话。
进行第一次模型调用，获取前言以及带参数的工具调用。
提取并在本地执行工具以生成建议。
将工具输出通过 call_id 关联回传给模型。
进行最终模型调用，让 GPT‑5 以简洁、友好的方式呈现结果。

from openai import OpenAI
import json
import random

client = OpenAI()

# --- Fake tool implementation ---
def medical_advice(symptom: str):
    remedies = {
        "headache": "You can take acetaminophen (paracetamol) or ibuprofen, rest in a quiet room, and stay hydrated.",
        "cough": "Drink warm fluids, use honey in tea, and consider over-the-counter cough syrup.",
        "fever": "Use acetaminophen to reduce fever, stay hydrated, and rest. See a doctor if >39°C.",
    }
    return {"advice": remedies.get(symptom.lower(), "Please consult a healthcare provider for guidance.")}

# --- Tool definition ---
tools = [{
    "type": "function",
    "name": "medical_advice",
    "description": "Provide safe, general over-the-counter advice for common symptoms.",
    "parameters": {
        "type": "object",
        "properties": {"symptom": {"type": "string"}},
        "required": ["symptom"],
        "additionalProperties": False
    },
    "strict": True,
}]

# --- Messages (system preamble instruction) ---
messages = [
    {"role": "system", "content": "Before you call a tool, explain why you are calling it in ONE short sentence prefixed with 'Preamble:'."},
    {"role": "user", "content": "What should I take for a headache?"}
]

# 1) First call: expect preamble + tool call
resp = client.responses.create(model="gpt-5", input=messages, tools=tools)
print("=== First Response ===")
for item in resp.output:
    t = getattr(item, "type", None)
    if t == "message":
        # Extract just the model's text
        content = getattr(item, "content", None)
        text = None
        if isinstance(content, list):
            text = "".join([c.text for c in content if hasattr(c, "text")])
        elif content:
            text = str(content)
        if text:
            # ✅ Only print once
            print(text)
    if t in ("function_call", "tool_call", "custom_tool_call"):
        print("Tool:", getattr(item, "name", None))
        print("Args:", getattr(item, "arguments", None))

# Extract tool call
tool_call = next(x for x in resp.output if getattr(x, "type", None) in ("function_call","tool_call","custom_tool_call"))
messages += resp.output

# 2) Execute tool locally
args = json.loads(getattr(tool_call, "arguments", "{}"))
symptom = args.get("symptom", "")
tool_result = medical_advice(symptom)

# 3) Return tool result
messages.append({
    "type": "function_call_output",
    "call_id": tool_call.call_id,
    "output": json.dumps(tool_result)
})

# 4) Final model call → natural answer
final = client.responses.create(model="gpt-5", input=messages, tools=tools)
print("\n=== Final Answer ===")
print(final.output_text)技术支持

您可以看到，在调用工具之前，它会先解释调用原因。这对于可观测性与调试十分有益。

总结

GPT-5 是 OpenAI 迄今最先进的模型，尤其在编码与基于代理的工作流方面表现卓越。其最新 API 功能让从头到尾构建生产级系统变得直观易行。

在本教程中，您学会了：

返回结构化输出：使用函数工具与 JSON Schema，为下游自动化提供可靠数据。
启用自由格式执行的自定义工具（原始文本），让模型能生成代码、SQL、Shell 脚本与 CSV，而不局限于 JSON 调用。
受限格式：在数学、SQL 或领域特定语言（DSL）等需要高精度的场景中，使用 Lark 语法约束。
限制工具访问：通过允许列表（或强制单一工具）提升安全性、可控性和确定性。
提升透明度：使用简短前言，让模型解释调用特定工具的原因，帮助可观测性与调试。

若想进一步了解可用的 OpenAI 工具，我建议您学习我们的OpenAI 基础技能路径与《使用 OpenAI API》课程。

作者

Abid Ali Awan

LinkedIn Twitter

作为一名持证的数据科学家，我热衷于利用前沿技术打造创新的机器学习应用。凭借在语音识别、数据分析与报告、MLOps、对话式人工智能以及自然语言处理方面的扎实背景，我不断打磨构建智能系统的能力，力求带来切实影响。除技术专长外，我也擅长沟通，能够将复杂概念提炼为清晰、简明的表述。因此，我成为数据科学领域备受关注的博主，与不断壮大的数据专业人士社区分享洞见与实践经验。目前，我专注于内容创作与编辑，借助大语言模型打造有力且吸引人的内容，帮助企业与个人更好地发挥数据价值。

主题

人工智能 OpenAI 大语言模型

主题

技术

GPT-5 函数调用教程

使用 AI 探索

GPT-5 中的函数调用：是什么与为何

什么是函数调用？

为什么要使用函数调用？

函数调用如何工作？

何时使用函数工具与自定义工具

函数工具（JSON Schema）：发送结构化数据

1. 环境准备

2. 定义工具

3. 实现工具

4. 开始对话

5. 执行工具调用并附加输出

6. 生成最终答案

自定义工具（自由格式）：发送原始文本

语法约束（Lark）：约束工具输出

工具允许列表：安全限制模型可用工具

前言（Preamble）：告知模型如何调用工具

总结

主题

DataCamp 热门课程

使用 OpenAI API

OpenAI 基础知识

使用 OpenAI API 构建 AI 系统

主题

技术

DataCamp 热门课程

使用 OpenAI API

OpenAI 基础知识

使用 OpenAI API 构建 AI 系统