当前位置：首页 > news >正文

理解AI 智能体：智能体架构

news 2025/8/24 14:37:14

1. 引言

智能体架构（agent architecture）是一份蓝图，它定义了AI智能体各组件的组织方式和交互机制，使智能体能够感知环境、进行推理并采取行动。本质上，它就像是智能体的数字大脑——整合了“眼睛”（传感器）、“大脑”（决策逻辑）和“手”（执行器）来处理信息并行动。

选择合适的架构对于构建有效的AI智能体至关重要。架构决定了智能体的各项能力，包括响应速度、处理复杂性的能力、学习适应性以及资源需求。例如，一个基于简单反射的智能体可能擅长实时反应，但在长期规划上表现不佳；而一个慎思型（deliberative）智能体或许能处理复杂目标，但计算成本更高。理解这些权衡取舍能让工程师根据应用领域匹配最合适的架构，从而实现最佳性能和可靠性。

2. 智能体架构

智能体架构大致可分为以下几类：

反应式 (Reactive)
慎思式 (Deliberative)
混合式 (Hybrid)
神经符号式 (Neural-Symbolic)
认知式 (Cognitive)

2.1 反应式架构

最直接的AI智能体设计模式被称为ReAct（思考-行动）。在这种方法中，一个大语言模型（LLM）首先分析情况并决定下一步要采取的行动。然后，该行动在环境中执行，并生成一个观察结果作为反馈。LLM处理这个观察结果，重新评估其下一步行动，选择另一个动作，并持续这个循环，直到它认为任务完成。

2.1.1 用例

反应式架构非常适合需要瞬间决策且响应可预测、定义明确的领域。经典的例子包括机器人和游戏：例如，一旦传感器检测到障碍物就能反射性避障的扫地机器人或无人机，或者电子游戏中针对玩家动作有预设即时反应的非玩家角色（NPC）（例如，敌人守卫一看到玩家就攻击）。
在工业环境中，简单的监控智能体可能在传感器读数超出范围时触发警报或关闭系统。这些智能体在实时控制系统中表现出色，但由于缺乏全局规划，它们被用于相对简单或严格受限的任务，这些任务的所有情况规则都可以预先定义。

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

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

from dotenv import load_dotenv
from openai import OpenAI_ = load_dotenv()
client = OpenAI()

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

class Agent:def __init__(self, system=""):self.system = systemself.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 resultdef execute(self):completion = client.chat.completions.create(model="gpt-4o",temperature=0,messages=self.messages)return completion.choices[0].message.content

接着，我们需要一个系统提示（system prompt）来指导我们的智能体使用另外两个工具完成任务：一个用于数学计算，另一个用于查找给定犬种的平均体重。

import openai
import re
import httpx
import osprompt = """
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 necessaryaverage_dog_weight:
e.g. average_dog_weight: Collie
returns average weight of a dog when given the breedExample session:Question: How much does a Bulldog weigh?
Thought: I should look the dogs weight using average_dog_weight
Action: average_dog_weight: Bulldog
PAUSEYou will be called again with this:Observation: A Bulldog weights 51 lbsYou 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
}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.

现在，我们可以通过一个循环来构建我们的智能体，使其能够进行多步工作：

abot = Agent(prompt)def query(question, max_turns=5):i = 0bot = Agent(prompt)next_prompt = questionwhile i < max_turns:i += 1result = 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 runaction, 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:returnquestion = """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: 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

如上所示，该智能体成功地使用两种不同的工具确定了边境牧羊犬和苏格兰梗的平均体重，然后对结果求和。

2.1.2 优势与局限性

反应式架构的主要优势是速度。没有复杂的推理开销，决策在恒定时间内完成，这对于实时机器人或高频交易等毫秒级响应至关重要的领域非常理想。
反应式智能体的设计和验证也相对简单，因为它们的行为由规则明确定义。
缺点在于它们的适应性有限，因为它们不学习或规划，无法轻松处理不可预见的场景或解决需要为实现目标而执行一系列动作的问题。
它们也往往是短视的，优化即时响应但不考虑长期后果（如果规则中没有包含一些战略逻辑，一个反应式机器人可能会在一个小循环里无休止地徘徊）。这些局限性推动了更先进的、包含内部状态和推理能力的架构的发展。

研究表明，不同的设计模式更适合不同的任务。我们无需从头构建这些架构，而是可以利用现有的、经过充分测试的、针对特定问题的解决方案。例如，LangGraph 在其文档中提供了一系列多智能体架构。

在本文中，我们将探讨这些架构以及如何将它们应用到我们的用例中。

2.2 慎思式架构

慎思式（Deliberative）智能体是基于模型的、目标驱动的智能体，它们在行动前进行推理。与即时响应的反应式智能体不同，慎思式智能体提前思考，使用内部模型评估多个可能的动作，并选择实现其目标的最佳计划。

感知（Sense）→ 建模（Model）→ 规划（Plan）→ 行动（Act）

感知：从环境接收新的输入。
建模：更新内部世界模型（例如符号状态、语义地图）。
慎思：生成可能的计划并模拟/评估其结果。
行动：执行最佳计划或实现目标的下一步。

这种方法类似于象棋AI如何提前规划好几步棋，而不是一步一步地反应。

示例伪代码：一个简化的慎思式智能体循环（受BDI原则启发）可能如下所示：

# Pseudocode for a deliberative agent with goal-oriented planning
initialize_state()
while True:perceive_environment(state)options = generate_options(state)            # possible plans or actionsbest_option = evaluate_options(options)      # deliberation: select best plancommit_to_plan(best_option, state)           # update intentionsexecute_next_action(best_option)if goal_achieved(state):break

在这个循环中，generate_options 可以根据当前状态和目标产生可能的动作或计划，evaluate_options 应用推理或规划（例如，模拟结果或使用启发式方法来选择一个好的计划），智能体一步一步地执行动作，并在每次需要时重新评估。这反映了一个慎思式智能体如何考虑未来后果并优化长期目标。例如，在一个路线规划智能体中，generate_options 可能会创建几条路线路径，而 evaluate_options 选择最短的安全路径。

2.3 混合架构

混合智能体架构（Hybrid agent architectures）结合了反应式和慎思式系统，以在动态环境中同时实现速度和智能。

反应层：对感官输入做出即时响应（例如，避障）。
慎思层：使用内部模型执行目标驱动的规划（例如，路线规划）。
这些层通常并行运作，以平衡快速响应和长期策略。

该架构通常分层结构：

底层：反应式（本能响应）
中间层（可选）：排序/协调
顶层：慎思式（目标推理和规划）
一个协调机制（如监督器或优先级规则）决定哪一层的输出优先。

percept = sense_environment()if is_urgent(percept):                      action = reactive_module(percept)       # Quick reflex
else:update(world_model, percept)action = deliberative_planner(world_model, current_goal)execute(action)

这种逻辑确保了安全性和效率，既能适应即时威胁，也能适应长期目标。

2.4 神经符号架构

神经符号（Neural-Symbolic 或 Neurosymbolic）架构结合了神经网络（用于从数据中学习）和符号AI（用于基于规则的推理），使智能体既能够感知复杂环境，又能对其进行推理。

神经网络：擅长模式识别（例如，图像、语音）。
符号系统：擅长逻辑、推理和可解释性。
结合目标：利用神经感知和符号理解来做出智能的、可解释的决策。

有两种主要的集成策略：

顺序式：神经模块处理原始输入（例如，检测物体）；符号模块对解释后的输出进行推理。
并行式：神经和符号模块同时工作，决策模块融合两者的输出。

示例伪代码：

percept = get_sensor_data()
nn_insights = neural_module.predict(percept)         # Perception (e.g., detect anomaly)
sym_facts = symbolic_module.update(percept)          # Translate data to logical facts
sym_conclusions = symbolic_module.infer(sym_facts)   # Apply domain knowledge
decision = policy_module.decide(nn_insights, sym_conclusions)
execute(decision)

这使得学习到的洞察和指导行动的显式规则得以结合。

2.5 认知架构

认知架构（Cognitive architectures）是旨在模拟类人通用智能的综合框架，通过将感知、记忆、推理和学习集成到一个统一的智能体系统中。

受人类认知启发。
遵循感知-思考-行动（Sense–Think–Act）循环：
1. 感知环境
2. 更新工作记忆
3. 使用产生式规则进行推理和决策
4. 通过执行器行动
旨在构建能够像人类一样学习、规划、解决问题和适应的智能体。

2.5.1 SOAR 架构

开发于20世纪80年代，用于实现通用智能行为。
工作记忆：保存当前情境。
产生式记忆：存储“如果-那么”规则。
使用通用子目标（universal subgoaling）——在遇到困难时设定子目标。
学习：使用“组块化（chunking）”——将经验转化为新规则。
示例用例：AI飞行员、人形机器人、决策智能体。

2.5.2 ACT-R 架构

根植于认知心理学。
由专用模块组成（例如，视觉、运动、记忆）。
每个模块使用自己的缓冲区作为临时工作记忆。
产生式规则管理缓冲区之间的数据流。
结合了符号推理和亚符号机制（如记忆激活）。

共同特点

模块化设计（感知、记忆、动作模块）。
多记忆系统：
1. 陈述性记忆（事实）
2. 程序性记忆（技能/规则）
3. 有时包括情景记忆（过去事件）
内置学习（Soar的组块化，ACT-R的调优）。

简化认知循环：

percept = perceive_environment()
update_working_memory(percept)
action = cognitive_reasoner.decide(working_memory)
execute(action)

像 SOAR 和 ACT-R 这样的认知架构提供了一个整体性的智能模型，集成了感知、记忆、决策和学习。它们不仅用于构建智能体——还帮助我们理解人类思维的工作方式。这些系统非常适合需要随时间学习、处理多样化任务并能像人类一样推理的智能体。

3. LangGraph 中的智能体设计模式

智能体架构（Agent architectures）和智能体设计模式（agentic design patterns）密切相关，但它们在AI智能体开发中处于不同的抽象层次。

智能体架构指的是结构框架或蓝图，定义了智能体如何构建和运作。它关乎核心组件及其组织方式——可以把它看作是智能体的“骨架”。一个架构规定了智能体如何感知环境、处理信息、做出决策并采取行动。

架构通常更多地关乎系统构建的“方式”——低层机制以及数据或控制流。

智能体设计模式则是更高层次、可复用的策略或模板，用于解决基于智能体的系统中的特定问题。它们较少关注智能体内部的具体细节，而更多地指导行为或交互方式，使其能够适应不同的上下文。可以将它们视为实现某些结果的“配方”。

设计模式关注“什么”和“为什么”——你希望智能体表现出什么行为或能力，以及为什么这种模式对特定场景有效。

LangGraph 将这些智能体架构组织成三个主要组：

3.1 多智能体系统 (Multi-Agent Systems)

网络 (Network)
监督者 (Supervisor)
分层团队 (Hierarchical Teams)

3.2 规划智能体 (Planning Agents)

规划并执行 (Plan-and-Execute)
无观察推理 (Reasoning without Observation)
LLM编译器 (LLMCompiler)

3.3 反思与批判 (Reflection & Critique)

基本反思 (Basic Reflection)
Reflexion
思维树 (Tree of Thoughts)
语言智能体树搜索 (Language Agent Tree Search)
自我发现智能体 (Self-Discover Agent)

下面让我们深入了解这些智能体设计模式。

4. 多智能体系统

4.1 多智能体网络 (Multi-agent Network)

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

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

4.2 多智能体监督者 (Multi-agent Supervisor)

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

4.3 分层智能体团队 (Hierarchical Agent Teams)

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

5. 规划智能体

5.1 规划并执行 (Plan-and-execute)

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

5.2 无观察推理 (Reasoning without observation - ReWOO)

在 ReWOO 中，Xu et al. 等人提出了一种智能体，它集成了多步规划器和变量替换来优化工具使用。这种方法非常类似于规划并执行架构。然而，与传统模型不同，ReWOO 架构在每个动作之后不包括观察步骤。相反，整个计划是预先创建的并且保持固定，不受任何后续观察的影响。

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

5.3 LLM编译器 (LLMCompiler)

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

它具有三个主要组件：

规划器 (Planner)：流式处理一个任务DAG。
任务获取单元 (Task Fetching Unit)：一旦任务可执行，就立即调度和执行它们。
连接器 (Joiner)：响应用户或触发第二个计划。

6. 反思与批判

6.1 基本反思 (Basic Reflection)

反思智能体提示LLM对其过去的行动进行反思，使其能够随着时间学习改进。有两个智能体：生成器（generator）和批判者（critique）。最简单的例子可能是一个写手和评论家。写手根据用户请求撰写文本，评论家审查文本，然后将他们的反思发送回写手。这个循环持续进行直到达到给定的迭代次数。

6.2 Reflexion

Reflexion（由 Shinn 等人提出）是一种旨在通过语言反馈和自我反思来学习的架构。该智能体明确地批判其任务响应，以生成更高质量的最终响应，但代价是更长的执行时间。与反思架构相比，Reflexion 智能体还包括工具执行。

《Reflexion: Language Agents with Verbal Reinforcement Learning》

该论文概述了3个主要组件：

具有自我反思能力的执行者（Actor (agent)）
外部评估器（External evaluator）（特定于任务，例如代码编译步骤）
情景记忆（Episodic memory），存储来自(1)的反思。

6.3 思维树 (Tree of Thoughts - ToT)

思维树（ToT，由 Yao, et. al 等人提出）是一种通用的LLM智能体搜索算法，它结合了反思/评估和简单搜索（在这种情况下是广度优先搜索BFS，但如果你愿意，也可以应用深度优先搜索DFS或其他算法）。

它具有三个主要步骤：

扩展 (Expand)：生成问题的一个或多个候选解决方案。
评分 (Score)：衡量响应的质量。
剪枝 (Prune)：保留前K个最佳候选方案

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

6.4 语言智能体树搜索 (Language Agent Tree Search - LATS)

语言智能体树搜索（LATS，由 Zhou, et. al 等人提出）是一种通用的LLM智能体搜索算法，它结合了反思/评估和搜索（特别是蒙特卡洛树搜索 Monte-Carlo Tree Search），与 ReACT、Reflexion 或思维树（ToT）等类似技术相比，实现了更好的整体任务性能。

它具有四个主要步骤：

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

6.5 自我发现智能体 (Self-Discover Agent)

自我发现（Self-discover）帮助大语言模型（LLMs）找出思考和解决复杂问题的最佳方式。

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

这样，与只使用一种方法相比，LLM使用了不同的推理工具并适应问题，从而获得更有效的解决方案。

自我发现与其他规划方法的不同之处在于它会自动为每个任务创建独特的推理策略。以下是它的不同之处：

推理模块 (Reasoning Modules)：它使用基本推理步骤并按特定顺序将它们组合起来。
无需人工帮助 (No Human Help)：它自行找出这些策略，不需要人工标注任务。
适应任务 (Adapts to the Task)：它找到解决每个问题的最佳方式，就像人类制定计划一样。
可迁移 (Transferable)：它创建的推理策略可以被不同类型的语言模型使用。

简而言之，自我发现的独特之处在于它结合了不同的推理方法，无需特定的任务指令即可创建计划。

7. 结语

在本篇博客中，我们探讨了智能体架构不断发展的面貌，从传统的反应式和慎思式模型，到更先进的混合式、神经符号式和认知式系统。然后，我们将这些基本概念与使用 LangGraph 的现代实现联系起来，展示了强大的智能体设计模式，如规划、协作、反思和批判。随着我们继续构建越来越智能和自主的系统，理解和应用这些架构原则将是解锁可扩展、模块化和目标驱动的AI解决方案的关键。AI的未来不在于孤立的智能，而在于协调、反思和有目的的智能体共同合作解决复杂任务。

查看全文

http://www.dtcms.com/a/343842.html