AiService构建器架构

@Slf4j
@Component
public class AiServiceBuilder {

    @Resource
    private LangChatProps langChatProps;

    @Resource
    private RedisTemplate<String, String> redisTemplate;

    @Resource
    private List<DynamicToolFactory> toolFactoryList;

    @Resource
    private PromptProcessor promptProcessor;

    @Resource
    private RagRetrieverBuilder ragRetrieverBuilder;
}

/**
 * 构建AI Service
 *
 * @param model          流式聊天模型
 * @param req            聊天请求对象
 * @param conversationId 会话ID
 * @return LangChatAgent实例
 */
public LangChatAgent build(
    StreamingChatModel model, 
    LcChatReq req, 
    String conversationId
) {
    log.info("开始构建AiService: conversationId={}, modelId={}, userId={}",
            conversationId, req.getModelId(), req.getUserId());

    var builder = AiServices.builder(LangChatAgent.class)
        .streamingChatModel(model)
        .chatMemoryProvider(memoryId -> buildChatMemory(conversationId, req));

    // 1. 配置SystemMessage
    var prompt = promptProcessor.process(req);
    if (StrUtil.isNotBlank(prompt)) {
        builder.systemMessageProvider(memoryId -> prompt);
        log.debug("系统提示词已配置: conversationId={}, promptLength={}",
                conversationId, prompt.length());
    } else {
        log.debug("未配置系统提示词: conversationId={}", conversationId);
    }

    // 2. 动态构建Tools
    if (CollUtil.isNotEmpty(toolFactoryList)) {
        toolFactoryList.forEach(factory -> {
            try {
                factory.dynamicTools(req, builder);
            } catch (Exception e) {
                log.error("动态工具构建失败: conversationId={}, factoryClass={}",
                        conversationId, factory.getClass().getSimpleName(), e);
            }
        });
        log.debug("工具工厂配置完成: conversationId={}, factoryCount={}",
                conversationId, toolFactoryList.size());
    }

    // 3. 构建RAG
    var ragComponents = ragRetrieverBuilder.build(req);
    if (CollUtil.isNotEmpty(ragComponents.retrievers())) {
        var augmentor = DefaultRetrievalAugmentor.builder()
            .contentAggregator(ragComponents.aggregator())
            .queryRouter(new DefaultQueryRouter(ragComponents.retrievers()))
            .build();
        builder.retrievalAugmentor(augmentor);

        log.info("RAG配置完成: conversationId={}, retrieverCount={}, hasRerank={}",
                conversationId,
                ragComponents.retrievers().size(),
                ragComponents.aggregator() != null);
    } else {
        log.debug("未配置RAG: conversationId={}", conversationId);
    }

    // 4. 构建Agent
    var agent = builder.build();

    log.info("AiService构建完成: conversationId={}, modelId={}, userId={}, hasPrompt={}, toolFactoryCount={}, retrieverCount={}",
            conversationId,
            req.getModelId(),
            req.getUserId(),
            StrUtil.isNotBlank(prompt),
            toolFactoryList != null ? toolFactoryList.size() : 0,
            ragComponents.retrievers().size());

    return agent;
}

/**
 * 构建ChatMemory
 */
private ChatMemory buildChatMemory(String conversationId, LcChatReq req) {
    var maxMessages = ObjectUtil.defaultIfNull(
            req.getHistoryCount(),
            langChatProps.getMemoryMaxMessage()
    );

    log.debug("构建ChatMemory: conversationId={}, maxMessages={}", 
            conversationId, maxMessages);

    return MessageWindowChatMemory.builder()
        .id(conversationId)
        .chatMemoryStore(new LcChatMemory(redisTemplate))
        .maxMessages(maxMessages)
        .build();
}

var prompt = promptProcessor.process(req);

if (StrUtil.isNotBlank(prompt)) {
    builder.systemMessageProvider(memoryId -> prompt);
}

public interface DynamicToolFactory {
    
    /**
     * 动态构建工具并添加到AiServices Builder
     *
     * @param req         聊天请求
     * @param aiServices  AiServices Builder
     */
    void dynamicTools(LcChatReq req, AiServices<LangChatAgent> aiServices);
}

if (CollUtil.isNotEmpty(toolFactoryList)) {
    toolFactoryList.forEach(factory -> {
        try {
            factory.dynamicTools(req, builder);
        } catch (Exception e) {
            log.error("动态工具构建失败: conversationId={}, factoryClass={}",
                    conversationId, factory.getClass().getSimpleName(), e);
        }
    });
}

@Component
public class PluginToolFactory implements DynamicToolFactory {
    
    @Resource
    private AigcPluginService pluginService;
    
    @Override
    public void dynamicTools(LcChatReq req, AiServices<LangChatAgent> aiServices) {
        // 获取启用的插件
        var plugins = pluginService.getEnabledPlugins(req.getUserId(), req.getAppId());
        
        if (CollUtil.isEmpty(plugins)) {
            return;
        }
        
        // 构建工具列表
        var tools = plugins.stream()
            .map(this::convertToTool)
            .collect(Collectors.toList());
        
        // 添加到AiServices
        aiServices.tools(tools);
    }
    
    private Tool convertToTool(AigcPlugin plugin) {
        // 将插件转换为LangChain4j Tool
        return Tool.builder()
            .name(plugin.getName())
            .description(plugin.getDescription())
            .addParameter(/* 参数定义 */)
            .execute((toolExecutionRequest) -> {
                // 执行插件逻辑
                return executePlugin(plugin, toolExecutionRequest);
            })
            .build();
    }
}

@Component
public class McpToolFactory implements DynamicToolFactory {
    
    @Resource
    private McpClientManager mcpClientManager;
    
    @Override
    public void dynamicTools(LcChatReq req, AiServices<LangChatAgent> aiServices) {
        // 获取启用的MCP服务器
        var mcpServers = mcpClientManager.getEnabledServers(req.getUserId());
        
        if (CollUtil.isEmpty(mcpServers)) {
            return;
        }
        
        // 获取所有MCP工具
        var tools = new ArrayList<Tool>();
        for (var server : mcpServers) {
            var serverTools = mcpClientManager.getTools(server.getId());
            tools.addAll(serverTools);
        }
        
        // 添加到AiServices
        aiServices.tools(tools);
    }
}

var ragComponents = ragRetrieverBuilder.build(req);

if (CollUtil.isNotEmpty(ragComponents.retrievers())) {
    var augmentor = DefaultRetrievalAugmentor.builder()
        .contentAggregator(ragComponents.aggregator())
        .queryRouter(new DefaultQueryRouter(ragComponents.retrievers()))
        .build();
    builder.retrievalAugmentor(augmentor);
}

AiServiceBuilder.build()
  │
  ├─→ streamingChatModel(model)
  │      # 设置流式聊天模型
  │
  ├─→ chatMemoryProvider()
  │      # 构建ChatMemory
  │      └─→ buildChatMemory(conversationId, req)
  │           ├─→ 获取maxMessages
  │           └─→ MessageWindowChatMemory.builder()
  │                ├─→ id(conversationId)
  │                ├─→ chatMemoryStore(LcChatMemory)
  │                └─→ maxMessages(maxMessages)
  │
  ├─→ systemMessageProvider()
  │      # 配置系统提示词
  │      └─→ PromptProcessor.process(req)
  │           ├─→ 获取应用级提示词
  │           ├─→ 获取模型级提示词
  │           └─→ 合并生成最终提示词
  │
  ├─→ tools()
  │      # 动态构建工具
  │      └─→ toolFactoryList.forEach()
  │           ├─→ PluginToolFactory
  │           │    └─→ 获取启用的插件
  │           │         └─→ 转换为Tool对象
  │           ├─→ McpToolFactory
  │           │    └─→ 获取启用的MCP服务器
  │           │         └─→ 获取所有工具
  │           └─→ CustomToolFactory (自定义)
  │
  ├─→ retrievalAugmentor()
  │      # 构建RAG组件
  │      └─→ RagRetrieverBuilder.build(req)
  │           ├─→ KnowledgeRetriever
  │           │    └─→ 知识库检索
  │           ├─→ SqlRetriever
  │           │    └─→ SQL检索
  │           ├─→ ContentAggregator
  │           │    └─→ ReRankingContentAggregator
  │           └─→ QueryRouter
  │                └─→ DefaultQueryRouter
  │
  └─→ build()
       # 构建Agent
       └─→ LangChatAgent实例

public interface LangChatAgent {
    
    /**
     * 流式聊天
     */
    TokenStream stream(String memoryId, String userMessage);
    
    /**
     * 聊天（非流式）
     */
    String chat(String memoryId, String userMessage);
}

@Component
@ConfigurationProperties(prefix = "langchat")
public class LangChatProps {
    
    /**
     * ChatMemory最大消息数量
     */
    private Integer memoryMaxMessage = 20;
    
    /**
     * 其他配置...
     */
}

langchat:
  memory:
    max-message: 20  # ChatMemory最大消息数量

@Component
public class CustomToolFactory implements DynamicToolFactory {
    
    @Resource
    private SomeService someService;
    
    @Override
    public void dynamicTools(LcChatReq req, AiServices<LangChatAgent> aiServices) {
        // 根据请求判断是否需要添加工具
        if (shouldAddTools(req)) {
            var tools = buildTools(req);
            aiServices.tools(tools);
        }
    }
    
    private List<Tool> buildTools(LcChatReq req) {
        return List.of(
            Tool.builder()
                .name("customTool")
                .description("自定义工具描述")
                .addParameter(/* 参数 */)
                .execute(this::executeTool)
                .build()
        );
    }
    
    private String executeTool(ToolExecutionRequest request) {
        // 执行工具逻辑
        return someService.execute(request);
    }
}

@Component
public class CustomPromptProcessor implements PromptProcessor {
    
    @Override
    public String process(LcChatReq req) {
        // 自定义提示词处理逻辑
        var prompt = new StringBuilder();
        
        // 添加角色定义
        prompt.append("你是一个专业的AI助手。\n");
        
        // 添加特定领域知识
        prompt.append("你精通以下领域：\n");
        prompt.append("- 编程\n");
        prompt.append("- 数据分析\n");
        
        // 添加行为规则
        prompt.append("请用简洁、准确的语言回答问题。\n");
        
        return prompt.toString();
    }
}

public class CustomChatMemoryStore implements ChatMemoryStore {
    
    private final SomeStorage storage;
    
    @Override
    public List<ChatMessage> getMessages(Object memoryId) {
        // 自定义获取消息逻辑
        return storage.getMessages(memoryId.toString());
    }
    
    @Override
    public void updateMessages(Object memoryId, List<ChatMessage> messages) {
        // 自定义更新消息逻辑
        storage.saveMessages(memoryId.toString(), messages);
    }
    
    @Override
    public void deleteMessages(Object memoryId) {
        // 自定义删除消息逻辑
        storage.deleteMessages(memoryId.toString());
    }
}

private ChatMemory buildChatMemory(String conversationId, LcChatReq req) {
    return MessageWindowChatMemory.builder()
        .id(conversationId)
        .chatMemoryStore(new CustomChatMemoryStore(customStorage))
        .maxMessages(maxMessages)
        .build();
}

@Lazy
@Resource
private List<DynamicToolFactory> toolFactoryList;

// 并行执行多个工具工厂
toolFactoryList.parallelStream().forEach(factory -> {
    try {
        factory.dynamicTools(req, builder);
    } catch (Exception e) {
        log.error("动态工具构建失败", e);
    }
});