<properties>
    <!-- 項目使用的 JDK 版本 -->
    <java.version>17</java.version>
    <!-- Spring AI Alibaba 相關(guān)依賴統(tǒng)一使用的版本 -->
    <spring-ai-alibaba.version>1.1.0.0-M5</spring-ai-alibaba.version>
    <!-- Spring AI 核心依賴統(tǒng)一使用的版本 -->
    <spring-ai.version>1.1.0</spring-ai.version>
</properties>
<dependencies>
    <!-- 基礎(chǔ) Web 能力：提供 Spring MVC / 內(nèi)嵌容器等 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- 通過 Spring AI 訪問本地 Ollama 大模型服務(wù) -->
    <dependency>
        <groupId>org.springframework.ai</groupId>
        <artifactId>spring-ai-starter-model-ollama</artifactId>
    </dependency>
    <!-- 向量數(shù)據(jù)庫：Spring AI 對 PgVector 的封裝 -->
    <dependency>
        <groupId>org.springframework.ai</groupId>
        <artifactId>spring-ai-starter-vector-store-pgvector</artifactId>
    </dependency>
    <!-- PostgreSQL JDBC 驅(qū)動，用于訪問數(shù)據(jù)庫 -->
    <dependency>
        <groupId>org.postgresql</groupId>
        <artifactId>postgresql</artifactId>
    </dependency>
</dependencies>
<dependencyManagement>
    <dependencies>
        <!-- Spring AI Alibaba 統(tǒng)一版本管理（國內(nèi)生態(tài)相關(guān)依賴） -->
        <dependency>
            <groupId>com.alibaba.cloud.ai</groupId>
            <artifactId>spring-ai-alibaba-bom</artifactId>
            <version>${spring-ai-alibaba.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
        <!-- Spring AI 官方 BOM（核心抽象與 Starter 的版本對齊） -->
        <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>

server:
  port: 8081                 # 應(yīng)用監(jiān)聽端口
  servlet:
    context-path: /alibaba-ai  # 統(tǒng)一的服務(wù)前綴
spring:
  ai:
    ollama:
      base-url: http://localhost:11434  # 本地 Ollama 服務(wù)地址
      chat:
        options:
          model: qwen3:0.6b             # 聊天用的 Qwen3 模型名稱
          temperature: 0.8              # 采樣溫度，越高回答越發(fā)散
      embedding:
        options:
          model: qwen3-embedding:0.6b   # 用于向量化的 embedding 模型
    vectorstore:
      pgvector:
        dimensions: 1024                # 向量維度，需要與 embedding 模型輸出一致
        distance-type: cosine_distance  # 相似度度量方式
        initialize-schema: true         # 啟動時自動創(chuàng)建 PgVector 表結(jié)構(gòu)
  datasource:
    url: jdbc:postgresql://<your-host>:5432/postgres?serverTimezone=Asia/Shanghai  # PostgreSQL 連接串
    username: postgres
    password: ****                      # 建議通過環(huán)境變量或配置中心注入

@RestController
@RequestMapping("/chatModel")
public class ChatModelController {
    // 注入由 Spring AI 自動裝配的 Ollama ChatModel
    private final ChatModel ollamaChatModel;
    public ChatModelController(ChatModel ollamaChatModel) {
        this.ollamaChatModel = ollamaChatModel;
    }
    @GetMapping("/chat")
    public Flux<String> chat(@RequestParam("message") String message) {
        // message：用戶輸入的自然語言問題
        return ollamaChatModel.stream(new Prompt(message))     // 以流式方式調(diào)用大模型
                .map(ChatResponse::getResult)                  // 提取每個增量響應(yīng)的結(jié)果對象
                .mapNotNull(result -> result.getOutput().getText()); // 只保留最終輸出的文本內(nèi)容
    }
}

@RestController
@RequestMapping("/chatClient")
public class ChatClientController {
    // 基于 ChatModel 封裝的高級客戶端，后續(xù)可以掛接 Adviser、工具等能力
    private final ChatClient ollamaChatClient;
    public ChatClientController(ChatClient ollamaChatClient) {
        this.ollamaChatClient = ollamaChatClient;
    }
    @GetMapping("/chat")
    public Flux<String> stream(@RequestParam("message") String message) {
        // 使用最簡單的 Prompt，直接將用戶輸入交給大模型，并以流式方式返回結(jié)果
        return ollamaChatClient
                .prompt(new Prompt(message))  // 構(gòu)造 Prompt 對象
                .stream()                     // 流式調(diào)用
                .content();                   // 提取文本內(nèi)容
    }
    @GetMapping("/prompt")
    public Flux<String> prompt() {
        PromptTemplate template = PromptTemplate.builder()
                .template("請用簡短中文回答：{question}") // 模板中定義占位符 {question}
                .variables(Map.of())                   // 這里可以預(yù)先聲明變量，也可以在 create 時傳入
                .build();
        // 使用實際問題填充模板變量
        Prompt prompt = template.create(Map.of("question", "Spring AI Alibaba 有什么特點？"));
        return ollamaChatClient.prompt(prompt).stream().content();
    }
}

@Component
public class SimpleMemories implements ChatMemory {
    private static final Map<String, List<Message>> MEMORIES_CACHE = new HashMap<>();
    @Override
    public void add(String conversationId, List<Message> messages) {
        // conversationId：會話標(biāo)識；messages：本輪新增的消息列表
        List<Message> memories = MEMORIES_CACHE.getOrDefault(conversationId, new ArrayList<>());
        if (messages != null && !messages.isEmpty()) {
            memories.addAll(messages);
        }
        MEMORIES_CACHE.put(conversationId, memories);
    }
    @Override
    public List<Message> get(String conversationId) {
        // 根據(jù)會話 ID 取出該會話的歷史消息
        return MEMORIES_CACHE.getOrDefault(conversationId, new ArrayList<>());
    }
    @Override
    public void clear(String conversationId) {
        // 清空某個會話的記憶
        List<Message> messages = MEMORIES_CACHE.get(conversationId);
        if (messages != null) {
            messages.clear();
        }
    }
}

@Component
public class MemoriesAdviser implements BaseAdvisor {
    private static final Map<String, List<Message>> MEMORIES = new HashMap<>();
    // 用于在 ChatClient 的上下文中標(biāo)識當(dāng)前會話 ID 的 key
    private static final String CHAT_MEMORIES_SESSION_ID = "chat_memories_session_id";
    @Override
    public ChatClientRequest before(ChatClientRequest request, AdvisorChain chain) {
        // 從上下文中讀取會話 ID，并取出其歷史消息
        String sessionId = request.context().get(CHAT_MEMORIES_SESSION_ID).toString();
        List<Message> messages = MEMORIES.getOrDefault(sessionId, new ArrayList<>());
        // 當(dāng)前請求的消息放到歷史消息后面，一起交給大模型
        messages.addAll(request.prompt().getInstructions());
        Prompt prompt = request.prompt().mutate().messages(messages).build();
        return request.mutate().prompt(prompt).build();
    }
    @Override
    public ChatClientResponse after(ChatClientResponse response, AdvisorChain chain) {
        // 把本次大模型回復(fù)寫回到對應(yīng)會話的記憶中
        AssistantMessage output = response.chatResponse().getResult().getOutput();
        String sessionId = response.context().get(CHAT_MEMORIES_SESSION_ID).toString();
        List<Message> messages = MEMORIES.getOrDefault(sessionId, new ArrayList<>());
        messages.add(output);
        MEMORIES.put(sessionId, messages);
        return response;
    }
}

@RestController
@RequestMapping("/rag")
public class RagChatClientController {
    private final ChatClient ragChatClient;
    private final PgVectorStore pgVectorStore;
    public RagChatClientController(ChatClient ragChatClient, PgVectorStore pgVectorStore) {
        this.ragChatClient = ragChatClient;
        this.pgVectorStore = pgVectorStore;
    }
    @GetMapping("/embedding")
    public void embeddingContent(@RequestParam("message") String message) {
        // message：待向量化的原始文本內(nèi)容
        TokenTextSplitter splitter = TokenTextSplitter.builder()
                .withChunkSize(50)                 // 每個分片的最大 token 數(shù)
                .withKeepSeparator(true)           // 是否保留分隔符（如換行符）
                .withMaxNumChunks(1024)            // 單次允許生成的最大分片數(shù)
                .withMinChunkLengthToEmbed(20)     // 小于該長度的分片不入庫，避免噪聲
                .withMinChunkSizeChars(10)         // 切分時的最小字符數(shù)，避免切得過碎
                .build();
        List<Document> docs = splitter.split(Document.builder().text(message).build()); // 將文本切分為多個 Document
        pgVectorStore.add(docs); // 寫入 PgVector 向量庫
    }
}

@Configuration
public class VectorChatClientConfig {
    @Bean("ragChatClient")
    public ChatClient ragChatClient(ChatModel chatModel, VectorStore vectorStore) {
        VectorStoreDocumentRetriever retriever = VectorStoreDocumentRetriever.builder()
                .vectorStore(vectorStore)     // 具體使用的向量庫實現(xiàn)，這里是 PgVector
                .topK(3)                      // 每次檢索返回相似度最高的前 3 條文檔
                .similarityThreshold(0.5)     // 相似度閾值，小于該值的文檔會被過濾掉
                .build();
        RetrievalAugmentationAdvisor advisor = RetrievalAugmentationAdvisor.builder()
                .documentRetriever(retriever) // 指定文檔檢索器
                .order(0)                     // Adviser 執(zhí)行順序，越小越先執(zhí)行
                .build();
        return ChatClient.builder(chatModel)
                .defaultAdvisors(advisor)     // 默認(rèn)啟用 RAG 能力
                .build();
    }
}

@Component
public class ZoomTool {
    @Tool(description = "通過時區(qū) ID 獲取當(dāng)前時間")
    public String getTimeByZone(@ToolParam(description = "時區(qū) ID，比如 Asia/Shanghai") String zone) {
        // zone：時區(qū) ID，示例：Asia/Shanghai、Europe/Berlin
        ZoneId zoneId = ZoneId.of(zone);
        ZonedDateTime now = ZonedDateTime.now(zoneId);
        return DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss").format(now); // 返回格式化后的時間字符串
    }
}

@Configuration
public class ToolChatClientConfig {
    @Bean("toolChatClient")
    public ChatClient toolChatClient(ChatModel ollamaChatModel, ZoomTool zoomTool) {
        // ollamaChatModel：底層使用的 Qwen3 模型；zoomTool：提供獲取時間的業(yè)務(wù)工具
        return ChatClient.builder(ollamaChatModel)
                .defaultSystem(this.systemPrompt()) // 設(shè)置默認(rèn)的系統(tǒng)提示詞，統(tǒng)一咖啡館背景
                .defaultTools(zoomTool)             // 將 ZoomTool 注冊為可調(diào)用的工具
                .build();
    }
    private String systemPrompt() {
        Map<String, Object> vars = new HashMap<>();
        vars.put("AMERICAN", "1-3");          // 美式咖啡制作時間（分鐘）
        vars.put("LATTE", "2");               // 拿鐵咖啡制作時間（分鐘）
        vars.put("TIME_ZONE", "Asia/Shanghai"); // 默認(rèn)時區(qū) ID
        SystemPromptTemplate tpl = SystemPromptTemplate.builder()
                .template("歡迎光臨 ZhouByte咖啡館，... 默認(rèn)時區(qū)：{TIME_ZONE}") // 系統(tǒng)提示詞模板
                .variables(vars)                                          // 綁定上面的變量
                .build();
        return tpl.render(); // 渲染出包含具體變量值的系統(tǒng)提示詞
    }
}

@RestController
@RequestMapping("/tool")
public class ToolChatController {
    private final ChatClient toolChatClient;
    public ToolChatController(ChatClient toolChatClient) {
        this.toolChatClient = toolChatClient;
    }
    @GetMapping("/chat")
    public Flux<String> chat(@RequestParam("message") String message) {
        return toolChatClient
                .prompt()          // 創(chuàng)建一次新的對話請求
                .user(message)     // 添加一條用戶消息
                .stream()          // 流式調(diào)用大模型
                .content();        // 只提取文本內(nèi)容返回
    }
}

@Configuration
public class GraphConfig {
    @Bean("quickStartGraph")
    public CompiledGraph quickStartGraph() throws GraphStateException {
        // "quickStartGraph"：圖名稱；后面的 Map 用于定義狀態(tài) key 的合并策略
        StateGraph graph = new StateGraph("quickStartGraph", () -> Map.of(
                "input", new ReplaceStrategy(),  // 多次寫入時，后寫入的值覆蓋之前的值
                "output", new ReplaceStrategy()
        ));
        graph.addNode("node1", AsyncNodeAction.node_async(state -> {
            // node1：設(shè)置初始 input 和 output
            return Map.of("input", "graphConfig_addNode", "output", "graphConfig_output");
        }));
        graph.addNode("node2", AsyncNodeAction.node_async(state -> {
            // node2：模擬業(yè)務(wù)處理，將 input 改為 ZhouByte
            return Map.of("input", "ZhouByte", "output", "EMPTY");
        }));
        // 定義執(zhí)行順序：START -> node1 -> node2 -> END
        graph.addEdge(StateGraph.START, "node1")
             .addEdge("node1", "node2")
             .addEdge("node2", StateGraph.END);
        return graph.compile();
    }
}

@RestController
@RequestMapping("/v1")
public class GraphController {
    @Resource
    private CompiledGraph quickStartGraph;
    @GetMapping("/graph")
    public Flux<String> startGraph() {
        // 這里傳入空的初始狀態(tài) Map，按定義好的 StateGraph 順序執(zhí)行
        return quickStartGraph.stream(Map.of())
                .map(NodeOutput::toString); // 將每個節(jié)點的輸出對象轉(zhuǎn)換為字符串返回
    }
}

@Configuration
public class ConditionalGraphConfig {
    @Bean("scoreDecisionGraph")
    public CompiledGraph scoreDecisionGraph() throws GraphStateException {
        StateGraph graph = new StateGraph("scoreDecisionGraph", () -> Map.of(
                "score", new ReplaceStrategy(),   // 保存當(dāng)前評分
                "result", new ReplaceStrategy()   // 保存決策結(jié)果
        ));
        // 讀取或設(shè)置評分（示例中從 state 中讀取，實際可由外部請求傳入）
        graph.addNode("checkScore", AsyncNodeAction.node_async(state -> {
            Integer score = (Integer) state.value("score").orElse(75); // 默認(rèn) 75 分
            return Map.of("score", score);
        }));
        // 三個業(yè)務(wù)分支節(jié)點：通過 / 復(fù)核 / 拒絕
        graph.addNode("pass", AsyncNodeAction.node_async(state ->
                Map.of("result", "PASS")));
        graph.addNode("review", AsyncNodeAction.node_async(state ->
                Map.of("result", "REVIEW")));
        graph.addNode("reject", AsyncNodeAction.node_async(state ->
                Map.of("result", "REJECT")));
        // 起點先進入評分檢查節(jié)點
        graph.addEdge(StateGraph.START, "checkScore");
        // 多條件邊：根據(jù) score 返回不同的“標(biāo)簽”，再由 mappings 決定下一跳節(jié)點
        graph.addConditionalEdges("checkScore",
                AsyncEdgeAction.edge_async(state -> {
                    int score = (Integer) state.value("score").orElse(0);
                    if (score >= 80) {
                        return "PASS";
                    }
                    if (score >= 60) {
                        return "REVIEW";
                    }
                    return "REJECT";
                }),
                Map.of(
                        "PASS", "pass",
                        "REVIEW", "review",
                        "REJECT", "reject"
                )
        );
        // 三個結(jié)果節(jié)點最終都指向 END
        graph.addEdge("pass", StateGraph.END);
        graph.addEdge("review", StateGraph.END);
        graph.addEdge("reject", StateGraph.END);
        return graph.compile();
    }
}

<dependency>
    <groupId>com.alibaba.cloud.ai</groupId>
    <artifactId>spring-ai-alibaba-starter-dashscope</artifactId>
    <version>1.1.0.0-M5</version>
</dependency>

spring:
  ai:
    dashscope:
      api-key: ${DASHSCOPE_API_KEY}      # 從環(huán)境變量或配置中心讀取 DashScope 的 API Key
      endpoint: https://dashscope.aliyuncs.com
      chat:
        options:
          model: qwen-plus              # 使用的通義千問在線模型
          temperature: 0.8              # 采樣溫度
          max-tokens: 2048              # 單次回答的最大 token 數(shù)