AI 教程 · 2026年7月10日 - GPT-5.6 API 入门：构建你的第一个 AI Agent

无涯2026-07-102026-08-02

AI 教程 · GPT-5.6 API 入门：构建你的第一个 AI Agent

背景 - GPT-5.6 发布背景和 Agent 能力概述

2026 年 7 月，OpenAI 正式发布了 GPT-5.6，这是 GPT-5 系列的一个重要里程碑更新。GPT-5.6 在推理能力、工具调用准确率、多模态理解以及长上下文处理方面均有显著提升。

GPT-5.6 的核心亮点包括：

增强的 Function Calling：工具调用准确率相比 GPT-5.5 提升约 30%，能够更可靠地处理复杂多步骤工具链。
1M Token 上下文窗口：轻松处理整本代码库或大规模文档。
原生结构化输出：无需额外提示即可生成严格遵循 JSON Schema 的输出。
更低的延迟和成本：推理速度提升 2 倍，输入/输出 token 价格降低 40%。

这些能力使得开发者可以构建真正实用的 AI Agent——能够自主感知环境、做出决策、调用工具并执行任务的智能体。在本教程中，我们将从零开始，用 GPT-5.6 API 构建一个具备联网搜索、数学计算和文件操作能力的 AI Agent。

第一步：准备环境

在开始之前，你需要完成以下准备工作。

获取 API 密钥

访问 OpenAI 平台并登录你的账号。
进入 API Keys 页面，点击 Create new secret key。
复制生成的密钥并妥善保存（关闭弹窗后将无法再次查看）。

⚠️ 安全提醒：切勿将 API 密钥提交到版本控制系统中。建议使用环境变量来管理密钥。

配置 Python 环境

本教程使用 Python 3.10+。推荐使用虚拟环境来隔离项目依赖：

# 创建项目目录
mkdir gpt56-agent-tutorial
cd gpt56-agent-tutorial

# 创建并激活虚拟环境
python3 -m venv venv
source venv/bin/activate  # Linux/macOS
# 或 venv\Scripts\activate  # Windows

安装 openai SDK

安装最新版 OpenAI Python SDK：

1	pip install openai

安装完成后，验证 SDK 版本：

1 2	import openai print(openai.__version__) # 应 >= 1.60.0

设置环境变量

1 2	export OPENAI_API_KEY="***" export OPENAI_BASE_URL="https://api.openai.com/v1" # 可选，使用代理时修改

第二步：基础 API 调用

现在我们来编写第一个 GPT-5.6 API 调用。创建一个名为 basic_chat.py 的文件：

import os
from openai import OpenAI

# 初始化客户端（自动读取 OPENAI_API_KEY 环境变量）
client = OpenAI()

# 模型名称
MODEL = "gpt-5.6-turbo"

# 发送首次对话
response = client.chat.completions.create(
    model=MODEL,
    messages=[
        {"role": "system", "content": "你是一个乐于助人的 AI 助手。"},
        {"role": "user", "content": "用中文解释一下什么是 AI Agent？"},
    ],
    temperature=0.7,
    max_tokens=500,
)

# 打印回复
print(response.choices[0].message.content)

运行脚本：

1	python basic_chat.py

输出示例（实际内容会有差异）：

AI Agent（智能体）是一种能够自主感知环境、做出决策并执行行动的人工智能系统。
它不仅仅是简单的问答模型——Agent 可以规划任务、调用工具、记忆上下文，
并持续迭代以达成用户指定的目标。想象一下，一个能够自己上网查资料、
写代码并运行测试的 AI 助手，这就是 Agent 的典型形态。

参数说明

参数	说明
`model`	模型名称，当前为 `gpt-5.6-turbo`
`messages`	对话消息列表，支持 `system`、`user`、`assistant` 角色
`temperature`	生成温度（0-2），越低越确定，越高越有创造性
`max_tokens`	最大输出 token 数
`stream`	设为 `True` 可启用流式输出

第三步：构建 Agent 核心循环

一个 AI Agent 的核心是一个循环：接收用户输入 → 调用 LLM → 检查是否需要调用工具 → 执行工具 → 将结果反馈给 LLM → 继续直到得出最终答案。

工具调用（Function Calling）基础

GPT-5.6 支持通过 tools 参数定义可调用的函数。我们先看一个简单的例子——让 Agent 能够执行数学运算。

创建 agent_core.py：

import json
import os
from openai import OpenAI

client = OpenAI()
MODEL = "gpt-5.6-turbo"


# 定义工具：计算器
def calculate(expression: str) -> str:
    """安全地计算数学表达式"""
    try:
        # 使用白名单方式安全执行
        allowed_names = {
            "abs": abs, "round": round, "min": min, "max": max,
            "sum": sum, "pow": pow, "int": int, "float": float,
        }
        result = eval(expression, {"__builtins__": {}}, allowed_names)
        return str(result)
    except Exception as e:
        return f"计算错误：{str(e)}"


# 工具定义（API 用）
tools = [
    {
        "type": "function",
        "function": {
            "name": "calculate",
            "description": "执行数学计算，支持 +、-、*、/、** 等运算",
            "parameters": {
                "type": "object",
                "properties": {
                    "expression": {
                        "type": "string",
                        "description": "数学表达式，例如 '(3 + 5) * 2'",
                    }
                },
                "required": ["expression"],
            },
        },
    }
]


# 工具名称到实际函数的映射
tool_map = {
    "calculate": calculate,
}


def run_agent(user_input: str, max_steps: int = 5) -> str:
    """Agent 核心循环"""
    messages = [
        {"role": "system", "content": "你是一个智能助手，可以使用工具来回答问题。"},
        {"role": "user", "content": user_input},
    ]

    for step in range(max_steps):
        print(f"\n--- 步骤 {step + 1} ---")

        response = client.chat.completions.create(
            model=MODEL,
            messages=messages,
            tools=tools,
            tool_choice="auto",
        )

        message = response.choices[0].message

        # 如果没有工具调用请求，说明 LLM 已给出最终答案
        if not message.tool_calls:
            return message.content

        # 处理工具调用
        messages.append(message)

        for tool_call in message.tool_calls:
            function_name = tool_call.function.name
            function_args = json.loads(tool_call.function.arguments)

            print(f"  调用工具: {function_name}({function_args})")

            # 执行工具函数
            result = tool_map[function_name](**function_args)

            print(f"  工具返回: {result}")

            # 将工具结果反馈给 LLM
            messages.append({
                "role": "tool",
                "tool_call_id": tool_call.id,
                "content": result,
            })

    return "已达到最大迭代步数，无法生成最终答案。"


if __name__ == "__main__":
    answer = run_agent("计算 (1234 + 5678) * 3.14 的结果是多少？")
    print(f"\n最终答案：{answer}")

运行测试：

1	python agent_core.py

预期输出：

--- 步骤 1 ---
  调用工具: calculate({'expression': '(1234 + 5678) * 3.14'})
  工具返回: 21701.68

--- 步骤 2 ---

最终答案：(1234 + 5678) * 3.14 的计算结果是 **21701.68**。

核心循环流程图

1
2
3

用户输入 → [LLM] → 是否有工具调用？
  ├── 否 → 返回最终答案
  └── 是 → 执行工具 → 结果反馈给 LLM → 回到 [LLM]

第四步：添加工具

一个实用的 Agent 需要多种工具。我们来添加网络搜索和文件读写功能。

工具一：网络搜索

由于我们不想依赖外部 API 密钥，这里使用 requests + BeautifulSoup 模拟简单的搜索能力。实际生产环境中建议集成 SerpAPI、Bing Search API 或 Tavily。

1	pip install requests beautifulsoup4

在 agent_core.py 中添加以下函数和工具定义：

import requests
from bs4 import BeautifulSoup


def web_search(query: str, max_results: int = 3) -> str:
    """执行网络搜索并返回摘要"""
    try:
        headers = {
            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
                          "AppleWebKit/537.36 (KHTML, like Gecko) "
                          "Chrome/120.0.0.0 Safari/537.36"
        }
        url = f"https://www.google.com/search?q={requests.utils.quote(query)}"
        resp = requests.get(url, headers=headers, timeout=10)
        resp.raise_for_status()

        soup = BeautifulSoup(resp.text, "html.parser")
        results = []

        for g in soup.select("div.g")[:max_results]:
            title = g.select_one("h3")
            snippet = g.select_one("div.VwiC3b")
            if title and snippet:
                results.append({
                    "title": title.get_text(strip=True),
                    "snippet": snippet.get_text(strip=True),
                })

        if not results:
            return f"未找到关于「{query}」的搜索结果。"

        output = f"关于「{query}」的搜索结果：\n\n"
        for i, r in enumerate(results, 1):
            output += f"{i}. {r['title']}\n   {r['snippet']}\n\n"
        return output.strip()

    except Exception as e:
        return f"搜索出错：{str(e)}"


# 在 tools 列表中添加新工具定义
tools.append({
    "type": "function",
    "function": {
        "name": "web_search",
        "description": "在互联网上搜索信息并返回网页摘要",
        "parameters": {
            "type": "object",
            "properties": {
                "query": {
                    "type": "string",
                    "description": "搜索关键词，例如 '2026年 AI 发展趋势'",
                },
                "max_results": {
                    "type": "integer",
                    "description": "返回的最大结果数量（1-5）",
                    "default": 3,
                },
            },
            "required": ["query"],
        },
    },
})

# 更新 tool_map
tool_map["web_search"] = web_search

工具二：文件操作

import os


def read_file(filepath: str) -> str:
    """读取指定文件的内容"""
    try:
        # 安全检查：防止读取系统敏感文件
        allowed_dir = os.path.abspath(".")
        target_path = os.path.abspath(filepath)
        if not target_path.startswith(allowed_dir):
            return "错误：不允许读取指定路径之外的文件。"
        if not os.path.isfile(target_path):
            return f"错误：文件 {filepath} 不存在。"
        with open(target_path, "r", encoding="utf-8") as f:
            return f.read()
    except Exception as e:
        return f"读取文件出错：{str(e)}"


def write_file(filepath: str, content: str) -> str:
    """将内容写入指定文件"""
    try:
        allowed_dir = os.path.abspath(".")
        target_path = os.path.abspath(filepath)
        if not target_path.startswith(allowed_dir):
            return "错误：不允许写入指定路径之外的文件。"
        os.makedirs(os.path.dirname(target_path), exist_ok=True)
        with open(target_path, "w", encoding="utf-8") as f:
            f.write(content)
        return f"成功写入文件：{filepath}（{len(content)} 字符）"
    except Exception as e:
        return f"写入文件出错：{str(e)}"

在 tools 和 tool_map 中注册这两个新工具后，Agent 就具备了搜索和文件操作能力。

第五步：完整 Agent 实例

现在我们将所有工具整合到一个完整的 Agent 中。创建一个新的文件 full_agent.py：

#!/usr/bin/env python3
"""
GPT-5.6 多工具 AI Agent 完整示例
"""

import json
import os
import requests
from bs4 import BeautifulSoup
from openai import OpenAI

# ==================== 配置 ====================

client = OpenAI()
MODEL = "gpt-5.6-turbo"
MAX_STEPS = 10

# ==================== 工具函数 ====================


def calculate(expression: str) -> str:
    """安全执行数学计算"""
    try:
        allowed = {
            "abs": abs, "round": round, "min": min, "max": max,
            "sum": sum, "pow": pow, "int": int, "float": float,
        }
        return str(eval(expression, {"__builtins__": {}}, allowed))
    except Exception as e:
        return f"计算错误：{e}"


def web_search(query: str, max_results: int = 3) -> str:
    """网络搜索"""
    try:
        headers = {
            "User-Agent": (
                "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
                "AppleWebKit/537.36 (KHTML, like Gecko) "
                "Chrome/120.0.0.0 Safari/537.36"
            )
        }
        url = f"https://www.google.com/search?q={requests.utils.quote(query)}"
        resp = requests.get(url, headers=headers, timeout=10)
        resp.raise_for_status()
        soup = BeautifulSoup(resp.text, "html.parser")
        results = []
        for g in soup.select("div.g")[:max_results]:
            title = g.select_one("h3")
            snippet = g.select_one("div.VwiC3b")
            if title and snippet:
                results.append(
                    f"• {title.get_text(strip=True)}\n  {snippet.get_text(strip=True)}"
                )
        return (
            "\n\n".join(results)
            if results
            else f"未找到「{query}」的相关结果。"
        )
    except Exception as e:
        return f"搜索出错：{e}"


def read_file(filepath: str) -> str:
    """读取文件"""
    try:
        allowed = os.path.abspath(".")
        target = os.path.abspath(filepath)
        if not target.startswith(allowed):
            return "错误：路径越权。"
        if not os.path.isfile(target):
            return f"文件不存在：{filepath}"
        with open(target, "r", encoding="utf-8") as f:
            return f.read()
    except Exception as e:
        return f"读文件出错：{e}"


def write_file(filepath: str, content: str) -> str:
    """写入文件"""
    try:
        allowed = os.path.abspath(".")
        target = os.path.abspath(filepath)
        if not target.startswith(allowed):
            return "错误：路径越权。"
        os.makedirs(os.path.dirname(target), exist_ok=True)
        with open(target, "w", encoding="utf-8") as f:
            f.write(content)
        return f"已写入 {filepath}（{len(content)} 字符）"
    except Exception as e:
        return f"写文件出错：{e}"


# ==================== 工具注册 ====================

tools = [
    {
        "type": "function",
        "function": {
            "name": "calculate",
            "description": "执行数学计算，如 '(3 + 5) * 2'",
            "parameters": {
                "type": "object",
                "properties": {
                    "expression": {
                        "type": "string",
                        "description": "数学表达式",
                    }
                },
                "required": ["expression"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "web_search",
            "description": "搜索互联网信息",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {"type": "string", "description": "搜索关键词"},
                    "max_results": {
                        "type": "integer",
                        "description": "返回结果数量",
                        "default": 3,
                    },
                },
                "required": ["query"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "read_file",
            "description": "读取文件内容",
            "parameters": {
                "type": "object",
                "properties": {
                    "filepath": {"type": "string", "description": "文件路径"},
                },
                "required": ["filepath"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "write_file",
            "description": "写入内容到文件",
            "parameters": {
                "type": "object",
                "properties": {
                    "filepath": {"type": "string", "description": "文件路径"},
                    "content": {"type": "string", "description": "文件内容"},
                },
                "required": ["filepath", "content"],
            },
        },
    },
]

tool_map = {
    "calculate": calculate,
    "web_search": web_search,
    "read_file": read_file,
    "write_file": write_file,
}

# ==================== Agent 循环 ====================


def run_agent(user_input: str) -> str:
    """运行 Agent 主循环"""
    messages = [
        {
            "role": "system",
            "content": (
                "你是一个拥有计算、搜索和文件操作能力的 AI Agent。"
                "请按以下规则工作：\n"
                "1. 分析用户需求，拆解为子任务。\n"
                "2. 每次调用一个工具，根据结果决定下一步。\n"
                "3. 所有信息收集完毕后，给出清晰完整的最终答案。\n"
                "4. 语言使用用户提问时使用的语言。"
            ),
        },
        {"role": "user", "content": user_input},
    ]

    for step in range(MAX_STEPS):
        print(f"\n{'='*50}\n  步骤 {step+1}/{MAX_STEPS}\n{'='*50}")

        response = client.chat.completions.create(
            model=MODEL,
            messages=messages,
            tools=tools,
            tool_choice="auto",
            temperature=0.3,
        )

        message = response.choices[0].message

        if not message.tool_calls:
            return message.content

        messages.append(message)

        for tc in message.tool_calls:
            name = tc.function.name
            args = json.loads(tc.function.arguments)
            print(f"  🔧 调用: {name}({json.dumps(args, ensure_ascii=False)})")

            result = tool_map[name](**args)
            print(f"  📦 结果: {result[:200]}..." if len(result) > 200 else f"  📦 结果: {result}")

            messages.append({
                "role": "tool",
                "tool_call_id": tc.id,
                "content": result,
            })

    return "⚠️ Agent 已达到最大步骤限制，请尝试简化问题。"


# ==================== 交互式运行 ====================

if __name__ == "__main__":
    print("🤖 GPT-5.6 AI Agent 已启动！（输入 'exit' 退出）")
    while True:
        try:
            user_input = input("\n👤 请输入你的问题：")
            if user_input.lower() in ("exit", "quit", "q"):
                print("👋 再见！")
                break
            answer = run_agent(user_input)
            print(f"\n🤖 最终答案：\n{answer}")
        except KeyboardInterrupt:
            print("\n\n👋 已中断。")
            break
        except Exception as e:
            print(f"\n❌ 发生错误：{e}")

运行完整 Agent

1	python full_agent.py

尝试以下示例问题：

计算问题：计算 2 的 10 次方，然后加上 2026
搜索+计算：搜索 2026 年诺贝尔物理学奖得主，然后计算他们年龄的平均值
文件操作：在当前目录创建一个名为 hello.txt 的文件，内容为 "Hello, GPT-5.6 Agent!"，然后读取它

示例运行输出：

🤖 GPT-5.6 AI Agent 已启动！（输入 'exit' 退出）

👤 请输入你的问题：计算 2 的 10 次方，然后加上 2026

==================================================
  步骤 1/10
==================================================
  🔧 调用: calculate({"expression": "2**10"})
  📦 结果: 1024

==================================================
  步骤 2/10
==================================================
  🔧 调用: calculate({"expression": "1024 + 2026"})
  📦 结果: 3050

==================================================
  步骤 3/10
==================================================

🤖 最终答案：
计算结果如下：

- 2 的 10 次方 = **1024**
- 1024 + 2026 = **3050**

因此最终结果是 **3050**。🎯

总结

恭喜！你已经用 GPT-5.6 API 构建了你的第一个 AI Agent。让我们回顾一下关键要点：

核心概念回顾

概念	说明
Function Calling	LLM 通过结构化参数调用外部函数的能力
Tool Registry	工具名称 → 实际函数的映射表
Agent Loop	推理 → 调用工具 → 反馈结果 → 继续推理的迭代循环
System Prompt	定义 Agent 行为和规则的初始指令

关键最佳实践

工具设计要精细：每个工具只做一件事，做好一件事。参数定义要清晰，description 字段要详细——GPT-5.6 会据此决定何时调用哪个工具。
安全始终第一：对文件路径做越界检查，对 eval 做沙箱化处理，API 密钥绝不硬编码。
控制迭代深度：设置 max_steps 防止无限循环。
调试先看 Step Log：每步的输入输出一目了然，方便定位问题。

下一步学习方向

多 Agent 协作：使用 gpt-5.6-turbo 构建多个专用 Agent（搜索 Agent、代码 Agent、分析 Agent），通过 Orchestrator 协调它们。
持久化记忆：集成向量数据库（如 Pinecone、Chroma）让 Agent 拥有长期记忆。
流式输出：用 stream=True 实现打字机效果的实时响应。
Assistants API：使用 OpenAI 的 Assistants API 自动管理线程、运行和工具调用。
生产化部署：加入重试机制、速率限制、日志监控，并用 FastAPI 包装为 Web 服务。

GPT-5.6 让构建 AI Agent 变得前所未有的简单和可靠。从今天开始动手，你会发现 Agent 的可能性远超想象。🚀

🧠 编者点评

教程类内容的价值在于「授人以渔」。在 AI 工具日新月异的今天，掌握核心方法和思维框架，比追逐最新工具更为重要。希望本文能为你提供实用的参考。

本教程发布于 2026 年 7 月 10 日。代码基于 openai Python SDK ≥ 1.60.0 和 GPT-5.6 模型。