AI实践｜基于 Spring AI 从0到1构建 AI Agent

spring.ai.openai.base-url=https://open.bigmodel.cn/api/paas/v4spring.ai.openai.api-key=你的API密钥spring.ai.openai.chat.options.model=glm-4spring.ai.openai.embedding.options.model=embedding-3

http://localhost:8080

# 非流式对话curl -X POST http://localhost:8080/api/chat \  -H "Content-Type: application/json" \  -d '{"message": "你好，介绍一下你的能力", "sessionId": "test-001"}'# 流式对话（SSE）curl -X POST http://localhost:8080/api/chat/stream \  -H "Content-Type: application/json" \

用户输入  │  ▼意图识别（IntentRecognizer）  │ 判断：这是知识问答还是通用对话？  ▼RAG 注入（RagService）  │ 如果是知识问答，检索知识库，将参考资料拼入上下文  ▼记忆管理（ChatMemory）  │ 自动摘要压缩 → 构建消息列表  ▼模型调用（ChatClient + ToolCallbacks）  │ LLM 决策：直接回答 or 调用工具？  │ 如果调用工具 → 执行工具 → 将结果返回 LLM → 继续决策（ReAct 循环）  ▼返回最终回复

public String chat(String sessionId, String userInput) {    ChatMemory memory = getOrCreateMemory(sessionId);    // 1. 意图识别    Intent intent = intentRecognizer.recognize(userInput);    // 2. 如果是 RAG 意图，先检索知识库并注入上下文    if (intent == Intent.RAG && ragService.isKnowledgeLoaded()) {        String ragContext = ragService.query(userInput);        if (ragContext != null && !ragContext.isBlank()) {            String enrichedInput = "以下是从知识库中检索到的相关参考资料，"                    + "请结合这些资料回答用户的问题：\n\n"                    + ragContext + "\n\n用户问题：" + userInput;            memory.addMessage(new UserMessage(enrichedInput));        } else {            memory.addMessage(new UserMessage(userInput));        }    } else {        memory.addMessage(new UserMessage(userInput));    }    // 3. 构建 Prompt 并Loop调用大模型（getMessages 内部自动触发摘要压缩）    List<Message> messages = memory.getMessages();    Prompt prompt = new Prompt(messages, buildChatOptions());    ChatClient.ChatClientRequestSpec requestSpec = chatClient.prompt(prompt);    if (!toolCallbacks.isEmpty()) {        requestSpec.toolCallbacks(toolCallbacks.toArray(new ToolCallback[0]));    }    String response = requestSpec.call().content();    memory.addMessage(new AssistantMessage(response != null ? response : ""));    return response != null ? response : "";}

boolean isToolCall = false;
do {
    // Before Call    var processedChatClientRequest = ChatClientRequest.builder()       .prompt(new Prompt(instructions, optionsCopy))       .context(chatClientRequest.context())       .build();
    // Next Call    processedChatClientRequest = this.doBeforeCall(processedChatClientRequest, callAdvisorChain);
    chatClientResponse = callAdvisorChain.copy(this).nextCall(processedChatClientRequest);
    chatClientResponse = this.doAfterCall(chatClientResponse, callAdvisorChain);
    // After Call
    // TODO: check that this tool call detection is sufficient for all chat models    // that support tool calls. (e.g. Anthropic and Bedrock are checking for    // finish status as well)    ChatResponse chatResponse = chatClientResponse.chatResponse();    isToolCall = chatResponse != null && chatResponse.hasToolCalls();
    if (isToolCall) {       Assert.notNull(chatResponse, "redundant check that should never fail, but here to help NullAway");       ToolExecutionResult toolExecutionResult = this.toolCallingManager          .executeToolCalls(processedChatClientRequest.prompt(), chatResponse);
       if (toolExecutionResult.returnDirect()) {
          // Return tool execution result directly to the application client.          chatClientResponse = chatClientResponse.mutate()             .chatResponse(ChatResponse.builder()                .from(chatResponse)                .generations(ToolExecutionResult.buildGenerations(toolExecutionResult))                .build())             .build();
          // Interrupt the tool calling loop and return the tool execution          // result directly to the client application instead of returning          // it to the LLM.          break;       }
       instructions = this.doGetNextInstructionsForToolCall(processedChatClientRequest, chatClientResponse,             toolExecutionResult);    }
}while (isToolCall); // loop until no tool calls are present

public List<Message> getMessages() {    // 在构建消息列表之前，自动尝试摘要压缩    compressIfNeeded();    List<Message> messages = new ArrayList<>();    // 将原始 system prompt 与摘要合并为一条 SystemMessage    if (systemMessage != null || (summaryText != null && !summaryText.isBlank())) {        String systemContent = systemMessage != null ? systemMessage.getText() : "";        if (summaryText != null && !summaryText.isBlank()) {            systemContent += "\n\n【以下是之前对话的摘要，请参考】\n" + summaryText;        }        messages.add(new SystemMessage(systemContent));    }    // ... 添加历史消息（跳过早期 Assistant 消息）    return Collections.unmodifiableList(messages);}private void compressIfNeeded() {    if (chatClient == null || history.size() <= COMPRESS_THRESHOLD_MESSAGES) {        return;    }    int compressEndIndex = history.size() - PRESERVE_RECENT_MESSAGES;    // 确保不会在 TOOL 消息的前面截断    while (compressEndIndex < history.size()            && history.get(compressEndIndex).getMessageType() == MessageType.TOOL) {        compressEndIndex--;    }    if (compressEndIndex <= 0) return;    List<Message> messagesToCompress = new ArrayList<>(history.subList(0, compressEndIndex));    String newSummary = SummaryCompressor.compress(chatClient, messagesToCompress, summaryText);    if (newSummary != null && !newSummary.isBlank()) {        this.summaryText = newSummary;        history.subList(0, compressEndIndex).clear();    }}

public interface InnerTool {    List<ToolCallback> loadToolCallbacks();}

用户："杭州今天天气怎么样？"  │  ▼LLM 分析意图，决定调用 get_weather 工具  │  ▼Spring AI 自动执行工具：get_weather({"city": "杭州"})  │  ▼工具返回结果："杭州，晴，22°C"  │  ▼LLM 基于工具结果生成最终回复："杭州今天天气晴朗，气温 22°C，适合出行。"

public String query(String question) {    // 1. 多路召回（语义 + BM25 + 查询改写，共 9 个候选）    List<Document> candidates = multiRecaller.recall(question, RECALL_CANDIDATE_COUNT);    // 2. Rerank 重排（取最相关的 3 个）    List<Document> relevantDocuments = llmReranker.rerank(question, candidates, TOP_K);    // 3. 拼接上下文    StringBuilder contextBuilder = new StringBuilder();    for (int i = 0; i < relevantDocuments.size(); i++) {        contextBuilder.append("【参考资料 ").append(i + 1).append("】\n");        contextBuilder.append(relevantDocuments.get(i).getContent()).append("\n\n");    }    return contextBuilder.toString().trim();}

// MultiRecaller 核心逻辑public List<Document> retrieve(String query, int topK) {    Map<String, Double> rrfScores = new HashMap<>();    Map<String, Document> keyToDocument = new LinkedHashMap<>();    for (Recaller retriever : retrievers) {        List<Document> results = retriever.retrieve(query, PER_ROUTE_CANDIDATE_COUNT);        // RRF 公式：score(d) = Σ 1 / (k + rank)，k=60 为平滑常数        accumulateRrfScores(results, rrfScores, keyToDocument);    }    return rrfScores.entrySet().stream()            .sorted(Map.Entry.<String, Double>comparingByValue().reversed())            .limit(topK)            .map(entry -> keyToDocument.get(entry.getKey()))            .toList();}

---name: summarizedescription: 对用户提供的文本内容进行摘要总结---请对以下文本进行摘要总结，提取核心要点：{{input}}

请对以下代码进行 Code Review，从代码质量、潜在 Bug、性能、可读性等维度给出改进建议：{{input}}

public SubAgent(String id, String name, String systemPrompt, ChatClient chatClient) {    this.memory = ChatMemory.forSubAgent();  // 独立记忆！    this.memory.setSystemPrompt(systemPrompt);    // ...}

public ToolCallback[] connect(String serverUrl) {    McpSyncClient mcpClient;    McpSchema.InitializeResult initResult;    // 优先尝试 Streamable HTTP，失败后回退到 SSE    try {        mcpClient = connectWithStreamableHttp(serverUrl);        initResult = mcpClient.initialize();    } catch (Exception streamableException) {        mcpClient = connectWithSse(serverUrl);        initResult = mcpClient.initialize();    }    // 自动发现远程工具    SyncMcpToolCallbackProvider provider = SyncMcpToolCallbackProvider.builder()            .mcpClients(mcpClient).build();    ToolCallback[] toolCallbacks = provider.getToolCallbacks();    // 持久化 URL，下次启动自动恢复    store.add(serverUrl);    return toolCallbacks;}