AI Agent 智能体
AI Agent 智能体 你可能已经习惯了这样的交互:你问一个问题,AI 给出一个答案。 你让它写一篇文章,它写一篇文章。 你让它翻译一句话,它翻译一句话。 这种模式下,AI 更像一个顾问——它给你建议,但不直接做事。 但如果任务稍微复杂一点呢?比如:帮我查一下明天北京的天气,如果温度超过 25 度,就给我推荐一件短袖衬衫,预算 300 元以内,然后把结果整
AI Agent 智能体
你可能已经习惯了这样的交互:你问一个问题,AI 给出一个答案。
你让它写一篇文章,它写一篇文章。
你让它翻译一句话,它翻译一句话。
这种模式下,AI 更像一个顾问——它给你建议,但不直接做事。
但如果任务稍微复杂一点呢?比如:帮我查一下明天北京的天气,如果温度超过 25 度,就给我推荐一件短袖衬衫,预算 300 元以内,然后把结果整理成邮件发给我老板。
用普通的对话 AI,你得分成好几步:
第一步:查明天北京天气。
第二步:如果超过 25 度,推荐 300 元以内的短袖衬衫。
第三步:帮我写一封邮件给老板,内容是……。
每一步都需要你手动推进。
而
AI Agent(智能体)
的思路是:你只需要说一遍帮我做这件事,它自己会把剩下的都做完。
它会自动判断需要做什么、调用什么工具、按什么顺序执行、遇到问题怎么调整,直到任务完成。
简单理解:普通 LLM 是军师,帮你出谋划策;AI Agent 是执行者,拿到目标后自己就去把事办了。
什么是 AI Agent
AI Agent 是一个能感知环境、做出决策、采取行动的自主系统。
学术一点的定义是:
Agent 是一个位于某环境中的实体,它能通过传感器感知环境,并通过执行器作用于环境,以实现一系列目标
。
这个定义听起来有点抽象,让我们用大白话拆解。
Agent vs 普通 LLM
先看一张对比表:
举个具体例子:"帮我订一张明天从上海去北京的机票,价格 1500 元以内。"
普通 LLM 可能会这样回答:"好的,我可以帮你写一段查询机票的代码,或者告诉你应该去哪个网站查询。"但它不会真的去查机票,更不会帮你下单。
而一个合格的 Agent 会:
1. 理解目标:订明天上海→北京,1500 元以内的机票。
2. 决定行动:我需要调用机票查询 API。
3. 执行行动:调用 API,获取航班列表。
4. 观察结果:获取到 10 个航班,其中 3 个在 1500 元以内。
5. 再次思考:选哪个?可能需要再查一下起降时间,或者询问用户偏好。
6. 继续行动:可能调用另一个 API 查准点率,或者直接给用户推荐选项。
7. 完成任务:帮用户锁定座位,生成订单链接。
看到区别了吗?
普通 LLM 给你答案,Agent 给你结果
。
Agent 的核心能力
一个完整的 Agent 通常具备以下三大核心能力:
感知
,就是 Agent 能看到发生了什么。比如用户发了一条消息、API 返回了一个结果、文件系统里新增了一个文件——这些都是感知的输入。
决策
,就是 Agent 基于感知到的信息,决定下一步做什么。是直接回答用户?还是需要调用工具?还是需要把大任务拆成小任务?这都是决策。
行动
,就是 Agent 真的去执行决策。调用搜索 API、读取文件、发送邮件、操作数据库——这些都是行动。
Agent 的基本架构
现在我们来看 Agent 的标准"四块拼图":大脑、工具、记忆、规划。
先看一张架构图:
大脑:LLM 作为推理核心
Agent 的大脑通常是一个大语言模型,比如 GPT-4、Claude、Llama 等。
这个 LLM 负责:
1. 理解用户的意图:用户说帮我订票,他真正想要的是什么?
2. 做决策:下一步我应该做什么?
3. 生成工具调用参数:要调用机票查询 API,需要哪些参数?
4. 整理最终答案:现在信息收集够了,怎么给用户一个清晰的总结?
LLM 是 Agent 的核心,但不是全部——就像人脑很重要,但也需要手脚才能做事。
工具:扩展 AI 的能力边界
原生 LLM 有两个明显的局限:
1. 知识截止:它不知道训练结束之后发生的事。
2. 无法交互:它不能直接读文件、查数据库、调用 API。
工具(Tools)就是用来解决这些问题的。
常见的工具类型:
给 Agent 工具,就像给人配了一台电脑——瞬间从只能想变成可以做。
记忆:短期 vs 长期记忆
LLM 原生是失忆的——每一次对话都是全新的,除非你把上下文塞进去。
而 Agent 需要记住很多东西:
短期记忆:刚才用户说了什么?我上一步调用了什么工具?得到了什么结果?
长期记忆:用户的偏好是什么?过去类似任务是怎么处理的?有哪些经验教训?
记忆系统的常见实现方式:
一个好的记忆系统,能让 Agent 看起来记得你,而不是每次都像第一次见面。
规划:任务分解
复杂任务不会一步完成,Agent 需要能把大目标拆成小步骤。
比如:帮我策划一场 10 人的生日派对。
Agent 可能会这样规划:
1. 先问清楚:预算多少?什么时候?在哪里?主角有什么偏好?
2. 然后:查一下附近的场地。
3. 接着:设计菜单。
4. 再接着:列出采购清单。
5. 最后:生成日程安排表。
规划的常见策略:
链式思考(Chain-of-Thought):一步一步想清楚,先做什么、后做什么。
树状规划(Tree-of-Thought):同时考虑多个可能的路径,选最优的。
反思(Reflection):做完一步后回头看看,有没有问题,需不需要调整。
工具调用:Tool Use / Function Calling
工具调用是 Agent 最基础也是最重要的能力。
让我们从是什么开始讲。
什么是 Function Calling
简单说:
Function Calling 就是 LLM 输出一个结构化的 JSON,告诉你它想调用哪个函数、传什么参数
。
不是 LLM 真的去执行这个函数——它只是告诉你它想调用,执行的事还得由你来做。
整个流程通常是这样的:
1. 你告诉 LLM:"这里有一些函数可以调用,每个函数的名字、参数、用途是……"
2. 用户发消息:"帮我查一下明天北京的天气。"
3. LLM 回复:"我要调用 get_weather 函数,参数是 city='北京', date='明天'。"
4. 你去调用这个函数(真的去查天气 API),得到结果。
5. 你把结果塞回给 LLM:"刚才的函数调用返回了:温度 25 度,晴天。"
6. LLM 基于这个结果,给用户一个自然语言回答:"明天北京晴天,温度 25 度,很舒适。"
看到了吗?LLM 负责想,你负责执行。
定义工具的 JSON Schema
要让 LLM 调用工具,你得先告诉它有哪些工具可用。
这个告诉的过程,就是用 JSON Schema 描述函数。
来看一个标准的函数定义格式:
实例
这是一个典型的工具定义(用 Python 字典表示,最终会转成 JSON)
tool_definition
=
{
"type"
:
"function"
,
"function"
:
{
"name"
:
"get_weather"
,
函数名
"description"
:
"查询指定城市指定日期的天气"
,
函数用途描述,LLM 会看这个
"parameters"
:
{
"type"
:
"object"
,
"properties"
:
{
"city"
:
{
"type"
:
"string"
,
"description"
:
"城市名称,比如'北京'、'上海'、'深圳'"
,
}
,
"date"
:
{
"type"
:
"string"
,
"description"
:
"日期,格式为 YYYY-MM-DD,比如'2024-06-18'"
,
}
,
"unit"
:
{
"type"
:
"string"
,
"enum"
:
[
"celsius"
,
"fahrenheit"
]
,
"description"
:
"温度单位,摄氏度或华氏度,默认摄氏度"
,
}
,
}
,
"required"
:
[
"city"
,
"date"
]
,
必填参数
}
,
}
,
}
另一个工具:搜索
search_tool
=
{
"type"
:
"function"
,
"function"
:
{
"name"
:
"web_search"
,
"description"
:
"在互联网上搜索最新信息,适合查新闻、实时数据、未知知识"
,
"parameters"
:
{
"type"
:
"object"
,
"properties"
:
{
"query"
:
{
"type"
:
"string"
,
"description"
:
"搜索关键词或问题"
,
}
,
"num_results"
:
{
"type"
:
"integer"
,
"description"
:
"返回多少条结果,默认 5"
,
"default"
:
5
,
}
,
}
,
"required"
:
[
"query"
]
,
}
,
}
,
}
另一个工具:计算器
calculator_tool
=
{
"type"
:
"function"
,
"function"
:
{
"name"
:
"calculate"
,
"description"
:
"执行数学计算,支持加减乘除、幂运算等"
,
"parameters"
:
{
"type"
:
"object"
,
"properties"
:
{
"expression"
:
{
"type"
:
"string"
,
"description"
:
"数学表达式,比如'25 * 4 + 10'、'sqrt(16)'"
,
}
,
}
,
"required"
:
[
"expression"
]
,
}
,
}
,
}
(
f
"已定义 {len([tool_definition, search_tool, calculator_tool])} 个工具:get_weather, web_search, calculate"
)
输出:已定义 3 个工具:get_weather, web_search, calculate
关键点:
description 非常重要——LLM 就是靠这个描述来理解这个工具是干什么的、什么时候用。
参数也要描述清楚——比如 unit 有 enum 约束,LLM 就知道只能从这两个值里选。
required 标出必填项——LLM 会确保这些参数一定有值。
代码实战:给 AI 添加搜索、计算工具
现在让我们写一个完整的、可运行的例子。
为了演示,我们用 Python 模拟 Function Calling 的完整流程。
实例
============================================
一个简化版的 Agent 工具调用演示
不需要真实的 API Key,用模拟数据演示
============================================
import
json
import
random
from
typing
import
Dict
,
Any
,
List
,
Optional
class
SimpleAgent:
"""一个简单的 Agent 演示类"""
def
__init__
(
self
)
:
注册可用的工具
self
.
tools
=
self
._define_tools
(
)
对话历史(记忆)
self
.
messages
: List
[
Dict
]
=
[
]
def
_define_tools
(
self
)
-
>
List
[
Dict
]
:
"""定义所有可用的工具"""
return
[
{
"name"
:
"web_search"
,
"description"
:
"搜索互联网获取最新信息"
,
"parameters"
:
{
"query"
:
{
"type"
:
"string"
,
"description"
:
"搜索关键词"
}
,
}
,
"required"
:
[
"query"
]
,
}
,
{
"name"
:
"calculate"
,
"description"
:
"执行数学计算"
,
"parameters"
:
{
"expression"
:
{
"type"
:
"string"
,
"description"
:
"数学表达式"
}
,
}
,
"required"
:
[
"expression"
]
,
}
,
{
"name"
:
"get_weather"
,
"description"
:
"查询天气"
,
"parameters"
:
{
"city"
:
{
"type"
:
"string"
,
"description"
:
"城市名"
}
,
"date"
:
{
"type"
:
"string"
,
"description"
:
"日期"
}
,
}
,
"required"
:
[
"city"
,
"date"
]
,
}
,
]
def
_call_tool
(
self
,
tool_name:
str
,
parameters: Dict
[
str
,
Any
]
)
-
>
str
:
"""(模拟)调用工具并返回结果"""
(
f
" [工具调用] {tool_name}({parameters})"
)
if
tool_name
==
"web_search"
:
query
=
parameters
[
"query"
]
模拟搜索结果
results
=
{
"runoob"
:
"菜鸟教程(runoob)是一个编程学习网站,提供大量编程教程和实例。"
,
"2024年6月18日北京天气"
:
"北京 2024-06-18:晴天,25°C,湿度 45%。"
,
"上海人口"
:
"上海 2024 年常住人口约 2489 万。"
,
}
return
results.
get
(
query
,
f
"搜索结果:未找到'{query}'的精确信息,这是一个模拟结果。"
)
elif
tool_name
==
"calculate"
:
expr
=
parameters
[
"expression"
]
try
:
注意:生产环境不要用 eval,这里只是演示
result
=
eval
(
expr
,
{
"__builtins__"
:
None
}
,
{
"sqrt"
:
lambda
x: x**
0.5
,
"pow"
:
pow
,
}
)
return
f
"计算结果:{expr} = {result}"
except
Exception
as
e:
return
f
"计算错误:{e}"
elif
tool_name
==
"get_weather"
:
city
=
parameters
[
"city"
]
date
=
parameters
[
"date"
]
模拟天气数据
weathers
=
[
"晴天"
,
"多云"
,
"小雨"
,
"阴天"
]
temp
=
random
.
randint
(
15
,
35
)
return
f
"{city} {date}:{random.choice(weathers)},{temp}°C"
else
:
return
f
"未知工具:{tool_name}"
def
_decide_action
(
self
,
user_input:
str
)
-
>
Dict
[
str
,
Any
]
:
"""
(模拟)LLM 决策过程
实际项目中这里会调用真实的 LLM API
"""
这里用简单的规则模拟,真实场景应该用 LLM
if
"搜索"
in
user_input
or
"查一下"
in
user_input
or
"什么是"
in
user_input:
提取搜索词(简单模拟)
query
=
user_input.
replace
(
"搜索"
,
""
)
.
replace
(
"查一下"
,
""
)
.
replace
(
"什么是"
,
""
)
.
strip
(
)
if
not
query:
query
=
"runoob"
return
{
"action"
:
"call_tool"
,
"tool"
:
"web_search"
,
"parameters"
:
{
"query"
: query
}
,
}
elif
"计算"
in
user_input
or
"等于"
in
user_input:
提取表达式(简单模拟)
return
{
"action"
:
"call_tool"
,
"tool"
:
"calculate"
,
"parameters"
:
{
"expression"
:
"25 * 4 + 10"
}
,
示例固定值
}
elif
"天气"
in
user_input:
return
{
"action"
:
"call_tool"
,
"tool"
:
"get_weather"
,
"parameters"
:
{
"city"
:
"北京"
,
"date"
:
"2024-06-18"
}
,
}
else
:
return
{
"action"
:
"respond"
,
"content"
:
"好的,我来帮你处理这个问题。"
+ user_input
,
}
def
run
(
self
,
user_input:
str
)
-
>
str
:
"""运行 Agent 处理用户输入"""
(
f
"[用户输入] {user_input}"
)
self
.
messages
.
append
(
{
"role"
:
"user"
,
"content"
: user_input
}
)
第一步:决定做什么
decision
=
self
._decide_action
(
user_input
)
if
decision
[
"action"
]
==
"call_tool"
:
第二步:调用工具
tool_result
=
self
._call_tool
(
decision
[
"tool"
]
,
decision
[
"parameters"
]
)
self
.
messages
.
append
(
{
"role"
:
"tool"
,
"content"
: tool_result
}
)
第三步:基于工具结果生成最终回答
(这里简单拼接,实际应该让 LLM 生成)
final_response
=
f
"根据我的查询:{tool_result}
\n
\n
希望这个信息对你有帮助!"
self
.
messages
.
append
(
{
"role"
:
"assistant"
,
"content"
: final_response
}
)
return
final_response
else
:
直接回答
self
.
messages
.
append
(
{
"role"
:
"assistant"
,
"content"
: decision
[
"content"
]
}
)
return
decision
[
"content"
]
============================================
测试这个 Agent
============================================
agent
=
SimpleAgent
(
)
(
"="
*
60
)
response1
=
agent.
run
(
"搜索一下 runoob 是什么"
)
(
f
"[Agent 回复]
\n
{response1}"
)
(
"
\n
"
+
"="
*
60
)
response2
=
agent.
run
(
"帮我查 2024-06-18 北京的天气"
)
(
f
"[Agent 回复]
\n
{response2}"
)
(
"
\n
"
+
"="
*
60
)
response3
=
agent.
run
(
"计算一下 25 * 4 + 10 等于多少"
)
(
f
"[Agent 回复]
\n
{response3}"
)
这个例子虽然简单,但它展示了 Function Calling 的完整闭环:
理解 → 决策 → 调用工具 → 观察结果 → 生成回答。
在真实项目中,
_decide_action
这一步会换成真实的 LLM 调用,让模型来决定用什么工具、传什么参数。
ReAct 规划循环
有了工具调用能力后,下一步就是:什么时候停?
简单任务可能一步就完成,但复杂任务往往需要多轮迭代。
这就是 ReAct 框架要解决的问题。
思考 → 行动 → 观察
ReAct 这个名字来自 Reasoning(推理)和 Acting(行动)的结合。
它的核心思想很简单:让 Agent 像人一样,想一步、做一步、看一看,然后重复这个循环,直到任务完成。
来看一张流程图:
每一轮循环包含三个步骤:
然后回到思考——根据观察到的结果,决定下一步做什么。
这个循环会一直继续,直到 Agent 判断任务完成了,这时它会跳出循环,给出最终答案。
让我们用一个具体例子来看 ReAct 是怎么工作的:
用户问题
:SpaceX 成立于哪一年?它的第一枚成功入轨的火箭叫什么?
思考 1
:我需要查找 SpaceX 的创立年份,以及它最早完成轨道级发射的火箭型号。这两个信息可能来自不同来源,最好一次性搜索关键词覆盖两者。
行动 1
:调用 web_search,查询"SpaceX 成立时间 第一枚入轨火箭"。
观察 1
:搜索结果摘要显示:"SpaceX(太空探索技术公司)成立于 2002 年,由埃隆·马斯克创立。其首枚成功进入地球轨道的火箭是猎鹰1号(Falcon 1),于 2008 年 9 月 28 日第四次试飞成功。"(信息完整,覆盖了两个子问题)
思考 2
:搜索结果已经同时给出了成立年份(2002年)和第一枚入轨火箭(猎鹰1号),没有歧义,信息可信。无需额外搜索。
最终回答
:SpaceX 成立于 2002 年,它的第一枚成功入轨的火箭是猎鹰1号(Falcon 1),于 2008 年 9 月 28 日完成这一里程碑。
说明
:看到了吗?每一步都有明确的"思考"、"行动"、"观察",而且 Agent 会自己判断什么时候停——这里只用了 1 轮行动就收集齐了全部所需信息,因此直接进入最终回答,没有多余的循环。
循环终止条件
ReAct 循环不能无限跑下去,需要终止条件。
常见的终止条件:
设计 Agent 时,一定要有"最大步数"这个安全阀门——不然它可能会在一个圈子里打转,永远停不下来。
记忆系统设计
Agent 工作时间长了,就会遇到一个问题:上下文窗口装不下所有对话历史。
这时候就需要一个好的记忆系统。
对话历史:短期记忆
最简单的记忆就是完整保存对话历史。
每次都把之前的所有消息塞给 LLM,这样它就能记住刚才发生了什么。
但这种方式有个明显的缺点:LLM 的上下文窗口是有限的。
比如 GPT-4 是 8K 或 32K,Claude 是 200K——虽大,但也不是无限。
对话短的时候没问题,一旦对话很长,或者每轮调用工具返回的内容很多,很快就装不下了。
向量数据库:长期记忆
当记忆太多、上下文装不下时,一个常用的方案是:
把记忆存到向量数据库里,需要的时候"检索"相关的出来
。
这个思路叫 RAG(Retrieval-Augmented Generation),在 Agent 里同样适用。
工作流程:
1. 每产生一条记忆(用户说的话、工具返回的结果、Agent 的思考),就转换成一个向量(Embedding)。
2. 把这个向量存到向量数据库里。
3. 当 Agent 需要回忆时,把当前的问题也转换成向量。
4. 在向量数据库里搜索"最相似"的几条记忆。
5. 只把这几条相关记忆放进 LLM 上下文。
这样,即使有一万条历史记忆,也只需要把最相关的那几条取出来用。
摘要压缩记忆
另一种记忆优化方案:
不存储完整对话原文,由大模型定期对历史会话生成精简摘要,仅持久保存摘要内容
。
原始长对话:
用户:帮我查天气。
Agent:查哪个城市?
用户:北京。
Agent:哪一天?
用户:明天。
……
压缩后摘要:
用户需要查询北京明日天气,Agent 先后确认城市与日期,用户明确查询时间为明天。
该方式可大幅削减Token开销:原本占用 500 Token的完整对话,仅需 50 Token的摘要即可留存核心信息。
落地项目通常会多方案搭配使用,分层管理会话记忆:
近期最新对话:完整留存,直接送入模型上下文;
久远历史对话:统一生成摘要,以摘要替代原文;
长期关键信息:存入向量数据库,按需检索调取。
主流 Agent 框架
理解了原理后,你可以自己写一个 Agent,也可以用现成的框架。
现在最流行的有这几个:
LangChain Agents
LangChain 是目前最流行的 LLM 应用开发框架,它内置了一套 Agent 系统。
核心概念:
Agent:大脑,决定做什么。
Tools:工具列表。
Toolkits:工具套装(比如把数据库相关的几个工具打包在一起)。
AgentExecutor:执行器,负责跑 ReAct 循环。
LangChain 的优点是生态丰富——现成的工具集成很多,开箱即用。
缺点是有时候显得有点重,抽象层次多,出问题时 debug 不容易。
LlamaIndex Agents
LlamaIndex(原来叫 GPT Index)更侧重数据连接——把你的私有数据(文档、数据库、API)和 LLM 接起来。
它的 Agent 强项是:
1. 查询结构化和非结构化数据。
2. 在多个数据源之间路由。
3. 做文档问答(RAG)。
如果你的 Agent 需要大量和"你的数据"打交道,LlamaIndex 是个好选择。
AutoGPT 原理
AutoGPT 是 2023 年初火起来的一个项目,它的特点是:完全自主。
你给它一个大目标(比如"帮我做一个网站"),它会自己:
1. 生成任务清单。
2. 执行任务。
3. 自我反思。
4. 调整计划。
5. 继续往前推进。
AutoGPT 第一次让很多人见识到了"自主 Agent"的威力,但它也暴露了 Agent 的很多问题:
经常在错误的方向上一路跑到黑,不会及时止损。
容易陷入死循环,重复做同样的事。
成本高——跑一圈可能花掉几十美元 API 费用。
但 AutoGPT 作为一个概念验证,非常有启发性。
CrewAI 多智能体
刚才说的都是单个 Agent,而 CrewAI 的思路是:让多个 Agent 组队协作。
比如你可以定义:
产品经理 Agent:负责理解需求、写 PRD。
工程师 Agent:负责写代码。
评审 Agent:负责 Code Review、提意见。
然后让它们像一个真实团队一样协作——互相讨论、分配任务、交付结果。
多智能体是一个很有前景的方向:单个 Agent 可能会犯错误,但多个 Agent 可以互相纠错、互补。
实战:搭建一个自动信息收集 Agent
现在让我们把前面讲的知识点串起来,写一个真正能用的 Agent。
我们要做的这个 Agent 叫
runoob-researcher
——给它一个主题,它会自动搜索、整理、生成一份研究报告。
实例
============================================
实战:自动信息收集 Agent
============================================
import
json
import
time
from
typing
import
Dict
,
Any
,
List
class
ResearchAgent:
"""
一个简单的研究型 Agent:
给定一个主题,自动搜索相关信息,整理成报告
"""
def
__init__
(
self
,
max_steps:
int
=
5
)
:
self
.
max_steps
=
max_steps
self
.
memory
: List
[
Dict
]
=
[
]
记忆
self
.
known_facts
: List
[
str
]
=
[
]
收集到的事实
self
.
queries_used
: List
[
str
]
=
[
]
用过的搜索词
def
_search_web
(
self
,
query:
str
)
-
>
str
:
"""(模拟)网络搜索"""
(
f
" 搜索:{query}"
)
time
.
sleep
(
0.5
)
模拟延迟
模拟知识库
knowledge_base
=
{
"人工智能"
:
"人工智能(AI)是计算机科学的一个分支,致力于创建能够执行通常需要人类智能的任务的系统。"
,
"机器学习"
:
"机器学习是人工智能的一个子集,它使计算机能够从数据中学习,而无需明确编程。"
,
"深度学习"
:
"深度学习是机器学习的一个子集,基于多层神经网络,特别擅长处理图像、文本等非结构化数据。"
,
"大语言模型"
:
"大语言模型(LLM)是一种基于 Transformer 架构的 AI 模型,经过海量文本训练,能够理解和生成人类语言。"
,
"Agent"
:
"AI Agent 是一种能自主感知环境、做出决策并采取行动的系统,通常由 LLM、工具、记忆、规划四部分组成。"
,
"Transformer"
:
"Transformer 是 Google 2017 年提出的一种神经网络架构,是现代 LLM 的基础,核心是注意力机制。"
,
"runoob"
:
"菜鸟教程(runoob)创建于 2013 年,是一个专注于编程教程的网站,提供多种编程语言的学习资源。"
,
}
查找最相关的知识
for
key
,
value
in
knowledge_base.
items
(
)
:
if
key
in
query:
return
value
return
f
"关于'{query}'的搜索结果:这是一个非常有趣的主题,涉及多个技术领域。(模拟结果)"
def
_think
(
self
,
step:
int
,
user_topic:
str
)
-
>
Dict
[
str
,
Any
]
:
"""
思考下一步做什么
(真实项目中这里应该调用 LLM)
"""
简单的启发式规则模拟思考过程
if
step
==
1
:
第一步:先搜索主题本身
return
{
"thought"
: f
"我需要先了解'{user_topic}'的基本定义和背景。"
,
"action"
:
"search"
,
"query"
: user_topic
,
}
elif
step
==
2
:
第二步:搜索相关技术
return
{
"thought"
:
"基本定义有了,现在我需要搜索相关的技术和概念。"
,
"action"
:
"search"
,
"query"
: f
"{user_topic} 相关技术"
,
}
elif
step
<
self
.
max_steps
:
中间步骤:继续深入
return
{
"thought"
:
"让我再搜索一些更多维度的信息,让报告更丰富。"
,
"action"
:
"search"
,
"query"
: f
"{user_topic} 应用场景"
,
}
else
:
最后一步:整理报告
return
{
"thought"
:
"我已经收集了足够的信息,现在可以整理最终报告了。"
,
"action"
:
"finish"
,
}
def
_observe
(
self
,
action_result:
str
)
:
"""观察结果,记录到记忆"""
self
.
known_facts
.
append
(
action_result
)
self
.
memory
.
append
(
{
"role"
:
"observation"
,
"content"
: action_result
,
}
)
def
_generate_report
(
self
,
topic:
str
)
-
>
str
:
"""基于收集到的信息生成报告"""
report
=
f
"# {topic} 研究报告
\n
\n
"
report +
=
f
"> 本报告由 runoob-researcher 自动生成
\n
\n
"
report +
=
"---
\n
\n
"
report +
=
"## 核心要点
\n
\n
"
for
i
,
fact
in
enumerate
(
self
.
known_facts
,
1
)
:
report +
=
f
"{i}. {fact}
\n
\n
"
report +
=
"---
\n
\n
"
report +
=
"## 总结
\n
\n
"
report +
=
f
"以上就是关于'{topic}'的主要信息整理。"
report +
=
"如需更深入的研究,可以进一步搜索相关学术论文或技术文档。
\n
"
return
report
def
run
(
self
,
topic:
str
)
-
>
str
:
"""运行研究 Agent"""
(
f
" runoob-researcher 启动!"
)
(
f
" 研究主题:{topic}"
)
(
"-"
*
50
)
for
step
in
range
(
1
,
self
.
max_steps
+
1
)
:
(
f
"
\n
第 {step} 步 / 共 {self.max_steps} 步"
)
1. 思考
decision
=
self
._think
(
step
,
topic
)
(
f
" 思考:{decision['thought']}"
)
if
decision
[
"action"
]
==
"finish"
:
(
" 收集完成,开始整理报告..."
)
break
2. 行动
if
decision
[
"action"
]
==
"search"
:
result
=
self
._search_web
(
decision
[
"query"
]
)
(
f
" 结果:{result[:60]}..."
)
3. 观察
self
._observe
(
result
)
生成最终报告
(
"
\n
"
+
"-"
*
50
)
(
" 生成研究报告..."
)
final_report
=
self
._generate_report
(
topic
)
return
final_report
============================================
试试看效果
============================================
agent
=
ResearchAgent
(
max_steps
=
4
)
report
=
agent.
run
(
"Agent 智能体"
)
(
"
\n
"
+
"="
*
50
)
(
report
)
(
"="
*
50
)
这个 Agent 虽然简化了 LLM 调用(用规则模拟),但整个流程是真实可用的。
你只需要把
_think
方法换成真实的 LLM API 调用,把
_search_web
换成真实的搜索 API,它就能真的帮你做研究了。
Agent 的局限与失败模式
AI Agent 很强大,但它不是万能的。
了解它的局限,能帮助你在合适的场景用它,也能避免踩坑。
常见的失败模式
1. 工具选择错误
用户问天气,Agent 去调用搜索;用户要搜索,Agent 去调用计算器。
这种错误很常见,特别是在工具定义不够清晰的时候。
2. 参数传递错误
日期格式不对、缺少必填参数、参数类型传错——这些都会导致工具调用失败。
3. 无限循环
Agent 陷入"搜索 A → 没找到 → 再搜索 A → 还是没找到 → 又搜索 A……"的死循环。
4. 过早停止
还没收集到足够信息,Agent 就觉得"够了",给出一个不完整的答案。
5. 幻觉(Hallucination)
Agent 可能会编造根本不存在的工具、不存在的参数,或者编造假的搜索结果。
6. 缺乏常识
有时候 Agent 会做一些人类看来很傻的事——比如用户说"帮我订明天的机票", Agent 去查"明天"是哪一天,但其实它应该用今天的日期加一天。
怎么让 Agent 更可靠
面对这些问题,业界有一些常用的 mitigation(缓解)策略:
一个实用的建议:不要一开始就追求完全自主。先从人机协作模式开始——Agent 提议做什么,人类确认后再执行。等你对它有信心了,再逐步放权。
CSS独立储备