Java程序员必看的RAG入门教程

RAG = 检索（Retrieval） + 增强（Augmented） + 生成（Generation）

import org.springframework.ai.rag.preretrieval.query.transformation.RewriteQueryTransformer;
import org.springframework.ai.chat.client.ChatClient;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
publicclass QueryRewriteConfig {
    
    @Bean
    public QueryTransformer queryTransformer(ChatClient.Builder builder) {
        String promptTemplate = """
            你是一个专业的查询改写助手。请将用户的原始问题改写为更清晰、更完整的独立查询。
            
            改写原则：
            1. 将口语表达转为书面表达
            2. 补全缺失的上下文信息（如代词指代）
            3. 使用知识库中常用的专业术语
            4. 保持查询的原始意图不变
            
            原始问题：{original_query}
            改写后的查询：
            """;
        
        return RewriteQueryTransformer.builder()
            .chatClientBuilder(builder)
            .promptTemplate(promptTemplate)
            .targetSearchSystem("vector_store")
            .build();
    }
}

import org.springframework.ai.rag.retrieval.search.HybridDocumentRetriever;
import org.springframework.ai.rag.retrieval.join.JoinDocumentJoiner;
import org.springframework.ai.rag.retrieval.search.VectorStoreDocumentRetriever;
import org.springframework.ai.rag.retrieval.search.KeywordDocumentRetriever;

@Configuration
publicclass HybridSearchConfig {
    
    @Bean
    public DocumentRetriever hybridRetriever(VectorStore vectorStore) {
        // 向量检索器
        VectorStoreDocumentRetriever vectorRetriever = VectorStoreDocumentRetriever.builder()
            .vectorStore(vectorStore)
            .similarityThreshold(0.7)
            .topK(10)
            .build();
        
        // 关键词检索器（需要先对文档建立BM25索引）
        KeywordDocumentRetriever keywordRetriever = KeywordDocumentRetriever.builder()
            .indexName("knowledge_base")
            .topK(10)
            .build();
        
        // 混合检索：使用 Reciprocal Rank Fusion 融合结果
        return HybridDocumentRetriever.builder()
            .retrievers(List.of(vectorRetriever, keywordRetriever))
            .joiner(JoinDocumentJoiner.reciprocalRankFusion())
            .build();
    }
}

import org.springframework.ai.rag.postretrieval.reranking.DiversityReranker;
import org.springframework.ai.rag.postretrieval.reranking.CompressionReranker;
import org.springframework.ai.rag.retrieval.search.DocumentRetriever;
import org.springframework.ai.rag.retrieval.search.VectorStoreDocumentRetriever;

@Configuration
publicclass RerankingConfig {
    
    @Bean
    public DocumentRetriever rerankedRetriever(VectorStore vectorStore, 
                                               ChatClient chatClient) {
        // 基础向量检索器，召回20个候选
        VectorStoreDocumentRetriever baseRetriever = VectorStoreDocumentRetriever.builder()
            .vectorStore(vectorStore)
            .topK(20)  // 多召回一些候选
            .build();
        
        // 重排序器1：多样性重排（避免返回的内容过于相似）
        DiversityReranker diversityReranker = DiversityReranker.builder()
            .minDegree(0.5)  // 最小多样性阈值
            .build();
        
        // 重排序器2：压缩重排（用LLM提取最相关片段，可减少上下文长度）
        CompressionReranker compressionReranker = CompressionReranker.builder()
            .chatClient(chatClient)
            .maxOutputTokens(500)
            .build();
        
        // 组合使用：先多样性重排，再压缩重排
        return baseRetriever.andThen(diversityReranker).andThen(compressionReranker);
    }
}

import org.springframework.ai.rag.preretrieval.query.expansion.MultiQueryExpander;

@Configuration
publicclass MultiVectorConfig {
    
    @Bean
    public QueryExpander multiQueryExpander(ChatClient.Builder builder) {
        String expansionPrompt = """
            请将以下用户问题扩展为2-4个不同的子查询，每个子查询从不同角度表述，以覆盖更全面的信息。
            子查询之间用换行分隔。
            
            用户问题：{original_query}
            
            扩展的子查询：
            """;
        
        return MultiQueryExpander.builder()
            .chatClientBuilder(builder)
            .promptTemplate(expansionPrompt)
            .numberOfQueries(3)  // 生成3个子查询
            .build();
    }
}

@Service
publicclass AdvancedRagService {
    
    @Autowired
    private QueryExpander queryExpander;      // 查询扩展
    @Autowired
    private DocumentRetriever hybridRetriever; // 混合检索器
    @Autowired
    private Reranker reranker;                 // 重排序器
    
    public String ask(String question) {
        // 1. 查询重写
        String rewritten = rewriteQuery(question);
        
        // 2. 多向量扩展（生成多个子查询）
        List<String> subQueries = queryExpander.expand(rewritten);
        
        // 3. 对每个子查询进行混合检索
        List<Document> allDocs = new ArrayList<>();
        for (String sq : subQueries) {
            allDocs.addAll(hybridRetriever.retrieve(sq));
        }
        
        // 4. 去重 + 重排序
        List<Document> uniqueDocs = deduplicate(allDocs);
        List<Document> reranked = reranker.rerank(uniqueDocs, question);
        
        // 5. 组装Prompt并生成答案
        return generateAnswer(question, reranked);
    }
}

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

@Configuration
publicclass RagConfig {
    
    @Bean
    public ChatClient chatClient(ChatClient.Builder builder) {
        return builder
            .defaultSystem("你是一个专业的智能问答助手，请基于提供的参考资料回答问题。")
            .build();
    }
    
    @Bean
    public VectorStore vectorStore(EmbeddingModel embeddingModel) {
        // 示例：使用内存存储（适合原型验证）
        SimpleVectorStore simpleVectorStore = SimpleVectorStore.builder(embeddingModel).build();
        return simpleVectorStore;
        // 生产环境可替换为 MilvusVectorStore、PgVectorStore 等
    }
    
    @Bean
    public EmbeddingModel embeddingModel() {
        returnnew DashScopeEmbeddingModel(
            DashScopeEmbeddingOptions.builder()
                .withModel("text-embedding-v3")
                .build()
        );
    }
}

@Service
publicclass KnowledgeBaseService {
    
    @Autowired
    private VectorStore vectorStore;
    
    @Autowired
    private EmbeddingModel embeddingModel;
    
    public void indexDocument(String content) {
        // 1. 文档切分
        List<Document> chunks = DocumentSplitter.recursive(500, 100).split(content);
        
        // 2. 向量化并存储
        vectorStore.add(chunks);
        
        System.out.println("已索引 " + chunks.size() + " 个文档块");
    }
}

@RestController
@RequestMapping("/api/rag")
publicclass RagController {
    
    @Autowired
    private ChatClient chatClient;
    
    @Autowired
    private VectorStore vectorStore;
    
    @PostMapping("/ask")
    public String ask(@RequestParam String question) {
        // 使用 QuestionAnswerAdvisor 自动完成检索增强
        return chatClient.prompt()
                .user(question)
                .advisors(new QuestionAnswerAdvisor(vectorStore))
                .call()
                .content();
    }
}