docker run -d \
--name pgvector \
--restart unless-stopped \
-p 5432:5432 \
-e POSTGRES_USER=postgres \
-e POSTGRES_PASSWORD=postgres \
-v ./data/postgresql:/var/lib/postgresql/data \
pgvector/pgvector:pg16

services:
pgvector:
  image: pgvector/pgvector:pg16
  container_name: pgvector
  restart: unless-stopped
  ports:
    - "5432:5432"
  volumes:
    - ./data/postgresql:/var/lib/postgresql/data
    #- ./conf/postgresql.conf:/var/lib/postgresql/data/postgresql.conf
    #- ./conf/pg_hba.conf:/var/lib/postgresql/data/pg_hba.conf
  environment:
    # POSTGRES_DB: postgres
    POSTGRES_USER: postgres
    POSTGRES_PASSWORD: postgres

docker run -d \
--name redis-stack \
--restart unless-stopped \
-p 6380:6379 \
-p 18001:8001 \
-v ./data/redis:/data \
redis/redis-stack:latest

services:
redis-stack:
  image: redis/redis-stack:latest
  container_name: redis-stack
  restart: unless-stopped
  ports:
    - "6380:6379" 
    - "18001:8001" 
  volumes:
    - ./data/redis:/data
    # - ./config/redis-stack.conf:/redis-stack.conf:ro
  # command: ["redis-server", "/redis-stack.conf"]
  healthcheck:
    test: ["CMD", "redis-cli", "ping"]
    interval: 10s
    timeout: 5s
    retries: 3

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!--spring-ai-alibaba dashscope-->
    <dependency>
        <groupId>com.alibaba.cloud.ai</groupId>
        <artifactId>spring-ai-alibaba-starter-dashscope</artifactId>
    </dependency>
    <!--ollama-->
    <!--
    <dependency>
        <groupId>org.springframework.ai</groupId>
        <artifactId>spring-ai-starter-model-ollama</artifactId>
        <version>1.0.0</version>
    </dependency>
    -->
    <!--lombok-->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
    <!--hutool-->
    <dependency>
        <groupId>cn.hutool</groupId>
        <artifactId>hutool-all</artifactId>
        <version>5.8.22</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

spring:
  datasource:
    url: jdbc:postgresql://127.0.0.1:5432/postgres
    username: postgres
    password: postgres
    driver-class-name: org.postgresql.Driver
  application:
    name: chat-memory
  data:
    redis:
      host: localhost
      port: 6379
      password:
      database: 1
      connect-timeout: 3
      timeout: 3
  ai:
    # ====SpringAIAlibaba Config=============
    dashscope:
      # 必选 配置环境变量 DASH_SCOPE_API_KEY=你的apiky
      api-key: ${DASH_SCOPE_API_KEY}
      # 可选 
      base-url: "https://dashscope.aliyuncs.com/compatible-mode/v1"
      # 可选，可在config中配置多个模型
      chat:
        options:
          model: "qwen-plus-2025-09-11"
     # ====SpringAI Config=============
    #openai:
      #api-key: ${OPENAI_API_KEY}
      #base-url: "https://api.openai.com/v1"
      #chat:
        #ptions:
          #model: "gpt-3.5-turbo"

@Bean
public DashScopeApi dashScopeApi() {
    return DashScopeApi.builder()
            .apiKey(System.getenv("DASH_SCOPE_API_KEY"))
            .build();
}

@RestController
@RequestMapping("/chat")
public class ChatHelloController {
    @Resource
    private ChatModel chatModel;
    @GetMapping(value = "/block")
    public String doChat(@RequestParam(name = "question", defaultValue = "你是谁") String question) {
        return chatModel.call(question);
    }
    @GetMapping(value = "/stream")
    public Flux<String> stream(@RequestParam(name = "question", defaultValue = "你是谁") String question) {
        return chatModel.stream(question);
    }
}

@Bean
public ChatClient chatClient(ChatModel dashscopeChatModel) {
 return ChatClient.builder(dashscopeChatModel).build();
}

private final ChatClient dashScopeChatClient;
public ChatClientController(ChatModel dashScopeChatModel) {
 this.dashScopeChatClient = ChatClient.builder(dashScopeChatModel).build();
}

@Resource
private ChatClient dashScopeChatClient;
@GetMapping("/client")
public String chatClientBlock(@RequestParam(name = "question", defaultValue = "2加9等于几") String question) {
    return dashScopeChatClient.prompt().user(question).call().content();
}
@GetMapping("/client")
public Flux<String> chatClientStream(@RequestParam(name = "question", defaultValue = "2加9等于几") String question) {
    return dashScopeChatClient.prompt().user(question).stream().content();
}

<!--ollama-->
<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-starter-model-ollama</artifactId>
    <version>1.0.0</version>
</dependency>

spring:
  application:
    name: ollama
  ai:
    ollama:
      base-url: "http://192.168.187.166:11434"
      chat:
        model: "qwen3:8b"

@Resource  
private ChatModel chatModel;  
      
public final ChatClient chatClient;  
public OllamaController(ChatClient.Builder builder) {  
    this.chatClient = builder.build();  
}

// ChatModel 方式
@GetMapping("/stream")
public Flux<String> stream(@RequestParam(name = "question", defaultValue = "你是谁") String question) {
    // 阻塞方式
    //return chatModel.call(question);
    // 流式方式
    return chatModel.stream(question);
}
    
// ChatClient方式
@GetMapping("/client")
public Flux<String> client(@RequestParam(name = "question", defaultValue = "你是谁") String question) {
    // 阻塞方式
    //return chatClient.prompt().user(question).call().content();
    // 流式方式
    return chatClient.prompt().user(question).stream().content();
}

@Configuration
public class SaaLLMConfig {
    
    private final String DEEPSEEK_MODEL = "deepseek-v3.1";
    private final String QWEN_MODEL = "qwen-plus-2025-09-11";
    
    @Bean(name = "deepseek")
    public ChatModel deepSeek() {
        return DashScopeChatModel.builder()
                .dashScopeApi(DashScopeApi.builder().apiKey(System.getenv("DASH_SCOPE_API_KEY")).build())
                .defaultOptions(DashScopeChatOptions.builder().withModel(DEEPSEEK_MODEL).build())
                .build();
    }

    @Bean(name = "qwen")
    public ChatModel qwen() {
        return DashScopeChatModel.builder()
                .dashScopeApi(DashScopeApi.builder().apiKey(System.getenv("DASH_SCOPE_API_KEY")).build())
                .defaultOptions(DashScopeChatOptions.builder().withModel(QWEN_MODEL).build())
                .build();
    }

    @Bean(name = "deepseekChatClient")
    public ChatClient deepseekChatClient(@Qualifier("deepseek") ChatModel deepseek) {
        return ChatClient.builder(deepseek)
                        .defaultOptions(ChatOptions.builder().model(DEEPSEEK_MODEL).build())
                        .build();
    }

    @Bean(name = "qwenChatClient")
    public ChatClient qwenChatClient(@Qualifier("qwen") ChatModel qwen) {
        return ChatClient.builder(qwen)
                        .defaultOptions(ChatOptions.builder().model(QWEN_MODEL).build())
                        .build();
    }

    @Bean(name = "ollamaChatClient")
    public ChatClient ollamaChatClient(@Qualifier("ollamaChatModel") ChatModel ollama) {
        return ChatClient.builder(ollama)
                .defaultOptions(ChatOptions.builder().model("qwen3:8b").build())
                .build();
    }
}

<!--spring-ai-alibaba dashscope-->
<dependency>
    <groupId>com.alibaba.cloud.ai</groupId>
    <artifactId>spring-ai-alibaba-starter-dashscope</artifactId>
</dependency>
<!-- redis 存储所需依赖 经过spring ai alibaba 又封装了一层 -->
<!--spring-ai-alibaba memory-redis-->
<dependency>
    <groupId>com.alibaba.cloud.ai</groupId>
    <artifactId>spring-ai-alibaba-starter-memory-redis</artifactId>
</dependency>
<!--jedis-->
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
</dependency>
<!--  postgresql 存储所需依赖 没有封装的 spring ai 原生支持的 -->
<!--spring-ai memory-jdbc-->
<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-starter-model-chat-memory-repository-jdbc</artifactId>
</dependency>
<dependency>
    <groupId>org.postgresql</groupId>
    <artifactId>postgresql</artifactId>
    <version>42.5.0</version>
</dependency>

spring:
  datasource:
    url: jdbc:postgresql://127.0.0.1:5432/postgres
    username: postgres
    password: postgres
    driver-class-name: org.postgresql.Driver
  application:
    name: chat-memory
  data:
    redis:
      host: localhost
      port: 6379
      password:
      database: 1
      connect-timeout: 3
      timeout: 3
  ai:
    chat:
      memory:
        repository:
          jdbc:
            initialize-schema: always

@Configuration
public class PostgresMemoryConfig {
    // 依赖注入：通过构造函数获取 JdbcTemplate
    private final JdbcTemplate jdbcTemplate;
    // 推荐使用构造函数注入，确保依赖不可变
    public PostgresMemoryConfig(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }
    /**
     * 定义 JdbcChatMemoryRepository Bean。
     * 它是 ChatMemoryRepository 接口的实现，负责将聊天记录存储到数据库中。
     *
     * @return 配置好的 JdbcChatMemoryRepository 实例
     */
    @Bean
    // 标记为 @Primary 以解决可能的歧义，确保在需要默认 ChatMemoryRepository 时优先选择 JDBC 实现。
    @Primary
    public JdbcChatMemoryRepository jdbcChatMemoryRepository() {
        return JdbcChatMemoryRepository.builder()
                // 注入之前获取的 JdbcTemplate
                .jdbcTemplate(jdbcTemplate)
                .build();
    }
}

@Configuration
public class SaaLLMConfig {
    private final String OLLAMA_MODEL = "qwen3:8b";
    /**
     * 定义 Ollama 聊天客户端 Bean，并集成 JDBC 聊天记忆。
     *
     * @param ollamaChatModel 依赖注入的 Ollama ChatModel 实例 (使用 @Qualifier 区分)
     * @param jdbcChatMemoryRepository 依赖注入的 JDBC 聊天记忆仓库
     * @return 配置了记忆功能的 ChatClient 实例
     */
    @Bean(name = "ollamaChatClient")
    public ChatClient ollamaChatClient(@Qualifier("ollamaChatModel") ChatModel ollamaChatModel,
                                       JdbcChatMemoryRepository jdbcChatMemoryRepository) {
        // 1. 构造 MessageWindowChatMemory（消息窗口记忆）
        // 它负责维护一个固定大小（窗口）的对话历史。
        MessageWindowChatMemory windowChatMemory = MessageWindowChatMemory
                .builder()
                // 关联具体的持久化仓库（这里是 JDBC）
                .chatMemoryRepository(jdbcChatMemoryRepository)
                // 设置最大消息数，超过此限制旧消息将被移除
                .maxMessages(100)
                .build();
        // 2. 构造 ChatClient
        return ChatClient
                .builder(ollamaChatModel)
                // 设置默认模型选项
                .defaultOptions(ChatOptions.builder().model(OLLAMA_MODEL).build())
                // 添加 MessageChatMemoryAdvisor，它是实现记忆功能的核心组件
                // Advisor 会在每次请求时读取历史记录，并在响应后写入新记录。
                .defaultAdvisors(MessageChatMemoryAdvisor.builder(windowChatMemory).build())
                .build();
    }
}

@RestController
@RequestMapping("/memory")
public class ChatMemoryController {
    @Resource(name = "ollamaChatClient")
    private ChatClient ollamaChatClient;
    @GetMapping("/chat3")
    public Flux<String> ollamaMemory(@RequestParam(name = "question", defaultValue = "1+1等于几") String question,
                                     String userId,
                                     String conversationId) {
        return ollamaChatClient.prompt(question).advisors(
                        // 构造唯一的会话标识符
                        advisorSpec -> advisorSpec.param(CONVERSATION_ID, userId + "-" + conversationId))
                .stream().content();
    }
}

@RestController
@RequestMapping("/prompt")
public class PromptController {
    @Resource(name = "deepseek")
    private ChatModel deepseekChatModel;
    
    @Resource(name = "deepseekChatClient")
    private ChatClient deepseekChatClient;

    @GetMapping("/law")
    public Flux<String> law(@RequestParam(name = "question", defaultValue = "你是谁") String question) {
        return deepseekChatClient.prompt()
                // 能力边界
                .system("你是一个法律助手，只回答法律问题，其它问题回复，我只能回答法律相关问题，其它无可奉告")
                .user(question)
                .stream()
                .content();
    }
    @GetMapping("/story/html")
    public Flux<String> storyHtml(@RequestParam(name = "question", defaultValue = "讲个故事") String question) {
        // 系统消息
        SystemMessage systemMessage = new SystemMessage("你是一个讲故事的助手,每个故事控制在600字以内且以HTML格式返回");
        // 用户消息
        UserMessage userMessage = new UserMessage(question);
        Prompt prompt = new Prompt(userMessage, systemMessage);
        return deepseekChatModel.stream(prompt)
                .mapNotNull(response ->
                        response.getResults().getFirst().getOutput().getText()
                );
    }
}

public Flux<String> story() {
    // 模板定义在代码中
    PromptTemplate promptTemplate = new PromptTemplate(
                     "讲一个关于{topic}的故事" +
                    "并以{output_format}格式输出，" +
                    "字数在{word_count}左右");
    // 创建 Prompt 对象
    Prompt prompt = promptTemplate.create(Map.of(
            "topic", topic,
            "output_format", outputFormat,
            "word_count", wordCount));
    // 流式调用
    return deepseekChatClient.prompt(prompt).stream().content();
}

public Flux<String> story() {
  // 1. SystemPromptTemplate：创建 SystemMessage
  SystemPromptTemplate systemPromptTemplate = new SystemPromptTemplate("你是{system_topic}助手，只回答{system_topic}其它无可奉告，以HTML格式的结果。");
  Message sysMessage = systemPromptTemplate.createMessage(Map.of("system_topic", sysTopic));
  // 2. PromptTemplate：创建 UserMessage
  PromptTemplate userPromptTemplate = new PromptTemplate("解释一下{user_topic}");
  Message userMessage = userPromptTemplate.createMessage(Map.of("user_topic", userTopic));
  // 3. 组合：将 SystemMessage 和 UserMessage 组合成 Prompt
  Prompt prompt = new Prompt(List.of(sysMessage, userMessage));
  // 4. 调用 LLM
  return deepseekChatModel.stream(prompt).mapNotNull(
          chatResponse -> chatResponse.getResult().getOutput().getText()
  );
}

// 假设 StudentRecord 包含 LLM 需要填充的字段
public record StudentRecord(
    String id, 
    String name, 
    String major, 
    String email
) {}

@RestController
@RequestMapping("/struct")
public class StructureOutputController {
    @Resource(name = "qwenChatClient")
    private ChatClient qwenChatClient;

    @GetMapping("/chat2")
    public StudentRecord chat2(@RequestParam(name = "name", defaultValue = "王一狗") String name,
                               @RequestParam(name = "email", defaultValue = "[email protected]") String email) {
        String stringTemplate = """
                学号1002，我叫{name},大学专业软件工程,邮箱{email}
                """;
        return qwenChatClient.prompt()
                .user(
                        promptUserSpec ->
                                // 这里的参数 name 和 email 会被替换成对应的值，但并不是返回的值，具体的值还需靠模型的理解能力。
                                promptUserSpec.text(stringTemplate).param("name", name).param("email", email)
                        // 这里返回的结果主要靠模型的理解能力，所以结果可能不准确，可以拿下面的例子测试一下。
                        //promptUserSpec.text("学号001，我是武汉市长江大桥,大学专业计算机科学与技术,邮箱[email protected]")
                        //promptUserSpec.text("学号001，我是李四不对我是张三的哥哥王五的弟弟武汉市长江大桥的哥哥王麻子的叔叔你爸爸,大学专业计算机科学与技术,邮箱[email protected]")
                        //promptUserSpec.text("学号001，我是李四不对我是张三,大学专业计算机科学与技术,邮箱[email protected]")
                        //promptUserSpec.text("学号001，我是李四李四的爸爸李鬼,大学专业计算机科学与技术,邮箱[email protected]")
                )
                .call()
                .entity(StudentRecord.class); // 指定返回的结构化 Java 对象类型
    }
}

<!-- 添加 Redis (RedisStack) 向量数据库依赖 -->
<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-starter-vector-store-redis</artifactId>
</dependency>
<!-- 添加 postgres 向量数据库依赖 -->
<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-starter-vector-store-pgvector</artifactId>
</dependency>
<!-- ollama -->
<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-starter-model-ollama</artifactId>
    <version>1.0.0</version>
</dependency>

spring:
  application:
    name: vector
  # pgvector (不是普通的postgres)
  datasource:
    url: jdbc:postgresql://127.0.0.1:5432/postgres
    username: postgres
    password: postgres
    driver-class-name: org.postgresql.Driver
  data:
    # redis stack (不是普通的redis)
    redis:
      host: localhost
      port: 6380
      database: 0
      connect-timeout: 3
      timeout: 3
  ai:
    dashscope:
      api-key: ${DASH_SCOPE_API_KEY}
      chat:
        options:
          model: qwen-plus-2025-09-11
      # embedding模型
      embedding:
        options:
          model: text-embedding-v4
    ollama:
      base-url: http://192.168.187.166:11434
      # embedding模型
      embedding:
        options:
          model: bge-m3:latest
    # 向量数据库配置 
    vectorstore:
      redis:
        index-name: custom-index
        prefix: custom-prefix
        initialize-schema: true
      pgvector:
        initialize-schema: true
        index-type: HNSW
        distance-type: COSINE_DISTANCE
        dimensions: 1024
        max-document-batch-size: 10000

@SpringBootApplication(exclude = {
        // 排除 Redis 的自动配置
        RedisVectorStoreAutoConfiguration.class,
        // 排除 PgVector 的自动配置
        PgVectorStoreAutoConfiguration.class
})
public class VectorApplication {
    // ...
}

@Configuration
public class VectorStoreConfig {
 @Resource
 @Qualifier("ollamaEmbeddingModel")
 private EmbeddingModel ollamaEmbeddingModel;
 @Resource
 private JedisPooled jedisClient;
 @Bean("redisVectorStore")
 public VectorStore redisVectorStore() {
     return RedisVectorStore.builder(jedisClient, ollamaEmbeddingModel)
             .indexName("custom-index")
             .prefix("custom-prefix:")
             .initializeSchema(true)
             .vectorAlgorithm(HSNW)
             .build();
 }
 @Bean("pgVectorStore")
 public VectorStore pgVectorStore(JdbcTemplate jdbcTemplate) {
     return PgVectorStore.builder(jdbcTemplate, ollamaEmbeddingModel)
             // 如果不指定默认是public
             .schemaName("embedding_vector")
             .vectorTableName("vector_store")
             .dimensions(1024)
             .maxDocumentBatchSize(1000)
             .build();
 }
}

@RestController
@RequestMapping("/vector")
public class VectorController {
 @Resource
 @Qualifier("ollamaEmbeddingModel")
 private EmbeddingModel ollamaEmbeddingModel;
 @GetMapping("/text2embed")
 public EmbeddingResponse text2Embed(@RequestParam(name = "text", defaultValue = "你好") String text) {
     EmbeddingResponse embeddingResponse = ollamaEmbeddingModel.call(new EmbeddingRequest(List.of(text),
             DashScopeEmbeddingOptions.builder().withModel("bge-m3:latest").build()));
     System.out.println(Arrays.toString(embeddingResponse.getResult().getOutput()));
     return embeddingResponse;
 }
}

--查看是否有 'vector' 拓展
SELECT name, default_version, installed_version
FROM pg_available_extensions
WHERE name = 'vector';
-- 当前数据库中创建 vector 拓展。vector 扩展（即 PgVector）提供了 vector 数据类型和相关的索引（如 HNSW、IVFFlat）操作符，是 PostgreSQL 能够存储和高效检索向量数据的核心。
CREATE
EXTENSION IF NOT EXISTS vector;
-- 创建 hstore 扩展。 hstore 扩展提供了用于存储键值对数据的 hstore 数据类型。在 PgVector 存储中，它常被用来存储向量关联的 Metadata（元数据），例如文档来源、作者、时间戳等信息。
CREATE
EXTENSION IF NOT EXISTS hstore;
-- 创建 uuid-ossp 扩展。 该扩展提供了生成 UUID (Universally Unique Identifier) 的函数，例如 uuid_generate_v4()。这在创建表时用作主键，保证每条记录 ID 的唯一性。
CREATE
EXTENSION IF NOT EXISTS "uuid-ossp";
-- 查看名为 'vector' 的扩展是否已经被安装到当前数据库中
SELECT extname, extversion, extnamespace::regnamespace AS schema
FROM pg_extension
WHERE extname = 'vector';
-- 创建一个名为 vector_store 的表，用于存储您的向量数据。
CREATE TABLE IF NOT EXISTS vector_store
(
    id        uuid DEFAULT uuid_generate_v4() PRIMARY KEY,
    content   text,
    metadata  json,
    embedding vector(1536)
    );
-- 修改 vector_store 表中 embedding 列的定义。将向量列的期望维度从 1536 修改为 1024。这条语句是用来解决您上一个错误 "expected 1536 dimensions, not 1024" 的核心操作。它确保数据库的表结构与您的 Embedding Model (Ollama/DashScope) 实际生成的 1024 维向量相匹配。
ALTER TABLE vector_store
ALTER COLUMN embedding TYPE vector(1024);

public void add() {
    List<Document> documents = List.of(
            new Document("咖啡豆的最佳烘焙温度通常在 200°C 左右。"),
            new Document("今天的会议将在下午三点开始，主要讨论季度预算。"),
            new Document("大型语言模型（LLM）在自然语言处理领域取得了突破性进展。"),
            new Document("我最喜欢在清晨的湖边散步，那里的空气十分清新。"),
            new Document("红烧肉的秘诀在于小火慢炖和适量的冰糖。"),
            new Document("向量数据库是存储和检索高维向量数据的关键技术。"),
            new Document("如何通过梯度下降法优化神经网络的权重？"),
            new Document("制作美味拿铁的关键是牛奶的完美发泡。"),
            new Document("机器学习和深度学习是人工智能的两个主要分支。"),
            new Document("本年度的财务报告将于本周五前提交给董事会审阅。"));
    // 使用redis stack存储
    redisVectorStore.add(documents);
    // 使用pgvector 存储
    pgVectorStore.add(documents);
}

public Map<String, List<Document>> getAll(@RequestParam(name = "text", defaultValue = "AI 技术的核心发展方向是什么？") String text) {
    SearchRequest searchRequest = SearchRequest.builder().query(text).topK(2).build();
    redisVectorStore.similaritySearch(searchRequest);
    pgVectorStore.similaritySearch(searchRequest);
    HashMap<String, List<Document>> map = new HashMap<>();
    map.put("redisVectorStore", redisVectorStore.similaritySearch(searchRequest));
    map.put("pgVectorStore", pgVectorStore.similaritySearch(searchRequest));
    return map;
}

00000 系统OK正确执行后的返回
A0001 用户端错误一级宏观错误码
A0100 用户注册错误二级宏观错误码
B1111 支付接口超时
C2222 Kafka消息解压严重

@Configuration
public class InitVectorDatabaseConfig {
    @Resource
    @Qualifier("pgVectorStore")
    private VectorStore pgVectorStore;
    @Resource
    @Qualifier("redisVectorStore")
    private VectorStore redisVectorStore;
    private final RedisTemplate<String, String> redisTemplate;
    public InitVectorDatabaseConfig(RedisTemplate<String, String> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }
    // 这里是外挂知识库的位置
    @Value("classpath:/knowledge-base/ops.txt")
    private org.springframework.core.io.Resource opsFile;

    @PostConstruct
    public void init() {
        TextReader textReader = new TextReader(opsFile);
        textReader.setCharset(Charset.defaultCharset());
        List<Document> list = new TokenTextSplitter().transform(textReader.read());
        String sourceMetadata = (String) textReader.getCustomMetadata().get("source");
        String textHash = SecureUtil.md5(sourceMetadata);
        // 为 PostgreSQL 和 Redis 分别设置防重复键
        String pgRedisKey = "vector-pg:" + textHash;
        String redisRedisKey = "vector-redis:" + textHash;
        // PostgreSQL 防重复检查
        Boolean pgFlag = redisTemplate.opsForValue().setIfAbsent(pgRedisKey, "1");
        if (Boolean.TRUE.equals(pgFlag)) {
            pgVectorStore.add(list);
            System.out.println("PostgreSQL 向量数据初始化完成");
        } else {
            System.out.println("PostgreSQL 向量数据已存在，跳过初始化");
        }
        // Redis 防重复检查
        Boolean redisFlag = redisTemplate.opsForValue().setIfAbsent(redisRedisKey, "1");
        if (Boolean.TRUE.equals(redisFlag)) {
            redisVectorStore.add(list);
            System.out.println("Redis 向量数据初始化完成");
        } else {
            System.out.println("Redis 向量数据已存在，跳过初始化");
        }
    }
}

@Resource
@Qualifier("pgVectorStore")
private VectorStore pgVectorStore;
@Resource
@Qualifier("redisVectorStore")
private VectorStore redisVectorStore;
public Flux<String> redisRag(String code) {
    // 1. 定义系统角色和指令
    String systemInfo = """
            你是一个专业的运维工程师,你的任务是根据提供的编码给出对应故障解释。
            你必须严格根据检索到的知识库内容进行回答,如果知识库中找不到匹配的信息,则回复“抱歉,知识库中未找到该故障码的解释。”
            """;
    // 2. 配置检索增强 Advisor
    RetrievalAugmentationAdvisor advisor = RetrievalAugmentationAdvisor.builder()
            // 绑定知识库检索器：这里指定使用 RedisVectorStore 进行检索
            .documentRetriever(VectorStoreDocumentRetriever.builder().vectorStore(redisVectorStore).build())
            // 绑定知识库检索器：这里指定使用 PostgreSQLVectorStore 进行检索
            //.documentRetriever(VectorStoreDocumentRetriever.builder().vectorStore(pgVectorStore).build())
            .build();
    // 3. 构建并发送请求
    return chatClient
            .prompt()
            .system(systemInfo) // 设置系统角色
            .user(code)        // 用户提问 (即查询的错误码)
            .advisors(advisor) // 关键：注入 RAG 检索增强 Advisor
            .stream()
            .content();
}

public class DateTimeTools {
    /**
     * 获取当前系统时间。
     * @Tool 注解将此方法注册为可供大模型调用的工具。
     * returnDirect = false: 表示工具结果将返回给大模型进行总结和生成。
     */
    @Tool(description = "获取当前时间", returnDirect = false)
    public String getCurrentTime() {
        return LocalDateTime.now().toString();
    }
}

@RequestMapping("/tool")
public class ToolCallingController {
    @Resource
    private ChatModel qwenChatModel;
    @GetMapping("/model")
    public Flux<String> chat(@RequestParam(name = "question", defaultValue = "你是谁现在几点?") String question) {
        // 1. 工具注册到工具集合里（ToolCallbacks负责将Java对象转换为LLM可读的工具描述）
        ToolCallback[] tools = ToolCallbacks.from(new DateTimeTools());
        // 2. 将工具集配置进ChatOptions对象，启用工具调用模式
        ChatOptions options = ToolCallingChatOptions.builder().toolCallbacks(tools).build();
        // 3. 构建提示词，携带工具配置
        Prompt prompt = new Prompt(question, options);
        // 4. 调用大模型并流式处理结果
        // ChatModel 会自动处理工具调用循环：LLM返回调用指令 -> 应用执行工具 -> 应用将结果返回给LLM
        return qwenChatModel.stream(prompt).mapNotNull(
                chatResponse -> chatResponse.getResult().getOutput().getText()
        );
    }
    // ...
}

// ...
@Resource
private ChatClient qwenChatClient;
// ...
@GetMapping("/client")
public Flux<String> chat2(@RequestParam(name = "question", defaultValue = "你是谁现在几点?") String question) {
    return qwenChatClient.prompt(question)
            // 通过 tools() 方法直接传入工具实例
            .tools(new DateTimeTools()) 
            .stream()
            .content(); // 流式获取最终回答内容
}

<dependencies>
    <!--注意事项
        spring-ai-starter-mcp-server-webflux不能和<artifactId>spring-boot-starter-web</artifactId>依赖并存，
        否则会使用tomcat启动,而不是netty启动，从而导致mcpserver启动失败，但程序运行是正常的，mcp客户端连接不上。
    -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>
    <!--mcp-server-webflux-->
    <dependency>
        <groupId>org.springframework.ai</groupId>
        <artifactId>spring-ai-starter-mcp-server-webflux</artifactId>
    </dependency>
    <!--lombok-->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.38</version>
    </dependency>
    <!--hutool-->
    <dependency>
        <groupId>cn.hutool</groupId>
        <artifactId>hutool-all</artifactId>
        <version>5.8.22</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

spring:
  application:
    name: mcp-server
  ai:
    mcp:
      server:
        type: async
        name: mcp-server
        version: 1.0.0

/**
 * 城市旅游新闻服务：为AI Agent提供今日城市旅游头条信息。
 */
@Service
public class TourismNewsService {
    /**
     * 根据城市名称获取今日热门旅游头条新闻或活动信息。
     * * @param city 城市名称，如“北京”、“上海”、“深圳”
     *
     * @return 城市今日旅游头条新闻摘要
     */
    @Tool(description = "根据城市名称获取今日热门旅游头条新闻或活动信息")
    public String getCityTourismNews(String city) {
        // 使用 Map 模拟数据库或外部 API 返回的今日头条数据
        Map<String, String> newsMap = Map.of(
                "北京", "今日头条：故宫博物院启动秋季“清代宫廷生活艺术”特展，限量门票现已开放线上预约。",
                "上海", "今日头条：外滩举办国际艺术周，多家知名美术馆延长开放时间，黄浦江游船票预订火爆。",
                "深圳", "今日头条：欢乐谷主题公园推出五折特惠活动，庆祝深圳特区成立周年，吸引大量家庭出游。"
        );
        return newsMap.getOrDefault(city, "抱歉：未查询到该城市今日旅游热门新闻！");
    }
}

@Configuration
public class McpServerConfig {
  public final WeatherService weatherService;
  public final TourismNewsService tourismNewsService;
  public McpServerConfig(WeatherService weatherService,
                         TourismNewsService tourismNewsService) {
      this.weatherService = weatherService;
      this.tourismNewsService = tourismNewsService;
  }
  /**
   * 将工具方法暴露给外部 mcp client 调用
   *
   * @return ToolCallbackProvider
   */
  @Bean
  public ToolCallbackProvider weatherTools() {
      return MethodToolCallbackProvider.builder()
              .toolObjects(weatherService, tourismNewsService)
              // .toolObjects(tourismNewsService)
              .build();
  }
}

  <!-- 2.mcp-clent 依赖 -->
<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-starter-mcp-client</artifactId>
</dependency>

spring:
  application:
    name: mcp-client
  ai:
    dashscope:
      api-key: ${DASH_SCOPE_API_KEY}
      base-url: "https://dashscope.aliyuncs.com/compatible-mode/v1"
      chat:
        options:
          model: "qwen-plus-2025-09-11"
    mcp:
      client:
        type: async
        name: mcp-client
        version: 1.0.0
        request-timeout: 60s
        toolcallback:
          enabled: true
        sse:
          connections:
            # 你的服务端地址
            mcp-server1:
              url: http://localhost:801

@Configuration
public class SaaLLMConfig {
    @Bean
    public ChatClient chatClient(ChatModel chatModel, ToolCallbackProvider tools) {
        return ChatClient.builder(chatModel)
                .defaultToolCallbacks(tools.getToolCallbacks())
                .build();
    }
}

@Resource
private ChatClient chatClient;
public Flux<String> chat(@RequestParam(name = "question", defaultValue = "北京") String question) {
    return chatClient.prompt(question).stream().content();
}

{
  "mcpServers": {
    "postgres": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-postgres",
        "postgresql://postgres:[email protected]:5432/postgres"
      ],
      "env": {
        "PATH": "/home/ice/.nvm/versions/node/v22.21.1/bin:/usr/local/bin:/usr/bin:/bin"
      }
    }
  }
}

spring:
  application:
    name: mcp-client
  ai:
    dashscope:
      api-key: ${DASH_SCOPE_API_KEY}
      chat:
        options:
          model: "qwen-plus-2025-09-11"
    mcp:
      client:
        request-timeout: 60s
        toolcallback:
          enabled: true
        stdio:
          # 刚刚的json 文件位置
          servers-configuration: classpath:/mcp.json
        enabled: true
        root-change-notification: true

@Configuration
public class SaaLLMConfig {
    @Bean
    public ChatClient chatClient(ChatModel chatModel, ToolCallbackProvider tools) {
        return ChatClient.builder(chatModel)
                //mcp协议，配置见yml文件，此处只赋能给ChatClient对象
                .defaultToolCallbacks(tools.getToolCallbacks())
                .build();
    }
}

public Flux<String> chat(String question) {
    return chatClient.prompt(question).stream().content();
}