使用Qwen2.5+SpringBoot+SpringAI+SpringWebFlux的基于意图识别的多智能体架构方案

public class AgentDispatcher {
    @Resource(name = "intentAgentProfile")
    private AgentProfile agentProfile;

    @Value("${business.llm.api-key}")
    private String apiKey;
    @Value("${business.llm.model}")
    private String model;
    @Value("${business.llm.url}")
    private String url;

    public AgentDispatchResult dispatch(String question) {
        //这里我们使用Qwen2.5大模型的OPENAI的接口兼容模式，使用OPENAI的Client即可调用Qwen2.5 14b模型，并支持Stream和functioncall。
        OpenAiApi api = new OpenAiApi(url, apiKey);
        //传入输出智能体Id的方法
        List<OpenAiApi.FunctionTool> functionTools = agentProfile.getFunctionTools();
        OpenAiApi.FunctionTool functionTool = functionTools.get(0);
        OpenAiApi.FunctionTool.Function function = functionTool.function();
        String intentFunction = function.name();
        OpenAiChatOptions chatOptions = OpenAiChatOptions.builder().withModel(model).withTemperature(agentProfile.getTemperature()).withTools(functionTools).withProxyToolCalls(true).build();
        OpenAiChatModel chatModel = new OpenAiChatModel(api, chatOptions);
        String systemPrompt = agentProfile.getSystemPrompt();
        SystemMessage systemMessage = new SystemMessage(systemPrompt);
        List<Message> messageList = new ArrayList<>();
        messageList.add(systemMessage);
        UserMessage userMessage = new UserMessage(question);
        messageList.add(userMessage);
        Prompt prompt = new Prompt(messageList);

        org.springframework.ai.chat.model.ChatResponse response = chatModel.call(prompt);
        AssistantMessage message = response.getResult().getOutput();
        List<AssistantMessage.ToolCall> toolCalls = message.getToolCalls();
        AssistantMessage.ToolCall call = toolCalls.get(0);
        String name = call.name();
        String arguments = call.arguments();
        if (name.equals(intentFunction)) {
            IntentParams intentParams = JSON.parseObject(arguments, IntentParams.class);
            String agentProfileId = intentParams.getAgentId();
            return new AgentDispatchResult(agentProfileId);
        }

        return null;
    }

}

    public AgentProfile getIntentAgentProfile() {
        AgentProfile agentProfile = new AgentProfile();
        agentProfile.setTemperature(0.0);
        String systemPrompt = "## 角色\n" +
                "你是一名擅长处理问题的经理，你能够将用户的问题准确地分配给对应的员工进行处理。\n" +
                "## 流程\n" +
                "1. 你首先要了解下面的几个员工擅长处理的问题范围，知道哪些问题应该分配给哪个员工。\n" +
                "2. 你被给予一个用户提问的历史记录。你要基于历史记录中最后一条进行问题分析，分析出用户的这条问题最适合让谁来处理。你要认真对待最后一条提问，即使是很简单的提问。\n" +
                "3. 如果你分析不出来，或者需要更多的参考，你就参照历史记录中的上一条提问来继续分析。\n" +
                "4. 最终，你要调用select_person_id方法选择你要分配给哪个员工，并输出你的完整分析过程";
        StringBuilder sb = new StringBuilder(systemPrompt);
        sb.append("##员工描述列表 ");
        List<AgentDescription> agentDescriptionList = agentProfileMap.entrySet().stream().map(entry -> new AgentDescription(entry.getKey(), entry.getValue().getDescription())).collect(Collectors.toList());
        agentProfile.setSystemPrompt(systemPrompt + agentDescriptionList);
        String functioncall = "[ {\n" + "            \"type\": \"function\",\n" + "            \"function\": {\n" + "                \"description\": \"选择员工Id\",\n" + "                \"name\": \"select_agent_id\",\n" + "                \"parameters\": {\n" + "                    \"type\": \"object\",\n" + "                    \"properties\": {\n" + "                        \"agentId\": {\n" + "                            \"type\": \"string\",\n" + "                            \"description\": \"智能体Id\"\n" + "                        }\n" + "                    }\n" + "                }\n" + "            }\n" + "        }]";
        List<OpenAiApi.FunctionTool> toolList = JSON.parseArray(functioncall, OpenAiApi.FunctionTool.class);
        agentProfile.setFunctionTools(toolList);
        return agentProfile;
    }

    private FunctionCallResult handleToolCall(AssistantMessage.ToolCall toolCall, Profile userProfile, Map<String, Object> extras, String enterpriseId,String agentId) {


        if (toolCall.type().equals(FunctionCallConstants.FUNCTION)) {
            String arguments = toolCall.arguments();
            String name = toolCall.name();
            FunctionCallRequest request = FunctionCallRequest.builder().functionName(name).functionArguments(arguments).userProfile(userProfile).extras(extras).enterpriseId(enterpriseId).agentId(agentId).build();
            FunctionCallResult callResult = functionCallService.apply(request);
            return callResult;

        }
        return null;
    }

@Component
@Slf4j
public class RemoteFunctionCallService implements FunctionCallService {

    private static final OkHttpClient client = new OkHttpClient.Builder()
            .connectTimeout(10, TimeUnit.SECONDS)
            .writeTimeout(10, TimeUnit.SECONDS)
            .readTimeout(30, TimeUnit.SECONDS)
            .build();

    private static final String BASE_URL = "http://localhost:8090/api/function/call"; // 替换为实际的服务地址

    @Override
    public FunctionCallResult apply(FunctionCallRequest callRequest) {
        String requestJson = JSON.toJSONString(callRequest);
        RequestBody body = RequestBody.create(
                MediaType.parse("application/json; charset=utf-8"),
                requestJson
        );

        Request request = new Request.Builder()
                .url(BASE_URL)
                .post(body)
                .build();

        try (Response response = client.newCall(request).execute()) {
            if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);

            // 解析返回的 JSON 响应为 FunctionCallResult 对象
            String responseBody = response.body().string();
            return JSON.parseObject(responseBody, FunctionCallResult.class);
        } catch (IOException e) {
            log.error("Error calling remote function: ", e);
            // 构建错误响应
            FunctionCallResult errorResult = new FunctionCallResult();
            errorResult.setCardMessage(false);
            errorResult.setDirectReturn(true);
            errorResult.setContent("Error executing remote function: " + e.getMessage());
            errorResult.setNextFinish(true);
            return errorResult;
        }
    }
}

@RestController
@RequestMapping("/function")
public class FunctionCallController {

    @Autowired
    private ApplicationContext context;

    @Autowired
    private AgentFunctionMappingCacheService agentFunctionMappingCacheService;

    @PostMapping("/call")
    public ResponseEntity<FunctionCallResult> callFunction(@RequestBody FunctionCallRequest request) {
        try {
            // 从缓存中获取对应的beanName
            String beanName = agentFunctionMappingCacheService.getBeanNameByAgentId(request.getAgentId());
            if (beanName == null) {
                return ResponseEntity.badRequest().body(FunctionCallResult.builder().
                        content("Agent not found or no corresponding handler.").build()
                );
            }

            // 从Spring上下文中获取对应的bean
            FunctionHandler handler = context.getBean(beanName, FunctionHandler.class);

            // 创建结果对象

            // 调用handler处理请求，并填充结果对象
            FunctionCallResult callResult = handler.handle(request);// 假设handle方法可以接收结果对象作为参数

            // 返回结果
            return ResponseEntity.ok(callResult);
        } catch (Exception e) {
            // 构建错误响应
            FunctionCallResult errorResult = FunctionCallResult.builder().content("Error executing function: " + e.getMessage()).build();
            return ResponseEntity.status(500).body(errorResult);
        }
    }
}

    public AgentInstance createAgentInstance(String agentInstanceId, AgentProfile agentProfile) {
        AgentInstance agentInstance = new AgentInstance();
        String systemPrompt = agentProfile.getSystemPrompt();
        SystemMessage systemMessage = new SystemMessage(systemPrompt);
        List<Message> messageList = new ArrayList<>();
        messageList.add(systemMessage);
        agentInstance.setAgentProfile(agentProfile);
        agentInstance.setMessageList(messageList);
        UUID uuid = UUID.randomUUID();
        agentInstance.setInstanceId(uuid.toString());
        agentInstanceMap.put(agentInstanceId, agentInstance);
        return agentInstance;
    }

    public AgentInstance getAgentInstanceById(String agentInstanceId) {
        return agentInstanceMap.get(agentInstanceId);
    }

    public AgentInstance updateAgentInstanceById(String agentId, List<Message> messageList) {
        String key = agentId;
        AgentInstance agentInstance = agentInstanceMap.get(key);
        if (agentInstance != null) {
            agentInstance.setMessageList(messageList);
            agentInstanceMap.put(key, agentInstance);
            return agentInstance;
        } else {
            return null;
        }
    }

@Override
    public Flux<ChatResponse> stream(AgentInstance agentInstance, Profile userProfile, Map<String, Object> extra, String enterpriseId) {
        List<Message> messageList = agentInstance.getMessageList();
        AgentProfile agentProfile = agentInstance.getAgentProfile();
        //agentOptions中包含了这个agent中拥有的方法描述。
        List<OpenAiApi.FunctionTool> functionTools = agentProfile.getFunctionTools();
        Double temperature = agentProfile.getTemperature();
        if (temperature == null) {
            temperature = 0.0;
        }
        OpenAiApi api = new OpenAiApi(url, apiKey);
        OpenAiChatOptions chatOptions = OpenAiChatOptions.builder().withModel(model).withTemperature(temperature).withTools(functionTools).withProxyToolCalls(true).build();
        OpenAiChatModel chatModel = new OpenAiChatModel(api, chatOptions);
        return processToolCall(chatModel, messageList, Set.of(OpenAiApi.ChatCompletionFinishReason.TOOL_CALLS.name(), OpenAiApi.ChatCompletionFinishReason.STOP.name()), toolCall -> handleToolCall(toolCall, userProfile, extra, enterpriseId,agentProfile.getId().toString()), agentInstance);
    }


    private Flux<ChatResponse> processToolCall(OpenAiChatModel chatModel, final List<Message> messageList, Set<String> finishReasons, Function<AssistantMessage.ToolCall, FunctionCallResult> customFunction, AgentInstance agentInstance) {
        try {
            String agentInstanceId = agentInstance.getInstanceId();
            Prompt prompt = new Prompt(messageList);
            Flux<org.springframework.ai.chat.model.ChatResponse> chatResponses = chatModel.stream(prompt);
            //如果是纯文本的回复，就用个stringbuffer来积累，用于下一次大模型对话中的MessageList
            final StringBuffer sb = new StringBuffer();
            return chatResponses.flatMap(chatResponse -> {
                //判断是不是funtioncall
                boolean isToolCall = toolCallHelper.isToolCall(chatResponse, finishReasons);

                if (isToolCall) {

                    Optional<Generation> toolCallGeneration = chatResponse.getResults().stream().filter(g -> !CollectionUtils.isEmpty(g.getOutput().getToolCalls())).findFirst();


                    AssistantMessage assistantMessage = toolCallGeneration.get().getOutput();
                    log.info("web助理大模型返回：" + JSON.toJSONString(assistantMessage));
                    List<ToolResponseMessage.ToolResponse> toolResponses = new ArrayList<>();

                    List<AssistantMessage.ToolCall> toolCalls = assistantMessage.getToolCalls();
                    AssistantMessage.ToolCall toolCall = null;
                    toolCall = toolCalls.get(toolCalls.size() - 1);

                    String arguments = toolCall.arguments();
                    String name = toolCall.name();

                    int lastIndexOf = arguments.lastIndexOf("{");
                    arguments = arguments.substring(lastIndexOf);
                    toolCall = new AssistantMessage.ToolCall(toolCall.id(), toolCall.type(), toolCall.name(), arguments);

                    String assistantMessageContent = assistantMessage.getContent();
                    assistantMessage = new AssistantMessage(assistantMessageContent, new HashMap<>(), Arrays.asList(toolCall));
                    //如果是正常的functioncall调用，就直接调用。
                    FunctionCallResult functionResponse = customFunction.apply(toolCall);
                    //tips 这一步至关重要，方法调用的结果直接影响大模型的判断。
                    String responseContent = functionResponse.getContent();
                    toolResponses.add(new ToolResponseMessage.ToolResponse(toolCall.id(), toolCall.name(), ModelOptionsUtils.toJsonString(responseContent)));


                    ToolResponseMessage toolMessageResponse = new ToolResponseMessage(toolResponses, Map.of());
                    //加入历史列表。
                    messageList.add(assistantMessage);

                    messageList.add(toolMessageResponse);
                    log.info("web用户当前会话历史：" + JSON.toJSONString(messageList));
                    //判断是不是卡片返回，如果是的话，在这里要返回卡片数据和卡片模版
                    //因为卡片是给用户看的，大模型不需要，所以不必给大模型返回。
                    boolean directReturn = functionResponse.isDirectReturn();
                    if (directReturn) {
                        boolean isCardMessage = functionResponse.isCardMessage();
                        if (isCardMessage) {
                            String content = functionResponse.getContent();
                            String cardTypeId = functionResponse.getCardTypeId();
                            Object cardDesc = cardFetcher.getCardDescById(cardTypeId);
                            Object data = functionResponse.getData();
                            agentManager.updateAgentInstanceById(agentInstanceId, messageList);
                            return Flux.just(ChatResponse.builder().status(Status.COMPLETED).content(content).data(data).design(cardDesc).build()); // 将 Mono 转换为 Flux
                        } else {
                            return Mono.just(ChatResponse.builder().status(Status.COMPLETED).build());
                        }
                    }

                    //如果是纯文本的内容，那就应该大模型返回了，大模型会继续分析这个调用结果。
                    //这个场景通常是是RAG的过程或者查询类的，需要大模型进一步的分析的。
                    agentManager.updateAgentInstanceById(agentInstanceId, messageList);
                    return processToolCall(chatModel, messageList, finishReasons, customFunction, agentInstance);
                }
                //这里就是不需要functioncall的处理，纯文本的回复。
                Generation generation = chatResponse.getResults().get(0);
                String content = generation.getOutput().getContent();
                AssistantMessage message = generation.getOutput();
                ChatGenerationMetadata metadata = generation.getMetadata();
                String finishReason = metadata.getFinishReason();
                sb.append(message.getContent());
                if ("STOP".equals(finishReason)) {
                    AssistantMessage assistantMessage = new AssistantMessage(sb.toString());
                    messageList.add(assistantMessage);
                    // 使用 flatMap 将 Mono 转换为 Flux，并确保更新操作完成后再继续流

                    agentManager.updateAgentInstanceById(agentInstanceId, messageList);
                    return Mono.just(ChatResponse.builder().status(Status.COMPLETED).build());

                }
                if (StringUtils.isEmpty(content)) {
                    return Flux.empty();
                }

                return Flux.just(ChatResponse.builder().content(content).status(Status.REPLYING).build());

            });
        } catch (Exception e) {
            log.error(e.getMessage());
            e.printStackTrace();
            return Flux.error(e);
        }

    }

    private FunctionCallResult handleToolCall(AssistantMessage.ToolCall toolCall, Profile userProfile, Map<String, Object> extras, String enterpriseId,String agentId) {


        if (toolCall.type().equals(FunctionCallConstants.FUNCTION)) {
            String arguments = toolCall.arguments();
            String name = toolCall.name();
            FunctionCallRequest request = FunctionCallRequest.builder().functionName(name).functionArguments(arguments).userProfile(userProfile).extras(extras).enterpriseId(enterpriseId).agentId(agentId).build();
            FunctionCallResult callResult = functionCallService.apply(request);
            return callResult;

        }
        return null;
    }