Spring AI Alibaba 集成 Redis 向量数据库实现 RAG 与记忆功能

1.2 配置文件（application.yml）

spring:
  data:
    redis:
      host: localhost
      port: 6379
      password: 123456
  lettuce:
    pool:
      max-active: 16
      max-idle: 8
      min-idle: 4
      timeout: 2000ms
  servlet:
    multipart:
      max-file-size: 100MB
      max-request-size: 100MB
application:
  name: Roadnetworktraffic
ai:
  vectorstore:
    redis:
      initialize-schema: true
      index-name: custom-index
      prefix: custom-prefix
  dashscope:
    embedding:
      baseUrl: https://dashscope.aliyuncs.com # 向量模型
      api-key: your-api-key-here
      options:
        model: text-embedding-v4
    api-key: your-api-key-here
    base-url: https://dashscope.aliyuncs.com/compatible-mode/v1
    chat:
      options:
        model: qwen-flash

关键配置说明：

• spring.data.redis：Redis 连接配置，用于向量存储和记忆存储
• spring.ai.vectorstore.redis：向量存储的 Redis 索引配置
• spring.ai.dashscope：通义千问模型配置，包括嵌入模型和对话模型

二、核心组件实现

2.1 Redis 记忆存储配置

@Configuration
public class RedisMemoryConfig {
    @Value("${spring.data.redis.host}")
    private String host;

    @Value("${spring.data.redis.port}")
    private int port;

    @Value("${spring.data.redis.password}")
    private String password;

    @Bean
    public RedisChatMemoryRepository redisChatMemoryRepository() {
        return RedisChatMemoryRepository.builder()
                .host(host)
                .password(password)
                .port(port)
                .build();
    }
}

功能说明：

• 通过 @Value 注入配置文件中的 Redis 连接参数
• 创建 RedisChatMemoryRepository Bean，用于存储对话历史
• 支持多会话隔离，每个会话 ID 对应独立的记忆存储

2.2 多模型配置（DeepSeek + Qwen）

@Configuration
public class SaaLLMConfig {
    @Value("${spring.ai.dashscope.api-key}")
    private String apiKey;

    // 模型名称常量
    private final String DEEPSEEK_MODEL = "deepseek-v3.2";
    private final String QWEN_MODEL = "qwen-flash";

    @Bean(name = "deepseek")
    public ChatClient deepSeek(RedisChatMemoryRepository redisChatMemoryRepository) {
        DashScopeChatModel dashScopeChatModel = DashScopeChatModel.builder()
                .dashScopeApi(DashScopeApi.builder().apiKey(apiKey).build())
                .defaultOptions(DashScopeChatOptions.builder().withModel(DEEPSEEK_MODEL).build())
                .build();
        return ChatClient.builder(dashScopeChatModel)
                .defaultAdvisors(MessageChatMemoryAdvisor.builder(
                        MessageWindowChatMemory.builder()
                                .chatMemoryRepository(redisChatMemoryRepository)
                                .maxMessages(10)
                                .build()).build())
                .defaultOptions(ChatOptions.builder().model(DEEPSEEK_MODEL).build())
                .build();
    }

    @Bean(name = "qwen")
    public ChatClient qwen(RedisChatMemoryRepository redisChatMemoryRepository) {
        DashScopeChatModel dashScopeChatModel = DashScopeChatModel.builder()
                .dashScopeApi(DashScopeApi.builder().apiKey(apiKey).build())
                .defaultOptions(DashScopeChatOptions.builder().withModel(QWEN_MODEL).build())
                .build();
        return ChatClient.builder(dashScopeChatModel)
                .defaultAdvisors(MessageChatMemoryAdvisor.builder(
                        MessageWindowChatMemory.builder()
                                .chatMemoryRepository(redisChatMemoryRepository)
                                .maxMessages(10)
                                .build()).build())
                .defaultOptions(ChatOptions.builder().model(QWEN_MODEL).build())
                .build();
    }
}

核心特性：

• 多模型支持：通过 @Qualifier 和 @Bean(name) 实现多模型注入
• 记忆集成：每个模型都配置了 MessageChatMemoryAdvisor，自动管理对话历史
• 记忆窗口：maxMessages(10) 限制每个会话最多保留 10 条消息，避免内存溢出

2.3 文档加载与向量存储

2.3.1 文档加载器

@Slf4j
@Component
public class AppDocumentLoader {
    @Value("classpath:/prompt/Gompt.txt")
    private Resource opsFile;

    public List<Document> loadMarkdowns() {
        TextReader textReader = new TextReader(opsFile);
        textReader.setCharset(Charset.defaultCharset());
        // 使用 TokenTextSplitter 进行文本分割
        List<Document> list = new TokenTextSplitter().transform(textReader.read());
        return list;
    }
}

关键点：

• 使用 TextReader 读取本地文档（支持多种格式）
• TokenTextSplitter 对长文本进行分块，便于向量化
• 返回 Document 列表，每个文档包含内容和元数据

2.3.2 向量存储 Bean

@Configuration
public class VectorStoreBean {
    @Resource
    private AppDocumentLoader appDocumentLoader;

    @Resource
    private EmbeddingModel embeddingModel;

    @Bean
    public VectorStore vectorStore() {
        // 创建 SimpleVectorStore（底层使用 Redis）
        VectorStore build = SimpleVectorStore.builder(embeddingModel).build();
        // 加载文档并添加到向量库
        List<Document> documents = appDocumentLoader.loadMarkdowns();
        build.add(documents);
        return build;
    }
}

RAG 核心流程：

1. 通过 SimpleVectorStore.builder() 创建向量存储实例
2. 调用 appDocumentLoader.loadMarkdowns() 加载本地文档
3. 使用 build.add(documents) 将文档向量化并存储到 Redis
4. 应用启动时自动完成知识库构建

三、RESTful API 实现

3.1 控制器层

@RestController
@RequestMapping("/aichat/stream")
@Slf4j
public class AiController {
    @Qualifier("deepseek")
    @Autowired
    private ChatClient deepseekModel;

    @Qualifier("qwen")
    @Autowired
    private ChatClient qwenModel;

    @Autowired
    private VectorStore vectorStore;

    @Value("classpath:/prompt/story-prompt.txt")
    private Resource storyPrompt;

    @GetMapping(value = "/deepseek")
    public Flux<String> chatDeepseek(@RequestParam String sessionId, @RequestParam String userContent) {
        return deepseekModel.prompt()
                .system(storyPrompt) // 系统提示词
                .user(userContent) // 用户输入
                .advisors(message -> {
                    // 设置会话 ID，用于记忆隔离
                    if (message != null) {
                        message.param(CONVERSATION_ID, sessionId);
                    }
                })
                .advisors(RetrievalAugmentationAdvisor.builder()
                        .documentRetriever(VectorStoreDocumentRetriever.builder()
                                .vectorStore(vectorStore)
                                .build())
                        .build())
                .stream() // 流式输出
                .content()
                .doOnError(e -> log.error("Stream error: " + e.getMessage()));
    }

    @GetMapping("/qwen")
    public Flux<String> chatQwen(@RequestParam String sessionId, @RequestParam String userContent) {
        return qwenModel.prompt()
                .system(storyPrompt)
                .user(userContent)
                .advisors(message -> {
                    if (message != null) {
                        message.param(CONVERSATION_ID, sessionId);
                    }
                })
                .stream()
                .content()
                .doOnError(e -> log.error("Stream error: " + e.getMessage()));
    }
}

API 特性：

核心功能实现：

1. RAG 检索增强：
   • 通过 RetrievalAugmentationAdvisor 集成向量检索
   • 用户提问时，自动从向量库检索相关文档片段
   • 将检索结果作为上下文注入到模型提示词中
2. 记忆管理：
   • message.param(CONVERSATION_ID, sessionId) 设置会话标识
   • 同一会话 ID 的对话会共享历史上下文
   • 支持多用户、多会话并行处理
3. 流式响应：
   • 使用 .stream() 返回 Flux<String> 实现流式输出
   • 支持 SSE（Server-Sent Events）协议，前端可实时接收

四、RAG 与记忆功能原理解析

4.1 检索增强生成（RAG）工作流程

用户提问 → 向量化查询 → Redis 向量库相似度检索 → 获取 top-k 相关文档 ↓ 构建提示词（系统提示 + 检索文档 + 历史对话 + 用户问题） ↓ 调用 AI 模型生成 → 返回响应 

检索过程：

• 用户输入的问题被 text-embedding-v4 模型向量化
• 在 Redis 向量索引中执行相似度搜索（默认使用余弦相似度）
• 返回最相关的文档片段作为上下文

4.2 对话记忆实现机制

Spring AI 通过 ChatMemory 抽象层管理对话状态：

// 记忆存储接口
public interface ChatMemory {
    void add(ChatMessage message);
    List<ChatMessage> getMessages();
    void clear();
}

// Redis 实现
public class RedisChatMemory implements ChatMemory {
    // 使用 Redis 存储，key 格式：memory:sessionId
}

记忆存储结构：

• 每个会话 ID 对应一个独立的 Redis key
• 使用 List 结构存储消息序列
• 支持 LRU 淘汰策略（通过 maxMessages 控制）

4.3 向量存储底层实现

SimpleVectorStore 底层使用 Redis 作为存储引擎：

public class RedisVectorStore implements VectorStore {
    // 使用 RedisSearch 模块创建向量索引
    public void createIndex(String indexName, VectorFieldSchema fieldSchema) {
        // 创建 HNSW 索引 FT.CREATE indexName ...
    }

    public void add(List<Document> documents) {
        // 调用 embeddingModel 生成向量
        List<Float> vector = embeddingModel.embed(document.getContent());
        // 存储到 Redis Hash
        redis.hset(key, "vector", vector, "content", content);
    }
}

技术栈：

• Redis 7.0+ 支持向量搜索（需启用 RedisSearch 模块）
• HNSW（Hierarchical Navigable Small World）索引算法
• 支持余弦相似度、欧氏距离等多种相似度计算

五、部署与测试

5.1 环境要求

• JDK 17+
• Redis 7.0+（需启用 RedisSearch 模块）
• Maven 3.6+
• 通义千问 API Key（用于模型调用）

5.2 Redis 配置

启动 Redis 时需启用模块：

redis-server --loadmodule /path/to/redisearch.so 

或使用 Docker：

docker run -p 6379:6379 redislabs/redisearch:latest 

5.3 应用启动

mvn clean package java -jar target/your-app.jar 

5.4 API 测试

测试 RAG 功能：

# 测试 DeepSeek 模型（带 RAG）
curl "http://localhost:8080/aichat/stream/deepseek?sessionId=test123&userContent=什么是 GIS？"
# 测试 Qwen 模型（不带 RAG）
curl "http://localhost:8080/aichat/stream/qwen?sessionId=test123&userContent=你好"

测试记忆功能：

# 第一次对话
curl "http://localhost:8080/aichat/stream/deepseek?sessionId=user1&userContent=我叫张三"
# 第二次对话（会记住上下文）
curl "http://localhost:8080/aichat/stream/deepseek?sessionId=user1&userContent=我的名字是什么？"

六、常见问题与优化建议

6.1 性能优化

向量检索优化：

• 调整 HNSW 索引参数（M、ef_construction）
• 使用 GPU 加速嵌入模型计算
• 对文档进行预处理（去重、关键信息提取）

内存优化：

• 合理设置 maxMessages，避免内存泄漏
• 使用 Redis 集群分担存储压力
• 定期清理过期会话

6.2 功能扩展

多知识库支持：

@Bean(name = "vectorStoreA")
public VectorStore vectorStoreA() {
    ...
}

@Bean(name = "vectorStoreB")
public VectorStore vectorStoreB() {
    ...
}
// 根据业务场景选择不同的向量库

混合检索策略：

• 结合关键词检索 + 向量检索
• 实现多路召回 + 重排序
• 支持元数据过滤（文档来源、时间范围等）

6.3 监控与日志

• 集成 Spring Boot Actuator 监控指标
• 记录向量检索耗时、模型调用延迟
• 设置告警阈值（如响应时间 > 3s）

七、总结

本文通过完整可运行的代码示例，详细介绍了 Spring AI Alibaba 集成 Redis 向量数据库实现 RAG 和记忆功能的完整方案。核心要点包括：

1. 配置简化：Spring AI 提供了声明式配置，大幅降低集成复杂度
2. 开箱即用：向量存储、记忆管理、模型调用等组件可快速集成
3. 生产就绪：支持流式响应、多会话隔离、性能优化等生产特性
4. 扩展性强：支持多模型、多知识库、自定义检索策略

该方案适用于智能客服、知识问答、文档检索等多种 AI 应用场景，具备良好的可维护性和扩展性。

注意事项：

• 确保 Redis 已安装并启用 RedisSearch 模块
• 替换配置文件中的 API Key 为实际值
• 根据业务需求调整向量索引参数和记忆窗口大小

通过本文的实践，您可以快速构建具备 RAG 和记忆能力的 AI 应用，提升用户体验和回答准确性。