一、路由工作流智能体、
1.什么是路由智能体
路由工作流智能体，这种模式是将输入通过 LLM Call Router 对意图识别，再交由下游的 LLM 执行。
📚 模式说明：
● 动态路径选择： Router 节点根据输入特征（如内容类型、用户意图）决定调用哪个LLM。
● 集中式决策： 所有输入需先经过Router（而非直接调用LLM），使用路由控制器降低业务系统之间的耦合度。
● 可扩展性： 图中预设3个LLM调用路径，实际上，可扩展更多分支，也就是说，路由模式可以灵活的增减处理模块，比较灵活。
● 这种模式适用于复杂业务，并且后续的处理逻辑比较独立的场景。
○ 比如：推荐课程、查询课程、购买课程，这都是独立的业务，可以用独立的智能体实现。
💡 为什么不把所有功能塞进一个智能体？
如果把推荐、咨询、购买、知识讲解等能力全部交给一个智能体，会导致以下问题：
工具集臃肿： 所有工具混在一起，大模型在决策时容易"选错工具"，降低调用准确率。
系统提示词过长： 一个 Prompt 要描述所有职责，指令越复杂，大模型遵循度越低。
难以维护： 修改某个功能可能影响其他功能，牵一发动全身。
通过路由模式拆分为多个专职智能体后，每个智能体**只关注自己的领域、只配备自己需要的工具，**既提升了大模型的决策准确率，也让系统更易维护和扩展。
2.实现流程
📚 流程说明：
- 当用户提出问题时，首先会发送给【意图分析智能体】，它会判断用户是想让我们推荐课程、查询课程信息还是购买课程。
- 一旦明确了用户的意图，就会根据不同的需求调用相应的智能体来完成任务，比如推荐课程或购买课程等。
- 这样做的好处是每个智能体都有明确的任务分工，并且只有在需要时才会调用特定的工具，不需要所有智能体都配备全套工具。这样一来，整个系统变得更加灵活高效了。
二、设计抽象类
1.自定义枚举类
不同的智能体，是需要通过类型来区分的，比较好的一种方式就是定义类型枚举。
java
package com.tianji.aigc.enums;
import cn.hutool.core.util.EnumUtil;
import lombok.Getter;
/**
* 智能体类型
*/
@Getter
public enum AgentTypeEnum {
ROUTE("ROUTE", "路由智能体"),
RECOMMEND("RECOMMEND", "课程推荐智能体"),
CONSULT("CONSULT", "课程咨询智能体"),
BUY("BUY", "课程购买智能体"),
KNOWLEDGE("KNOWLEDGE", "知识讲解智能体");
private final String agentName;
private final String desc;
AgentTypeEnum(String agentName, String desc) {
this.agentName = agentName;
this.desc = desc;
}
@Override
public String toString() {
return this.name();
}
/**
* 通过智能体的名称查找枚举
*/
public static AgentTypeEnum agentNameOf(String agentName) {
return EnumUtil.getBy(AgentTypeEnum::getAgentName, agentName);
}
}枚举类的设计要点：agentName 字段是路由智能体返回的"指令标识"------RouteAgent 分析用户意图后，会返回一个类似 "RECOMMEND"、"BUY" 的字符串，Service 层通过这个名称反查对应的 Agent 实例来执行后续逻辑。
2.定义Agent接口
我们可以想一下，每个智能体都有什么相关的方法，就把他们抽象出来，形成一个Agent interface，子类只需要实现接口即可。
应该有的方法：
- process （普通对话）
- processStream （流式对话）
- getAgentType （获取智能体类型）
- stop （停止方法）
- systemMessage （获取系统提示词方法）
以上这些都是基本的操作方法。实际上，对于一个智能体而言，与大模型或Tools交互，还需要一些设定，比如toolContext、advisors等，所以还需要额外的加一个方法：
- tools （工具集）
- toolContext （工具上下文参数）
- advisors （Advisor列表）
- advisorParams （Advisor参数列表）
- systemMessageParams （系统提示词中的参数列表）
💡 为什么用 default 方法？
并非每个智能体都需要工具和 Advisor。比如路由智能体（RouteAgent）只负责意图分析，不需要任何工具；知识讲解智能体（KnowledgeAgent）也不需要 RAG 增强。通过 default 方法提供空实现，子类只需按需覆写自己关心的方法，避免每个子类都写一堆空方法。
所以，基于上面的分析，就可以定义Agent interface了：
java
package com.tianji.aigc.agent;
import com.tianji.aigc.enums.AgentTypeEnum;
import com.tianji.aigc.vo.ChatEventVO;
import org.springframework.ai.chat.client.advisor.api.Advisor;
import reactor.core.publisher.Flux;
import java.util.List;
import java.util.Map;
/**
* AI代理接口，定义处理聊天事件和会话的核心能力
*/
public interface Agent {
/**
* 表示空参数的预定义数组
*/
Object[] EMPTY_OBJECTS = new Object[0];
/**
* 处理流式请求（如流式回答）
*
* @param question 用户输入的问题
* @param sessionId 会话唯一标识
* @return 包含中间结果的反应式事件流（Flux）
*/
Flux<ChatEventVO> processStream(String question, String sessionId);
/**
* 处理标准请求（非流式）
*
* @param question 用户输入的问题
* @param sessionId 会话唯一标识
* @return 最终处理结果字符串
*/
String process(String question, String sessionId);
/**
* 获取智能体类型标识
*
* @return 代理类型枚举值（如：ROUTE、RECOMMEND等）
*/
AgentTypeEnum getAgentType();
/**
* 停止指定会话的处理
*
* @param sessionId 需要终止的会话ID
*/
void stop(String sessionId);
/**
* 获取系统提示信息模板，默认为空字符串，子类可以覆盖重写该方法以返回自定义的系统提示信息。
*
* @return 系统提示的文本模板
*/
default String systemMessage() {
return "";
}
/**
* 获取工具列表，默认返回空数组。子类需根据需求覆盖此方法。
*/
default Object[] tools() {
return EMPTY_OBJECTS;
}
/**
* 创建并返回一个工具上下文的空Map对象。
*
* @param sessionId 会话标识符
* @param requestId 请求标识符
* @return 默认返回一个空的Map对象，子类可以覆盖重写该方法以返回自定义的工具上下文。
*/
default Map<String, Object> toolContext(String sessionId, String requestId) {
return Map.of();
}
/**
* Advisor列表，默认返回空对象
*/
default List<Advisor> advisors() {
return List.of();
}
/**
* 创建并返回一个Advisor的空Map对象。
*
* @param sessionId 会话标识符
* @param requestId 请求标识符
* @return 默认返回一个空的Map对象，子类可以覆盖重写该方法以返回自定义的工具上下文。
*/
default Map<String, Object> advisorParams(String sessionId, String requestId) {
return Map.of();
}
/**
* 获取系统提示信息模板的参数，默认为空Map，子类可以覆盖重写该方法以返回自定义的系统提示信息参数。
*/
default Map<String, Object> systemMessageParams() {
return Map.of();
}
}3.编写抽象类
有了接口之后，我们对 process、processStream、stop 等通用逻辑做统一实现，提取出 AbstractAgent 抽象类。这样具体的子类只需要关注"自己是什么类型"、"用什么系统提示词"、"配备哪些工具"这些差异化配置即可。
java
package com.tianji.aigc.agent;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.IdUtil;
import cn.hutool.core.util.StrUtil;
import com.tianji.aigc.config.ToolResultHolder;
import com.tianji.aigc.constants.Constant;
import com.tianji.aigc.enums.ChatEventTypeEnum;
import com.tianji.aigc.service.ChatService;
import com.tianji.aigc.service.ChatSessionService;
import com.tianji.aigc.vo.ChatEventVO;
import com.tianji.common.utils.UserContext;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.ai.chat.client.ChatClient;
import org.springframework.ai.chat.memory.ChatMemory;
import org.springframework.ai.chat.messages.AssistantMessage;
import reactor.core.publisher.Flux;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
@Slf4j
public abstract class AbstractAgent implements Agent {
@Resource
private ChatSessionService chatSessionService;
@Resource
private ChatClient chatClient;
@Resource
private ChatMemory chatMemory;
// 输出结束的标记
public static final ChatEventVO STOP_EVENT = ChatEventVO.builder().eventType(ChatEventTypeEnum.STOP.getValue()).build();
// 存储大模型的生成状态，这里采用ConcurrentHashMap是确保线程安全
// 目前的版本暂时用Map实现，如果考虑分布式环境的话，可以考虑用redis来实现
public static final Map<String, Boolean> GENERATE_STATUS = new ConcurrentHashMap<>();
@Override
public String process(String question, String sessionId) {
// 获取用户id
var userId = UserContext.getUser();
var requestId = this.generateRequestId();
//更新会话时间
this.chatSessionService.update(sessionId, question, userId);
return this.getChatClientRequest(sessionId, requestId, question)
.call()
.content();
}
public Flux<ChatEventVO> processStream(String question, String sessionId) {
// 获取用户id
var userId = UserContext.getUser();
var requestId = this.generateRequestId();
// 大模型输出内容的缓存器，用于在输出中断后的数据存储
var outputBuilder = new StringBuilder();
// 获取对话id
var conversationId = ChatService.getConversationId(sessionId);
//更新会话时间
this.chatSessionService.update(sessionId, question, userId);
return this.getChatClientRequest(sessionId, requestId, question)
.stream()
.chatResponse()
.doFirst(() -> GENERATE_STATUS.put(sessionId, true)) // 第一次输出内容时执行
.doOnError(throwable -> GENERATE_STATUS.remove(sessionId)) // 出现异常时，删除标识
.doOnComplete(() -> GENERATE_STATUS.remove(sessionId)) // 完成时执行，删除标识
.doOnCancel(() -> {
// 当输出被取消时，保存输出的内容到历史记录中
this.saveStopHistoryRecord(conversationId, outputBuilder.toString());
})
.takeWhile(response -> { // 通过返回值来控制Flux流是否继续，true：继续，false：终止
return GENERATE_STATUS.getOrDefault(sessionId, false);
})
.map(chatResponse -> {
var finishReason = chatResponse.getResult().getMetadata().getFinishReason();
if (StrUtil.equals(Constant.STOP, finishReason)) {
var messageId = chatResponse.getMetadata().getId();
ToolResultHolder.put(messageId, Constant.REQUEST_ID, requestId);
}
// 获取大模型的输出的内容
var text = chatResponse.getResult().getOutput().getText();
// 追加到输出内容中
outputBuilder.append(text);
// 封装响应对象
return ChatEventVO.builder()
.eventData(text)
.eventType(ChatEventTypeEnum.DATA.getValue())
.build();
})
.concatWith(Flux.defer(() -> {
// 通过请求id获取到参数列表，如果不为空，就将其追加到返回结果中
var map = ToolResultHolder.get(requestId);
if (CollUtil.isNotEmpty(map)) {
ToolResultHolder.remove(requestId); // 清除参数列表
// 响应给前端的参数数据
var chatEventVO = ChatEventVO.builder()
.eventData(map)
.eventType(ChatEventTypeEnum.PARAM.getValue())
.build();
return Flux.just(chatEventVO, STOP_EVENT);
}
return Flux.just(STOP_EVENT);
}));
}
private ChatClient.ChatClientRequestSpec getChatClientRequest(String sessionId, String requestId, String question) {
return this.chatClient.prompt()
.system(promptSystem -> promptSystem.text(this.systemMessage()).params(this.systemMessageParams()))
.advisors(advisor -> advisor.advisors(this.advisors()).params(this.advisorParams(sessionId, requestId)))
.tools(this.tools())
.toolContext(this.toolContext(sessionId, requestId))
.user(question);
}
/**
* 保存停止输出的记录
*
* @param conversationId 对话id
* @param content 大模型输出的内容
*/
private void saveStopHistoryRecord(String conversationId, String content) {
this.chatMemory.add(conversationId, new AssistantMessage(content));
}
private String generateRequestId() {
return IdUtil.fastSimpleUUID();
}
@Override
public Map<String, Object> advisorParams(String sessionId, String requestId) {
var conversationId = ChatService.getConversationId(sessionId);
return Map.of(ChatMemory.CONVERSATION_ID, conversationId);
}
@Override
public void stop(String sessionId) {
GENERATE_STATUS.remove(sessionId);
}
}💡 抽象类的核心设计思想：
AbstractAgent 封装了完整的对话流程模板------从请求构建、流式输出控制、到中断处理与历史记录保存，所有子类共享这套逻辑。子类只需覆写几个"配置点"（系统提示词、工具集、Advisor 等），即可快速创建一个新的智能体。这就是典型的模板方法模式。
三、路由智能体
路由智能体是整个系统的"调度员"，它不需要工具，不需要 RAG，只需要一个精心设计的系统提示词，让大模型根据用户问题返回对应的智能体名称即可。
1.系统提示词
java
# 角色
天机AI意图分析师
## 能力
1. 识别用户意图并匹配对应编号：
- RECOMMEND（课程推荐）
- BUY（课程购买）
- CONSULT（课程咨询）
- KNOWLEDGE（知识讲解）
2. 特殊场景处理：
- 识别关键词触发意图：
- BUY: 确认购买/下单/是的确认
- RECOMMEND: 包含年龄/学历/兴趣信息
- 识别问候语并礼貌回应：你好/您好
3. 非相关提问时礼貌拒答
## 约束
精准识别，避免误判
## 输出
- 匹配意图时返回编号
- 问候语场景返回「您好！有什么可以帮您？」
- 无匹配时用自然语言回复
## 示例
输入：20岁本科想学Java → RECOMMEND
输入：现在要下单 → BUY
输入：这个课程多少钱 → CONSULT
输入：java是什么 → KNOWLEDGE
输入：你好 → 您好！有什么可以帮您？
输入：今天天气 → 抱歉我只处理课程相关问题2.编写智能体
java
package com.tianji.aigc.agent;
import com.tianji.aigc.config.SystemPromptConfig;
import com.tianji.aigc.enums.AgentTypeEnum;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Component;
/**
* 路由智能体
*/
@Component
@RequiredArgsConstructor
public class RouteAgent extends AbstractAgent {
private final SystemPromptConfig systemPromptConfig;
@Override
public String systemMessage() {
return this.systemPromptConfig.getRouteAgentSystemMessage().get();
}
@Override
public AgentTypeEnum getAgentType() {
return AgentTypeEnum.ROUTE;
}
}可以看到，路由智能体非常"轻量"------没有覆写 tools()、advisors() 等方法，因为它只需要做意图分析，不需要调用任何工具或知识库。
四、推荐智能体
1.系统提示词
java
# 在线教育客服&讲师指南
## 核心职责
分步精准推荐：信息采集 → 课程匹配 → 执行推荐
## 强制流程
1. **信息采集（必须优先）**
- 必须收集三项核心数据：
▪ 年龄（数字）
▪ 最高学历（初中/高中/本科/硕士等）
▪ 编程基础（无经验/基础语法/项目经验）
- 任一信息缺失时：立即停止推荐，礼貌追问直至信息完整
2. **课程匹配
- 强制：要通过课程id查询课程之后再输出
- 匹配逻辑：
1) 精准匹配（年龄+学历+兴趣）
2) 向下兼容课程（如学历达标但年龄较小）
3) 关联领域Top3课程
3. **推荐执行
- 每次推荐必须包含：
▪ 数据关联说明（例："针对25岁本科学历..."）
▪ 课程适配点（例："包含实战项目模块..."）
- 禁止推荐未经数据验证的课程
## 关键规则
- 阻断机制：未收齐三项数据前禁用推荐功能
- 数据校验：发现矛盾数据（如"12岁硕士学历"）需确认
- 异常处理：无匹配时提供「人工咨询」入口
- 必须要输出课程id、价格、介绍等信息2.编写智能体
java
package com.tianji.aigc.agent;
import com.tianji.aigc.config.SystemPromptConfig;
import com.tianji.aigc.constants.Constant;
import com.tianji.aigc.enums.AgentTypeEnum;
import com.tianji.aigc.tools.CourseTools;
import com.tianji.common.utils.UserContext;
import lombok.RequiredArgsConstructor;
import org.springframework.ai.chat.client.advisor.api.Advisor;
import org.springframework.ai.chat.client.advisor.vectorstore.QuestionAnswerAdvisor;
import org.springframework.ai.vectorstore.SearchRequest;
import org.springframework.ai.vectorstore.VectorStore;
import org.springframework.stereotype.Component;
import java.util.List;
import java.util.Map;
@Component
@RequiredArgsConstructor
public class RecommendAgent extends AbstractAgent {
private final SystemPromptConfig systemPromptConfig;
private final VectorStore vectorStore;
private final CourseTools courseTools;
@Override
public String systemMessage() {
return this.systemPromptConfig.getRecommendAgentSystemMessage().get();
}
@Override
public AgentTypeEnum getAgentType() {
return AgentTypeEnum.RECOMMEND;
}
@Override
public List<Advisor> advisors() {
// 创建RAG增强
var qaAdvisor = QuestionAnswerAdvisor.builder(this.vectorStore)
.searchRequest(SearchRequest.builder().similarityThreshold(0.6d).topK(6).build())
.build();
return List.of(qaAdvisor);
}
@Override
public Object[] tools() {
return new Object[]{courseTools};
}
@Override
public Map<String, Object> toolContext(String sessionId, String requestId) {
var userId = UserContext.getUser();
return Map.of(
Constant.USER_ID, userId, // 设置用户id参数
Constant.REQUEST_ID, requestId // 设置请求id参数
);
}
}推荐智能体的"装备"比较齐全：
· CourseTools： 用于调用课程查询接口，获取课程详情。
· RAG Advisor： 从向量库中检索课程相关的知识片段，辅助大模型做出更精准的推荐。
其余三个智能体（ConsultAgent、BuyAgent、KnowledgeAgent）的设计思路完全一致，只是系统提示词和工具集不同，这里不再赘述。
五、整合五个Agent，实现Service类
AgentServiceImpl 是路由模式的核心调度层，它实现了 ChatService 接口，负责编排"先路由、再执行"的整体流程：
java
package com.tianji.aigc.service.impl;
import cn.hutool.extra.spring.SpringUtil;
import com.tianji.aigc.agent.AbstractAgent;
import com.tianji.aigc.agent.Agent;
import com.tianji.aigc.enums.AgentTypeEnum;
import com.tianji.aigc.enums.ChatEventTypeEnum;
import com.tianji.aigc.service.ChatService;
import com.tianji.aigc.vo.ChatEventVO;
import lombok.RequiredArgsConstructor;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.stereotype.Service;
import reactor.core.publisher.Flux;
@Service
@RequiredArgsConstructor
public class AgentServiceImpl implements ChatService {
@Override
public Flux<ChatEventVO> chat(String question, String sessionId) {
// 先通过路由智能体，分析用户的意图，再执行后面的逻辑
var result = this.findAgentByType(AgentTypeEnum.ROUTE).process(question, sessionId);
var agentTypeEnum = AgentTypeEnum.agentNameOf(result);
var agent = this.findAgentByType(agentTypeEnum);
if (agent == null) {
// 找不到对应的智能体，直接返回结果
var chatEventVO = ChatEventVO.builder()
.eventType(ChatEventTypeEnum.DATA.getValue())
.eventData(result)
.build();
return Flux.just(chatEventVO, AbstractAgent.STOP_EVENT);
}
// 执行智能体的逻辑
return agent.processStream(question, sessionId);
}
/**
* 根据代理类型查找对应的Agent实例
*
* @param agentTypeEnum 要查找的代理类型
* @return 与给定类型匹配的Agent实例，如果未找到或类型为null则返回null
*/
private Agent findAgentByType(AgentTypeEnum agentTypeEnum) {
if (agentTypeEnum == null) {
return null;
}
var beans = SpringUtil.getBeansOfType(Agent.class);
// 遍历所有Agent Bean查找匹配类型
for (var agent : beans.values()) {
if (agentTypeEnum == agent.getAgentType()) {
return agent;
}
}
return null;
}
/**
* 停止生成
*
* @param sessionId 会话ID
*/
@Override
public void stop(String sessionId) {
this.findAgentByType(AgentTypeEnum.ROUTE).stop(sessionId);
}
}💡 整体调度流程总结：
RouteAgent.process()（同步调用）： 将用户问题发给路由智能体，大模型返回一个智能体名称字符串（如 "RECOMMEND"）。
AgentTypeEnum.agentNameOf()： 将字符串反查为枚举类型。
findAgentByType() ：从 Spring 容器中遍历所有 Agent 实现，找到类型匹配的智能体实例。
agent.processStream()（流式调用）： 由目标智能体执行具体业务，以 SSE 流式返回给前端。
如果路由智能体没有识别到明确意图（比如用户在闲聊），它会直接给出回答，此时 findAgentByType 返回 null，Service 层会将路由智能体的回答直接封装为响应返回。