解锁RAG与Spring AI的实战应用（万字详细教学与完整步骤流程实践）

<dependency>
  <groupId>org.springframework.ai</groupId>
  <artifactId>spring-ai-markdown-document-reader</artifactId>
  <version>1.0.0-M6</version>
</dependency>

@Component
@Slf4j
class TravelAppDocumentLoader {
    private final ResourcePatternResolver resourcePatternResolver;                                  TravelAppDocumentLoader(ResourcePatternResolver resourcePatternResolver) {                          this.resourcePatternResolver = resourcePatternResolver;
                                                                                                                                                                             }
    public List<Document> loadMarkdowns() {
        List<Document> allDocuments = new ArrayList<>();
        try {
            // 这里可以修改为你要加载的多个 Markdown 文件的路径模式
            Resource[] resources =
            resourcePatternResolver.getResources("classpath:document/*.md");
            for (Resource resource : resources) {
                String fileName = resource.getFilename();
                MarkdownDocumentReaderConfig config = MarkdownDocumentReaderConfig.builder()                        .withHorizontalRuleCreateDocument(true)
                .withIncludeCodeBlock(false)
                .withIncludeBlockquote(false)
                .withAdditionalMetadata("filename", fileName)
                .build();
                MarkdownDocumentReader reader = new MarkdownDocumentReader(resource, config);
                allDocuments.addAll(reader.get());
            }
        } catch (IOException e) {
            log.error("Markdown 文档加载失败", e);
        }
        return allDocuments;
    }
}

@SpringBootTest
class TravelAppDocumentLoaderTest {
    @Resource
    private TravelAppDocumentLoader travelAppDocumentLoader;
    @Test
    void loadMarkdowns() {
        travelAppDocumentLoader.loadMarkdowns();
    }
}

allDocuments.addAll(reader.get());

@Configuration
public class TravelAppVectorStoreConfig {
    @Resource
    private TravelAppDocumentLoader travelAppDocumentLoader;
    @Bean
    //注意这里的EmbeddingModel导入的是Spring AI的
    VectorStore travelAppVectorStore(EmbeddingModel dashscopeEmbeddingModel){
        SimpleVectorStore simpleVectorStore =
        SimpleVectorStore.builder(dashscopeEmbeddingModel).build();
        List<Document> documentList = travelAppDocumentLoader.loadMarkdowns();
        simpleVectorStore.add(documentList);
        return simpleVectorStore;
    }
}

//知识库问答功能
@Resource
private VectorStore travelAppVectorStore;
/**
* RAG知识库进行对话
* @param message
* @param chatId
* @return
*/
public String doChatWithRag(String message,String chatId){
    ChatResponse chatResponse = chatClient
    .prompt()
    .user(message)
    .advisors(spec -> spec.param(CHAT_MEMORY_CONVERSATION_ID_KEY,chatId)
              .param(CHAT_MEMORY_RETRIEVE_SIZE_KEY,10))
    //开启日志顾问，观察效果
    .advisors(new MyLoggerAdvisor())
    //应用RAG知识库进行问答
    .advisors(new QuestionAnswerAdvisor(travelAppVectorStore))
    .call()
    .chatResponse();
    String content = chatResponse.getResult().getOutput().getText();
    log.info("content: {}",content);
    return content;
}

@Test
void doChatWithRag() {
    String chatId = UUID.randomUUID().toString();
    String message ="我的预算不多，只有500块钱怎么规划才能穷游3天";
    String answer = travelApp.doChatWithRag(message, chatId);
    Assertions.assertNotNull(answer);
}

/**
 * 自定义基于阿里云知识库服务的 RAG 增强顾问
 */
@Configuration
@Slf4j
public class TravelAppRagCloudAdvisorConfig {

    @Value("${spring.ai.dashscope.api-key}")
    private String dashScopeApiKey;

    @Bean
    public Advisor loveAppRagCloudAdvisor() {
        DashScopeApi dashScopeApi = new DashScopeApi(dashScopeApiKey);
        final String KNOWLEDGE_INDEX = "AI旅游规划大师";
        DocumentRetriever dashScopeDocumentRetriever = new DashScopeDocumentRetriever(dashScopeApi,
                                                                                      DashScopeDocumentRetrieverOptions.builder()
                                                                                      .withIndexName(KNOWLEDGE_INDEX)
                                                                                      .build());
        return RetrievalAugmentationAdvisor.builder()
        .documentRetriever(dashScopeDocumentRetriever)
        .build();
    }
}

@Resource
private Advisor travelAppRagCloudAdvisor;
public String doChatWithRag(String message,String chatId){
    ChatResponse chatResponse = chatClient
    .prompt()
    .user(message)
    .advisors(spec -> spec.param(CHAT_MEMORY_CONVERSATION_ID_KEY,chatId)
              .param(CHAT_MEMORY_RETRIEVE_SIZE_KEY,10))
    //开启日志顾问，观察效果
    .advisors(new MyLoggerAdvisor())
    //本地RAG和云知识库开启一个就好了
    //应用本地RAG知识库进行问答
    .advisors(new QuestionAnswerAdvisor(travelAppVectorStore))
    //应用RAG检索增强服务（基于阿里云知识库服务进行问答）
    .advisors(travelAppRagCloudAdvisor) 
    .call()
    .chatResponse(); 
    String content = chatResponse.getResult().getOutput().getText();
    log.info("content: {}",content);
    return content;
}

<dependency>
  <groupId>org.springframework.ai</groupId>
  <artifactId>spring-ai-starter-vector-store-pgvector</artifactId>
  <version>1.0.0-M7</version>
</dependency>

spring: 
    datasource:
        url: jdbc:postgresql://改为你的公网地址/yu_ai_agent
        username: 改为你的用户名
        password: 改为你的密码
    ai:
        vectorstore:
        pgvector:
        index-type: HNSW
        dimensions: 1536
        distance-type: COSINE_DISTANCE
        max-document-batch-size: 10000 # Optional: Maximum number of documents per batch

<!--        手动整合向量数据库-->
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<dependency>
  <groupId>org.postgresql</groupId>
  <artifactId>postgresql</artifactId> 
  <scope>runtime</scope>
</dependency>
<dependency>
  <groupId>org.springframework.ai</groupId>
  <artifactId>spring-ai-pgvector-store</artifactId>
  <version>1.0.0-M6</version>
</dependency>

@Configuration
public class PgVectorVectorStoreConfig {
    @Resource
    private TravelAppDocumentLoader travelAppDocumentLoader;
    @Bean
    public VectorStore pgVectorVectorStore(JdbcTemplate jdbcTemplate, EmbeddingModel
                                           dashscopeEmbeddingModel){
        PgVectorStore vectorStore = PgVectorStore.builder(jdbcTemplate,
                                                          dashscopeEmbeddingModel)
        .dimensions(1536)           // Optional: defaults to model dimensions or 1536 
        .distanceType(COSINE_DISTANCE)      // Optional: defaults to COSINE_DISTANCE
        .indexType(HNSW)                    // Optional: defaults to HNSW
        .initializeSchema(true)             // Optional: defaults to false
        .schemaName("public")                // Optional: defaults to "public"
        .vectorTableName("vector_store")     // Optional: defaults to "vector_store"
        .maxDocumentBatchSize(10000)         // Optional: defaults to 10000
        .build();
        return vectorStore;
    }
}

@SpringBootTest
class PgVectorVectorStoreConfigTest {
    @Resource 
    private VectorStore pgVectorVectorStore;
    @Test 
    void pgVectorVectorStore() {  
        List<Document> documents = List.of(  
            new Document("我是小楼，很高兴认识你", Map.of("meta1", "meta1")),  
            new Document("旅游如何预订景点"),
            new Document("有什么美食推荐", Map.of("meta2", "meta2")));
        // 添加文件 
        pgVectorVectorStore.add(documents);
        // 相似度查询 
        List<Document> results = 
        this.pgVectorVectorStore.similaritySearch(SearchRequest.builder().query("我是谁，阿巴阿巴").topK(3).build()); 
    }
}

@SpringBootApplication(exclude = {
    // 为了便于大家开发调试和部署，取消数据库自动配置，需要使用 PgVector 时把 DataSourceAutoConfiguration.class 删除
    DataSourceAutoConfiguration.class
})
public class DogAiAgentApplication {
    public static void main(String[] args) {
        SpringApplication.run(DogAiAgentApplication.class, args);}
}

@Resource
private VectorStore pgVectorVectorStore;
//本地RAG和云知识库开启一个就好了
//应用本地RAG知识库进行问答
//                .advisors(new QuestionAnswerAdvisor(travelAppVectorStore))
//应用RAG检索增强服务（基于阿里云知识库服务进行问答）
//                .advisors(travelAppRagCloudAdvisor) 
//应用RAG检索增强服务（基于PGVector向量存储）
.advisors(new QuestionAnswerAdvisor(pgVectorVectorStore))

//载入文档
List<Document> documents =travelAppDocumentLoader.loadMarkdowns();
vectorStore.add(documents);
return vectorStore;

/**
* 自定义基于token的切词器
*/
@Component
class MyTokenTextSplitter {
    public List<Document> splitDocuments(List<Document> documents) {
        TokenTextSplitter splitter = new TokenTextSplitter();
        return splitter.apply(documents);
    }
    public List<Document> splitCustomized(List<Document> documents) {
        TokenTextSplitter splitter = new TokenTextSplitter(200, 100, 10, 5000, true); 
        return splitter.apply(documents);
    }
}

@Resource
private MyTokenTextSplitter myTokenTextSplitter;
@Bean
VectorStore travelAppVectorStore(EmbeddingModel dashscopeEmbeddingModel){
SimpleVectorStore simpleVectorStore =
SimpleVectorStore.builder(dashscopeEmbeddingModel).build();
//加载文档
List<Document> documentList = travelAppDocumentLoader.loadMarkdowns();
//自主切分文档
List<Document> splitDocuments = myTokenTextSplitter.splitCustomized(documentList);
simpleVectorStore.add(splitDocuments);
return simpleVectorStore;
}

//提取文档状态作为标签
String status = filename.substring(filename.length() - 6, filename.length() - 3);
MarkdownDocumentReaderConfig config = MarkdownDocumentReaderConfig.builder()
.withHorizontalRuleCreateDocument(true)
.withIncludeCodeBlock(false)   
.withIncludeBlockquote(false)    
.withAdditionalMetadata("filename", filename) 
.withAdditionalMetadata("status", status)

@Component
public class MyKeywordEnricher { 
    @Resource  
    private ChatModel dashscopeChatModel; 
    List<Document> enrichDocuments(List<Document> documents){       
        KeywordMetadataEnricher enricher = new 
        KeywordMetadataEnricher(this.dashscopeChatModel,5); 
        return enricher.apply(documents);  
    }   
}

@Bean
VectorStore travelAppVectorStore(EmbeddingModeldashscopeEmbeddingModel){    
    SimpleVectorStore simpleVectorStore = 
    SimpleVectorStore.builder(dashscopeEmbeddingModel).build();    
    //加载文档   
    List<Document> documentList = travelAppDocumentLoader.loadMarkdowns();   
    //自主切分文档//     
    List<Document> splitDocuments = myTokenTextSplitter.splitCustomized(documentList);  
    //自动补充关键词元信息     
    List<Document> enrichedDocuments = myKeywordEnricher.enrichDocuments(documentList);  
    simpleVectorStore.add(enrichedDocuments);   
    return simpleVectorStore;
}

@Component
public class MultiQueryExpanderDemo {
    private final ChatClient.Builder chatClientBuilder; 
    public MultiQueryExpanderDemo(ChatModel dashscopeChatModel) {  
        this.chatClientBuilder = ChatClient.builder(dashscopeChatModel); 
    }  
    public List<Query> expand(String query) {  
        MultiQueryExpander queryExpander = MultiQueryExpander.builder() 
        .chatClientBuilder(chatClientBuilder)  
        .numberOfQueries(3)     
        .build();
        List<Query> queries = queryExpander.expand(new Query("谁是小楼？"));   
        return queries; 
    }
}

@SpringBootTest
class MultiQueryExpanderDemoTest { 
    @Resource 
    private MultiQueryExpanderDemo multiQueryExpanderDemo; 
    @Test 
    void expand() { 
        List<Query> queries = multiQueryExpanderDemo.expand("谁是小楼？搞快点回答我谢谢");     
        Assertions.assertNotNull(queries); 
    }
}

/**
* 查询重写器
*/
@Component
public class QueryRewriter { 
    private final QueryTransformer queryTransformer;  
    public QueryRewriter(ChatModel dashscopeChatModel) { 
        ChatClient.Builder builder = ChatClient.builder(dashscopeChatModel);   
        queryTransformer = RewriteQueryTransformer.builder()   
        .chatClientBuilder(builder)    
        .build(); 
    } 
    public String doQueryRewriter(String prompt){ 
        Query query = new Query(prompt);  
        //执行查询重写    
        Query transformedQuery = queryTransformer.transform(query);  
        //输出重写后的查询  
        return transformedQuery.text();  
    }
}

@Resource
private QueryRewriter queryRewriter;
public String doChat(String message,String chatId){
    //查询重写
    String rewrittenMessage = queryRewriter.doQueryRewriter(message); 
    ChatResponse chatResponse = chatClient   
    .prompt()     
    //使用改写后的查询信息   
    .user(rewrittenMessage)

/**
* 创建自定义RAG检索增强顾问工厂
*/
public class TravelAppRagCustomAdvisorFactory { 
    public static Advisor createTravelAppRagCustomAdvisorFactory(VectorStore vectorStore, 
                                                                 String status){ 
        //过滤特定状态的文档 
        Filter.Expression expression = new FilterExpressionBuilder()   
        .eq("status", status) 
        .build();    
        DocumentRetriever documentRetriever = VectorStoreDocumentRetriever.builder()  
        .vectorStore(vectorStore)
        .filterExpression(expression) // 过滤条件 
        .similarityThreshold(0.5) // 相似度阈值
        .topK(3) // 返回文档数量 
        .build();   
        return RetrievalAugmentationAdvisor.builder()  
        .documentRetriever(documentRetriever)
        //                .queryAugmenter()
        .build(); 
    }
}

advisors(
    TravelAppRagCustomAdvisorFactory.createTravelAppRagCustomAdvisorFactory(
        travelAppVectorStore,"钱" 
    )

public class TravelAppContextualQueryAugmenterFactory {
    public static ContextualQueryAugmenter createInstance(){
        PromptTemplate emptyContextPromptTemplate = new PromptTemplate("""你应该输出下面的内             容： 抱歉，我只能回答旅游规划相关的问题，别的没办法帮到您嘞，请见谅，有问题可以联系人工客服                 """);
        return ContextualQueryAugmenter.builder()
        .allowEmptyContext(false)
        .emptyContextPromptTemplate(emptyContextPromptTemplate)
        .build();
    }
}

.queryAugmenter(TravelAppContextualQueryAugmenterFactory.createInstance())

// advisors(
//     TravelAppRagCustomAdvisorFactory.createTravelAppRagCustomAdvisorFactory(
//         travelAppVectorStore,"钱" 
//     )