【值得收藏】深度解析大模型Agent：8种模式实现与多Agent协作架构
问题："帮我分析一下公司上个月的销售数据，找出问题并给出改进建议"人类思考过程：1. 理解问题：需要分析销售数据，找出问题，提出建议2. 制定计划：- 先获取销售数据- 分析数据趋势- 识别异常点- 分析原因- 提出改进方案3. 执行计划：- 调用数据库查询销售数据- 使用Excel或Python分析数据- 生成图表可视化- 写分析报告4. 反思调整：- 如果数据不够，调整查询条件- 如果分析有误
·
本文深入讲解了大模型智能体(Agent)的架构设计与实现，详细介绍了8种核心工作模式，包括ReAct、Agentic RAG等，并提供了Java实战代码。文章探讨了多Agent协作系统架构，对比了CrewAI、AutoGen等主流框架，讲解了A2A协作模式，为开发者提供了从理论到实践的完整指南，帮助构建真正智能的AI系统。
一、从工具调用到智能体
1.1 什么是Agent？
想象一下人类解决问题的过程：
问题："帮我分析一下公司上个月的销售数据，找出问题并给出改进建议"
人类思考过程：
1. 理解问题：需要分析销售数据，找出问题，提出建议
2. 制定计划：
- 先获取销售数据
- 分析数据趋势
- 识别异常点
- 分析原因
- 提出改进方案
3. 执行计划：
- 调用数据库查询销售数据
- 使用Excel或Python分析数据
- 生成图表可视化
- 写分析报告
4. 反思调整：
- 如果数据不够，调整查询条件
- 如果分析有误，重新分析
- 如果建议不切实际，修改建议
Agent就是具备这种思考能力的AI系统。
1.2 Agent vs 传统AI的区别
| 维度 | 传统AI | Agent |
|---|---|---|
| 交互方式 | 一问一答 | 多轮对话，持续交互 |
| 任务复杂度 | 单一任务 | 复杂多步骤任务 |
| 决策能力 | 被动响应 | 主动规划和决策 |
| 学习能力 | 静态知识 | 从经验中学习 |
| 错误处理 | 简单重试 | 分析原因，调整策略 |
| 工具使用 | 固定工具 | 动态选择和组合工具 |
1.3 Agent的核心组件
┌─────────────────────────────────────────┐
│ Agent │
├─────────────────────────────────────────┤
│ 1. 感知层 (Perception) │
│ - 理解用户输入 │
│ - 解析环境状态 │
├─────────────────────────────────────────┤
│ 2. 推理层 (Reasoning) │
│ - 任务分解 │
│ - 计划制定 │
│ - 决策逻辑 │
├─────────────────────────────────────────┤
│ 3. 行动层 (Action) │
│ - 工具调用 │
│ - 环境交互 │
│ - 结果处理 │
├─────────────────────────────────────────┤
│ 4. 记忆层 (Memory) │
│ - 短期记忆（对话历史） │
│ - 长期记忆（经验知识） │
│ - 工作记忆（当前任务状态） │
├─────────────────────────────────────────┤
│ 5. 学习层 (Learning) │
│ - 从成功案例学习 │
│ - 从失败案例学习 │
│ - 策略优化 │
└─────────────────────────────────────────┘
1.4 Agent的工作流程
graph TD
A[用户输入] --> B[感知层：理解任务]
B --> C[推理层：制定计划]
C --> D[行动层：执行步骤]
D --> E{任务完成？}
E -->|否| F[反思：分析结果]
F --> G[调整计划]
G --> D
E -->|是| H[生成最终回答]
H --> I[更新记忆]
二、Agent的8种核心模式详解
Agent有多种工作模式，每种模式都有其特定的应用场景和优势。本节将详细介绍8种主要的Agent模式。
2.1 规划与执行模式（Planning & Execution）
是什么：
规划与执行模式将复杂任务分解为多个子任务，先制定详细计划，再按计划执行。
运行过程：
- 任务分解：将复杂任务分解为可执行的子任务
- 计划制定：为每个子任务制定执行策略
- 顺序执行：按计划顺序执行子任务
- 结果整合：将子任务结果整合为最终答案
应用场景：
- 软件开发项目
- 数据分析任务
- 内容创作
- 复杂问题求解
执行流程图：
graph TD
A[接收任务] --> B[任务分解]
B --> C[制定计划]
C --> D[执行子任务1]
D --> E[执行子任务2]
E --> F[执行子任务N]
F --> G[整合结果]
G --> H[返回最终答案]
D --> I{子任务成功?}
I -->|否| J[调整计划]
J --> D
I -->|是| E
2.2 自我提问模式（Self-Questioning）
是什么：
Agent通过不断向自己提问来深入理解问题，逐步逼近正确答案。
运行过程：
- 初始问题：接收用户问题
- 自我提问：生成相关问题
- 回答问题：逐一回答生成的问题
- 综合答案：基于所有回答生成最终答案
应用场景：
- 复杂推理问题
- 学术研究
- 深度分析
- 创意生成
执行流程图：
graph TD
A[接收问题] --> B[生成相关问题1]
B --> C[回答问题1]
C --> D[生成相关问题2]
D --> E[回答问题2]
E --> F[生成相关问题N]
F --> G[回答问题N]
G --> H[综合所有答案]
H --> I[生成最终答案]
C --> J{需要更多问题?}
J -->|是| D
J -->|否| H
2.3 思考与自省模式（Reflection & Introspection）
是什么：
Agent在执行过程中不断反思自己的行为和结果，通过自我评估来改进表现。
运行过程：
- 执行任务：执行当前任务
- 结果评估：评估执行结果的质量
- 自我反思：分析成功或失败的原因
- 策略调整：基于反思结果调整策略
- 重新执行：使用新策略重新执行
应用场景：
- 学习型任务
- 优化问题
- 持续改进
- 自适应系统
执行流程图：
graph TD
A[接收任务] --> B[执行任务]
B --> C[评估结果]
C --> D[自我反思]
D --> E{结果满意?}
E -->|否| F[分析失败原因]
F --> G[调整策略]
G --> B
E -->|是| H[完成任务]
D --> I[记录经验]
I --> J[更新知识库]
2.4 ReAct模式（通用）
是什么：
ReAct = Reasoning + Acting，通过思考-行动-观察的循环来解决问题。
运行过程：
- Thought：思考当前状态和下一步行动
- Action：选择并执行具体行动
- Observation：观察行动结果
- 循环：重复上述过程直到任务完成
应用场景：
- 通用问题求解
- 工具使用
- 环境交互
- 复杂推理
执行流程图：
graph TD
A[接收任务] --> B[Thought: 思考]
B --> C[Action: 行动]
C --> D[Observation: 观察]
D --> E{任务完成?}
E -->|否| B
E -->|是| F[返回结果]
C --> G[工具调用]
G --> H[环境交互]
H --> D
2.5 ReAct RAG Agent模式
是什么：
结合ReAct模式和RAG技术，Agent能够检索外部知识来辅助推理和行动。
运行过程：
- Thought：思考需要什么信息
- Retrieval：检索相关文档
- Action：基于检索结果执行行动
- Observation：观察行动结果
- 循环：重复直到任务完成
应用场景：
- 知识密集型任务
- 文档问答
- 研究分析
- 信息整合
执行流程图：
graph TD
A[接收任务] --> B[Thought: 思考需要什么信息]
B --> C[Retrieval: 检索相关文档]
C --> D[Action: 基于检索结果行动]
D --> E[Observation: 观察结果]
E --> F{任务完成?}
F -->|否| B
F -->|是| G[返回结果]
C --> H[向量数据库]
H --> I[文档检索]
I --> D
2.6 Agentic RAG模式
是什么：
Agentic RAG将RAG过程本身作为Agent的任务，Agent能够主动决定检索策略和生成策略。
运行过程：
- 任务分析：分析任务类型和需求
- 检索策略：决定检索方法和参数
- 文档检索：执行检索操作
- 内容生成：基于检索结果生成答案
- 质量评估：评估生成结果的质量
- 迭代优化：根据评估结果优化策略
应用场景：
- 智能问答系统
- 文档分析
- 知识管理
- 内容生成
执行流程图：
graph TD
A[接收任务] --> B[任务分析]
B --> C[制定检索策略]
C --> D[执行文档检索]
D --> E[内容生成]
E --> F[质量评估]
F --> G{质量满意?}
G -->|否| H[优化策略]
H --> C
G -->|是| I[返回结果]
D --> J[多源检索]
J --> K[结果融合]
K --> E
2.7 思维树模式（Tree of Thoughts）
是什么：
思维树模式通过生成多个思考路径，评估每个路径的价值，选择最优路径继续执行。
运行过程：
- 初始思考：生成多个初始思考方向
- 路径扩展：为每个思考方向生成子路径
- 价值评估：评估每个路径的价值
- 路径选择：选择最有价值的路径
- 深度搜索：在选定路径上继续扩展
- 结果生成：基于最优路径生成最终答案
应用场景：
- 复杂推理问题
- 创意生成
- 策略规划
- 多方案比较
执行流程图：
graph TD
A[接收任务] --> B[生成初始思考]
B --> C[扩展思考路径]
C --> D[评估路径价值]
D --> E[选择最优路径]
E --> F{达到目标?}
F -->|否| C
F -->|是| G[生成最终答案]
C --> H[路径1]
C --> I[路径2]
C --> J[路径N]
H --> D
I --> D
J --> D
2.8 模式对比总结
| 模式 | 优势 | 劣势 | 适用场景 | 复杂度 |
|---|---|---|---|---|
| 规划与执行 | 结构清晰，易于控制 | 灵活性不足 | 有明确流程的任务 | 中等 |
| 自我提问 | 深度思考，全面分析 | 效率较低 | 复杂推理问题 | 高 |
| 思考与自省 | 持续改进，自适应 | 收敛慢 | 学习型任务 | 高 |
| ReAct | 通用性强，透明性好 | 计算成本高 | 通用问题求解 | 中等 |
| ReAct RAG | 知识丰富，准确性高 | 检索开销大 | 知识密集型任务 | 高 |
| Agentic RAG | 智能化程度高 | 实现复杂 | 智能问答系统 | 很高 |
| 思维树 | 全局最优，创意丰富 | 计算量大 | 复杂推理和创意 | 很高 |
三、Java实战：构建自主Agent系统
3.1 环境准备
<!-- pom.xml --><project><properties><spring-ai.version>1.1.0-M3</spring-ai.version></properties><dependencies><!-- Spring AI Starter --><dependency><groupId>org.springframework.ai</groupId><artifactId>spring-ai-openai-spring-boot-starter</artifactId></dependency><!-- Spring Boot Web --><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency><!-- Spring Boot Data JPA --><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-jpa</artifactId></dependency><!-- H2 Database --><dependency><groupId>com.h2database</groupId><artifactId>h2</artifactId><scope>runtime</scope></dependency></dependencies><dependencyManagement><dependencies><dependency><groupId>org.springframework.ai</groupId><artifactId>spring-ai-bom</artifactId><version>${spring-ai.version}</version><type>pom</type><scope>import</scope></dependency></dependencies></dependencyManagement></project>
# application.ymlspring:ai:openai:api-key:${OPENAI_API_KEY}chat:options:model:gpt-4o-minitemperature:0.0datasource:url:jdbc:h2:mem:testdbdriver-class-name:org.h2.Driverusername:sapassword:passwordjpa:hibernate:ddl-auto:create-dropshow-sql:true
3.2 核心Agent接口定义
package com.example.agent.core;
import java.util.List;
import java.util.Map;
/**
* Agent核心接口
*/publicinterfaceAgent {
/**
* 执行任务
*/
AgentResult executeTask(String task, Map<String, Object> context);
/**
* 获取Agent能力
*/
List<String> getCapabilities();
/**
* 获取Agent状态
*/
AgentStatus getStatus();
/**
* 更新记忆
*/voidupdateMemory(Memory memory);
/**
* 获取记忆
*/
List<Memory> getMemories();
}
/**
* Agent结果
*/publicrecordAgentResult(
boolean success,
String result,
Map<String, Object> metadata,
List<String> errors
) {}
/**
* Agent状态
*/publicenumAgentStatus {
IDLE, BUSY, ERROR, LEARNING
}
/**
* 记忆
*/publicrecordMemory(
String id,
String content,
MemoryType type,
long timestamp,
Map<String, Object> metadata
) {}
/**
* 记忆类型
*/publicenumMemoryType {
SHORT_TERM, LONG_TERM, WORKING, EPISODIC
}
3.3 ReAct Agent实现
package com.example.agent.react;
import com.example.agent.core.*;
import org.springframework.ai.chat.client.ChatClient;
import org.springframework.stereotype.Component;
import java.util.*;
/**
* ReAct Agent实现
*/@ComponentpublicclassReActAgentimplementsAgent {
privatefinal ChatClient chatClient;
privatefinal ToolRegistry toolRegistry;
privatefinal MemoryManager memoryManager;
privatefinal PromptTemplate promptTemplate;
privateAgentStatusstatus= AgentStatus.IDLE;
privatefinal List<Memory> memories = newArrayList<>();
publicReActAgent(ChatClient.Builder chatClientBuilder,
ToolRegistry toolRegistry,
MemoryManager memoryManager,
PromptTemplate promptTemplate) {
this.chatClient = chatClientBuilder.build();
this.toolRegistry = toolRegistry;
this.memoryManager = memoryManager;
this.promptTemplate = promptTemplate;
}
@Overridepublic AgentResult executeTask(String task, Map<String, Object> context) {
status = AgentStatus.BUSY;
try {
// 1. 初始化ReAct循环
List<ReActStep> steps = newArrayList<>();
StringcurrentThought="";
intmaxIterations=10;
intiteration=0;
// 2. ReAct循环while (iteration < maxIterations) {
iteration++;
// Thought: 思考Stringthought= generateThought(task, currentThought, steps);
steps.add(newReActStep("Thought", thought, null, null));
// Action: 行动Actionaction= generateAction(thought, steps);
if (action == null) {
break; // 没有更多行动，任务完成
}
steps.add(newReActStep("Action", action.name(), action.arguments(), null));
// Observation: 观察Stringobservation= executeAction(action);
steps.add(newReActStep("Observation", observation, null, null));
// 检查是否完成任务if (isTaskComplete(observation, task)) {
break;
}
currentThought = thought;
}
// 3. 生成最终答案StringfinalAnswer= generateFinalAnswer(task, steps);
// 4. 更新记忆
updateMemory(newMemory(
UUID.randomUUID().toString(),
"Task: " + task + "\nResult: " + finalAnswer,
MemoryType.EPISODIC,
System.currentTimeMillis(),
Map.of("steps", steps.size(), "success", true)
));
status = AgentStatus.IDLE;
returnnewAgentResult(true, finalAnswer, Map.of("steps", steps), List.of());
} catch (Exception e) {
status = AgentStatus.ERROR;
returnnewAgentResult(false, "", Map.of(), List.of(e.getMessage()));
}
}
private String generateThought(String task, String previousThought, List<ReActStep> steps) {
Stringprompt= promptTemplate.buildReActThoughtPrompt(task, previousThought, steps);
return chatClient.prompt()
.user(prompt)
.call()
.content();
}
private Action generateAction(String thought, List<ReActStep> steps) {
Stringprompt= promptTemplate.buildReActActionPrompt(thought, steps, toolRegistry.getAvailableTools());
Stringresponse= chatClient.prompt()
.user(prompt)
.call()
.content();
return parseAction(response);
}
private String executeAction(Action action) {
Tooltool= toolRegistry.getTool(action.name());
if (tool != null) {
return tool.execute(action.arguments());
}
return"Tool not found: " + action.name();
}
privatebooleanisTaskComplete(String observation, String originalTask) {
// 简化的任务完成判断return observation.toLowerCase().contains("task completed") ||
observation.toLowerCase().contains("final answer");
}
private String generateFinalAnswer(String task, List<ReActStep> steps) {
Stringprompt= promptTemplate.buildFinalAnswerPrompt(task, steps);
return chatClient.prompt()
.user(prompt)
.call()
.content();
}
@Overridepublic List<String> getCapabilities() {
return toolRegistry.getAvailableTools().stream()
.map(Tool::getName)
.toList();
}
@Overridepublic AgentStatus getStatus() {
return status;
}
@OverridepublicvoidupdateMemory(Memory memory) {
memories.add(memory);
memoryManager.saveMemory(memory);
}
@Overridepublic List<Memory> getMemories() {
returnnewArrayList<>(memories);
}
}
/**
* ReAct步骤
*/publicrecordReActStep(
String type, // Thought, Action, Observation
String content,
Map<String, Object> arguments,
String result
) {}
/**
* 行动
*/publicrecordAction(
String name,
Map<String, Object> arguments
) {}
3.4 提示词模板
package com.example.agent.prompt;
import org.springframework.stereotype.Component;
import java.util.List;
import java.util.Map;
/**
* Agent提示词模板
*/@ComponentpublicclassPromptTemplate {
public String buildReActThoughtPrompt(String task, String previousThought, List<ReActStep> steps) {
StringBuilderprompt=newStringBuilder();
prompt.append("你是一个智能助手，正在使用ReAct模式解决问题。\n\n");
prompt.append("任务：").append(task).append("\n\n");
if (!steps.isEmpty()) {
prompt.append("之前的步骤：\n");
for (ReActStep step : steps) {
prompt.append(step.type()).append(": ").append(step.content()).append("\n");
}
prompt.append("\n");
}
prompt.append("现在请思考下一步应该做什么。\n");
prompt.append("Thought: ");
return prompt.toString();
}
public String buildReActActionPrompt(String thought, List<ReActStep> steps, List<Tool> availableTools) {
StringBuilderprompt=newStringBuilder();
prompt.append("基于你的思考，请选择下一步行动。\n\n");
prompt.append("可用工具：\n");
for (Tool tool : availableTools) {
prompt.append("- ").append(tool.getName()).append(": ").append(tool.getDescription()).append("\n");
}
prompt.append("\n请按以下格式回答：\n");
prompt.append("Action: 工具名称\n");
prompt.append("Action Input: 工具参数\n");
return prompt.toString();
}
public String buildFinalAnswerPrompt(String task, List<ReActStep> steps) {
StringBuilderprompt=newStringBuilder();
prompt.append("基于以下步骤，请生成最终答案：\n\n");
prompt.append("任务：").append(task).append("\n\n");
prompt.append("执行步骤：\n");
for (ReActStep step : steps) {
prompt.append(step.type()).append(": ").append(step.content()).append("\n");
}
prompt.append("\nFinal Answer: ");
return prompt.toString();
}
public String buildSelfQuestioningPrompt(String question) {
return String.format("""
你是一个善于自我提问的智能助手。对于以下问题，请生成3-5个相关的子问题来帮助深入理解：
原问题：%s
请生成相关问题：
1.
2.
3.
4.
5.
然后逐一回答这些问题，最后综合所有答案给出最终回答。
""", question);
}
public String buildReflectionPrompt(String task, String result, boolean success) {
return String.format("""
请对以下任务执行结果进行反思：
任务：%s
结果：%s
成功：%s
请分析：
1. 执行过程中的优点
2. 存在的问题
3. 改进建议
4. 下次如何做得更好
""", task, result, success);
}
}
3.5 工具注册表
package com.example.agent.tools;
import org.springframework.stereotype.Component;
import java.util.List;
import java.util.Map;
import java.util.HashMap;
/**
* 工具注册表
*/@ComponentpublicclassToolRegistry {
privatefinal Map<String, Tool> tools = newHashMap<>();
publicToolRegistry() {
// 注册基础工具
registerTool(newCalculatorTool());
registerTool(newSearchTool());
registerTool(newFileTool());
registerTool(newDatabaseTool());
}
publicvoidregisterTool(Tool tool) {
tools.put(tool.getName(), tool);
}
public Tool getTool(String name) {
return tools.get(name);
}
public List<Tool> getAvailableTools() {
return List.copyOf(tools.values());
}
}
/**
* 工具接口
*/publicinterfaceTool {
String getName();
String getDescription();
String execute(Map<String, Object> arguments);
}
/**
* 计算器工具
*/@ComponentpublicclassCalculatorToolimplementsTool {
@Overridepublic String getName() {
return"calculator";
}
@Overridepublic String getDescription() {
return"执行数学计算";
}
@Overridepublic String execute(Map<String, Object> arguments) {
Stringexpression= (String) arguments.get("expression");
try {
// 简化的计算器实现doubleresult= evaluateExpression(expression);
return"计算结果: " + result;
} catch (Exception e) {
return"计算错误: " + e.getMessage();
}
}
privatedoubleevaluateExpression(String expression) {
// 这里应该使用更安全的表达式求值器// 为了示例，使用简单的实现return Double.parseDouble(expression.replaceAll("[^0-9.]", ""));
}
}
/**
* 搜索工具
*/@ComponentpublicclassSearchToolimplementsTool {
@Overridepublic String getName() {
return"search";
}
@Overridepublic String getDescription() {
return"搜索网络信息";
}
@Overridepublic String execute(Map<String, Object> arguments) {
Stringquery= (String) arguments.get("query");
// 模拟搜索return"搜索结果: 关于 '" + query + "' 的信息...";
}
}
/**
* 文件工具
*/@ComponentpublicclassFileToolimplementsTool {
@Overridepublic String getName() {
return"file";
}
@Overridepublic String getDescription() {
return"文件操作";
}
@Overridepublic String execute(Map<String, Object> arguments) {
Stringoperation= (String) arguments.get("operation");
Stringfilename= (String) arguments.get("filename");
switch (operation) {
case"read":
return"读取文件: " + filename;
case"write":
return"写入文件: " + filename;
default:
return"未知操作: " + operation;
}
}
}
/**
* 数据库工具
*/@ComponentpublicclassDatabaseToolimplementsTool {
@Overridepublic String getName() {
return"database";
}
@Overridepublic String getDescription() {
return"数据库查询";
}
@Overridepublic String execute(Map<String, Object> arguments) {
Stringquery= (String) arguments.get("query");
// 模拟数据库查询return"查询结果: " + query;
}
}
3.6 记忆管理器
package com.example.agent.memory;
import com.example.agent.core.Memory;
import com.example.agent.core.MemoryType;
import org.springframework.stereotype.Component;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
import java.util.List;
import java.util.stream.Collectors;
/**
* 记忆管理器
*/@ComponentpublicclassMemoryManager {
privatefinal MemoryRepository memoryRepository;
privatefinalintmaxMemories=1000;
publicMemoryManager(MemoryRepository memoryRepository) {
this.memoryRepository = memoryRepository;
}
publicvoidsaveMemory(Memory memory) {
MemoryEntityentity=newMemoryEntity(
memory.id(),
memory.content(),
memory.type().name(),
memory.timestamp(),
memory.metadata()
);
memoryRepository.save(entity);
// 清理旧记忆
cleanupOldMemories();
}
public List<Memory> getMemoriesByType(MemoryType type) {
return memoryRepository.findByType(type.name())
.stream()
.map(this::entityToMemory)
.collect(Collectors.toList());
}
public List<Memory> getRecentMemories(int limit) {
return memoryRepository.findRecentMemories(limit)
.stream()
.map(this::entityToMemory)
.collect(Collectors.toList());
}
public List<Memory> searchMemories(String query) {
return memoryRepository.findByContentContaining(query)
.stream()
.map(this::entityToMemory)
.collect(Collectors.toList());
}
privatevoidcleanupOldMemories() {
longcount= memoryRepository.count();
if (count > maxMemories) {
List<MemoryEntity> oldestMemories = memoryRepository.findOldestMemories((int)(count - maxMemories));
memoryRepository.deleteAll(oldestMemories);
}
}
private Memory entityToMemory(MemoryEntity entity) {
returnnewMemory(
entity.getId(),
entity.getContent(),
MemoryType.valueOf(entity.getType()),
entity.getTimestamp(),
entity.getMetadata()
);
}
}
/**
* 记忆实体
*/@Entity@Table(name = "memories")publicclassMemoryEntity {
@Idprivate String id;
@Column(columnDefinition = "TEXT")private String content;
private String type;
privatelong timestamp;
@Column(columnDefinition = "TEXT")private String metadata; // JSON格式// 构造函数、getter、setterpublicMemoryEntity() {}
publicMemoryEntity(String id, String content, String type, long timestamp, Map<String, Object> metadata) {
this.id = id;
this.content = content;
this.type = type;
this.timestamp = timestamp;
this.metadata = convertMetadataToString(metadata);
}
private String convertMetadataToString(Map<String, Object> metadata) {
// 将Map转换为JSON字符串return"{}"; // 简化实现
}
// getter和setter方法public String getId() { return id; }
publicvoidsetId(String id) { this.id = id; }
public String getContent() { return content; }
publicvoidsetContent(String content) { this.content = content; }
public String getType() { return type; }
publicvoidsetType(String type) { this.type = type; }
publiclonggetTimestamp() { return timestamp; }
publicvoidsetTimestamp(long timestamp) { this.timestamp = timestamp; }
public String getMetadata() { return metadata; }
publicvoidsetMetadata(String metadata) { this.metadata = metadata; }
}
/**
* 记忆仓库
*/@RepositorypublicinterfaceMemoryRepositoryextendsJpaRepository<MemoryEntity, String> {
List<MemoryEntity> findByType(String type);
@Query("SELECT m FROM MemoryEntity m ORDER BY m.timestamp DESC LIMIT ?1")
List<MemoryEntity> findRecentMemories(int limit);
List<MemoryEntity> findByContentContaining(String query);
@Query("SELECT m FROM MemoryEntity m ORDER BY m.timestamp ASC LIMIT ?1")
List<MemoryEntity> findOldestMemories(int limit);
}
3.7 多Agent协作系统
package com.example.agent.collaboration;
import com.example.agent.core.Agent;
import com.example.agent.core.AgentResult;
import org.springframework.stereotype.Component;
import java.util.*;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ConcurrentHashMap;
/**
* 多Agent协作系统
*/@ComponentpublicclassMultiAgentSystem {
privatefinal Map<String, Agent> agents = newConcurrentHashMap<>();
privatefinal MessageBus messageBus;
privatefinal TaskScheduler taskScheduler;
publicMultiAgentSystem(MessageBus messageBus, TaskScheduler taskScheduler) {
this.messageBus = messageBus;
this.taskScheduler = taskScheduler;
}
publicvoidregisterAgent(String agentId, Agent agent) {
agents.put(agentId, agent);
messageBus.registerAgent(agentId, agent);
}
public CompletableFuture<AgentResult> executeCollaborativeTask(String task, Map<String, Object> context) {
return CompletableFuture.supplyAsync(() -> {
// 1. 任务分解
List<SubTask> subTasks = decomposeTask(task);
// 2. 分配任务
Map<String, SubTask> assignments = assignTasks(subTasks);
// 3. 并行执行
Map<String, CompletableFuture<AgentResult>> futures = newHashMap<>();
for (Map.Entry<String, SubTask> entry : assignments.entrySet()) {
StringagentId= entry.getKey();
SubTasksubTask= entry.getValue();
futures.put(agentId, CompletableFuture.supplyAsync(() -> {
Agentagent= agents.get(agentId);
return agent.executeTask(subTask.description(), subTask.context());
}));
}
// 4. 等待所有任务完成
Map<String, AgentResult> results = newHashMap<>();
for (Map.Entry<String, CompletableFuture<AgentResult>> entry : futures.entrySet()) {
try {
results.put(entry.getKey(), entry.getValue().get());
} catch (Exception e) {
results.put(entry.getKey(), newAgentResult(false, "", Map.of(), List.of(e.getMessage())));
}
}
// 5. 整合结果return integrateResults(task, results);
});
}
private List<SubTask> decomposeTask(String task) {
// 简化的任务分解逻辑
List<SubTask> subTasks = newArrayList<>();
if (task.contains("开发")) {
subTasks.add(newSubTask("需求分析", "分析用户需求", Map.of()));
subTasks.add(newSubTask("系统设计", "设计系统架构", Map.of()));
subTasks.add(newSubTask("编码实现", "实现功能代码", Map.of()));
subTasks.add(newSubTask("测试验证", "测试系统功能", Map.of()));
} elseif (task.contains("分析")) {
subTasks.add(newSubTask("数据收集", "收集相关数据", Map.of()));
subTasks.add(newSubTask("数据处理", "清洗和处理数据", Map.of()));
subTasks.add(newSubTask("数据分析", "分析数据趋势", Map.of()));
subTasks.add(newSubTask("结果报告", "生成分析报告", Map.of()));
} else {
subTasks.add(newSubTask("任务执行", task, Map.of()));
}
return subTasks;
}
private Map<String, SubTask> assignTasks(List<SubTask> subTasks) {
Map<String, SubTask> assignments = newHashMap<>();
List<String> availableAgents = newArrayList<>(agents.keySet());
for (inti=0; i < subTasks.size() && i < availableAgents.size(); i++) {
assignments.put(availableAgents.get(i), subTasks.get(i));
}
return assignments;
}
private AgentResult integrateResults(String originalTask, Map<String, AgentResult> results) {
StringBuilderintegratedResult=newStringBuilder();
integratedResult.append("协作任务完成结果：\n\n");
booleanallSuccess=true;
for (Map.Entry<String, AgentResult> entry : results.entrySet()) {
StringagentId= entry.getKey();
AgentResultresult= entry.getValue();
integratedResult.append("Agent ").append(agentId).append(": ");
if (result.success()) {
integratedResult.append("成功 - ").append(result.result()).append("\n");
} else {
integratedResult.append("失败 - ").append(result.errors()).append("\n");
allSuccess = false;
}
}
returnnewAgentResult(allSuccess, integratedResult.toString(), Map.of("collaboration", true), List.of());
}
}
/**
* 子任务
*/publicrecordSubTask(
String name,
String description,
Map<String, Object> context
) {}
/**
* 消息总线
*/@ComponentpublicclassMessageBus {
privatefinal Map<String, Agent> registeredAgents = newConcurrentHashMap<>();
privatefinal Queue<Message> messageQueue = newLinkedList<>();
publicvoidregisterAgent(String agentId, Agent agent) {
registeredAgents.put(agentId, agent);
}
publicvoidsendMessage(Message message) {
messageQueue.offer(message);
processMessage(message);
}
privatevoidprocessMessage(Message message) {
Agentreceiver= registeredAgents.get(message.receiver());
if (receiver != null) {
// 异步处理消息
CompletableFuture.runAsync(() -> {
// 这里应该调用Agent的消息处理方法
System.out.println("Agent " + message.receiver() + " 收到消息: " + message.content());
});
}
}
publicvoidbroadcast(String sender, String content) {
for (String agentId : registeredAgents.keySet()) {
if (!agentId.equals(sender)) {
Messagemessage=newMessage(sender, agentId, content, System.currentTimeMillis());
sendMessage(message);
}
}
}
}
/**
* 消息
*/publicrecordMessage(
String sender,
String receiver,
String content,
long timestamp
) {}
/**
* 任务调度器
*/@ComponentpublicclassTaskScheduler {
publicvoidscheduleTask(String taskId, Runnable task, long delayMs) {
CompletableFuture.delayedExecutor(delayMs, java.util.concurrent.TimeUnit.MILLISECONDS)
.execute(task);
}
publicvoidscheduleRecurringTask(String taskId, Runnable task, long intervalMs) {
CompletableFuture.runAsync(() -> {
while (true) {
try {
task.run();
Thread.sleep(intervalMs);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
break;
}
}
});
}
}
3.8 REST API控制器
package com.example.agent.controller;
import com.example.agent.core.Agent;
import com.example.agent.core.AgentResult;
import com.example.agent.react.ReActAgent;
import org.springframework.web.bind.annotation.*;
import java.util.Map;
/**
* Agent REST API控制器
*/@RestController@RequestMapping("/api/agent")publicclassAgentController {
privatefinal ReActAgent reactAgent;
privatefinal MultiAgentSystem multiAgentSystem;
publicAgentController(ReActAgent reactAgent, MultiAgentSystem multiAgentSystem) {
this.reactAgent = reactAgent;
this.multiAgentSystem = multiAgentSystem;
}
@PostMapping("/execute")public AgentResult executeTask(@RequestBody TaskRequest request) {
return reactAgent.executeTask(request.task(), request.context());
}
@PostMapping("/collaborate")public CompletableFuture<AgentResult> executeCollaborativeTask(@RequestBody TaskRequest request) {
return multiAgentSystem.executeCollaborativeTask(request.task(), request.context());
}
@GetMapping("/status")public Map<String, Object> getAgentStatus() {
return Map.of(
"status", reactAgent.getStatus(),
"capabilities", reactAgent.getCapabilities(),
"memoryCount", reactAgent.getMemories().size()
);
}
@GetMapping("/memories")public List<Memory> getMemories() {
return reactAgent.getMemories();
}
}
/**
* 任务请求
*/publicrecordTaskRequest(
String task,
Map<String, Object> context
) {}
四、Agent开源开发框架
4.1 主流框架对比
| 框架 | 语言 | 特点 | 适用场景 | 活跃度 |
|---|---|---|---|---|
| LangChain | Python | 生态丰富，组件化 | 快速原型，RAG应用 | ⭐⭐⭐⭐⭐ |
| LangGraph | Python | 状态图，复杂流程 | 复杂Agent系统 | ⭐⭐⭐⭐ |
| CrewAI | Python | 角色驱动，协作 | 内容创作，团队协作 | ⭐⭐⭐⭐ |
| AutoGen | Python | 对话驱动，灵活 | 多Agent对话 | ⭐⭐⭐⭐ |
| MetaGPT | Python | 标准化流程 | 软件开发 | ⭐⭐⭐ |
| Spring AI | Java | 企业级，Spring生态 | 企业应用 | ⭐⭐⭐⭐ |
| Semantic Kernel | C# | 微软生态 | .NET应用 | ⭐⭐⭐ |
| Haystack | Python | 搜索和RAG | 搜索应用 | ⭐⭐⭐ |
4.2 框架详细介绍
4.2.1 LangChain
特点：
- 丰富的组件库
- 支持多种LLM
- 强大的工具集成
- 活跃的社区
核心组件：
from langchain.agents import AgentExecutor, create_tool_calling_agent
from langchain.tools import Tool
from langchain.prompts import ChatPromptTemplate
适用场景：
- RAG应用
- 快速原型开发
- 工具集成
4.2.2 LangGraph
特点：
- 基于状态图
- 支持复杂流程
- 条件分支
- 循环控制
核心概念：
from langgraph.graph import StateGraph, END
from langgraph.checkpoint import MemorySaver
适用场景：
- 复杂工作流
- 多步骤任务
- 状态管理
4.2.3 CrewAI
特点：
- 角色定义清晰
- 任务流程明确
- 协作机制完善
- 适合团队工作
核心组件：
from crewai import Agent, Task, Crew, Process
适用场景：
- 内容创作
- 研究分析
- 团队协作
4.2.4 AutoGen
特点：
- 对话式协作
- 高度灵活
- 支持复杂协商
- 可定制性强
核心组件：
import autogen
from autogen import ConversableAgent, GroupChat, GroupChatManager
适用场景：
- 多Agent对话
- 复杂协商
- 创意生成
4.2.5 Spring AI
特点：
- 企业级特性
- Spring生态集成
- 类型安全
- 生产就绪
核心组件：
import org.springframework.ai.chat.client.ChatClient;
import org.springframework.ai.chat.model.ChatModel;
适用场景：
- 企业应用
- 微服务架构
- Java生态
4.3 框架选择指南
选择标准：
-
项目需求
- 简单任务 → LangChain
- 复杂流程 → LangGraph
- 团队协作 → CrewAI
- 对话系统 → AutoGen
-
技术栈
- Python → LangChain/LangGraph
- Java → Spring AI
- C# → Semantic Kernel
-
团队经验
- 新手 → LangChain
- 有经验 → 根据需求选择
-
项目规模
- 原型 → LangChain
- 生产 → Spring AI/LangGraph
五、A2A（Agent-to-Agent）协作模式
5.1 A2A基本概念
A2A（Agent-to-Agent）是指Agent之间直接进行协作和通信的模式，不依赖中央协调器。
核心特点：
- 去中心化协作
- 直接通信
- 自主决策
- 动态适应
5.2 A2A vs 传统协作
| 维度 | 传统协作 | A2A协作 |
|---|---|---|
| 架构 | 中心化 | 去中心化 |
| 通信 | 通过中央节点 | 直接通信 |
| 决策 | 中央协调 | 自主决策 |
| 扩展性 | 受限于中央节点 | 水平扩展 |
| 容错性 | 单点故障 | 分布式容错 |
5.3 A2A应用场景
-
分布式系统
- 微服务架构
- 边缘计算
- 物联网系统
-
智能网络
- 自动驾驶
- 智能交通
- 智慧城市
-
协作平台
- 多Agent游戏
- 虚拟团队
- 智能助手网络
5.4 A2A实现要点
通信协议：
- 消息格式标准化
- 异步通信
- 错误处理
- 超时机制
协调机制：
- 共识算法
- 任务分配
- 冲突解决
- 负载均衡
安全考虑：
- 身份认证
- 权限控制
- 数据加密
- 审计日志
5.5 A2A发展趋势
- 标准化协议：统一的Agent通信标准
- 智能路由：基于AI的消息路由
- 自适应协作：动态调整协作策略
- 跨域协作：不同系统间的Agent协作
- 安全增强：更强的安全机制
六、总结
6.1 常见问题解答
Q1: Agent和传统的聊天机器人有什么区别？
回答：
- 传统聊天机器人：一问一答，被动响应
- Agent：主动规划，多步骤执行，具备推理能力
Q2: ReAct模式有什么局限性？
回答：
- 计算成本高：每个思考步骤都需要调用LLM
- 执行时间长：多轮交互导致响应慢
- 错误累积：早期错误会影响后续步骤
- 上下文限制：长对话可能超出模型上下文窗口
Q3: 多Agent系统如何避免冲突？
回答：
- 使用锁机制避免资源冲突
- 任务去重避免重复执行
- 状态同步保持一致性
Q4: 如何评估Agent的性能？
回答：
- 任务完成率
- 平均执行时间
- 资源利用率
- 错误率
- 用户满意度
6.2 核心要点回顾
- Agent是具备推理和行动能力的AI系统
- 8种Agent模式：规划与执行、自我提问、思考与自省、ReAct、ReAct RAG Agent、Agentic RAG、思维树等
- 多Agent协作：通过角色分工和消息传递实现复杂任务
- 主流框架：CrewAI（角色驱动）、AutoGen（对话驱动）、MetaGPT（流程标准化）
- Java实现：基于Spring AI的企业级Agent系统
- A2A协作：去中心化的Agent间直接通信
6.3 技术选型建议
应用场景 → 推荐方案
─────────────────────────────────
内容创作 → CrewAI
复杂协商 → AutoGen
软件开发 → MetaGPT
研究分析 → CrewAI + ReAct
创意设计 → AutoGen
项目管理 → MetaGPT
企业应用 → Spring AI
那么，如何系统的去学习大模型LLM？
作为一名从业五年的资深大模型算法工程师，我经常会收到一些评论和私信，我是小白，学习大模型该从哪里入手呢？我自学没有方向怎么办？这个地方我不会啊。如果你也有类似的经历，一定要继续看下去！这些问题啊，也不是三言两语啊就能讲明白的。
所以我综合了大模型的所有知识点，给大家带来一套全网最全最细的大模型零基础教程。在做这套教程之前呢，我就曾放空大脑，以一个大模型小白的角度去重新解析它，采用基础知识和实战项目相结合的教学方式，历时3个月，终于完成了这样的课程，让你真正体会到什么是每一秒都在疯狂输出知识点。
由于篇幅有限，⚡️ 朋友们如果有需要全套 《2025全新制作的大模型全套资料》，扫码获取~
为什么要学习大模型？
我国在A大模型领域面临人才短缺,数量与质量均落后于发达国家。2023年，人才缺口已超百万，凸显培养不足。随着AI技术飞速发展，预计到2025年,这一缺口将急剧扩大至400万,严重制约我国AI产业的创新步伐。加强人才培养,优化教育体系,国际合作并进是破解困局、推动AI发展的关键。
👉大模型学习指南+路线汇总👈
我们这套大模型资料呢，会从基础篇、进阶篇和项目实战篇等三大方面来讲解。
👉①.基础篇👈
基础篇里面包括了Python快速入门、AI开发环境搭建及提示词工程，带你学习大模型核心原理、prompt使用技巧、Transformer架构和预训练、SFT、RLHF等一些基础概念，用最易懂的方式带你入门大模型。
👉②.进阶篇👈
接下来是进阶篇，你将掌握RAG、Agent、Langchain、大模型微调和私有化部署，学习如何构建外挂知识库并和自己的企业相结合，学习如何使用langchain框架提高开发效率和代码质量、学习如何选择合适的基座模型并进行数据集的收集预处理以及具体的模型微调等等。
👉③.实战篇👈
实战篇会手把手带着大家练习企业级的落地项目（已脱敏），比如RAG医疗问答系统、Agent智能电商客服系统、数字人项目实战、教育行业智能助教等等，从而帮助大家更好的应对大模型时代的挑战。
👉④.福利篇👈
最后呢，会给大家一个小福利，课程视频中的所有素材，有搭建AI开发环境资料包，还有学习计划表，几十上百G素材、电子书和课件等等，只要你能想到的素材，我这里几乎都有。我已经全部上传到CSDN，朋友们如果需要可以微信扫描下方CSDN官方认证二维码免费领取【保证100%免费】
相信我，这套大模型系统教程将会是全网最齐全 最易懂的小白专用课！！
葡萄城是专业的软件开发技术和低代码平台提供商，聚焦软件开发技术，以“赋能开发者”为使命，致力于通过表格控件、低代码和BI等各类软件开发工具和服务
更多推荐
10
0- 0
已为社区贡献1条内容
所有评论(0)