随着大语言模型技术的快速发展，能够自主规划与执行的智能体技术正成为AI应用开发的新焦点。与传统的响应式AI不同，智能体是一个能感知环境、做出决策并执行动作的软件实体。本文将系统性地介绍如何运用Multi-Agent（多智能体）架构、Skills（技能）模式和Spring AI框架，构建一个具备自主决策能力的智能体系统，并深入探讨其核心组件与协作机制。
一、智能体基础概念
1.1 什么是智能体
智能体具备以下几个区别于传统程序的核心特征：
- 自主性：能够独立做出决策，无需人工持续干预。
- 感知能力：能够接收和处理来自用户或其他系统的外部信息。
- 决策能力：基于当前状态和目标，从多种可能的行动中选择最优方案。
- 执行能力：能够调用工具或技能来执行决策，从而影响环境。
- 学习能力：能够从过去的交互和经验中学习，以优化未来的决策策略。
1.2 智能体的核心组件
一个典型的智能体由感知、决策、执行和记忆四个层次的核心组件构成：
智能体组件架构：
┌─────────────────────────────────────────┐
│ 感知层 (Perception) │
│ ┌──────┐ ┌──────┐ ┌──────┐ │
│ │ 消息 │ │ 传感器│ │ 配置 │ │
│ │ 接收 │ │ 数据 │ │ 数据 │ │
│ └──────┘ └──────┘ └──────┘ │
└─────────────────────────────────────────┘
↓
┌─────────────────────────────────────────┐
│ 决策层 (Decision) │
│ ┌──────────────────────────────┐ │
│ │ 决策策略引擎 │ │
│ │ - 规则引擎 │ │
│ │ - AI分析 │ │
│ │ - 强化学习 │ │
│ └──────────────────────────────┘ │
└─────────────────────────────────────────┘
↓
┌─────────────────────────────────────────┐
│ 执行层 (Action) │
│ ┌──────┐ ┌──────┐ ┌──────┐ │
│ │ 技能 │ │ 工具 │ │ 接口 │ │
│ │ 调用 │ │ 调用 │ │ 调用 │ │
│ └──────┘ └──────┘ └──────┘ │
└─────────────────────────────────────────┘
↓
┌─────────────────────────────────────────┐
│ 记忆层 (Memory) │
│ ┌──────┐ ┌──────┐ ┌──────┐ │
│ │ 工作 │ │ 长期 │ │ 语义 │ │
│ │ 记忆 │ │ 记忆 │ │ 记忆 │ │
│ └──────┘ └──────┘ └──────┘ │
└─────────────────────────────────────────┘
1.3 智能体状态机
智能体在其生命周期中会经历不同的状态，使用状态机可以清晰地管理这一过程：
/**
* 智能体状态枚举
*/
public enum AgentState {
IDLE, // 空闲 - 等待新任务
PROCESSING, // 处理中 - 正在处理用户请求
EXECUTING, // 执行中 - 正在执行技能或工具
WAITING, // 等待中 - 等待外部响应或用户反馈
ERROR // 错误 - 处理过程发生异常
}
二、Skills技能模式
2.1 什么是Skills模式
Skills模式是一种模块化设计方法，它将智能体的能力封装成独立的“技能”单元。每个Skill代表一种特定的功能（如查询、计算、存储），智能体可以根据任务需求动态地加载和执行相应的技能组合。
这种模式的优势显而易见：
- 模块化：每个技能独立开发、测试和部署，职责单一。
- 可扩展：新增能力只需实现并注册新的Skill，无需修改智能体核心。
- 可组合：多个简单技能可以组合起来，协同完成复杂任务。
- 可重用：同一技能可以被不同的智能体实例共享使用。
2.2 Skill接口设计
定义一个通用的Skill接口是技能模式的基础，它规范了所有技能必须具备的行为：
/**
* 智能体技能接口
*/
public interface Skill {
/**
* 获取技能名称
*/
String getName();
/**
* 获取技能描述
*/
String getDescription();
/**
* 检查技能是否可执行
*
* @param agent 当前智能体
* @param context 上下文信息
* @return 是否可执行
*/
boolean canExecute(Agent agent, AgentContext context);
/**
* 执行技能
*
* @param agent 当前智能体
* @param context 上下文信息
* @param parameters 执行参数
* @return 执行结果
*/
SkillResult execute(Agent agent, AgentContext context,
Map<String, Object> parameters);
/**
* 获取技能优先级
*/
int getPriority();
}
2.3 常见技能类型
2.3.1 查询技能（QuerySkill）
允许智能体从数据库、API等外部数据源主动获取信息。
/**
* 查询技能
*/
public class QuerySkill implements Skill {
private DataSource dataSource;
public QuerySkill(DataSource dataSource) {
this.dataSource = dataSource;
}
@Override
public String getName() {
return "查询技能";
}
@Override
public SkillResult execute(Agent agent, AgentContext context,
Map<String, Object> parameters) {
String queryType = parameters.getOrDefault("type", "default").toString();
String queryKey = parameters.getOrDefault("key", "").toString();
// 从数据源查询
Object result = dataSource.query(queryType, queryKey);
// 存储到上下文
context.storeInWorkingMemory("query_result_" + queryKey, result);
return SkillResult.success("查询成功")
.addData("result", result);
}
}
2.3.2 记忆技能（MemorySkill）
负责管理智能体的记忆，包括短期的工作记忆和长期的持久化记忆。
/**
* 记忆技能
*/
public class MemorySkill implements Skill {
private MemoryStorage storage;
public MemorySkill(MemoryStorage storage) {
this.storage = storage;
}
@Override
public SkillResult execute(Agent agent, AgentContext context,
Map<String, Object> parameters) {
String operation = parameters.getOrDefault("operation", "store").toString();
switch (operation) {
case “store”:
storage.store(
parameters.get(“key”).toString(),
parameters.get(“value”)
);
return SkillResult.success(“存储成功”);
case “retrieve”:
Object value = storage.retrieve(parameters.get(“key”).toString());
return SkillResult.success(“检索成功”)
.addData(“value”, value);
case “search”:
List<Map.Entry<String, Object>> results =
storage.search(parameters.get(“keyword”).toString());
return SkillResult.success(“搜索成功”)
.addData(“count”, results.size())
.addData(“results”, results);
default:
return SkillResult.fail(“不支持的操作: ” + operation);
}
}
}
2.3.3 协作技能（CollaborationSkill）
使智能体能够与其他智能体进行通信、协调行动，是实现多智能体系统的关键。
/**
* 协作技能
*/
public class CollaborationSkill implements Skill {
private AgentOrchestrator orchestrator;
@Override
public SkillResult execute(Agent agent, AgentContext context,
Map<String, Object> parameters) {
// 广播消息给其他智能体
String message = parameters.get(“message”).toString();
List<Future<AgentMessage>> futures =
orchestrator.broadcast(createMessage(message));
// 等待所有智能体响应
List<AgentDecision> decisions = collectDecisions(futures);
// 协调决策
AgentDecision finalDecision =
orchestrator.coordinateDecisions(decisions);
return SkillResult.success(“协作完成”)
.addData(“decision”, finalDecision);
}
}
三、决策策略模式
3.1 决策策略的作用
决策策略定义了智能体“如何思考”的核心逻辑。它根据当前环境（上下文）和自身状态，决定下一步要采取的最佳行动。采用策略模式可以将决策逻辑从智能体主体中解耦，实现决策算法的灵活切换和热插拔。
/**
* 决策策略接口
*/
public interface DecisionStrategy {
/**
* 做出决策
*/
AgentDecision makeDecision(Agent agent, AgentContext context);
}
3.2 AI驱动的决策策略
利用大语言模型的推理能力，我们可以构建出非常智能的决策策略。智能体可以将当前状况整理成提示词（Prompt），交给LLM分析，并解析LLM的回复作为最终决策。
/**
* AI决策策略
*/
public class SimpleAIDecisionStrategy implements DecisionStrategy {
private AIService aiService;
@Override
public AgentDecision makeDecision(Agent agent, AgentContext context) {
// 构建决策提示词
String prompt = buildDecisionPrompt(agent, context);
// 调用AI获取决策
String aiResponse = aiService.chat(prompt);
// 解析AI响应为决策
return parseAIDecision(aiResponse);
}
private String buildDecisionPrompt(Agent agent, AgentContext context) {
StringBuilder sb = new StringBuilder();
sb.append(“你是一个智能决策助手。\n\n”);
sb.append(“智能体名称: ”).append(agent.getAgentName()).append(“\n”);
sb.append(“当前状态: ”).append(agent.getState().getDesc()).append(“\n”);
sb.append(“可选择的动作:\n”);
sb.append(“ 1. QUERY - 查询更多信息\n”);
sb.append(“ 2. EXECUTE - 执行任务\n”);
sb.append(“ 3. ANALYZE - 分析情况\n”);
sb.append(“ 4. COMPLETE - 任务完成\n\n”);
sb.append(“请以JSON格式返回决策:\n”);
sb.append(“{\“action\”: \“动作\”, \“reason\”: \“理由\”}”);
return sb.toString();
}
}
3.3 决策协调
当多个智能体参与同一个任务并各自给出决策时，需要一个协调器来整合意见，形成统一的最终决策。常见的协调策略包括按置信度排序、投票、加权平均等。
/**
* 智能体协调器
*/
public class AgentOrchestrator {
/**
* 协调多个决策
*/
public AgentDecision coordinateDecisions(List<AgentDecision> decisions) {
// 按置信度排序
List<AgentDecision> sorted = decisions.stream()
.sorted((a, b) -> Double.compare(
b.getConfidence(),
a.getConfidence()))
.collect(Collectors.toList());
// 如果最高置信度明显大于次高，则采用最高
if (sorted.size() >= 2) {
double topConfidence = sorted.get(0).getConfidence();
double secondConfidence = sorted.get(1).getConfidence();
if (topConfidence - secondConfidence > 0.2) {
return sorted.get(0);
}
}
// 否则合并决策
return mergeDecisions(decisions);
}
}
四、上下文管理
4.1 AgentContext的作用
AgentContext 是智能体的“大脑”和“记忆中枢”，它维护了智能体在一次会话或任务执行过程中所有的运行时状态和信息，是连接感知、决策、执行和记忆各模块的纽带。
/**
* 智能体上下文
*/
public class AgentContext {
// 当前智能体
private Agent currentAgent;
// 消息历史（保留最近100条）
private List<AgentMessage> messageHistory;
// 全局变量
private Map<String, Object> variables;
// 工作记忆（短期）
private Map<String, Object> workingMemory;
// 长期记忆
private Map<String, Object> longTermMemory;
// 协作智能体列表
private List<Agent> collaborators;
// 用户会话ID
private String sessionId;
/**
* 添加消息到历史
*/
public void addMessage(AgentMessage message) {
messageHistory.add(message);
if (messageHistory.size() > 100) {
messageHistory.remove(0);
}
}
/**
* 获取最近的消息
*/
public List<AgentMessage> getRecentMessages(int count) {
int start = Math.max(0, messageHistory.size() - count);
return new ArrayList<>(
messageHistory.subList(start, messageHistory.size())
);
}
/**
* 存储到工作记忆
*/
public void storeInWorkingMemory(String key, Object value) {
workingMemory.put(key, value);
}
/**
* 从工作记忆获取
*/
public Object getFromWorkingMemory(String key) {
return workingMemory.get(key);
}
/**
* 清除上下文
*/
public void clear() {
messageHistory.clear();
workingMemory.clear();
variables.clear();
}
}
4.2 记忆层次
一个健全的智能体记忆系统应包含多个层次，模仿人类的记忆结构：
记忆层次结构：
┌─────────────────────────────────────┐
│ 感知记忆 (Perceptual) │
│ - 最近的感知输入 │
│ - 临时缓存 │
│ - 寿命: 毫秒级 │
└─────────────────────────────────────┘
↓
┌─────────────────────────────────────┐
│ 工作记忆 (Working) │
│ - 当前任务相关的信息 │
│ - 中间计算结果 │
│ - 寿命: 会话级 │
└─────────────────────────────────────┘
↓
┌─────────────────────────────────────┐
│ 长期记忆 (Long-term) │
│ - 知识库 │
│ - 历史经验 │
│ - 用户偏好 │
│ - 寿命: 永久/可配置 │
└─────────────────────────────────────┘
↓
┌─────────────────────────────────────┐
│ 语义记忆 (Semantic) │
│ - 向量索引 │
│ - 语义检索 │
│ - 寿命: 永久 │
└─────────────────────────────────────┘
五、消息处理机制
5.1 消息类型
为了清晰地区分和处理不同意图的通信，我们需要定义标准的消息类型。
/**
* 消息类型枚举
*/
public enum MessageType {
QUERY, // 查询 - 请求信息
COMMAND, // 命令 - 执行指令
RESPONSE, // 响应 - 回复消息
NOTIFY, // 通知 - 系统通知
ERROR // 错误 - 错误报告
}
5.2 消息处理流程
智能体处理消息通常遵循一个标准流程：接收消息、根据类型路由、执行具体逻辑、生成响应、更新状态并存储历史。这里可以使用模板方法模式来定义骨架。
/**
* 智能体消息处理
*/
public abstract class Agent {
/**
* 处理消息（模板方法）
*/
public final void processMessage(AgentMessage message,
AgentContext context) {
// 1. 子类实现具体处理逻辑
AgentMessage response = handleMessage(message, context);
if (response != null) {
// 2. 存储到消息历史
context.addMessage(response);
}
// 3. 更新智能体状态
updateState(message, context);
}
/**
* 处理消息的具体实现（子类覆盖）
*/
protected abstract AgentMessage handleMessage(
AgentMessage message, AgentContext context
);
/**
* 更新状态
*/
protected void updateState(AgentMessage message,
AgentContext context) {
this.state = calculateNewState(message, context);
}
/**
* 计算新状态（子类可覆盖）
*/
protected AgentState calculateNewState(AgentMessage message,
AgentContext context) {
switch (message.getType()) {
case QUERY:
return AgentState.PROCESSING;
case COMMAND:
return AgentState.EXECUTING;
case RESPONSE:
return AgentState.IDLE;
default:
return this.state;
}
}
}
六、Spring Boot集成
在Java生态中，使用Spring Boot可以快速搭建智能体系统的服务框架，管理依赖注入和配置。
6.1 依赖配置
首先，在pom.xml中引入必要的依赖。
<dependencies>
<!-- Spring Boot Web -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<version>2.7.14</version>
</dependency>
<!-- Lombok -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.26</version>
</dependency>
<!-- 测试 -->
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter</artifactId>
<version>5.9.2</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.mockito</groupId>
<artifactId>mockito-core</artifactId>
<version>4.11.0</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.assertj</groupId>
<artifactId>assertj-core</artifactId>
<version>3.24.2</version>
<scope>test</scope>
</dependency>
</dependencies>
6.3 配置类
通过Spring的配置类，我们将核心组件声明为Bean，方便依赖注入和管理。
/**
* 系统配置
*/
@Configuration
public class SystemConfiguration {
@Bean
public AgentOrchestrator agentOrchestrator() {
return new AgentOrchestrator();
}
@Bean
public AIService aiService() {
return new MockAIService();
}
@Bean
public SimpleAIDecisionStrategy aiDecisionStrategy(
AIService aiService) {
return new SimpleAIDecisionStrategy(aiService);
}
@Bean
public CollaborationSkill collaborationSkill() {
return new CollaborationSkill();
}
@Bean
public MemorySkill memorySkill() {
return new MemorySkill(new SimpleMemoryStorage());
}
}
七、多智能体协作
单一智能体的能力是有限的，通过多智能体协作，可以完成更复杂、需要多角色配合的任务。
7.1 协作场景
多智能体系统特别适用于以下场景：
- 任务分解：将复杂任务拆解为子任务，分发给不同智能体并行执行。
- 角色分工：每个智能体扮演专家角色（如分析员、执行员、审核员）。
- 信息互补：整合拥有不同知识库或数据源的智能体。
- 冗余验证：多个智能体处理同一任务，通过结果对比提高可靠性。
7.2 协作模式
7.2.1 层次协作
这是一种主从式结构，由一个协调者（Orchestrator）智能体接收任务，进行分析和规划，然后指挥下属的多个执行者智能体。
用户请求
↓
主控智能体（Orchestrator）
↓
├→ 分析智能体（任务分解）
├→ 执行智能体1（子任务1）
├→ 执行智能体2（子任务2）
└→ 执行智能体3（子任务3）
↓
结果汇总与整合
7.2.2 平等协作
所有智能体地位平等，通过广播机制接收任务，各自独立决策，然后通过投票、置信度加权等方式协调出一个最终结果。
用户请求
↓
消息广播
↓
├→ 智能体A（独立决策）
├→ 智能体B（独立决策）
└→ 智能体C（独立决策）
↓
决策协调（投票、加权等）
↓
最终结果
7.3 协调器实现
AgentOrchestrator是多智能体系统的中枢，负责注册、通信和决策协调。它通常会利用线程池（ExecutorService）来管理多个智能体的并发执行。
/**
* 智能体协调器
*/
public class AgentOrchestrator {
// 注册的智能体
private Map<String, Agent> agents;
// 共享上下文
private AgentContext sharedContext;
// 线程池
private ExecutorService executorService;
/**
* 注册智能体
*/
public void registerAgent(Agent agent) {
agents.put(agent.getAgentId(), agent);
sharedContext.addCollaborator(agent);
}
/**
* 广播消息到所有智能体
*/
public List<Future<AgentMessage>> broadcast(
AgentMessage message) {
List<Future<AgentMessage>> futures = new ArrayList<>();
for (Agent agent : agents.values()) {
Future<AgentMessage> future =
executorService.submit(() -> {
agent.processMessage(message, sharedContext);
return message;
});
futures.add(future);
}
return futures;
}
/**
* 协调决策
*/
public AgentDecision coordinateDecisions(
List<AgentDecision> decisions) {
// 按置信度排序
List<AgentDecision> sorted = decisions.stream()
.sorted((a, b) -> Double.compare(
b.getConfidence(), a.getConfidence()))
.collect(Collectors.toList());
// 合并决策
return mergeDecisions(sorted);
}
}
八、系统整体架构
综合以上所有组件，我们可以描绘出整个智能体系统的整体架构。它通常分为接口层、智能体核心层、服务层和基础设施层，清晰地展示了数据流和组件间的交互关系。
九、完整示例：SimpleChatAgent
理论需要实践来印证。下面我们实现一个简单的聊天智能体，并将其集成到REST API中。
9.1 实现代码
/**
* 简单聊天智能体
*/
public class SimpleChatAgent extends Agent {
private AIService aiService;
public SimpleChatAgent(String agentId, String agentName,
AIService aiService) {
super(agentId, agentName);
this.aiService = aiService;
}
@Override
protected AgentMessage handleMessage(
AgentMessage message, AgentContext context) {
switch (message.getType()) {
case QUERY:
return handleQuery(message, context);
case COMMAND:
return handleCommand(message, context);
case RESPONSE:
return handleResponse(message, context);
case NOTIFY:
return handleNotification(message, context);
default:
return createErrorResponse(“未知消息类型”);
}
}
private AgentMessage handleQuery(AgentMessage message,
AgentContext context) {
// 使用AI生成响应
String aiResponse = aiService.chat(message.getContent());
return createResponseMessage(agentId, aiResponse);
}
private AgentMessage handleCommand(AgentMessage message,
AgentContext context) {
String content = message.getContent().toLowerCase();
if (content.contains(“clear”)) {
context.clear();
return createResponseMessage(agentId, “上下文已清除”);
} else if (content.contains(“help”)) {
return createResponseMessage(agentId,
“可用命令: clear(清除), help(帮助), status(状态)”);
} else if (content.contains(“status”)) {
return createResponseMessage(agentId,
String.format(“当前状态: %s”, state.getDesc()));
}
return createResponseMessage(agentId, “命令已处理”);
}
@Override
protected AgentDecision makeDefaultDecision(AgentContext context) {
Object lastResponse = context.getFromWorkingMemory(“last_response”);
if (lastResponse != null) {
return new AgentDecision(AgentAction.WAIT, “等待用户反馈”);
}
return new AgentDecision(AgentAction.QUERY, “需要更多信息”);
}
}
9.2 REST API接口
最后，我们通过Spring MVC控制器提供HTTP接口，让外部系统能够创建智能体、发送消息和触发决策。
/**
* 智能体控制器
*/
@RestController
@RequestMapping(“/api/agent”)
public class AgentController {
@Resource
private AgentOrchestrator orchestrator;
@Resource
private AIService aiService;
/**
* 创建智能体
*/
@PostMapping(“/create”)
public ApiResponse createAgent(@RequestBody CreateAgentRequest request) {
SimpleChatAgent agent = new SimpleChatAgent(
request.getAgentId(),
request.getAgentName(),
aiService
);
orchestrator.registerAgent(agent);
return ApiResponse.success(“智能体创建成功”)
.addData(“agentId”, agent.getAgentId());
}
/**
* 发送消息到智能体
*/
@PostMapping(“/message”)
public ApiResponse sendMessage(@RequestBody MessageRequest request) {
AgentMessage message = new AgentMessage(
MessageType.QUERY,
request.getSenderId(),
request.getContent()
);
Future<AgentMessage> future =
orchestrator.sendMessage(request.getAgentId(), message);
AgentMessage response = future.get(10, TimeUnit.SECONDS);
return ApiResponse.success(“消息已处理”)
.addData(“content”, response.getContent());
}
/**
* 智能体决策
*/
@PostMapping(“/decision”)
public ApiResponse makeDecision(@RequestBody DecisionRequest request) {
Agent agent = findAgent(request.getAgentId());
AgentDecision decision = agent.decide(orchestrator.getSharedContext());
return ApiResponse.success(“决策完成”)
.addData(“action”, decision.getAction())
.addData(“reason”, decision.getReason())
.addData(“confidence”, decision.getConfidence());
}
}
十、总结
本文详细阐述了构建自主决策智能体系统的完整架构与方法论。核心思想可以概括为以下几点：
- 模块化设计：通过Skills模式将能力解耦，使智能体变得灵活且易于扩展。新增功能就像安装新插件一样简单。
- 策略模式：将决策逻辑抽象为可插拔的策略，允许我们在规则引擎、AI模型、强化学习等不同决策方式间自由切换。
- 上下文管理：
AgentContext 作为智能体的“记忆体”，是维持对话连贯性、实现状态感知和进行复杂推理的基石。
- 多智能体协作：通过协调器（Orchestrator）组织多个智能体分工合作，能够解决远超单个智能体能力的复杂问题，是迈向强人工智能应用的关键一步。
将Spring AI的能力注入到这个架构中，可以极大地增强智能体的理解和生成能力。希望这份指南能为你构建自己的智能体系统提供清晰的路径和实用的代码参考。如果你对更多Java后端架构或人工智能应用实践感兴趣，欢迎在云栈社区继续交流探讨。
发表于 2 小时前
|
查看: 3|
回复: 0
