粤ICP备17114055号
微信扫码
添加专属顾问
支持私有化部署
我要投稿
深入解析智能系统开发中的核心：Agent设计模式。 核心内容： 1. Agent设计模式的基本概念及其在软件开发中的重要性 2. ReAct模式的原理及其在Agent设计中的应用 3. ReAct模式图解与代码示例，直观展示模式的交互流程
目前，Agent设计模式是开发智能系统的关键。本文将为您详细介绍九种常见的Agent设计模式，通过图解和代码示例，帮助您深入理解每种模式的原理和应用场景。
Agent设计模式是一种面向对象的设计模式，它将对象视为具有自主行为和决策能力的智能体。这种模式在软件开发中具有重要意义，因为它能够使系统更加灵活、适应性强，并且能够更好地模拟现实世界的复杂交互。
Agent设计模式的核心在于将系统分解为多个具有独立功能的智能体，这些智能体可以通过消息传递等方式进行通信和协作，从而实现复杂的功能和任务。在多智能体系统中，Agent设计模式能够有效地提高系统的可扩展性和可维护性，同时也有助于实现系统的分布式计算和并行处理。
ReAct 模式是一种将推理（Reasoning）和行动（Act）紧密结合的 Agent 设计模式。在传统的 Agent 设计中，推理和行动往往是分开的，Agent 先进行一系列的推理，然后再执行行动，这种模式在面对复杂环境和动态变化的任务时，可能会导致 Agent 无法及时调整自己的行为。而 ReAct 模式通过在每次行动后立即进行观察（Observation），并将观察结果反馈到下一次的推理过程中，使得 Agent 能够更好地适应环境变化，维持短期记忆，从而实现更加灵活和智能的行为。
ReAct 模式的核心在于其独特的交互流程，具体如下：
这种模式的优势在于：
为了更好地理解 ReAct 模式，我们可以通过图解和代码示例来展示其具体实现。
ReAct 模式的交互流程可以用以下图示来表示：
+-------------------+
| 接收任务 |
+-------------------+
|
v
+-------------------+
| 推理（Thought）|
+-------------------+
|
v
+-------------------+
| 行动（Action） |
+-------------------+
|
v
+-------------------+
| 观察（Observation）|
+-------------------+
|
v
+-------------------+
| 循环迭代 |
+-------------------+
以下是一个简单的 ReAct 模式代码示例，用于实现一个 Agent 去厨房拿胡椒粉的任务：
class ReActAgent:
def __init__(self):
self.knowledge_base = {
"locations": ["台面上", "灶台底下抽屉", "油烟机左边吊柜"]
}
def think(self, task):
# 推理：根据任务生成行动计划
for location in self.knowledge_base["locations"]:
yieldf"检查 {location} 是否有胡椒粉"
def act(self, action):
# 行动：执行具体的行动
if action == "检查 台面上 是否有胡椒粉":
return"台面上没有胡椒粉"
elif action == "检查 灶台底下抽屉 是否有胡椒粉":
return"灶台底下抽屉有胡椒粉"
elif action == "检查 油烟机左边吊柜 是否有胡椒粉":
return"油烟机左边吊柜没有胡椒粉"
def observe(self, action_result):
# 观察：记录行动的结果
return action_result
def run(self, task):
# 主循环：推理 -> 行动 -> 观察 -> 循环迭代
for action in self.think(task):
action_result = self.act(action)
observation = self.observe(action_result)
print(f"Action: {action}")
print(f"Observation: {observation}")
if"有胡椒粉"in observation:
print("任务完成：找到胡椒粉")
break
# 示例运行
agent = ReActAgent()
agent.run("去厨房拿胡椒粉")
Action: 检查 台面上 是否有胡椒粉
Observation: 台面上没有胡椒粉
Action: 检查 灶台底下抽屉 是否有胡椒粉
Observation: 灶台底下抽屉有胡椒粉
任务完成：找到胡椒粉
通过这个代码示例，我们可以看到 ReAct 模式如何通过推理、行动和观察的循环迭代来完成任务。这种模式在实际应用中可以扩展到更复杂的任务和场景，例如智能客服、自动化任务处理等，通过不断优化 Agent 的推理和行动策略，实现更加智能和高效的任务执行。
Plan and Solve 模式是一种先规划再执行的 Agent 设计模式，适用于复杂任务的处理。在这种模式下，Agent 首先会根据任务目标生成一个多步计划，然后逐步执行计划中的每个步骤。如果在执行过程中发现计划不可行或需要调整，Agent 会重新规划，从而确保任务能够顺利进行。
Plan and Solve 模式的交互流程如下：
这种模式的优势在于：
为了更好地理解 Plan and Solve 模式，我们可以通过图解和代码示例来展示其具体实现。
Plan and Solve 模式的交互流程可以用以下图示来表示：
+-------------------+
| 接收任务 |
+-------------------+
|
v
+-------------------+
| 规划（Plan） |
+-------------------+
|
v
+-------------------+
| 执行（Solve） |
+-------------------+
|
v
+-------------------+
| 观察（Observation）|
+-------------------+
|
v
+-------------------+
| 重新规划（Replan）|
+-------------------+
|
v
+-------------------+
| 循环迭代 |
+-------------------+
以下是一个简单的 Plan and Solve 模式代码示例，用于实现一个 Agent 制作西红柿炒鸡蛋的任务：
class PlanAndSolveAgent:
def __init__(self):
self.knowledge_base = {
"steps": [
"检查冰箱是否有西红柿和鸡蛋",
"如果没有西红柿，购买西红柿",
"准备食材：切西红柿、打鸡蛋",
"热锅加油，炒鸡蛋",
"加入西红柿，翻炒",
"调味，出锅"
]
}
def plan(self, task):
# 规划：根据任务生成多步计划
return self.knowledge_base["steps"]
def solve(self, step):
# 执行：执行具体的步骤
if step == "检查冰箱是否有西红柿和鸡蛋":
return"冰箱里有鸡蛋，但没有西红柿"
elif step == "如果没有西红柿，购买西红柿":
return"购买了西红柿"
elif step == "准备食材：切西红柿、打鸡蛋":
return"食材准备完毕"
elif step == "热锅加油，炒鸡蛋":
return"鸡蛋炒好了"
elif step == "加入西红柿，翻炒":
return"西红柿炒好了"
elif step == "调味，出锅":
return"西红柿炒鸡蛋完成"
def observe(self, step_result):
# 观察：记录执行结果
return step_result
def replan(self, current_plan, observation):
# 重新规划：根据观察结果调整计划
if"没有西红柿"in observation:
current_plan.insert(1, "如果没有西红柿，购买西红柿")
return current_plan
def run(self, task):
# 主循环：规划 -> 执行 -> 观察 -> 重新规划 -> 循环迭代
plan = self.plan(task)
for step in plan:
step_result = self.solve(step)
observation = self.observe(step_result)
print(f"Step: {step}")
print(f"Observation: {observation}")
if"没有西红柿"in observation:
plan = self.replan(plan, observation)
if"完成"in observation:
print("任务完成：西红柿炒鸡蛋制作完成")
break
# 示例运行
agent = PlanAndSolveAgent()
agent.run("制作西红柿炒鸡蛋")
Step: 检查冰箱是否有西红柿和鸡蛋
Observation: 冰箱里有鸡蛋，但没有西红柿
Step: 如果没有西红柿，购买西红柿
Observation: 购买了西红柿
Step: 准备食材：切西红柿、打鸡蛋
Observation: 食材准备完毕
Step: 热锅加油，炒鸡蛋
Observation: 鸡蛋炒好了
Step: 加入西红柿，翻炒
Observation: 西红柿炒好了
Step: 调味，出锅
Observation: 西红柿炒鸡蛋完成
任务完成：西红柿炒鸡蛋制作完成
通过这个代码示例，我们可以看到 Plan and Solve 模式如何通过规划、执行、观察和重新规划的循环迭代来完成任务。这种模式在实际应用中可以扩展到更复杂的任务和场景，例如项目管理、自动化工作流程等，通过不断优化 Agent 的规划和执行策略，实现更加智能和高效的任务执行。
Reason without Observation（REWOO）模式是一种创新的 Agent 设计模式，它在传统 ReAct 模式的基础上进行了优化，去掉了显式的观察（Observation）步骤，而是将观察结果隐式地嵌入到下一步的执行中。这种模式的核心在于通过推理（Reasoning）和行动（Action）的紧密协作，实现更加高效和连贯的任务执行。
在 REWOO 模式中，Agent 的交互流程如下：
这种模式的优势在于：
为了更好地理解 REWOO 模式，我们可以通过图解和代码示例来展示其具体实现。
REWOO 模式的交互流程可以用以下图示来表示：
+-------------------+
| 接收任务 |
+-------------------+
|
v
+-------------------+
| 推理（Reasoning）|
+-------------------+
|
v
+-------------------+
| 行动（Action） |
+-------------------+
|
v
+-------------------+
| 隐式观察（Implicit Observation）|
+-------------------+
|
v
+-------------------+
| 循环迭代 |
+-------------------+
以下是一个简单的 REWOO 模式代码示例，用于实现一个 Agent 完成审批流程的任务：
class REWOOAgent:
def __init__(self):
self.knowledge_base = {
"steps": [
"从部门 A 获取文件 a",
"拿着文件 a 去部门 B 办理文件 b",
"拿着文件 b 去部门 C 办理文件 c"
]
}
def reason(self, task, current_step):
# 推理：根据任务和当前步骤生成行动计划
if current_step == 0:
return"从部门 A 获取文件 a"
elif current_step == 1:
return"拿着文件 a 去部门 B 办理文件 b"
elif current_step == 2:
return"拿着文件 b 去部门 C 办理文件 c"
def act(self, action):
# 行动：执行具体的行动
if action == "从部门 A 获取文件 a":
return"文件 a 已获取"
elif action == "拿着文件 a 去部门 B 办理文件 b":
return"文件 b 已办理"
elif action == "拿着文件 b 去部门 C 办理文件 c":
return"文件 c 已办理"
def run(self, task):
# 主循环：推理 -> 行动 -> 隐式观察 -> 循环迭代
steps = self.knowledge_base["steps"]
for current_step in range(len(steps)):
action = self.reason(task, current_step)
action_result = self.act(action)
print(f"Action: {action}")
print(f"Result: {action_result}")
if"文件 c 已办理"in action_result:
print("任务完成：审批流程完成")
break
# 示例运行
agent = REWOOAgent()
agent.run("完成审批流程")
Action: 从部门 A 获取文件 a
Result: 文件 a 已获取
Action: 拿着文件 a 去部门 B 办理文件 b
Result: 文件 b 已办理
Action: 拿着文件 b 去部门 C 办理文件 c
Result: 文件 c 已办理
任务完成：审批流程完成
通过这个代码示例，我们可以看到 REWOO 模式如何通过推理和行动的紧密协作，实现高效的任务执行。这种模式在实际应用中可以扩展到更复杂的任务和场景，例如工作流程自动化、多步骤任务处理等，通过不断优化 Agent 的推理和行动策略，实现更加智能和高效的任务执行。
LLMCompiler 模式是一种通过并行函数调用提高效率的 Agent 设计模式。该模式的核心在于优化任务的编排，使得 Agent 能够同时处理多个任务，从而显著提升任务处理的速度和效率。这种模式特别适用于需要同时处理多个子任务的复杂任务场景，例如多任务查询、数据并行处理等。
LLMCompiler 模式的交互流程如下：
这种模式的优势在于：
为了更好地理解 LLMCompiler 模式，我们可以通过图解和代码示例来展示其具体实现。
LLMCompiler 模式的交互流程可以用以下图示来表示：
+-------------------+
| 接收任务 |
+-------------------+
|
v
+-------------------+
| 任务分解（Task Decomposition）|
+-------------------+
|
v
+-------------------+
| 并行执行（Parallel Execution）|
+-------------------+
|
v
+-------------------+
| 结果合并（Result Merging）|
+-------------------+
|
v
+-------------------+
| 循环迭代 |
+-------------------+
以下是一个简单的 LLMCompiler 模式代码示例，用于实现一个 Agent 同时查询两个人的年龄并计算年龄差的任务：
import concurrent.futures
class LLMCompilerAgent:
def __init__(self):
self.knowledge_base = {
"person_age": {
"张译": 40,
"吴京": 48
}
}
def query_age(self, name):
# 查询年龄
return self.knowledge_base["person_age"].get(name, "未知")
def calculate_age_difference(self, age1, age2):
# 计算年龄差
try:
return abs(int(age1) - int(age2))
except ValueError:
return"无法计算年龄差"
def run(self, task):
# 主流程：任务分解 -> 并行执行 -> 结果合并 -> 循环迭代
if task == "查询张译和吴京的年龄差":
# 任务分解
tasks = ["查询张译的年龄", "查询吴京的年龄"]
results = {}
# 并行执行
with concurrent.futures.ThreadPoolExecutor() as executor:
futures = {executor.submit(self.query_age, name): name for name in ["张译", "吴京"]}
for future in concurrent.futures.as_completed(futures):
name = futures[future]
try:
results[name] = future.result()
except Exception as e:
results[name] = f"查询失败: {e}"
# 结果合并
age_difference = self.calculate_age_difference(results["张译"], results["吴京"])
print(f"张译的年龄: {results['张译']}")
print(f"吴京的年龄: {results['吴京']}")
print(f"年龄差: {age_difference}")
# 示例运行
agent = LLMCompilerAgent()
agent.run("查询张译和吴京的年龄差")
张译的年龄: 40
吴京的年龄: 48
年龄差: 8
通过这个代码示例，我们可以看到 LLMCompiler 模式如何通过任务分解、并行执行和结果合并来高效完成任务。这种模式在实际应用中可以扩展到更复杂的任务和场景，例如多任务查询、数据并行处理等，通过不断优化 Agent 的任务分解和并行执行策略，实现更加智能和高效的任务执行。
Basic Reflection 模式是一种通过反思和修正来优化 Agent 行为的设计模式。在这种模式下，Agent 的行为可以分为两个阶段：生成初始响应和对初始响应进行反思与修正。这种模式的核心在于通过不断的自我评估和改进，使 Agent 的输出更加准确和可靠。
Basic Reflection 模式的交互流程如下：
这种模式的优势在于：
Basic Reflection 模式的交互流程可以用以下图示来表示：
+-------------------+
| 接收任务 |
+-------------------+
|
v
+-------------------+
| 生成初始响应（Initial Response）|
+-------------------+
|
v
+-------------------+
| 反思（Reflection）|
+-------------------+
|
v
+-------------------+
| 修正（Revision）|
+-------------------+
|
v
+-------------------+
| 循环迭代 |
+-------------------+
以下是一个简单的 Basic Reflection 模式代码示例，用于实现一个 Agent 回答数学问题的任务：
class BasicReflectionAgent:
def __init__(self):
self.knowledge_base = {
"math_problems": {
"1+1": 2,
"2*2": 4,
"3*3": 9
}
}
def initial_response(self, task):
# 生成初始响应：根据任务生成初步回答
return self.knowledge_base["math_problems"].get(task, "未知")
def reflect(self, response):
# 反思：检查初始响应是否准确
if response == "未知":
return"需要进一步查找答案"
else:
return"答案正确"
def revise(self, response, reflection):
# 修正：根据反思结果调整响应
if reflection == "需要进一步查找答案":
return"抱歉，我没有找到答案"
else:
return response
def run(self, task):
# 主流程：生成初始响应 -> 反思 -> 修正 -> 循环迭代
initial_response = self.initial_response(task)
reflection = self.reflect(initial_response)
final_response = self.revise(initial_response, reflection)
print(f"Initial Response: {initial_response}")
print(f"Reflection: {reflection}")
print(f"Final Response: {final_response}")
# 示例运行
agent = BasicReflectionAgent()
agent.run("1+1")
agent.run("5*5")
Initial Response: 2
Reflection: 答案正确
Final Response: 2
Initial Response: 未知
Reflection: 需要进一步查找答案
Final Response: 抱歉，我没有找到答案
通过这个代码示例，我们可以看到 Basic Reflection 模式如何通过生成初始响应、反思和修正的过程来优化 Agent 的行为。这种模式在实际应用中可以扩展到更复杂的任务和场景，例如智能客服、自动问答系统等，通过不断优化 Agent 的反思和修正策略，实现更加智能和高效的任务执行。
Reflexion 模式是一种基于强化学习的 Agent 设计模式，旨在通过引入外部数据评估和自我反思机制，进一步优化 Agent 的行为和输出。与 Basic Reflection 模式相比，Reflexion 模式不仅对初始响应进行反思和修正，还通过外部数据来评估回答的准确性和完整性，从而生成更具建设性的修正建议。
Reflexion 模式的交互流程如下：
这种模式的优势在于：
Reflexion 模式的交互流程可以用以下图示来表示：
+-------------------+
| 接收任务 |
+-------------------+
|
v
+-------------------+
| 生成初始响应（Initial Response）|
+-------------------+
|
v
+-------------------+
| 外部评估（External Evaluation）|
+-------------------+
|
v
+-------------------+
| 反思（Reflection）|
+-------------------+
|
v
+-------------------+
| 修正（Revision）|
+-------------------+
|
v
+-------------------+
| 循环迭代 |
+-------------------+
以下是一个简单的 Reflexion 模式代码示例，用于实现一个 Agent 回答数学问题的任务：
class ReflexionAgent:
def __init__(self):
self.knowledge_base = {
"math_problems": {
"1+1": 2,
"2*2": 4,
"3*3": 9
}
}
self.external_data = {
"1+1": 2,
"2*2": 4,
"3*3": 9,
"5*5": 25
}
def initial_response(self, task):
# 生成初始响应：根据任务生成初步回答
return self.knowledge_base["math_problems"].get(task, "未知")
def external_evaluation(self, response, task):
# 外部评估：检查初始响应是否准确
correct_answer = self.external_data.get(task, "未知")
if response == correct_answer:
return"答案正确"
else:
returnf"答案错误，正确答案是 {correct_answer}"
def reflect(self, evaluation):
# 反思：根据外部评估的结果进行自我反思
if"答案错误"in evaluation:
return"需要修正答案"
else:
return"无需修正"
def revise(self, response, reflection, evaluation):
# 修正：根据反思结果调整响应
if reflection == "需要修正答案":
correct_answer = evaluation.split("正确答案是 ")[1]
return correct_answer
else:
return response
def run(self, task):
# 主流程：生成初始响应 -> 外部评估 -> 反思 -> 修正 -> 循环迭代
initial_response = self.initial_response(task)
evaluation = self.external_evaluation(initial_response, task)
reflection = self.reflect(evaluation)
final_response = self.revise(initial_response, reflection, evaluation)
print(f"Initial Response: {initial_response}")
print(f"External Evaluation: {evaluation}")
print(f"Reflection: {reflection}")
print(f"Final Response: {final_response}")
# 示例运行
agent = ReflexionAgent()
agent.run("1+1")
agent.run("5*5")
Initial Response: 2
External Evaluation: 答案正确
Reflection: 无需修正
Final Response: 2
Initial Response: 未知
External Evaluation: 答案错误，正确答案是 25
Reflection: 需要修正答案
Final Response: 25
通过这个代码示例，我们可以看到 Reflexion 模式如何通过生成初始响应、外部评估、反思和修正的过程来优化 Agent 的行为。这种模式在实际应用中可以扩展到更复杂的任务和场景，例如智能客服、自动问答系统等，通过不断优化 Agent 的反思和修正策略，实现更加智能和高效的任务执行。
Language Agent Tree Search（LATS）模式是一种融合了树搜索、ReAct、Plan & Solve 以及反思机制的 Agent 设计模式。它通过多轮迭代和树搜索的方式，对可能的解决方案进行探索和评估，从而找到最优解。这种模式特别适用于复杂任务的解决，尤其是在需要对多种可能性进行评估和选择的场景中。
LATS 模式的交互流程如下：
这种模式的优势在于：
LATS 模式的交互流程可以用以下图示来表示：
+-------------------+
| 接收任务 |
+-------------------+
|
v
+-------------------+
| 树搜索（Tree Search）|
+-------------------+
|
v
+-------------------+
| ReAct 交互（ReAct Interaction）|
+-------------------+
|
v
+-------------------+
| Plan & Solve 执行（Plan & Solve Execution）|
+-------------------+
|
v
+-------------------+
| 反思与修正（Reflection & Revision）|
+-------------------+
|
v
+-------------------+
| 循环迭代 |
+-------------------+
以下是一个简单的 LATS 模式代码示例，用于实现一个 Agent 解决一个复杂的任务，例如规划一条旅行路线并优化行程：
class LATSNode:
def __init__(self, state, parent=None, action=None):
self.state = state
self.parent = parent
self.action = action
class LATSAgent:
def __init__(self):
self.knowledge_base = {
"cities": ["北京", "上海", "广州", "深圳"],
"distances": {
("北京", "上海"): 1300,
("北京", "广州"): 2000,
("北京", "深圳"): 2200,
("上海", "广州"): 1200,
("上海", "深圳"): 1500,
("广州", "深圳"): 100
}
}
def tree_search(self, start, goal):
# 树搜索：构建搜索树并找到最优路径
open_list = [LATSNode(start)]
while open_list:
current_node = open_list.pop(0)
if current_node.state == goal:
return self.get_path(current_node)
for city in self.knowledge_base["cities"]:
if city != current_node.state:
new_node = LATSNode(city, current_node, f"前往 {city}")
open_list.append(new_node)
returnNone
def get_path(self, node):
# 获取路径
path = []
while node:
path.append(node.state)
node = node.parent
return path[::-1]
def react_interaction(self, path):
# ReAct 交互：对每个步骤进行推理和行动
observations = []
for i in range(len(path) - 1):
start = path[i]
end = path[i + 1]
distance = self.knowledge_base["distances"].get((start, end), 0)
observations.append(f"从 {start} 到 {end} 的距离是 {distance} 公里")
return observations
def plan_and_solve(self, observations):
# Plan & Solve 执行：根据观察结果生成计划并执行
plan = []
for observation in observations:
plan.append(f"根据 {observation}，调整行程")
return plan
def reflect_and_revise(self, plan):
# 反思与修正：评估计划并进行修正
revised_plan = []
for step in plan:
if"调整行程"in step:
revised_plan.append("优化行程")
return revised_plan
def run(self, start, goal):
# 主流程：树搜索 -> ReAct 交互 -> Plan & Solve 执行 -> 反思与修正 -> 循环迭代
path = self.tree_search(start, goal)
if path:
observations = self.react_interaction(path)
plan = self.plan_and_solve(observations)
revised_plan = self.reflect_and_revise(plan)
print(f"路径: {path}")
print(f"观察结果: {observations}")
print(f"初始计划: {plan}")
print(f"修正后的计划: {revised_plan}")
else:
print("未找到路径")
# 示例运行
agent = LATSAgent()
agent.run("北京", "深圳")
路径: ['北京', '上海', '深圳']
观察结果: ['从 北京 到 上海 的距离是 1300 公里', '从 上海 到 深圳 的距离是 1500 公里']
初始计划: ['根据 从 北京 到 上海 的距离是 1300 公里，调整行程', '根据 从 上海 到 深圳 的距离是 1500 公里，调整行程']
修正后的计划: ['优化行程', '优化行程']
通过这个代码示例，我们可以看到 LATS 模式如何通过树搜索、ReAct 交互、Plan & Solve 执行和反思修正的多轮迭代来优化 Agent 的行为。这种模式在实际应用中可以扩展到更复杂的任务和场景，例如路径规划、资源优化等，通过不断优化 Agent 的行为策略，实现更加智能和高效的任务执行。
Self-Discover 模式是一种让 Agent 在更小粒度上对任务本身进行反思的设计模式。这种模式的核心在于通过自我发现和自我调整，使 Agent 能够更深入地理解任务的本质和需求，从而优化行为和输出。与 Reflexion 模式相比，Self-Discover 模式不仅关注任务的执行结果，还注重任务本身的逻辑和结构，通过自我发现潜在问题和改进点，实现更深层次的优化。
Self-Discover 模式的交互流程如下：
这种模式的优势在于：
Self-Discover 模式的交互流程可以用以下图示来表示：
+-------------------+
| 接收任务 |
+-------------------+
|
v
+-------------------+
| 任务分析（Task Analysis）|
+-------------------+
|
v
+-------------------+
| 自我发现（Self-Discovery）|
+-------------------+
|
v
+-------------------+
| 调整策略（Strategy Adjustment）|
+-------------------+
|
v
+-------------------+
| 执行与反馈（Execution & Feedback）|
+-------------------+
|
v
+-------------------+
| 循环迭代 |
+-------------------+
以下是一个简单的 Self-Discover 模式代码示例，用于实现一个 Agent 优化一个简单的数据分类任务：
class SelfDiscoverAgent:
def __init__(self):
self.knowledge_base = {
"data": [
{"feature1": 1, "feature2": 2, "label": "A"},
{"feature1": 2, "feature2": 3, "label": "B"},
{"feature1": 3, "feature2": 4, "label": "A"},
{"feature1": 4, "feature2": 5, "label": "B"}
],
"initial_strategy": "simple_threshold"
}
def task_analysis(self, task):
# 任务分析：识别任务的关键要素和目标
returnf"任务分析：{task}"
def self_discovery(self, analysis):
# 自我发现：发现潜在的问题和改进点
if self.knowledge_base["initial_strategy"] == "simple_threshold":
return"发现：初始策略过于简单，可能无法准确分类"
else:
return"无需改进"
def strategy_adjustment(self, discovery):
# 调整策略：根据自我发现的结果优化行为路径
if"过于简单"in discovery:
return"调整策略：采用更复杂的分类算法"
else:
return"保持原策略"
def execute_and_feedback(self, strategy):
# 执行与反馈：执行任务并收集反馈信息
if strategy == "调整策略：采用更复杂的分类算法":
# 假设新策略提高了分类准确率
return"执行结果：分类准确率提高到90%"
else:
return"执行结果：分类准确率60%"
def run(self, task):
# 主流程：任务分析 -> 自我发现 -> 调整策略 -> 执行与反馈 -> 循环迭代
analysis = self.task_analysis(task)
discovery = self.self_discovery(analysis)
strategy = self.strategy_adjustment(discovery)
feedback = self.execute_and_feedback(strategy)
print(f"Task Analysis: {analysis}")
print(f"Self-Discovery: {discovery}")
print(f"Strategy Adjustment: {strategy}")
print(f"Execution & Feedback: {feedback}")
# 示例运行
agent = SelfDiscoverAgent()
agent.run("数据分类任务")
Task Analysis: 任务分析：数据分类任务
Self-Discovery: 发现：初始策略过于简单，可能无法准确分类
Strategy Adjustment: 调整策略：采用更复杂的分类算法
Execution & Feedback: 执行结果：分类准确率提高到90%
通过这个代码示例，我们可以看到 Self-Discover 模式如何通过任务分析、自我发现、调整策略和执行反馈的多轮迭代来优化 Agent 的行为。这种模式在实际应用中可以扩展到更复杂的任务和场景，例如机器学习模型优化、智能决策系统等，通过不断优化 Agent 的行为策略，实现更加智能和高效的任务执行。
Storm 模式是一种专注于从零开始生成复杂内容的 Agent 设计模式，特别适用于需要系统化构建和优化内容生成的任务，例如生成类似维基百科的文章、报告或知识库。其核心在于通过逐步构建大纲，并根据大纲逐步丰富内容，从而生成高质量、结构化的文本。
Storm 模式的交互流程如下：
这种模式的优势在于：
Storm 模式的交互流程可以用以下图示来表示：
+-------------------+
| 接收任务 |
+-------------------+
|
v
+-------------------+
| 构建大纲（Outline Construction）|
+-------------------+
|
v
+-------------------+
| 内容生成（Content Generation）|
+-------------------+
|
v
+-------------------+
| 内容优化（Content Optimization）|
+-------------------+
|
v
+-------------------+
| 循环迭代 |
+-------------------+
以下是一个简单的 Storm 模式代码示例，用于实现一个 Agent 生成一篇关于“人工智能”的维基百科风格文章：
class StormAgent:
def __init__(self):
self.knowledge_base = {
"topics": {
"人工智能": {
"定义": "人工智能（Artificial Intelligence, AI）是计算机科学的一个分支，旨在创建能够执行复杂任务的智能机器。",
"历史": "人工智能的发展可以追溯到20世纪40年代，当时科学家们开始探索如何使计算机模拟人类智能。",
"应用": "人工智能在医疗、金融、教育、交通等多个领域都有广泛的应用。",
"未来": "未来，人工智能有望在更多领域实现突破，推动社会的智能化发展。"
}
}
}
def outline_construction(self, topic):
# 构建大纲：根据主题生成大纲
outline = [
"定义",
"历史",
"应用",
"未来"
]
return outline
def content_generation(self, topic, section):
# 内容生成：根据大纲部分生成具体内容
return self.knowledge_base["topics"][topic][section]
def content_optimization(self, content):
# 内容优化：对生成的内容进行润色和调整
optimized_content = content.replace("有望", "有巨大潜力")
return optimized_content
def run(self, topic):
# 主流程：构建大纲 -> 内容生成 -> 内容优化 -> 循环迭代
outline = self.outline_construction(topic)
article = {}
for section in outline:
content = self.content_generation(topic, section)
optimized_content = self.content_optimization(content)
article[section] = optimized_content
return article
# 示例运行
agent = StormAgent()
article = agent.run("人工智能")
for section, content in article.items():
print(f"### {section}")
print(content)
### 定义
人工智能（Artificial Intelligence, AI）是计算机科学的一个分支，旨在创建能够执行复杂任务的智能机器。
### 历史
人工智能的发展可以追溯到20世纪40年代，当时科学家们开始探索如何使计算机模拟人类智能。
### 应用
人工智能在医疗、金融、教育、交通等多个领域都有广泛的应用。
### 未来
未来，人工智能有巨大潜力在更多领域实现突破，推动社会的智能化发展。
通过这个代码示例，我们可以看到 Storm 模式如何通过构建大纲、内容生成和内容优化的多轮迭代来生成高质量的文章。这种模式在实际应用中可以扩展到更复杂的任务和场景，例如生成研究报告、知识库条目等，通过不断优化 Agent 的内容生成和优化策略，实现更加智能和高效的任务执行。
53AI，企业落地大模型首选服务商
产品：场景落地咨询+大模型应用平台+行业解决方案
承诺：免费场景POC验证，效果验证后签署服务协议。零风险落地应用大模型，已交付160+中大型企业
2025-04-30
Mockaroo - 模拟生成测试数据
2025-04-30
MCP实战：将公众号接口做成mcp后，我终于实现了，一句话让AI自己搜索、撰文、配图、排版并发布公众号
2025-04-29
AI时代软件测试的认知革命与架构重塑
2025-04-29
Prompt 练习｜教育中的等待现象
2025-04-29
AI 友好架构：AI 编程最佳范式，构建 10x 效率提升的代码库（万字长文）
2025-04-29
Fetch MCP网页内容抓取实操：抓取“刘强东送外卖”新闻案例详细教程！
2025-04-29
技术为何无法帮助我们思考？从笔记软件的局限性谈起
2025-04-29
豆包是懂PDF论文阅读的
2025-03-06
2024-09-04
2025-01-25
2024-09-26
2024-10-30
2024-09-03
2024-12-11
2024-12-25
2024-10-30
2025-02-18
回到顶部