AI入门

AI Agent 智能体

资料核对与更新:2026-11-18 · 阅读约39分钟

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"

]

,

}

,

}

,

}

print

(

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

:

"""(模拟)调用工具并返回结果"""

print

(

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 处理用户输入"""

print

(

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

(

)

print

(

"="

*

60

)

response1

=

agent.

run

(

"搜索一下 runoob 是什么"

)

print

(

f

"[Agent 回复]

\n

{response1}"

)

print

(

"

\n

"

+

"="

*

60

)

response2

=

agent.

run

(

"帮我查 2024-06-18 北京的天气"

)

print

(

f

"[Agent 回复]

\n

{response2}"

)

print

(

"

\n

"

+

"="

*

60

)

response3

=

agent.

run

(

"计算一下 25 * 4 + 10 等于多少"

)

print

(

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

:

"""(模拟)网络搜索"""

print

(

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"""

print

(

f

" runoob-researcher 启动!"

)

print

(

f

" 研究主题:{topic}"

)

print

(

"-"

*

50

)

for

step

in

range

(

1

,

self

.

max_steps

+

1

)

:

print

(

f

"

\n

第 {step} 步 / 共 {self.max_steps} 步"

)

1. 思考

decision

=

self

._think

(

step

,

topic

)

print

(

f

"   思考:{decision['thought']}"

)

if

decision

[

"action"

]

==

"finish"

:

print

(

"   收集完成,开始整理报告..."

)

break

2. 行动

if

decision

[

"action"

]

==

"search"

:

result

=

self

._search_web

(

decision

[

"query"

]

)

print

(

f

"   结果:{result[:60]}..."

)

3. 观察

self

._observe

(

result

)

生成最终报告

print

(

"

\n

"

+

"-"

*

50

)

print

(

" 生成研究报告..."

)

final_report

=

self

._generate_report

(

topic

)

return

final_report

============================================

试试看效果

============================================

agent

=

ResearchAgent

(

max_steps

=

4

)

report

=

agent.

run

(

"Agent 智能体"

)

print

(

"

\n

"

+

"="

*

50

)

print

(

report

)

print

(

"="

*

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独立储备