解锁 AI 代理：5 种设计模式以简化您的代理工作流程

Rifx.Online
AI Applications , AI Research , Machine Learning
05 Mar, 2025

AI 智能体和基于智能体的 workflow：一种设计模式方法

近年来，许多从事人工智能 (AI) 的大型企业都将重点转移到了智能体和基于智能体的 workflow 上。这些先进的解决方案处于全自动化任务的最前沿。幸运的是，由于开发了众多旨在构建 AI 智能体和基于智能体的 workflow 的框架，实施这些系统无需重新发明轮子。这些框架允许开发人员创建复杂的基于智能体的系统，而无需了解智能体构建的每一个复杂细节。就像在软件工程中一样，AI 智能体也出现了设计模式，从而能够开发出经过验证的可靠架构。

图片由 bing ai 生成

智能体可以定义为能够推理、规划并与其环境交互的大语言模型。它们还能够与其他智能体协作和沟通，以完成更复杂的任务。如果您想了解更多关于智能体的信息，可以查看我的文章。对于本文，我将假设您知道什么是智能体及其组成部分。

智能体的组成部分

通过开发基于智能体的框架，许多公司开始构建自己的多智能体系统，并寻求解决其所有智能体任务的灵丹妙药。两年前，研究人员[1]设计了一个名为 ChatDev 的多智能体协作系统。 ChatDev 就像一家虚拟软件公司，通过持有不同角色的各种智能体运营，例如首席执行官、首席产品官、艺术设计师、程序员、评审员、测试员等，就像一家普通的软件工程公司一样。

ChatDev[1]

所有这些智能体一起工作并相互沟通以创建电子游戏，他们的努力证明是成功的。在取得这一成就之后，许多人认为可以使用这种多智能体架构来处理任何软件工程任务，其中每个 AI 都有一个不同的角色。然而，现实世界的实验表明，并非每个问题都可以用相同的架构来解决。在某些情况下，更简单的架构可以提供更有效、更具成本效益的解决方案。

最简单的 AI 智能体设计模式称为 ReAct。在这种模式中，LLM 首先思考要做什么，然后决定要采取的行动，该行动随后在环境中执行，并返回一个观察结果。有了这种观察结果，LLM 就会重复。然后再次思考要做什么，决定采取另一个行动，并继续进行，直到它认为已经完成。

ReAct 设计模式[1]

对于简单的任务，可以使用纯代码轻松构建 React 设计模式，而无需使用框架。

首先，我们需要一个大语言模型来充当智能体的大脑：

from dotenv import load_dotenv
from openai import OpenAI

_ = load_dotenv()
client = OpenAI()

然后，我们可以将我们的简单智能体构建为一个类，以返回我们的消息：

class Agent:
    def __init__(self, system=""):
        self.system = system
        self.messages = []
        if self.system:
            self.messages.append({"role": "system", "content": system})

def __call__(self, message):
        self.messages.append({"role": "user", "content": message})
        result = self.execute()
        self.messages.append({"role": "assistant", "content": result})
        return result

def execute(self):
        completion = client.chat.completions.create(
                        model="gpt-4o",
                        temperature=0,
                        messages=self.messages)
        return completion.choices[0].message.content

然后，我们需要一个系统提示，以指示我们的智能体使用另外两个工具来完成任务：一个用于数学计算，另一个用于找出给定犬种的平均体重。

import openai
import re
import httpx
import os

prompt = """
You run in a loop of Thought, Action, PAUSE, Observation.
At the end of the loop you output an Answer
Use Thought to describe your thoughts about the question you have been asked.
Use Action to run one of the actions available to you - then return PAUSE.
Observation will be the result of running those actions.

Your available actions are:

calculate:
e.g. calculate: 4 * 7 / 3
Runs a calculation and returns the number - uses Python so be sure to use floating point syntax if necessary

average_dog_weight:
e.g. average_dog_weight: Collie
returns average weight of a dog when given the breed

Example session:

Question: How much does a Bulldog weigh?
Thought: I should look the dogs weight using average_dog_weight
Action: average_dog_weight: Bulldog
PAUSE

You will be called again with this:

Observation: A Bulldog weights 51 lbs

You then output:

Answer: A bulldog weights 51 lbs
""".strip()

def calculate(what):
    return eval(what)

def average_dog_weight(name):
    if name in "Scottish Terrier":
        return("Scottish Terriers average 20 lbs")
    elif name in "Border Collie":
        return("a Border Collies average weight is 37 lbs")
    elif name in "Toy Poodle":
        return("a toy poodles average weight is 7 lbs")
    else:
        return("An average dog weights 50 lbs")

known_actions = {
    "calculate": calculate,
    "average_dog_weight": average_dog_weight
}

现在，我们可以通过循环运行我们的智能体来使其在多个步骤中工作：

abot = Agent(prompt)

def query(question, max_turns=5):
    i = 0
    bot = Agent(prompt)
    next_prompt = question
    while i < max_turns:
        i += 1
        result = bot(next_prompt)
        print(result)
        actions = [
            action_re.match(a)
            for a in result.split('\n')
            if action_re.match(a)
        ]
        if actions:
            # There is an action to run
            action, action_input = actions[0].groups()
            if action not in known_actions:
                raise Exception("Unknown action: {}: {}".format(action, action_input))
            print(" -- running {} {}".format(action, action_input))
            observation = known_actions[action](action_input)
            print("Observation:", observation)
            next_prompt = "Observation: {}".format(observation)
        else:
            return

question = """I have 2 dogs, a border collie and a scottish terrier. \
What is their combined weight"""
query(question)

Thought: I need to find the average weight of a Border Collie and a Scottish Terrier, then add them together to get the combined weight.
Action: average_dog_weight

## LangGraph 中的 Agent 架构

: Border Collie PAUSE — running average_dog_weight Border Collie Observation: a Border Collies average weight is 37 lbs Action: average_dog_weight: Scottish Terrier PAUSE — running average_dog_weight Scottish Terrier Observation: Scottish Terriers average 20 lbs Thought: Now that I have the average weights of both dogs, I can calculate their combined weight by adding them together. Action: calculate: 37 + 20 PAUSE — running calculate 37 + 20 Observation: 57 Answer: The combined weight of a Border Collie and a Scottish Terrier is 57 lbst


正如我们上面所看到的，agent 通过使用两个不同的工具解决了查找 Border Collie 和 Scottish Terrier 犬种的平均体重，然后将平均体重相加的问题。

可以使用纯代码构建不同的架构。但重要的是要记住是什么让 agents 如此有前景。它们可以通过相互沟通和分配工作来完成更复杂的任务。构建这些类型的架构很快就会成为一个巨大的挑战，因此许多 AI 公司构建了自己的框架来简化 Agentic 工作流程的构建。我个人在其中许多框架中进行了实验，并在我较早的[文章](https://readmedium.com/which-ai-agent-framework-i-should-use-crewai-langgraph-majestic-one-and-pure-code-e16a6e4d9252)中对它们进行了比较。

> 许多研究表明，不同的设计模式最适合不同的任务。我们可以利用针对我们特定问题的经过验证的解决方案，而不是从头开始设计和构建这些架构。例如，LangGraph 在其文档中提供了各种多 agent 架构。在本文中，我们将探讨这些架构，以更好地了解它们如何应用于我们自己的挑战。

LangGraph 将这些 agent 架构组织成三个主要组：

*   多 agent 系统
*   规划 agent
*   反思与批判

1. 多智能体系统

1.1 网络

解决复杂任务的一种方法是使用“分而治之”的策略。使用路由器，可以将任务路由到专门处理该特定任务的智能体。

多智能体网络[5]

这种架构被称为多智能体网络架构。

1.2 监督者

这种架构与网络架构非常相似，区别在于有一个监督者智能体来协调不同的智能体，而不是路由器。

多智能体监督者[5]

1.3 层次团队

层次团队架构源于一个想法：“如果单个智能体不足以解决特定任务怎么办？”在这种情况下，监督者智能体不是协调几个智能体，而是协调由多个智能体组成的几个团队。

层次智能体团队[5]

2. 规划智能体

2.1. 规划并执行

在这种架构中，首先智能体根据给定的任务生成子任务。然后，单个任务（专业化）智能体解决子任务，如果任务完成，结果将发送回规划器智能体。规划器智能体根据结果形成不同的计划。如果任务完成，规划器智能体将响应用户。

规划并执行[5]

2.2 无观察的推理

在 ReWOO 中，Xu 等人 [6] 引入了一个智能体，该智能体将多步规划器与变量替换相结合，以优化工具的使用。这种方法与规划并执行架构非常相似。然而，与传统模型不同，ReWOO 架构在每个动作之后不包括观察步骤。相反，整个计划是预先创建的，并且保持固定，不受任何后续观察的影响。

ReWOO 架构[5]

规划器智能体构造一个包含子任务的计划来解决任务，而工作者智能体只需完成子任务，然后响应用户。

2.3 LLMCompiler

LLMCompiler 是一种智能体架构，旨在通过在 DAG（有向无环图）中急切地执行任务来加速智能体任务的执行。它还通过减少对 LLM 的调用次数来节省冗余 token 使用的成本。以下是其计算图的概述：

LLMCompiler[5]

它有 3 个主要组成部分：

规划器：流式传输任务的 DAG。
任务提取单元：在任务可执行后立即调度和执行任务
连接器：响应用户或触发第二个计划

3. 反思与批判

3.1 基本反思

反思智能体提示 LLM 反思其过去的行动，从而使其能够随着时间的推移学习和改进。有两个智能体：生成器和评论员。最简单的例子可以是一个作家和评论员。作家根据用户请求编写文本，评论员审查文本，然后将其反思发送回作家。此循环将持续到给定的迭代次数。

反思[5]

3.2 Reflexion

Reflexion by Shinn, et. al[7]., 是一种旨在通过口头反馈和自我反思来学习的架构。智能体明确地批判其对任务的响应，以生成更高质量的最终响应，但会增加执行时间。与反思架构相比，Reflexion 智能体还包括工具执行。

Reflexion[5]

该论文概述了 3 个主要组成部分：

具有自我反思的 Actor（智能体）
外部评估者（特定于任务，例如代码编译步骤）
存储来自 (1) 的反思的事件记忆。

3.3 思想之树

Yao[8] 等人提出的思想之树（ToT）是一种通用的 LLM 智能体搜索算法，它结合了反思/评估和简单搜索（在这种情况下为 BFS，但如果您愿意，可以使用 DFS 或其他算法）。

思想之树[5]

它有三个主要步骤：

扩展：生成 1 个或多个问题的候选解决方案。
评分：衡量响应的质量。
修剪：保留前 K 个最佳候选者

然后，如果未找到解决方案（或解决方案质量不足），则返回到“扩展”。

3.4 语言智能体树搜索

Zhou 等人提出的语言智能体树搜索 [9] (LATS) 是一种通用的 LLM 智能体搜索算法，它结合了反思/评估和搜索（特别是蒙特卡洛树搜索），与 ReACT、Reflexion 或思想之树等类似技术相比，可以实现更好的整体任务性能。

语言智能体树搜索[5]

它有四个主要步骤：

选择：根据步骤 (2) 的总奖励选择最佳的下一个操作。要么响应（如果找到解决方案或达到最大搜索深度），要么继续搜索。
扩展和模拟：选择要执行的“最佳” 5 个潜在操作并并行执行它们。
反思 + 评估：观察这些行动的结果，并根据反思（以及可能的外部反馈）对决策进行评分
反向传播：根据结果更新根轨迹的分数。

3.4 Self-Discover Agent

Self-discover 帮助大型语言模型（LLMs）找出解决棘手问题的最佳方法。

首先，它通过选择和更改基本的推理步骤，为每个问题找到一个独特的计划
然后，它使用这个计划逐步解决问题

通过这种方式，LLM 使用不同的推理工具并根据问题进行调整，从而实现比仅使用一种方法更有效的解决方案。

Self-Discover Agent[10]

Self-discover 从其他规划方法中脱颖而出，因为它会自动为每个任务创建独特的推理策略。以下是它的不同之处：

推理模块：它使用基本的推理步骤，并将它们按特定顺序组合在一起
无需人工帮助：它自行找出这些策略，无需人工标记任务
适应任务：它找到解决每个问题的最佳方法，就像人类制定计划一样
可迁移：它创建的推理策略可以被不同类型的语言模型使用

简而言之，Self-discover 的独特之处在于它结合了不同的推理方法来创建计划，而无需特定的任务指令。

结论

在本文中，我们探讨了 AI 智能体及其设计模式的演变，重点介绍了智能体框架如何使复杂 AI 系统的开发变得民主化。通过讨论基本概念和 ReAct 模式等实际实现，我们证明了更简单、更具成本效益的架构通常可以有效地解决特定任务。我们还研究了增强 AI 功能的高级多智能体系统、规划智能体和反思框架。ChatDev 等项目的成功突显了多智能体协作的潜力，而 LangGraph 等工具简化了构建复杂的智能体工作流程。总的来说，理解和利用这些设计模式使开发人员能够为各种应用创建可靠且可扩展的 AI 系统。

参考文献

[1] Qian, Chen, et al. “Chatdev: Communicative agents for software development.” arXiv preprint arXiv:2307.07924 (2023).

[2] “ChatDev”, GitHub — OpenBMB/ChatDev: Create Customized Software using Natural Language Idea (through LLM-powered Multi-Agent Collaboration)

[3] “AI Agents in Langgraph”, https://learn.deeplearning.ai/courses/ai-agents-in-langgraph/

[4] “AI Agentic Design Patterns with Autogen”, https://learn.deeplearning.ai/courses/ai-agentic-design-patterns-with-autogen

[5] “Tutorials”, https://langchain-ai.github.io/langgraph/tutorials/

[6] Xu, Binfeng, et al. “Rewoo: Decoupling reasoning from observations for efficient augmented language models.” arXiv preprint arXiv:2305.18323 (2023).

[7] Shinn, Noah, et al. “Reflexion: Language agents with verbal reinforcement learning, 2023.” URL https://arxiv. org/abs/2303.11366 (2023).

[8] Yao, Shunyu, et al. “Tree of thoughts: Deliberate problem solving with large language models.” Advances in neural information processing systems 36 (2023): 11809–11822.

[9] Zhou, Andy, et al. “Language agent tree search unifies reasoning acting and planning in language models.” arXiv preprint arXiv:2310.04406 (2023).

[10] Zhou, Pei, et al. “Self-discover: Large language models self-compose reasoning structures.” Advances in Neural Information Processing Systems 37 (2025): 126032–126058.