一、面试题目
在你看来，一个成熟的AI Agent系统，其通用的抽象架构是怎样的？特别是，感知、规划、行动和记忆这四个核心模块，它们之间是如何协同工作，形成一个完整闭环的？请详细阐述一下你的理解。
二、知识储备
要回答好这个问题，你需要对Agent的四大核心模块及其相互关系有深刻的理解。
1. 感知 (Perception)
① 功能：Agent的"五官"，负责从环境中接收信息。这不仅包括用户的自然语言输入，还包括来自工具调用的API返回结果（如JSON数据）、网页内容、甚至是图像、声音等多模态信息。
② 难点：多模态信息的对齐与融合。例如，如何将用户说的"这张图片里的猫"与上传的图片数据在语义上关联起来。
2. 规划 (Planning)
① 功能：Agent的"大脑"，是决策中心。它接收感知到的信息和来自记忆的知识，将复杂的、模糊的用户目标拆解成一系列可执行的、有序的子任务或步骤。
② 关键技术：
- ReAct (Reasoning + Acting)：推理和行动交替进行，动态调整策略。
- Tree-of-Thoughts (ToT)：探索多种可能的推理路径，选择最优解。
- Self-Reflection：对自身上一步的行动结果进行评估和反思，从而修正后续计划。
3. 行动 (Action)
① 功能：Agent的"手脚"，负责执行规划模块生成的任务。这通常通过调用外部工具来实现，如搜索引擎、代码解释器、数据库查询接口、各种API等。
② 难点：工具选择的准确性和调用参数的规范性。Agent需要精确地将规划中的意图转化为工具能理解的参数格式。
4. 记忆 (Memory)
① 功能：Agent的"经验库"，贯穿整个交互流程。它确保Agent在多轮对话中不迷失，并能利用历史经验优化当前决策。
② 分层设计：
- 短期记忆 (Short-term Memory)：存储当前会话的上下文，如最近的几轮对话。通常通过滑动窗口实现，保证对话的连贯性。
- 长期记忆 (Long-term Memory)：持久化存储跨会话的信息，如用户偏好、历史任务记录、领域知识库等。常使用向量数据库或关系型数据库实现，支持语义检索。
5. 模块间的联动逻辑
- 这是一个持续的循环过程：感知输入 -> 记忆检索 -> 大脑规划 -> 工具行动 -> 结果反馈 -> 记忆更新。每一次行动的结果都会作为新的感知输入，触发新一轮的规划和行动，直到任务完成。
三、破局之道
（你可以这样自信地回答）
一个健壮的Agent架构，其本质是为大模型构建一个"认知-行动"的闭环。我们可以将其类比为人类的工作方式：
- 感知是眼睛和耳朵，负责接收外界信号；
- 记忆是大脑皮层，存储着我们的经验和背景知识；
- 规划是前额叶，负责思考、决策和制定计划；
- 行动是我们的双手，负责执行计划并与世界互动。
它们的闭环协作流程是这样的：
首先，感知模块 接收到用户指令或环境反馈。紧接着，它会唤醒记忆模块，从中检索相关的历史信息、用户偏好或先验知识，为决策提供上下文。
然后，规划模块基于当前的感知信息和检索到的记忆，像一个战略家一样，将复杂目标拆解为一系列有序的、可操作的子任务。
接下来，行动模块作为执行者，根据规划好的步骤，精准地调用相应的工具（如API、数据库）来完成任务。
最后，行动产生的结果会再次被感知模块 捕获，形成新的观察。这个新的观察又会触发新一轮的记忆检索、规划和行动。如此循环往复，直至达成最终目标。整个过程产生的新经验和关键信息，也会被沉淀到记忆模块中，让Agent在下一次面对类似情境时变得更加聪明。
四、代码实现
下面我们用Python和JavaScript分别展示一个简化的核心闭环逻辑。为了清晰起见，我们将每个模块抽象为一个类或对象。
Python 版本
python
import json
from typing import List, Dict, Any
# --- 模拟模块 ---
class Perception:
"""感知模块：处理输入"""
def perceive(self, input_data: Any) -> Dict[str, Any]:
print(f"️ [感知] 接收到输入: {input_data}")
# 这里可以加入更复杂的预处理逻辑，如多模态信息融合
return {"type": "user_input", "content": input_data}
class Memory:
"""记忆模块：简单的记忆管理"""
def __init__(self):
self.short_term = []
self.long_term = {} # 简化版，实际应为向量数据库等
def retrieve(self, query: str) -> List[str]:
print(f" [记忆] 正在检索与 '{query}' 相关的信息...")
# 模拟从长期记忆中检索
if "天气" in query:
return ["用户喜欢晴天。"]
return []
def add(self, info: str):
print(f" [记忆] 保存新信息: {info}")
self.short_term.append(info)
class Planning:
"""规划模块：分解任务"""
def plan(self, goal: str, context: List[str]) -> List[Dict[str, str]]:
print(f" [规划] 正在为目标 '{goal}' 制定计划...")
# 这里是核心的LLM推理部分，简化为硬编码逻辑
if "北京天气" in goal:
return [
{"action": "search_weather", "args": {"city": "北京"}}
]
return []
class Action:
"""行动模块：执行工具调用"""
def execute(self, action_plan: List[Dict[str, str]]) -> Any:
for step in action_plan:
action_name = step["action"]
args = step["args"]
print(f"️ [行动] 执行动作: {action_name}, 参数: {args}")
# 模拟工具调用
if action_name == "search_weather":
# 模拟API调用
result = f"北京今天晴天，温度25度。"
print(f" [行动] 动作 {action_name} 执行成功，结果: {result}")
return result
return None
# --- 核心引擎 ---
class AgentCore:
"""Agent核心引擎：协调各模块形成闭环"""
def __init__(self):
self.perception = Perception()
self.memory = Memory()
self.planning = Planning()
self.action = Action()
def run(self, user_input: str):
# 1. 感知
perceived_info = self.perception.perceive(user_input)
# 2. 记忆检索
relevant_memory = self.memory.retrieve(perceived_info["content"])
# 3. 规划
task_plan = self.planning.plan(perceived_info["content"], relevant_memory)
# 4. 行动
action_result = self.action.execute(task_plan)
# 5. 记忆更新 (形成闭环的关键)
if action_result:
self.memory.add(f"任务'{{user_input}}'的结果是: {{action_result}}")
return action_result
# --- 运行示例 ---
if __name__ == "__main__":
agent = AgentCore()
final_response = agent.run("今天北京天气怎么样？")
print(f"\n Agent最终回复: {{final_response}}")JavaScript 版本
javascript
// --- 模拟模块 ---
class Perception {
/** 感知模块：处理输入 */
perceive(inputData) {
console.log(`️ [感知] 接收到输入: ${inputData}`);
// 这里可以加入更复杂的预处理逻辑
return { type: 'user_input', content: inputData };
}
}
class Memory {
/** 记忆模块：简单的记忆管理 */
constructor() {
this.shortTerm = [];
this.longTerm = {}; // 简化版
}
retrieve(query) {
console.log(` [记忆] 正在检索与 '${query}' 相关的信息...`);
// 模拟从长期记忆中检索
if (query.includes('天气')) {
return ['用户喜欢晴天。'];
}
return [];
}
add(info) {
console.log(` [记忆] 保存新信息: ${info}`);
this.shortTerm.push(info);
}
}
class Planning {
/** 规划模块：分解任务 */
plan(goal, context) {
console.log(` [规划] 正在为目辬 '${goal}' 制定计划...`);
// 这里是核心的LLM推理部分，简化为硬编码逻辑
if (goal.includes('北京天气')) {
return [
{ action: 'search_weather', args: { city: '北京' } }
];
}
return [];
}
}
class Action {
/** 行动模块：执行工具调用 */
execute(actionPlan) {
for (const step of actionPlan) {
const actionName = step.action;
const args = step.args;
console.log(`️ [行动] 执行动作: ${actionName}, 参数: ${JSON.stringify(args)}`);
// 模拟工具调用
if (actionName === 'search_weather') {
// 模拟API调用
const result = `北京今天晴天，温度25度。`;
console.log(` [行动] 动作 ${actionName} 执行成功，结果: ${result}`);
return result;
}
}
return null;
}
}
// --- 核心引擎 ---
class AgentCore {
/** Agent核心引擎：协调各模块形成闭环 */
constructor() {
this.perception = new Perception();
this.memory = new Memory();
this.planning = new Planning();
this.action = new Action();
}
run(userInput) {
// 1. 感知
const perceivedInfo = this.perception.perceive(userInput);
// 2. 记忆检索
const relevantMemory = this.memory.retrieve(perceivedInfo.content);
// 3. 规划
const taskPlan = this.planning.plan(perceivedInfo.content, relevantMemory);
// 4. 行动
const actionResult = this.action.execute(taskPlan);
// 5. 记忆更新 (形成闭环的关键)
if (actionResult) {
this.memory.add(`任务'${userInput}'的结果是: ${actionResult}`);
}
return actionResult;
}
}
// --- 运行示例 ---
const agent = new AgentCore();
const finalResponse = agent.run('今天北京天气怎么样？');
console.log(`\n Agent最终回复: ${finalResponse}`);