LangChain4j开发RAG入门示例

本文将详细介绍如何基于Java语言，使用Langchain4j开源框架、Milvus向量数据、阿里Qwen大模型，开发一个RAG入门级简单示例。本示例虽然简单，但涉及到多个知识点，包括：Milvus初始化、Embedding模型、文档切片、Springboot集成Langchain4j、Langchain4j调用Qwen大模型等。

1、前提条件

• JDK为17以上版本，本人使用的jdk21版本；
• SpringBoot版本为3.x以上，本项目使用的是SpringBoot 3.4.0版本；
• 本文采用了阿里巴巴的Qwen大模型进行实验与验证，但您同样可以选择使用DeepSeek大模型作为替代方案。若选用阿里巴巴的AI服务，则需首先在阿里云平台上开通相应的大型模型服务，并获取所需的API密钥，以便在后续代码中调用。具体的开通与配置步骤，请参阅阿里云大模型服务平台“百炼”的相关文档和指南如何获取API Key_大模型服务平台百炼(Model Studio)-阿里云帮助中心。这样可以确保您能够顺利地集成和使用这些先进的AI资源。
• 提前安装部署好Milvus数据库，本文示例使用的Milvus2.5.4版本

2、创建springboot工程

本示例的springboot工程结构如下：

其中,Langchain4jRagApplication启动类代码如下：

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.core.env.Environment;

@SpringBootApplication
public class Langchain4jRagApplication {

    private static final Logger log = LoggerFactory.getLogger(Langchain4jRagApplication.class);

    public static void main(String[] args) {
        ConfigurableApplicationContext application = SpringApplication.run(Langchain4jRagApplication.class, args);
        Environment env = application.getEnvironment();
        String port = env.getProperty("server.port");
        log.info("Application启动成功，服务端口为：" + port);

    }
}

3、添加maven依赖

创建springboot工程后，在pom.xml文件里引入langchain4j、milvus、dashscope、tika相关Jar包。

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.4.0</version>
    </parent>

    <groupId>com.yuncheng</groupId>
    <artifactId>langchain4j-rag-demo</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>21</maven.compiler.source>
        <maven.compiler.target>21</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <langchain4j.version>1.0.0-beta1</langchain4j.version>
    </properties>

    <dependencies>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-webflux</artifactId>
        </dependency>

        <dependency>
            <groupId>dev.langchain4j</groupId>
            <artifactId>langchain4j-spring-boot-starter</artifactId>
            <version>${langchain4j.version}</version>
        </dependency>

        <dependency>
            <groupId>dev.langchain4j</groupId>
            <artifactId>langchain4j-community-dashscope-spring-boot-starter</artifactId>
            <version>${langchain4j.version}</version>
            <exclusions>
                <exclusion>
                    <groupId>org.slf4j</groupId>
                    <artifactId>slf4j-simple</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

        <dependency>
            <groupId>dev.langchain4j</groupId>
            <artifactId>langchain4j-milvus</artifactId>
            <version>${langchain4j.version}</version>
        </dependency>

        <dependency>
            <groupId>dev.langchain4j</groupId>
            <artifactId>langchain4j-document-parser-apache-tika</artifactId>
            <version>${langchain4j.version}</version>
        </dependency>

        <dependency>
            <groupId>dev.langchain4j</groupId>
            <artifactId>langchain4j-reactor</artifactId>
            <version>${langchain4j.version}</version>
        </dependency>
        
    </dependencies>
</project>

4、配置yml文件

#配置milvus向量数据库的IP和端口、模型名称、api-key

server:
  port: 8099

milvus:
  host: 192.168.3.17
  port: 19530

langchain4j:
  community:
    dashscope:
      chat-model:
        model-name: qwen-plus
        api-key: sk-4d6e6db446014411ad92c0e8fa143964
      streaming-chat-model:
        model-name: qwen-plus
        api-key: sk-4d6e6db446014411ad92c0e8fa143964
      embedding-model:
        api-key: sk-4d6e6db446014411ad92c0e8fa143964
        model-name: text-embedding-v2

5、创建EmbeddingStore

以下源代码定义了一个Spring自动装配类 RagConfig ，用于初始化创建ChatMemoryStore 对象和基于Milvus向量数据库的EmbeddingStore对象。

import dev.langchain4j.store.embedding.EmbeddingStore;
import dev.langchain4j.store.embedding.milvus.MilvusEmbeddingStore;
import dev.langchain4j.store.memory.chat.ChatMemoryStore;
import dev.langchain4j.store.memory.chat.InMemoryChatMemoryStore;
import io.milvus.common.clientenum.ConsistencyLevelEnum;
import io.milvus.param.IndexType;
import io.milvus.param.MetricType;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class RagConfig {
    private static final Logger log = LoggerFactory.getLogger(RagConfig.class);

    @Value("${milvus.host}")
    private String host;
    @Value("${milvus.port}")
    private Integer port;
    
    @Bean
    public ChatMemoryStore chatMemoryStore() {
        log.info("==========初始化ChatMemoryStore");
        return new InMemoryChatMemoryStore();
    }

    @Bean
    public EmbeddingStore createEmbeddingStore() {

        log.info("==========开始创建Milvus的Collection");
        MilvusEmbeddingStore store = MilvusEmbeddingStore.builder()
                .host(host)
                .port(port)
                .collectionName("langchain_01")
                .dimension(1536)
                .indexType(IndexType.FLAT)
                .metricType(MetricType.COSINE)
//                .username("username")
//                .password("password")
                .consistencyLevel(ConsistencyLevelEnum.EVENTUALLY)
                .autoFlushOnInsert(true)
                .idFieldName("id")
                .textFieldName("text")
                .metadataFieldName("metadata")
                .vectorFieldName("vector")
                .build();
        log.info("==========创建Milvus的Collection完成");
        return store;
    }
}

6、创建RagService

这个类RAG逻辑实现的核心类，用于处理文档向量存储，以及RAG过程。

import dev.langchain4j.data.document.Document;
import dev.langchain4j.data.document.DocumentSplitter;
import dev.langchain4j.data.document.loader.FileSystemDocumentLoader;
import dev.langchain4j.data.document.parser.apache.tika.ApacheTikaDocumentParser;
import dev.langchain4j.data.document.splitter.DocumentByParagraphSplitter;
import dev.langchain4j.data.embedding.Embedding;
import dev.langchain4j.data.segment.TextSegment;
import dev.langchain4j.memory.chat.MessageWindowChatMemory;
import dev.langchain4j.model.chat.ChatLanguageModel;
import dev.langchain4j.model.chat.StreamingChatLanguageModel;
import dev.langchain4j.model.embedding.EmbeddingModel;
import dev.langchain4j.rag.DefaultRetrievalAugmentor;
import dev.langchain4j.rag.content.retriever.ContentRetriever;
import dev.langchain4j.rag.content.retriever.EmbeddingStoreContentRetriever;
import dev.langchain4j.rag.query.transformer.CompressingQueryTransformer;
import dev.langchain4j.rag.query.transformer.QueryTransformer;
import dev.langchain4j.service.AiServices;
import dev.langchain4j.store.embedding.EmbeddingStore;
import dev.langchain4j.store.memory.chat.ChatMemoryStore;
import jakarta.annotation.Resource;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.core.io.support.ResourcePatternResolver;
import org.springframework.stereotype.Service;
import reactor.core.publisher.Flux;

import java.io.File;
import java.util.List;

@Service
public class RagService {
    private static final Logger log = LoggerFactory.getLogger(RagService.class);
    private final ResourcePatternResolver resourcePatternResolver = new PathMatchingResourcePatternResolver();
    @Resource
    private StreamingChatLanguageModel streamingChatLanguageModel;
    @Resource
    private ChatLanguageModel chatLanguageModel;
    @Resource
    private EmbeddingModel embeddingModel;
    @Resource
    private EmbeddingStore<TextSegment> embeddingStore;
    @Resource
    private ChatMemoryStore chatmemoryStore;

    /**
     * RAG主要实现逻辑
     * @param chatId 对话ID
     * @param message 用户提问的内容
     * @return 返回检索增强生成的内容
     */
    public Flux<String> chatStream(String chatId,String message) {

        AiServices<Customer> aiServices = AiServices.builder(Customer.class)
                .chatMemoryProvider(memoryId -> MessageWindowChatMemory.builder()
                        .id(chatId)
                        .chatMemoryStore(chatmemoryStore)
                        .maxMessages(50)
                        .build());

        aiServices.streamingChatLanguageModel(streamingChatLanguageModel);
        aiServices.chatLanguageModel(chatLanguageModel);

        // 先进行知识库检索
        ContentRetriever contentRetriever = EmbeddingStoreContentRetriever.builder()
                .embeddingModel(embeddingModel)
                .embeddingStore(embeddingStore)
                .maxResults(10)
                .minScore(0.5)
                .build();

        //将用户的查询和前面的对话压缩到一个独立的查询中。可以显著提高检索质量。
        QueryTransformer queryTransformer = new CompressingQueryTransformer(chatLanguageModel);

        //检索增强生成
        aiServices.retrievalAugmentor(DefaultRetrievalAugmentor
                .builder()
                .queryTransformer(queryTransformer)
                .contentRetriever(contentRetriever)
                .build());

        Customer customer = aiServices.build();
        return customer.stream(chatId, message);
    }

    /**
     * 解析文档、切片、embedding、并保存到向量数据库
     */
    public void importDocuments(){
        try {
            log.info("===================开始导入文档到向量数据库");
            org.springframework.core.io.Resource[] resourceList = resourcePatternResolver.getResources("classpath:documents/*");
            for (org.springframework.core.io.Resource resource : resourceList) {
                File file = resource.getFile();
                log.info("导入文档的名称为："+file.getName());
                Document document = FileSystemDocumentLoader.loadDocument(file.getAbsolutePath(), new ApacheTikaDocumentParser());
                document.metadata().put("docsName", file.getName());

                DocumentSplitter splitter = new DocumentByParagraphSplitter(1000,0);
                List<TextSegment> segments = splitter.split(document);
                log.info("对文档的切片数量为："+segments.size());
                List<Embedding> embeddings = embeddingModel.embedAll(segments).content();
                embeddingStore.addAll(embeddings, segments);
                log.info("===================导入文档到向量数据库完成");
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }

}

注意：在本示例中，Spring Boot工程的 resources/documents/目录下放置了一个名为“云程低代码平台介绍.docx”文件。该文件将被读取、切片、embedding、向量存储，并基于该文件验证检索增强生成（RAG）。

该文档的在线地址为：https://yunchengxc.yuque.com/staff-kxgs7i/sxhe93/nx1vu6ygryv2bu7f

7、创建Customer

import dev.langchain4j.service.MemoryId;
import dev.langchain4j.service.SystemMessage;
import dev.langchain4j.service.UserMessage;
import reactor.core.publisher.Flux;
public interface Customer {
    @SystemMessage("""
            你是云程低代码平台客服人员，请你友好、礼貌、简洁回答客户的问题。
            你只回答与云程低代码平台相关问题，如果是其它问题，请礼貌拒绝。
            """)
    Flux<String> stream(@MemoryId String id, @UserMessage String message);
}

其中，系统提示词通过@SystemMessage注释注入。

8、创建RagController

import jakarta.annotation.Resource;
import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.*;
import reactor.core.publisher.Flux;

@RestController
@RequestMapping("/rag")
public class RagController {
    @Resource
    private RagService chatService;

    @GetMapping(value = "/dbinit")
    public String dbInit() {
        chatService.importDocuments();
        return "OK";
    }

    @GetMapping(value = "/chat", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
    public Flux<String> chatStream(@RequestParam(value = "chatId",required = false,defaultValue = "1") String chatId,@RequestParam(value = "message") String message) {
        return chatService.chatStream(chatId, message);
    }
}
 

该类中有2个方法，可以通过http调用，一个是初始化向量库方法dbInit，一个是chat对话方法chatStream。

9、验证测试RAG效果

9.1、在Milvus中创建Collection

以上代码编写完成后，启动springboot工程，启动时会在Milvus数据库中自动创建
langchain_01的collection，创建向量表的逻辑是由RagConfig类的createEmbeddingStore()方法完成的。

9.2、导入本地word文档到向量库

浏览器中输入：http://localhost:8099/rag/dbinit

执行成功后，也可以通过Milvus自带的webui工具查看。

说明该文档被划分为2个切片，进行了向量化存储。

9.3、RAG检索增强生成测试

浏览器中输入：

http://localhost:8099/rag/chat?message=云程低代码平台移动端采用什么技术开发

我们期望检索增强生成（RAG）系统能够返回与上传文档语义相关内容，并提供最优结果。通过这一过程，可以验证RAG是否对本地知识库进行相似度检索，最后调用大语言模型输出内容，跟预期内容是否一致。

10、RAG执行原理

RAG 通过结合检索技术和生成模型的强大能力，使智能体能够实时从外部数据源获取信息，并在生成过程中增强其知识深度和推理能力。

如上图所示，总体上 RAG 是分为离线和运行时两部分。离线部分是将一些领域特有数据进行向量化的过程，将向量化的数据存入向量数据库。图中后半部分体现的运行时流程，Langchain4j框架在组装 prompt 时，会优先检索向量数据库，连同用户的原始问题组合到一起给到大模型，大模型根据用户问题、上下文以及自己的推理生成响应。

11、结束语

通过本文的详细讲解和实践示例，我们成功展示了如何使用Springboot工程、Langchain4j开源框架、Milvus向量数据、阿里Qwen大模型，搭建一个基于AI大模型的本地知识库系统，实现检索增强生成（RAG）。

Langchain4j官方文档：https://docs.langchain4j.dev/