零基础从入门到精通 AI Agent 开发（全栈保姆级教程）上篇：Agent 核心原理、ReAct 框架、基础工具调用、记忆管理、单 Agent 开发实战
·
目录
- 开篇：AI Agent 到底是什么？为什么是 AI 的下一个拐点？
- 核心基石：AI Agent 的核心原理与六大核心组件
- 灵魂框架：ReAct 框架深度拆解与从零实现
- 能力延伸：Agent 基础工具调用完整实现（含自定义工具）
- 长期记忆：Agent 记忆管理系统设计与落地
- 全链路实战：从零开发一个完整的单 Agent 智能助手
- 常见问题 FAQ & 下篇预告 & 互动环节
1. 开篇：AI Agent 到底是什么？为什么是 AI 的下一个拐点？
我知道很多同学都有过这样的经历：
学会了调用 OpenAI/通义千问/文心一言的 API，能写个简单的对话机器人，甚至能做个简单的 RAG 知识库，但再往前就卡住了——
你想让 AI 帮你「分析 2026 年 Q1 新能源汽车销量数据，生成可视化报告并发送到我的邮箱」，普通大模型只会告诉你「你可以先去XX网站爬取数据，再用 Pandas 清洗，用 Matplotlib 画图，最后用 SMTP 发邮件」，但它自己完全不会动手做。
这就是普通大模型和 AI Agent 的核心区别：
- 普通大模型：「一问一答、被动响应、只会说不会做」，所有能力都局限在训练数据和上下文窗口内，无法和真实世界交互
- AI Agent：「给定目标、自主规划、主动执行、反思迭代、直到完成目标」，它给大模型装上了手脚（工具调用）、记忆（长期/短期记忆）、眼睛（信息感知）和大脑（规划反思能力），能自主完成复杂的真实世界任务
举个最直观的例子，同样是上面的报告需求，AI Agent 的执行流程是：
- 拆解目标：把「生成销量报告发邮箱」拆成 5 个子任务：获取数据→清洗数据→可视化分析→撰写报告→发送邮件
- 自主行动：调用爬虫工具获取公开销量数据，调用 Python 工具清洗数据、生成可视化图表
- 结果反馈：把执行结果回传给大模型，判断当前步骤是否完成，有没有错误需要修正
- 迭代执行：如果数据获取失败，自动换个数据源重试；如果图表不符合要求，自动调整代码重新生成
- 完成交付：所有步骤完成后，自动撰写报告，调用邮件工具发送到你的邮箱，全程无需你任何干预
这就是 AI Agent 的魔力——它把大模型从一个「聊天机器人」变成了一个「能帮你解决实际问题的智能助理」，也是目前公认的通用人工智能（AGI）的核心落地形态。
很多人说 AI Agent 门槛很高，其实完全不是。现在的开发生态已经极度成熟，你不需要自己训练大模型，不需要懂 Transformer 底层原理，只要会基础的 Python，跟着这篇教程，就能从零开发出属于自己的 AI Agent。
这篇保姆级教程的上篇，我们会彻底搞定单 Agent 开发的全链路核心能力，从原理到代码，从理论到实战，一步都不落下。
2. 核心基石：AI Agent 的核心原理与六大核心组件
在动手写代码之前，我们必须先搞懂 AI Agent 的核心逻辑。很多人学 Agent 只会调 LangChain 的封装，却不懂底层原理，遇到问题根本不知道怎么调试，这就是我们要先解决的问题。
2.1 AI Agent 的本质
AI Agent 的本质，是以大语言模型（LLM）为核心决策大脑，通过模块化的组件，实现自主感知、规划、执行、反思的闭环智能系统。
简单来说：LLM 是大脑，Agent 是给大脑搭建的完整「身体」。没有身体的大脑，只能空想；没有大脑的身体，只是一堆没有灵魂的代码。
2.2 AI Agent 六大核心组件
一个完整的、可落地的 AI Agent，必须包含以下 6 个核心组件，缺一不可。我会用最通俗的语言给你讲透每个组件的作用，零基础也能一眼看懂。
| 组件名称 | 核心作用 | 通俗类比 | 核心实现 |
|---|---|---|---|
| 核心大脑（LLM Core） | Agent 的决策中心，负责所有的思考、规划、判断、推理 | 人的大脑 | GPT-4o、Claude 3、Llama 3、Qwen 2 等大模型，仅需调用 API |
| 规划模块（Planning） | 把复杂的大目标拆解成可执行的子任务，制定执行计划 | 人的规划能力 | ReAct 框架、思维链（CoT）、思维树（ToT）、反思迭代 |
| 工具调用模块（Tool Use） | Agent 的「手脚」，让 LLM 能和真实世界交互，突破自身能力限制 | 人的手和脚 | 搜索引擎、计算器、Python 解释器、API 调用、文件操作等自定义工具 |
| 记忆模块（Memory） | Agent 的「大脑记忆」，存储历史对话、用户偏好、执行经验，实现长期个性化交互 | 人的记忆 | 短期记忆（上下文窗口）、长期记忆（向量数据库+RAG 检索） |
| 执行模块（Execution） | 负责落地规划的步骤，调用对应工具，处理执行异常，返回结果 | 人的行动能力 | 工具调度器、异常处理、重试机制 |
| 反思与迭代模块（Reflection） | Agent 的「复盘能力」，判断任务进度，修正错误，优化执行方案 | 人的复盘反思 | 结果校验、错误归因、方案调整、循环终止判断 |
2.3 AI Agent 核心工作闭环
所有 AI Agent 的运行，都是围绕这 6 个组件的无限循环，直到任务完成。核心流程如下：
用户输入目标 → 规划模块拆解任务 → 工具调用模块选择工具 → 执行模块执行工具
↑ ↓
反思迭代模块校验结果 ← 大脑处理执行结果 ← 记忆模块存储执行过程
这个闭环，就是 AI Agent 能自主完成任务的核心逻辑。接下来的所有内容，都是围绕这个闭环，把每个模块拆解开，从零实现，再整合到一起。
3. 灵魂框架：ReAct 框架深度拆解与从零实现
如果说 LLM 是 Agent 的大脑，那 ReAct 框架就是 Agent 的灵魂。它是目前工业界最主流、最稳定、落地性最强的 Agent 执行框架，没有之一。我们必须把它彻底学透。
3.1 ReAct 框架是什么？
ReAct 框架由 Google Brain 和普林斯顿大学在 2022 年的论文《ReAct: Synergizing Reasoning and Acting in Language Models》中提出，核心是 Reasoning（推理） + Acting（行动） 的循环闭环。
它彻底解决了传统大模型的两个核心痛点：
- 幻觉问题：传统大模型会编造不存在的信息，而 ReAct 要求所有结论必须基于行动后的真实结果
- 无法落地：传统大模型只会空想，而 ReAct 把推理和行动结合，思考一步、行动一步、拿到结果再思考下一步，真正解决问题
3.2 ReAct 与 思维链（CoT）的核心区别
很多同学会把 ReAct 和 CoT 搞混，这里一句话讲透：
- 思维链（CoT）：只停留在「思考」层面，让大模型把思考过程一步步说出来，但全程没有任何实际行动，还是「纸上谈兵」
- ReAct 框架：「思考→行动→观察→再思考」的完整闭环，思考是为了行动，行动的结果反过来指导下一步思考，真正做到「知行合一」
3.3 ReAct 框架的核心循环流程
ReAct 的执行过程，严格遵循 4 步循环，直到任务完成，输出最终答案。我用一个最直观的例子给你讲明白：
用户需求：2026 年 4 月 18 日，广州番禺的天气是多少？
| 步骤 | 内容示例 | 核心作用 |
|---|---|---|
| Thought（思考） | 用户需要今天广州番禺的实时天气，我的训练数据没有实时信息，必须调用天气查询工具，输入地点广州番禺，日期2026-04-18 | 明确当前要做什么，为什么要这么做，制定行动方案 |
| Action（行动） | 调用【天气查询工具】，参数：city=广州番禺，date=2026-04-18 | 基于思考结果，执行具体的工具调用，明确工具名称和参数 |
| Observation（观察） | 2026年4月18日，广州番禺，多云，气温22-28℃，南风3级，湿度65% | 获取工具执行后的真实结果，作为下一步思考的依据 |
| 循环/终止 | 思考：我已经拿到了完整的天气信息，可以输出最终答案了 → 输出 Final Answer | 基于观察结果，判断是否继续循环，还是任务完成 |
就是这么一个简单的循环，却能支撑起几乎所有复杂的 Agent 任务。接下来，我们就从零开始，用 Python 实现一个完整的 ReAct 框架。
3.4 从零实现 ReAct 框架（保姆级代码）
3.4.1 环境准备
首先，我们安装必要的依赖，配置基础环境：
# 安装核心依赖
pip install openai python-dotenv
然后，在项目根目录创建 .env 文件，配置你的 OpenAI API Key：
# .env 文件
OPENAI_API_KEY=你的OpenAI API Key
OPENAI_BASE_URL=https://api.openai.com/v1 # 如有代理地址可配置
3.4.2 第一步：封装 LLM 核心调用函数
我们先封装一个通用的 LLM 调用函数，后续所有的推理都会用到它，代码可直接复用：
# llm.py
import os
from dotenv import load_dotenv
from openai import OpenAI
# 加载环境变量
load_dotenv()
# 初始化 OpenAI 客户端
client = OpenAI(
api_key=os.getenv("OPENAI_API_KEY"),
base_url=os.getenv("OPENAI_BASE_URL")
)
def llm_call(messages, model="gpt-3.5-turbo", temperature=0):
"""
通用 LLM 调用函数
:param messages: 对话上下文列表
:param model: 调用的模型名称
:param temperature: 温度值，0 表示输出最稳定，无随机性
:return: 大模型的输出内容
"""
response = client.chat.completions.create(
model=model,
messages=messages,
temperature=temperature
)
return response.choices[0].message.content.strip()
# 测试函数
if __name__ == "__main__":
test_messages = [{"role": "user", "content": "你好，请问你能做什么？"}]
print(llm_call(test_messages))
运行这段代码，如果能正常输出大模型的回复，说明环境配置成功了。
3.4.3 第二步：编写 ReAct 核心提示词模板
提示词是 ReAct 框架的核心，它决定了大模型能不能严格按照 ReAct 的格式输出，会不会乱编内容。我们必须写得足够严谨、清晰，给大模型明确的指令。
这里我给你一个工业级可用的 ReAct 提示词模板，经过无数次调优，稳定性极强：
# react_prompt.py
REACT_SYSTEM_PROMPT = """
你是一个基于 ReAct 框架的智能 AI Agent，你必须严格按照以下规则执行任务，绝对不能违反。
## 核心规则
1. 你的执行过程必须严格遵循「Thought → Action → Observation」的循环，直到任务完成，输出 Final Answer
2. 你只能在 Thought 中思考，在 Action 中执行工具调用，在 Observation 中接收工具返回的结果，绝对不能编造 Observation 的内容
3. 你所有的结论必须基于 Observation 的真实结果，绝对不能编造、虚构任何不存在的信息，严禁出现幻觉
4. 每次循环只能执行一个 Action，绝对不能一次执行多个 Action
5. 只有当你确认已经获取了足够的信息，完成了用户的目标，才能输出 Final Answer
## 执行格式规范
你必须严格按照以下格式输出，绝对不能修改格式：
1. 思考阶段：必须以「Thought: 」开头，写下你当前的思考内容，明确你要做什么、为什么要这么做
2. 行动阶段：必须以「Action: 」开头，写下你要调用的工具名称和参数，格式为「工具名称|参数1=值1&参数2=值2」
3. 观察阶段：我会给你返回「Observation: 」开头的工具执行结果，你必须基于这个结果进行下一步思考
4. 终止阶段：当任务完成时，必须以「Final Answer: 」开头，写下最终的答案
## 可用工具列表
你只能使用以下提供的工具，绝对不能使用不存在的工具：
- 计算器工具：用于执行数学计算，参数为 expression，格式为 计算器工具|expression=计算表达式
- 示例：Action: 计算器工具|expression=100*20+50
## 补充规则
- 如果你多次执行 Action 都无法获取正确结果，请停止循环，在 Final Answer 中说明原因
- 你必须用中文进行思考和输出，绝对不能使用英文
- 不要和用户对话，不要问用户额外的问题，只专注于完成用户给定的目标
"""
这个提示词里，我们先只给了一个「计算器工具」，用来测试 ReAct 框架的核心逻辑，后续我们会添加更多工具。
3.4.4 第三步：实现工具执行函数
接下来，我们实现工具的执行逻辑，解析大模型输出的 Action，调用对应的工具，返回结果：
# tools.py
def calculator_tool(expression):
"""
计算器工具：执行数学计算
:param expression: 数学计算表达式，比如 "100*20+50"
:return: 计算结果
"""
try:
# 安全计算，禁止执行危险代码
result = eval(expression, {"__builtins__": None}, {})
return f"计算结果：{expression} = {result}"
except Exception as e:
return f"计算错误：{str(e)}"
# 工具映射表：把工具名称和对应的执行函数关联起来
TOOL_MAP = {
"计算器工具": calculator_tool
}
def execute_action(action_str):
"""
解析 Action 字符串，执行对应的工具，返回结果
:param action_str: 大模型输出的 Action 内容，格式为「工具名称|参数1=值1&参数2=值2」
:return: Observation 结果
"""
try:
# 拆分工具名称和参数
tool_name, params_str = action_str.split("|", 1)
# 解析参数
params = {}
for param in params_str.split("&"):
key, value = param.split("=", 1)
params[key.strip()] = value.strip()
# 检查工具是否存在
if tool_name not in TOOL_MAP:
return f"错误：不存在工具【{tool_name}】，请使用可用的工具"
# 执行工具
tool_func = TOOL_MAP[tool_name]
return tool_func(**params)
except Exception as e:
return f"Action 解析错误：{str(e)}，请严格按照指定格式输出 Action"
这里我们做了安全限制，eval 函数禁止执行内置函数，避免恶意代码执行，同时做了完整的异常处理，保证框架的稳定性。
3.4.5 第四步：实现 ReAct 核心循环逻辑
最后，我们把所有模块整合起来，实现 ReAct 的核心循环，这是整个框架的入口：
# react_agent.py
from llm import llm_call
from react_prompt import REACT_SYSTEM_PROMPT
from tools import execute_action
def react_agent_run(user_query, max_loop=10):
"""
ReAct Agent 核心运行函数
:param user_query: 用户的目标/问题
:param max_loop: 最大循环次数，防止死循环
:return: 最终答案
"""
# 初始化对话上下文，先加入系统提示词
messages = [
{"role": "system", "content": REACT_SYSTEM_PROMPT},
{"role": "user", "content": user_query}
]
# 循环次数计数器
loop_count = 0
print(f"===== 开始执行 ReAct Agent，用户目标：{user_query} =====")
while loop_count < max_loop:
loop_count += 1
print(f"\n----- 第 {loop_count} 次循环 -----")
# 调用 LLM 进行推理
llm_output = llm_call(messages)
print(f"LLM 输出：\n{llm_output}")
# 把 LLM 输出加入上下文
messages.append({"role": "assistant", "content": llm_output})
# 判断是否输出了 Final Answer，任务完成
if "Final Answer:" in llm_output:
final_answer = llm_output.split("Final Answer:")[-1].strip()
print(f"\n===== 任务完成，最终答案：{final_answer} =====")
return final_answer
# 解析 Action
if "Action:" in llm_output:
# 提取 Action 内容
action_str = llm_output.split("Action:")[-1].strip()
print(f"解析到 Action：{action_str}")
# 执行 Action，获取 Observation
observation = execute_action(action_str)
observation_content = f"Observation: {observation}"
print(f"执行结果：{observation_content}")
# 把 Observation 加入上下文
messages.append({"role": "user", "content": observation_content})
# 没有 Action 也没有 Final Answer，格式错误
else:
error_msg = "Observation: 你没有按照格式输出 Action 或 Final Answer，请严格遵守规则输出"
print(error_msg)
messages.append({"role": "user", "content": error_msg})
# 超过最大循环次数，强制终止
print(f"\n===== 任务失败，超过最大循环次数 {max_loop} =====")
return "任务执行失败，已超过最大尝试次数，请简化你的需求后重试"
# 测试 ReAct Agent
if __name__ == "__main__":
# 测试用例1：简单计算
react_agent_run("请问 234*567+890 的结果是多少？")
# 测试用例2：复杂计算
# react_agent_run("一个长方形的长是 25.5 厘米，宽是 12.8 厘米，请问它的面积是多少平方米？")
3.4.6 运行测试，见证奇迹
现在，运行 react_agent.py 文件，你会看到 Agent 完整的执行过程：
- 首先输出 Thought，思考需要调用计算器工具
- 输出 Action，指定工具名称和计算表达式
- 执行工具，返回 Observation 计算结果
- 再次思考，确认结果正确，输出 Final Answer
恭喜你！你已经从零实现了一个完整的 ReAct 框架，这是 AI Agent 开发最核心的一步。市面上所有的 Agent 框架，包括 LangChain、AutoGPT，底层核心都是这个 ReAct 循环。
3.5 ReAct 框架进阶优化技巧
这里给你几个工业级的优化技巧，解决新手最容易遇到的问题：
- 解决格式错误问题：在提示词里加入更多的示例，给大模型明确的格式参考；用正则表达式强制解析 Thought/Action，提升容错率
- 解决死循环问题：除了设置最大循环次数，还可以在提示词里要求 Agent 记录每次的执行结果，避免重复执行相同的 Action
- 解决幻觉问题：在提示词里强制要求 Agent 必须标注所有信息的来源，所有结论必须有对应的 Observation 支撑
- 提升执行效率：对于简单的问题，允许 Agent 直接输出 Final Answer，不需要调用工具，减少不必要的循环
4. 能力延伸：Agent 基础工具调用完整实现（含自定义工具）
ReAct 框架搭好了，现在我们要给 Agent 装上「手脚」——工具调用。这是 Agent 突破大模型自身限制，能解决真实世界问题的核心能力。
4.1 工具调用的本质
工具调用的本质，是大模型根据用户的需求，自动判断需要调用的工具，生成符合工具要求的参数，程序执行工具后，把结果返回给大模型。
现在主流的大模型（GPT-3.5/4o、Claude 3、Qwen 2、Llama 3）都原生支持 Tool Calling（之前叫 Function Calling），是大模型经过微调后专门优化的能力，比纯提示词实现的工具调用稳定 10 倍以上。
接下来，我们会先讲工具的标准定义，然后实现多个常用的自定义工具，最后把工具集成到我们的 ReAct Agent 里，让 Agent 拥有更强大的能力。
4.2 工具的标准定义
一个工业级可用的工具，必须包含 4 个核心要素，缺一不可：
- 工具名称：唯一标识，大模型用来指定调用的工具，必须简洁清晰
- 工具描述：给大模型看的说明，明确告诉大模型这个工具是做什么的，什么时候应该用这个工具，是大模型选择工具的核心依据
- 参数定义：用 JSON Schema 格式定义工具需要的参数，包括参数名称、类型、是否必填、描述，大模型会根据这个定义生成正确的参数
- 执行函数：工具的具体实现代码，接收参数，执行逻辑，返回结果
4.3 从零实现常用自定义工具
我们来实现 4 个 Agent 开发中最常用的工具，覆盖 90% 的日常场景，你可以直接复用，也可以基于这个模板开发自己的自定义工具。
4.3.1 环境准备，安装新的依赖
# 安装新的依赖
pip install serpapi requests
SerpAPI 是一个搜索引擎聚合 API，提供免费额度，用来实现谷歌/百度搜索功能，注册地址：https://serpapi.com/，注册后拿到 API Key，添加到 .env 文件里：
# .env 文件新增
SERPAPI_API_KEY=你的SerpAPI API Key
4.3.2 工具1：搜索引擎工具（实时信息获取）
解决大模型训练数据过时，无法获取实时信息的问题，是 Agent 最核心的工具之一：
# tools.py 新增
import os
import requests
from dotenv import load_dotenv
load_dotenv()
SERPAPI_API_KEY = os.getenv("SERPAPI_API_KEY")
def search_tool(query, num_results=5):
"""
搜索引擎工具：获取实时网络信息，解决实时信息、未知知识查询的问题
:param query: 搜索关键词，必须清晰明确
:param num_results: 返回的搜索结果数量，默认5条
:return: 搜索结果
"""
try:
params = {
"q": query,
"api_key": SERPAPI_API_KEY,
"num": num_results,
"hl": "zh-CN",
"gl": "cn"
}
response = requests.get("https://serpapi.com/search", params=params)
response.raise_for_status()
search_results = response.json()
# 解析搜索结果，只保留核心信息
results = []
if "organic_results" in search_results:
for result in search_results["organic_results"][:num_results]:
results.append({
"标题": result.get("title"),
"摘要": result.get("snippet"),
"链接": result.get("link")
})
if not results:
return "搜索结果为空，没有找到相关信息，请更换搜索关键词重试"
# 格式化返回结果
result_str = f"搜索关键词：{query}\n搜索结果：\n"
for i, item in enumerate(results, 1):
result_str += f"{i}. 标题：{item['标题']}\n 摘要：{item['摘要']}\n 链接：{item['链接']}\n\n"
return result_str
except Exception as e:
return f"搜索工具执行错误：{str(e)}"
# 更新工具映射表
TOOL_MAP = {
"计算器工具": calculator_tool,
"搜索引擎工具": search_tool
}
4.3.3 工具2：Python 代码执行工具（数据分析/可视化）
让 Agent 能编写并执行 Python 代码，完成复杂的数据分析、可视化、文件处理等任务，是 Agent 最强大的工具之一：
# tools.py 新增
import io
import contextlib
import matplotlib.pyplot as plt
# 禁止中文乱码
plt.rcParams["font.family"] = ["SimHei", "WenQuanYi Micro Hei", "Heiti TC"]
plt.rcParams["axes.unicode_minus"] = False
def python_exec_tool(code):
"""
Python 代码执行工具：执行 Python 代码，完成数据分析、可视化、文件处理等任务
:param code: 要执行的 Python 代码，必须完整可运行
:return: 代码执行的输出结果
"""
try:
# 捕获标准输出
output_buffer = io.StringIO()
with contextlib.redirect_stdout(output_buffer):
# 安全执行代码，限制内置函数，禁止危险操作
exec(code, {"__builtins__": __builtins__}, {"plt": plt})
output = output_buffer.getvalue()
if not output:
output = "代码执行成功，无输出内容"
return f"Python 代码执行结果：\n{output}"
except Exception as e:
return f"Python 代码执行错误：{str(e)}"
# 更新工具映射表
TOOL_MAP = {
"计算器工具": calculator_tool,
"搜索引擎工具": search_tool,
"Python代码执行工具": python_exec_tool
}
4.3.4 工具3：文件读写工具（本地文件操作）
让 Agent 能读取、写入本地文件，完成文档处理、代码生成、数据存储等任务：
# tools.py 新增
def file_read_tool(file_path):
"""
文件读取工具：读取本地文件的内容
:param file_path: 要读取的文件路径，相对路径或绝对路径
:return: 文件内容
"""
try:
with open(file_path, "r", encoding="utf-8") as f:
content = f.read()
return f"文件 {file_path} 读取成功，内容：\n{content}"
except Exception as e:
return f"文件读取错误：{str(e)}"
def file_write_tool(file_path, content):
"""
文件写入工具：将内容写入本地文件，覆盖原有内容
:param file_path: 要写入的文件路径
:param content: 要写入的文件内容
:return: 写入结果
"""
try:
with open(file_path, "w", encoding="utf-8") as f:
f.write(content)
return f"文件 {file_path} 写入成功，共写入 {len(content)} 个字符"
except Exception as e:
return f"文件写入错误：{str(e)}"
# 更新工具映射表
TOOL_MAP = {
"计算器工具": calculator_tool,
"搜索引擎工具": search_tool,
"Python代码执行工具": python_exec_tool,
"文件读取工具": file_read_tool,
"文件写入工具": file_write_tool
}
4.4 升级 ReAct 提示词，支持多工具自动选择
现在，我们需要更新 ReAct 的系统提示词，把新增的工具加进去，让大模型能自动选择合适的工具：
# react_prompt.py 更新 REACT_SYSTEM_PROMPT 中的可用工具列表
REACT_SYSTEM_PROMPT = """
你是一个基于 ReAct 框架的智能 AI Agent，你必须严格按照以下规则执行任务，绝对不能违反。
## 核心规则
1. 你的执行过程必须严格遵循「Thought → Action → Observation」的循环，直到任务完成，输出 Final Answer
2. 你只能在 Thought 中思考，在 Action 中执行工具调用，在 Observation 中接收工具返回的结果，绝对不能编造 Observation 的内容
3. 你所有的结论必须基于 Observation 的真实结果，绝对不能编造、虚构任何不存在的信息，严禁出现幻觉
4. 每次循环只能执行一个 Action，绝对不能一次执行多个 Action
5. 只有当你确认已经获取了足够的信息，完成了用户的目标，才能输出 Final Answer
## 执行格式规范
你必须严格按照以下格式输出，绝对不能修改格式：
1. 思考阶段：必须以「Thought: 」开头，写下你当前的思考内容，明确你要做什么、为什么要这么做
2. 行动阶段：必须以「Action: 」开头，写下你要调用的工具名称和参数，格式为「工具名称|参数1=值1&参数2=值2」
3. 观察阶段：我会给你返回「Observation: 」开头的工具执行结果，你必须基于这个结果进行下一步思考
4. 终止阶段：当任务完成时，必须以「Final Answer: 」开头，写下最终的答案
## 可用工具列表
你只能使用以下提供的工具，绝对不能使用不存在的工具：
1. 计算器工具：用于执行数学计算，必填参数为 expression，格式为 计算器工具|expression=计算表达式
示例：Action: 计算器工具|expression=100*20+50
2. 搜索引擎工具：用于获取实时网络信息、新闻、天气、未知知识等，必填参数为 query，可选参数 num_results
示例：Action: 搜索引擎工具|query=2026年4月18日广州番禺天气&num_results=3
3. Python代码执行工具：用于执行Python代码，完成数据分析、可视化、文件处理等任务，必填参数为 code
示例：Action: Python代码执行工具|code=print("hello world")
4. 文件读取工具：用于读取本地文件内容，必填参数为 file_path
示例：Action: 文件读取工具|file_path=./data.csv
5. 文件写入工具：用于将内容写入本地文件，必填参数为 file_path 和 content
示例：Action: 文件写入工具|file_path=./test.txt&content=你好世界
## 补充规则
- 如果你多次执行 Action 都无法获取正确结果，请停止循环，在 Final Answer 中说明原因
- 你必须用中文进行思考和输出，绝对不能使用英文
- 不要和用户对话，不要问用户额外的问题，只专注于完成用户给定的目标
- 对于需要实时信息的问题，必须使用搜索引擎工具，绝对不能编造过时的信息
- 对于复杂的计算、数据分析、可视化任务，必须使用Python代码执行工具
"""
4.5 测试升级后的 Agent 能力
现在，我们来测试一下 Agent 的新能力，运行 react_agent.py，试试这些需求：
# 测试实时信息查询
react_agent_run("2026年4月18日广州番禺的天气是多少？")
# 测试数据分析与可视化
react_agent_run("生成100个符合正态分布的随机数，画出直方图和正态分布曲线，保存为plot.png文件")
# 测试文件操作
react_agent_run("写一首关于春天的七言绝句，保存到spring_poem.txt文件里")
你会发现，Agent 能自动判断需要调用的工具，自主执行，完成所有的任务！
4.6 工具调用最佳实践
这里给你几个工业级的工具开发最佳实践，避坑指南：
- 工具描述要精准：工具的描述必须明确「什么时候用」、「能做什么」、「不能做什么」，描述越精准，大模型选择工具的准确率越高
- 参数定义要清晰：必填参数必须明确标注，每个参数都要有清晰的描述，最好给示例，减少大模型生成错误参数的概率
- 安全第一：绝对不要给工具过高的系统权限，比如执行系统命令、删除文件等，必须做严格的权限限制和异常处理
- 结果要精简：工具返回的结果要尽量精简，只保留核心信息，避免超长内容占用上下文窗口，影响大模型的推理
- 错误提示要友好：工具执行出错时，返回的错误信息要明确，告诉大模型哪里错了，应该怎么修正，方便 Agent 自动重试
5. 长期记忆：Agent 记忆管理系统设计与落地
现在，我们的 Agent 已经能思考、能行动、能调用工具了，但它还有一个致命的问题：没有长期记忆。
比如你告诉它「我叫小张，是一名大二的人工智能专业学生」，下次对话它就完全忘了，因为每次运行 Agent，上下文都是全新的。没有记忆的 Agent，永远只能做一次性的任务，无法实现个性化、长周期的交互。
这一节，我们就给 Agent 装上「大脑记忆」，实现完整的记忆管理系统。
5.1 记忆的分类：对应人类认知科学
我们按照人类的认知科学，把 Agent 的记忆分为 3 类，每一类都有明确的作用和实现方式：
| 记忆类型 | 核心作用 | 对应 Agent 实现 | 存储方式 |
|---|---|---|---|
| 感官记忆 | 瞬时接收的信息，实时输入 | 用户当前提问、工具返回的实时结果 | 临时变量，单次循环内有效 |
| 短期记忆（工作记忆） | 当前任务的执行过程、对话上下文，正在处理的信息 | ReAct 循环的 Thought/Action/Observation、当前对话的上下文 | LLM 上下文窗口，内存缓存 |
| 长期记忆 | 历史对话、用户偏好、过往的执行经验、成功/失败的案例，需要长期保存的信息 | 用户的个人信息、历史任务记录、知识沉淀 | 向量数据库 + 关系型数据库，持久化存储 |
5.2 短期记忆管理：优化上下文，避免窗口溢出
短期记忆的核心问题，是 LLM 的上下文窗口是有限的，比如 GPT-3.5-turbo 是 16K 窗口，GPT-4o 是 128K 窗口，如果对话太长，就会超出窗口，导致程序报错。
我们给 Agent 实现一个短期记忆管理器，核心优化逻辑：
- 保留系统提示词，永远放在上下文的最前面
- 保留最近的 N 轮对话，过滤掉太旧的内容
- 对超长的工具返回结果，自动做摘要精简，只保留核心信息
- 对历史对话做定期总结，把多轮对话压缩成一段摘要，节省窗口空间
这里我们实现一个极简的短期记忆管理器：
# memory.py
def build_short_term_memory(messages, max_history_rounds=10, max_observation_length=500):
"""
构建短期记忆，优化上下文，避免窗口溢出
:param messages: 完整的对话上下文列表
:param max_history_rounds: 保留的最大对话轮数，一轮=assistant+user
:param max_observation_length: Observation 的最大长度，超过自动截断
:return: 优化后的对话上下文
"""
# 系统提示词永远保留
system_prompt = messages[0]
optimized_messages = [system_prompt]
# 过滤掉系统提示词，只保留对话内容
conversation = messages[1:]
# 每两轮为一个对话回合，保留最近的 max_history_rounds 轮
start_index = max(0, len(conversation) - max_history_rounds * 2)
recent_conversation = conversation[start_index:]
# 处理超长的 Observation，自动截断
for msg in recent_conversation:
content = msg["content"]
if "Observation:" in content and len(content) > max_observation_length:
# 截断超长内容，保留开头和结尾
truncated_content = content[:max_observation_length] + "\n...（内容过长，已截断）"
optimized_messages.append({"role": msg["role"], "content": truncated_content})
else:
optimized_messages.append(msg)
return optimized_messages
然后，我们更新 ReAct Agent 的核心循环，在每次调用 LLM 之前，都用这个函数优化上下文：
# react_agent.py 中，在调用 llm_call 之前，加入上下文优化
# 调用 LLM 进行推理
optimized_messages = build_short_term_memory(messages)
llm_output = llm_call(optimized_messages)
5.3 长期记忆管理：向量数据库 + RAG 检索
长期记忆的核心挑战，是我们不能把所有的历史记忆都塞到上下文窗口里，所以需要用 RAG（检索增强生成） 的思路：
- 记忆存储：把历史对话、用户偏好等长期记忆，用 Embedding 模型转换成向量，存储到向量数据库里
- 记忆检索：当用户输入新的问题时，先从向量数据库里检索和当前问题最相关的记忆内容
- 记忆注入：把检索到的相关记忆，注入到上下文的开头，让大模型能用到过往的信息
接下来，我们从零实现一个完整的长期记忆系统。
5.3.1 环境准备，安装向量数据库依赖
# 安装向量数据库 Chroma 和 Embedding 依赖
pip install chromadb langchain-openai
5.3.2 实现长期记忆管理器
# memory.py 新增
import os
import chromadb
from dotenv import load_dotenv
from langchain_openai import OpenAIEmbeddings
from chromadb.utils import embedding_functions
load_dotenv()
# 初始化 Embedding 模型，用于把文本转换成向量
embedding_model = OpenAIEmbeddings(
model="text-embedding-3-small",
api_key=os.getenv("OPENAI_API_KEY"),
base_url=os.getenv("OPENAI_BASE_URL")
)
# 适配 Chroma 的 Embedding 函数
openai_ef = embedding_functions.OpenAIEmbeddingFunction(
api_key=os.getenv("OPENAI_API_KEY"),
api_base=os.getenv("OPENAI_BASE_URL"),
model_name="text-embedding-3-small"
)
# 初始化 Chroma 向量数据库客户端
chroma_client = chromadb.PersistentClient(path="./agent_memory")
# 创建记忆集合
memory_collection = chroma_client.get_or_create_collection(
name="agent_long_term_memory",
embedding_function=openai_ef,
metadata={"description": "AI Agent 长期记忆存储"}
)
class LongTermMemory:
def __init__(self, user_id="default_user"):
self.user_id = user_id
def add_memory(self, memory_content, memory_type="conversation"):
"""
添加一条长期记忆
:param memory_content: 记忆内容，文本格式
:param memory_type: 记忆类型，conversation=对话记忆，user_preference=用户偏好，task_experience=任务经验
"""
# 生成唯一的记忆ID
memory_id = f"{self.user_id}_{memory_type}_{chroma_client.max_batch_size + 1}"
# 写入向量数据库
memory_collection.add(
documents=[memory_content],
metadatas=[{"user_id": self.user_id, "memory_type": memory_type}],
ids=[memory_id]
)
print(f"已添加长期记忆：{memory_content[:50]}...")
def search_memory(self, query, top_k=3):
"""
检索和当前查询相关的长期记忆
:param query: 当前用户的查询/目标
:param top_k: 返回最相关的记忆数量
:return: 相关记忆列表
"""
results = memory_collection.query(
query_texts=[query],
n_results=top_k,
where={"user_id": self.user_id}
)
if not results["documents"][0]:
return []
# 格式化返回结果
related_memories = []
for doc, metadata in zip(results["documents"][0], results["metadatas"][0]):
related_memories.append({
"content": doc,
"type": metadata["memory_type"]
})
return related_memories
def build_memory_prompt(self, query):
"""
构建记忆提示词，把相关的长期记忆注入到上下文里
:param query: 当前用户的查询/目标
:return: 记忆提示词文本
"""
related_memories = self.search_memory(query)
if not related_memories:
return ""
memory_prompt = "## 相关历史记忆\n以下是和当前用户需求相关的历史记忆，你可以参考这些信息：\n"
for i, memory in enumerate(related_memories, 1):
memory_prompt += f"{i}. {memory['content']}\n"
return memory_prompt
5.3.3 把长期记忆集成到 ReAct Agent 里
现在，我们更新 ReAct Agent 的代码，把长期记忆集成进去，让 Agent 能记住用户的偏好和历史对话：
# react_agent.py 更新
from llm import llm_call
from react_prompt import REACT_SYSTEM_PROMPT
from tools import execute_action
from memory import build_short_term_memory, LongTermMemory
def react_agent_run(user_query, user_id="default_user", max_loop=10):
"""
ReAct Agent 核心运行函数，集成长期记忆
:param user_query: 用户的目标/问题
:param user_id: 用户ID，用于区分不同用户的记忆
:param max_loop: 最大循环次数，防止死循环
:return: 最终答案
"""
# 初始化长期记忆
long_term_memory = LongTermMemory(user_id=user_id)
# 检索相关的长期记忆，构建记忆提示词
memory_prompt = long_term_memory.build_memory_prompt(user_query)
# 构建系统提示词，注入长期记忆
system_prompt = REACT_SYSTEM_PROMPT
if memory_prompt:
system_prompt += "\n\n" + memory_prompt
# 初始化对话上下文
messages = [
{"role": "system", "content": system_prompt},
{"role": "user", "content": user_query}
]
loop_count = 0
full_process = [] # 存储完整的执行过程，用于保存到长期记忆
print(f"===== 开始执行 ReAct Agent，用户目标：{user_query} =====")
while loop_count < max_loop:
loop_count += 1
print(f"\n----- 第 {loop_count} 次循环 -----")
# 优化短期记忆，避免上下文溢出
optimized_messages = build_short_term_memory(messages)
# 调用 LLM 进行推理
llm_output = llm_call(optimized_messages)
print(f"LLM 输出：\n{llm_output}")
# 把 LLM 输出加入上下文和执行过程
messages.append({"role": "assistant", "content": llm_output})
full_process.append(llm_output)
# 判断是否输出了 Final Answer，任务完成
if "Final Answer:" in llm_output:
final_answer = llm_output.split("Final Answer:")[-1].strip()
print(f"\n===== 任务完成，最终答案：{final_answer} =====")
# 把任务执行过程保存到长期记忆
memory_content = f"用户需求：{user_query}\n执行结果：{final_answer}\n执行过程：{'; '.join(full_process)}"
long_term_memory.add_memory(memory_content, memory_type="task_experience")
# 把用户的偏好信息保存到长期记忆
if "我叫" in user_query or "我是" in user_query or "我喜欢" in user_query:
long_term_memory.add_memory(user_query, memory_type="user_preference")
return final_answer
# 解析 Action
if "Action:" in llm_output:
action_str = llm_output.split("Action:")[-1].strip()
print(f"解析到 Action：{action_str}")
# 执行 Action，获取 Observation
observation = execute_action(action_str)
observation_content = f"Observation: {observation}"
print(f"执行结果：{observation_content}")
# 把 Observation 加入上下文和执行过程
messages.append({"role": "user", "content": observation_content})
full_process.append(observation_content)
# 格式错误处理
else:
error_msg = "Observation: 你没有按照格式输出 Action 或 Final Answer，请严格遵守规则输出"
print(error_msg)
messages.append({"role": "user", "content": error_msg})
full_process.append(error_msg)
# 超过最大循环次数，强制终止
print(f"\n===== 任务失败，超过最大循环次数 {max_loop} =====")
return "任务执行失败，已超过最大尝试次数，请简化你的需求后重试"
# 测试长期记忆能力
if __name__ == "__main__":
# 第一次对话，告诉 Agent 你的信息
react_agent_run("我叫小张，是一名大二的人工智能专业学生，我喜欢用Python做数据分析，以后叫我小张就好", user_id="zhang")
# 第二次对话，测试记忆能力
react_agent_run("你还记得我叫什么吗？我是学什么专业的？我喜欢用什么做数据分析？", user_id="zhang")
5.3.4 运行测试，见证记忆能力
运行代码，你会发现，第二次对话的时候，Agent 能准确说出你的名字、专业和偏好！它已经真正拥有了长期记忆能力。
5.4 记忆管理最佳实践
- 记忆分类存储：把用户偏好、对话历史、任务经验分开存储，检索的时候可以按类型过滤，提升准确率
- 记忆质量优先：不是所有内容都要存到长期记忆里，只存储有价值的信息，比如用户的核心偏好、重要的任务经验，避免记忆污染
- 混合检索提升准确率：除了向量检索，还可以加上关键词检索、时间过滤，提升记忆检索的准确率
- 记忆遗忘机制：给记忆加上权重，重要的记忆权重高，长期保留；不重要的记忆权重低，定期清理，避免记忆库越来越大
- 隐私保护：用户的敏感信息，比如手机号、身份证号、地址等，必须加密存储，绝对不能泄露
6. 全链路实战：从零开发一个完整的单 Agent 智能助手
恭喜你！到这里，你已经掌握了 AI Agent 所有的核心模块：ReAct 框架、工具调用、记忆管理。现在，我们把所有模块整合起来，开发一个完整的、工业级可用的单 Agent 智能助手，真正实现从零到一的落地。
6.1 智能助手的核心能力
我们要开发的这个 Agent，具备以下完整能力：
- 实时信息查询：天气、新闻、股票、热点事件等
- 数学计算与数据分析：复杂计算、数据处理、可视化
- 代码开发与执行：Python 代码编写、运行、调试
- 文件操作：读取、写入、修改本地文件
- 长期记忆：记住用户的偏好、历史对话、任务经验
- 自主规划与执行：基于 ReAct 框架，完成复杂的多步骤任务
6.2 完整的项目结构
我们把所有代码整理成规范的项目结构，方便后续扩展：
agent_tutorial/
├── .env # 环境变量配置
├── llm.py # LLM 调用封装
├── react_prompt.py # ReAct 提示词模板
├── tools.py # 工具定义与执行
├── memory.py # 记忆管理系统
├── agent.py # 完整的 Agent 封装
└── test_agent.py # 测试文件
6.3 完整的 Agent 封装代码
我们把所有模块整合起来，封装成一个 IntelligentAgent 类，提供简单易用的接口：
# agent.py
from llm import llm_call
from react_prompt import REACT_SYSTEM_PROMPT
from tools import execute_action, TOOL_MAP
from memory import build_short_term_memory, LongTermMemory
class IntelligentAgent:
def __init__(self, user_id="default_user", model="gpt-3.5-turbo", max_loop=15):
"""
初始化智能 Agent
:param user_id: 用户ID，区分不同用户的记忆
:param model: 使用的大模型
:param max_loop: 最大循环次数
"""
self.user_id = user_id
self.model = model
self.max_loop = max_loop
self.long_term_memory = LongTermMemory(user_id=user_id)
self.messages = []
self.full_process = []
# 初始化系统提示词
self.system_prompt = REACT_SYSTEM_PROMPT
# 加入可用工具列表，让大模型清楚能调用的工具
self.system_prompt += f"\n\n当前可用工具列表：{list(TOOL_MAP.keys())}"
def reset(self):
"""重置 Agent 的对话上下文，开启新的对话"""
self.messages = []
self.full_process = []
print("Agent 已重置，开启新的对话")
def run(self, user_query):
"""
运行 Agent，执行用户的目标
:param user_query: 用户的需求/目标
:return: 最终答案
"""
# 检索相关长期记忆，注入系统提示词
memory_prompt = self.long_term_memory.build_memory_prompt(user_query)
current_system_prompt = self.system_prompt
if memory_prompt:
current_system_prompt += "\n\n" + memory_prompt
# 初始化对话上下文
self.messages = [
{"role": "system", "content": current_system_prompt},
{"role": "user", "content": user_query}
]
self.full_process = []
loop_count = 0
print(f"\n===== 智能助手启动，用户需求：{user_query} =====")
while loop_count < self.max_loop:
loop_count += 1
print(f"\n----- 执行步骤 {loop_count} -----")
# 优化短期记忆，避免上下文溢出
optimized_messages = build_short_term_memory(self.messages)
# 调用 LLM 推理
llm_output = llm_call(optimized_messages, model=self.model)
print(f"🤖 助手思考：\n{llm_output}")
# 加入上下文
self.messages.append({"role": "assistant", "content": llm_output})
self.full_process.append(llm_output)
# 任务完成，输出最终答案
if "Final Answer:" in llm_output:
final_answer = llm_output.split("Final Answer:")[-1].strip()
print(f"\n✅ 任务完成！最终结果：\n{final_answer}")
# 保存到长期记忆
self._save_to_long_term_memory(user_query, final_answer)
return final_answer
# 解析并执行 Action
if "Action:" in llm_output:
action_str = llm_output.split("Action:")[-1].strip()
print(f"🔧 执行工具：{action_str}")
# 执行工具
observation = execute_action(action_str)
observation_content = f"Observation: {observation}"
print(f"📋 执行结果：{observation}")
# 加入上下文
self.messages.append({"role": "user", "content": observation_content})
self.full_process.append(observation_content)
# 格式错误处理
else:
error_msg = "Observation: 你没有按照格式输出 Action 或 Final Answer，请严格遵守规则，使用指定的格式输出。"
print(f"⚠️ 格式错误：{error_msg}")
self.messages.append({"role": "user", "content": error_msg})
self.full_process.append(error_msg)
# 超过最大循环次数
final_error = f"任务执行失败，已超过最大执行次数 {self.max_loop}，请简化需求后重试。"
print(f"\n❌ {final_error}")
return final_error
def _save_to_long_term_memory(self, user_query, final_answer):
"""保存任务信息到长期记忆"""
# 保存任务经验
task_memory = f"用户需求：{user_query}\n执行结果：{final_answer}\n执行步骤数：{len(self.full_process)}"
self.long_term_memory.add_memory(task_memory, memory_type="task_experience")
# 保存用户偏好信息
if any(keyword in user_query for keyword in ["我叫", "我是", "我喜欢", "我希望", "我的", "我不喜欢"]):
self.long_term_memory.add_memory(user_query, memory_type="user_preference")
print("💾 已保存用户偏好信息到长期记忆")
6.4 测试我们的智能助手
现在，我们创建 test_agent.py 文件，来测试这个完整的 Agent，覆盖多个复杂场景：
# test_agent.py
from agent import IntelligentAgent
if __name__ == "__main__":
# 初始化 Agent，指定用户ID
agent = IntelligentAgent(user_id="test_user", model="gpt-3.5-turbo")
# 场景1：实时信息查询
print("==================== 场景1：实时信息查询 ====================")
agent.run("2026年4月18日广州番禺的天气是多少？今天的上证指数收盘点数是多少？")
# 场景2：数据分析与可视化
print("\n==================== 场景2：数据分析与可视化 ====================")
agent.run("生成200个符合正态分布的随机数，计算均值和方差，画出直方图和正态分布曲线，添加标题和坐标轴标签，保存为normal_dist.png文件")
# 场景3：文件操作与内容生成
print("\n==================== 场景3：文件操作与内容生成 ====================")
agent.run("写一篇关于AI Agent发展趋势的800字文章，保存到ai_agent_trend.md文件里")
# 场景4：长期记忆测试
print("\n==================== 场景4：长期记忆测试 ====================")
agent.run("我叫小李，是一名产品经理，我平时需要写产品需求文档，做竞品分析，以后你叫我李经理就好")
agent.run("你还记得我叫什么吗？我的职业是什么？我平时需要做什么工作？")
# 场景5：复杂多步骤任务
print("\n==================== 场景5：复杂多步骤任务 ====================")
agent.run("帮我查一下2026年第一季度国内新能源汽车销量排名前5的品牌，每个品牌的销量是多少，市场占比是多少，把结果整理成表格，保存到new_energy_sales.csv文件里")
运行这个文件，你会看到我们的 Agent 能自主完成所有的复杂任务，从实时信息查询，到数据分析可视化，到文件操作，再到长期记忆，全部完美实现！
6.5 调试与优化技巧
- 开启详细日志：运行的时候，能看到 Agent 完整的思考过程、工具执行过程，哪里出了问题一目了然
- 优化提示词：如果 Agent 经常选错工具，就优化工具的描述，给更明确的使用场景
- 调整温度值：执行任务的时候，temperature 设为 0，保证输出稳定；创作内容的时候，可以设为 0.7，增加创意性
- 限制循环次数：简单任务把 max_loop 设为 5-10，复杂任务设为 15-20，避免死循环
- 处理超长结果：如果工具返回的结果太长，自动做摘要，只保留核心信息，避免上下文溢出
7. 常见问题 FAQ & 下篇预告 & 互动环节
7.1 常见问题 FAQ
这里整理了新手学习过程中最容易遇到的问题，一次性给你解决：
Q1：我的 Agent 经常出现幻觉，编造不存在的信息，怎么办？
A1：核心解决方法：
- 在提示词里强制要求 Agent 所有结论必须基于 Observation 的结果，严禁编造信息
- 给工具加上更精准的描述，让 Agent 明确什么时候必须调用工具，不能空想
- 增加反思环节，让 Agent 在输出 Final Answer 之前，校验所有信息的来源
- 优先使用原生支持 Tool Calling 的大模型，比如 GPT-3.5/4o、Claude 3，稳定性远高于纯提示词实现
Q2：我的 Agent 经常陷入死循环，重复执行相同的 Action，怎么办？
A2：解决方法：
- 设置最大循环次数，强制终止
- 在提示词里要求 Agent 记录每次的执行结果，如果连续2次执行相同的 Action 没有进展，就停止并说明原因
- 优化工具的错误提示，告诉 Agent 哪里错了，应该怎么修正，而不是重复执行
- 给 Agent 增加反思能力，让它判断当前的方案是不是可行，要不要换个思路
Q3：没有 OpenAI API Key，能用开源大模型吗？
A3：完全可以！现在主流的开源大模型，比如 Llama 3、Qwen 2、GLM 4、通义千问开源版，都支持 Tool Calling，你只需要修改 llm.py 里的 LLM 调用函数，换成对应的开源模型的接口即可，后续的所有代码都不用改。
Q4：Agent 调用工具的时候，经常生成错误的参数，怎么办？
A4：解决方法：
- 在提示词里给每个工具加上明确的参数示例，告诉大模型正确的格式
- 用 JSON Schema 严格定义参数的类型、必填项、取值范围
- 增加参数校验逻辑，执行工具之前先校验参数是否正确，错误的话返回明确的提示，让 Agent 修正
- 优先使用大模型原生的 Tool Calling 能力，它对参数生成的优化远好于纯提示词
Q5：Agent 的上下文窗口经常溢出，怎么办？
A5：解决方法：
- 用我们实现的短期记忆管理器，只保留最近的对话轮次，过滤旧内容
- 对超长的工具返回结果做摘要，只保留核心信息
- 定期对历史对话做总结，把多轮对话压缩成一段摘要，节省窗口空间
- 优先使用窗口更大的模型，比如 GPT-4o（128K）、Claude 3 Opus（200K）
7.2 下篇预告
恭喜你！看到这里，你已经完全掌握了单 Agent 开发的所有核心能力，从零实现了一个完整的智能 Agent，已经超过了 80% 刚入门 AI Agent 开发的开发者！
在下篇里，我们会进入更进阶、更强大的多 Agent 世界，带你实现生产级的 Agent 系统，核心内容包括：
- 多 Agent 协作的核心原理与角色分工：产品经理、开发工程师、测试工程师、项目经理多角色协同
- LangGraph 工作流深度拆解与实战：从零搭建复杂的 Agent 工作流
- MCP 协议集成：让你的 Agent 接入无限的工具生态
- Agent 规划与反思能力进阶：思维树、反思框架、自我优化
- 生产级 Agent 平台搭建：前端界面、权限管理、日志监控、高可用部署
7.3 互动环节
学习过程中遇到任何问题，都可以在评论区留言，我会一一解答！
同时，欢迎在评论区告诉我：
- 你在学习 AI Agent 的过程中，遇到的最大的坑是什么？
- 你最想开发一个什么样的 AI Agent？比如个人助理、代码助手、数据分析机器人？
- 下篇内容，你最想先看哪部分的详细讲解？
- 关注我，下篇更新第一时间通知，还有附加篇《AI Agent 面试八股文全集》，帮你搞定秋招春招，拿下大厂 Offer！
版权声明：本文为原创内容，未经授权禁止转载，商用必究。
欢迎加入DeepSeek 技术社区。在这里，你可以找到志同道合的朋友，共同探索AI技术的奥秘。
更多推荐
17
0- 0
已为社区贡献8条内容
所有评论(0)