Java 开发者大模型应用开发实战：基于 RAG 的检索增强生成实践

在此架构中涉及两个核心模型：

• 向量 Embedding 模型：对本地知识的向量表征处理，将文本转化为计算机理解的向量表示。
• LLM 问答大模型：负责理解语义召回的段落 + 用户问题结合构建的 Prompt，进行精准回答。

环境准备

Java：JDK 1.8 ElasticSearch：7.16.1

对于 ElasticSearch 的安装，可以通过 docker-compose 在本地快速部署。编写 docker-compose.yml 配置文件，当前部署目录建 data 文件夹挂载数据目录：

version: "3"
services:
  elasticsearch:
    image: elasticsearch:7.16.1
    ports:
      - "9200:9200"
      - "9300:9300"
    environment:
      node.name: es
      cluster.name: elasticsearch
      discovery.type: single-node  
      ES_JAVA_OPTS: -Xms4096m -Xmx4096m
    volumes:
      - ./data:/usr/share/elasticsearch/data
    deploy:
      resources:
        limits:
          cpus: "4"
          memory: 5G
        reservations:
          cpus: "1"
          memory: 2G
    restart: always

启动 Es：docker-compose up -d

应用初体验

程序启动后，在命令行终端可以看到可交互的界面。通过 add 和 chat 两个命令完成整个流程。

1. 加载文档：使用 add 命令加载文档。在 data 目录下存储 txt 文件，通过命令加载向量处理。
2. 对话测试：日志显示保存向量成功后，使用 chat 命令进行对话。

例如，针对知识库中的时政人物介绍新闻进行问答：

• 问题 1：苏州 2022 年全市的 GDP 是多少？
• 问题 2：吉林省宣传部部长现在是谁？

对比通用大模型（如 ChatGPT），基于现有知识回答的内容（RAG）能够有效避免大模型胡说八道，且回答更精准。这是因为通用大模型训练成本高，无法按周、月甚至年的频率更新，而 RAG 允许应用系统基于最新的私有数据进行回答。

技术实现

新建 Spring Boot 项目，根据 RAG 流程图，主要分为数据的向量处理和问答两步。由于通过 Spring Shell 实现，代码分为两个 Command 命令：

• add：在 data 目录下存放 txt 内容，通过 add file 名称 实现文档向量化流程加载处理。实际生产中可通过定时任务、MQ 消息等方式异步处理。
• chat：通过命令 chat 问题 在 Spring Shell 命令行终端进行对话。

1. 初始化向量数据库索引

程序启动时自动构建向量数据库的索引集合：

/**
 * 初始化向量数据库 index
 * @param collectionName 名称
 * @param dim 维度
 */
public boolean initCollection(String collectionName,int dim){
    log.info("collection:{}", collectionName);
    IndexOperations indexOperations = elasticsearchRestTemplate.indexOps(IndexCoordinates.of(collectionName));
    if (!indexOperations.exists()) {
        log.info("index not exists,create");
        Document document = Document.from(this.elasticMapping(dim));
        indexOperations.create(new HashMap<>(), document);
        return true;
    }
    return true;
}

Es 中的 Index Mapping 结构中，vector 字段类型为 dense_vector，并且指定向量维度为 1024。向量维度的长度与最终向量 Embedding 模型息息相关，不同模型维度不同（如 ChatGPT 为 1536，百度文心一言为 368）。本文选择智谱 AI 的向量模型，返回维度为 1024，故设置为 1024。

2. 文档向量化处理 (Add Command)

add 命令实现文档的向量化过程处理，主要步骤如下：

1. 加载文档并分割：读取 data 目录下的文件流，按固定字数（如 256）分割，得到分割集合 chunkResults。

@Slf4j
@Component
@AllArgsConstructor
public class TxtChunk {

    public List<ChunkResult> chunk(String docId){
        String path="data/"+docId+".txt";
        log.info("start chunk---> docId:{},path:{}",docId,path);
        ClassPathResource classPathResource=new ClassPathResource(path);
        try {
            String txt=IoUtil.read(classPathResource.getInputStream(), StandardCharsets.UTF_8);
            //按固定字数分割，256
            String[] lines=StrUtil.split(txt,256);
            log.info("chunk size:{}", ArrayUtil.length(lines));
            List<ChunkResult> results=new ArrayList<>();
            AtomicInteger atomicInteger=new AtomicInteger(0);
            for (String line:lines){
                ChunkResult chunkResult=new ChunkResult();
                chunkResult.setDocId(docId);
                chunkResult.setContent(line);
                chunkResult.setChunkId(atomicInteger.incrementAndGet());
                results.add(chunkResult);
            }
            return results;
        } catch (IOException e) {
            log.error(e.getMessage());
        }
        return new ArrayList<>();
    }

}

2. Embedding 向量化：将分块的集合通过智谱 AI 提供的向量 Embedding 模型进行向量化处理。

public List<EmbeddingResult> embedding(List<ChunkResult> chunkResults){
    log.info("start embedding,size:{}",CollectionUtil.size(chunkResults));
    if (CollectionUtil.isEmpty(chunkResults)){
        return new ArrayList<>();
    }
    List<EmbeddingResult> embeddingResults=new ArrayList<>();
    for (ChunkResult chunkResult:chunkResults){
        embeddingResults.add(this.embedding(chunkResult));
    }
    return embeddingResults;
}

public EmbeddingResult embedding(ChunkResult chunkResult){
   String apiKey= this.getApiKey();
   OkHttpClient.Builder builder = new OkHttpClient.Builder()
           .connectTimeout(20000, TimeUnit.MILLISECONDS)
           .readTimeout(20000, TimeUnit.MILLISECONDS)
           .writeTimeout(20000, TimeUnit.MILLISECONDS)
           .addInterceptor(new ZhipuHeaderInterceptor(apiKey));
   OkHttpClient okHttpClient = builder.build();
   EmbeddingResult embedRequest=new EmbeddingResult();
   embedRequest.setPrompt(chunkResult.getContent());
   embedRequest.setRequestId(Objects.toString(chunkResult.getChunkId()));
   Request request = new Request.Builder()
           .url("https://open.bigmodel.cn/api/paas/v3/model-api/text_embedding/invoke")
           .post(RequestBody.create(MediaType.parse(ContentType.JSON.getValue()), GSON.toJson(embedRequest)))
           .build();
   try {
       Response response= okHttpClient.newCall(request).execute();
       String result=response.body().string();
       ZhipuResult zhipuResult= GSON.fromJson(result, ZhipuResult.class);
       EmbeddingResult ret= zhipuResult.getData();
       ret.setPrompt(embedRequest.getPrompt());
       ret.setRequestId(embedRequest.getRequestId());
       return  ret;
   } catch (IOException e) {
       throw new RuntimeException(e);
   }

}

3. 存储向量：向量处理成功后，将向量数据存储在向量数据库中间件 (ElasticSearch) 中。

public void store(String collectionName,List<EmbeddingResult> embeddingResults){
    log.info("save vector,collection:{},size:{}",collectionName, CollectionUtil.size(embeddingResults));
    List<IndexQuery> results = new ArrayList<>();
    for (EmbeddingResult embeddingResult : embeddingResults) {
        ElasticVectorData ele = new ElasticVectorData();
        ele.setVector(embeddingResult.getEmbedding());
        ele.setChunkId(embeddingResult.getRequestId());
        ele.setContent(embeddingResult.getPrompt());
        results.add(new IndexQueryBuilder().withObject(ele).build());
    }
    List<IndexedObjectInformation> bulkedResult = elasticsearchRestTemplate.bulkIndex(results, IndexCoordinates.of(collectionName));
    int size = CollectionUtil.size(bulkedResult);
    log.info("保存向量成功-size:{}", size);
}

3. 问答实现 (Chat Command)

数据处理完成后，实现问答 chat 命令：

@AllArgsConstructor
@Slf4j
@ShellComponent
public class ChatCommand {

    final VectorStorage vectorStorage;
    final ZhipuAI zhipuAI;

    @ShellMethod(value = "chat with files")
    public String chat(String question){
        if (StrUtil.isBlank(question)){
            return "You must send a question";
        }
        //句子转向量
        double[] vector=zhipuAI.sentence(question);
        // 向量召回
        String collection= vectorStorage.getCollectionName();
        String vectorData=vectorStorage.retrieval(collection,vector);
        if (StrUtil.isBlank(vectorData)){
            return "No Answer!";
        }
        // 构建 Prompt
        String prompt= LLMUtils.buildPrompt(question,vectorData);
        zhipuAI.chat(prompt);
        return StrUtil.EMPTY;
    }

}

主要步骤如下：

1. 句子转向量：将用户的问句首先通过向量 Embedding 模型转化得到一个多维的浮点型向量数组。

public double[] sentence(String sentence){
    ChunkResult chunkResult=new ChunkResult();
    chunkResult.setContent(sentence);
    chunkResult.setChunkId(RandomUtil.randomInt());
    EmbeddingResult embeddingResult=this.embedding(chunkResult);
    return embeddingResult.getEmbedding();
}

2. 向量召回：根据向量数据查询向量数据库召回相似的段落内容。

public String retrieval(String collectionName,double[] vector){
    Map<String, Object> params = new HashMap<>();
    params.put("query_vector", vector);
    // 计算 cos 值 +1，避免出现负数的情况，得到结果后，实际 score 值在减 1 再计算
    Script script = new Script(ScriptType.INLINE, Script.DEFAULT_SCRIPT_LANG, "cosineSimilarity(params.query_vector, 'vector')+1", params);
    ScriptScoreQueryBuilder scriptScoreQueryBuilder = new ScriptScoreQueryBuilder(QueryBuilders.boolQuery(), script);
    NativeSearchQuery nativeSearchQuery = new NativeSearchQueryBuilder()
            .withQuery(scriptScoreQueryBuilder)
            .withPageable(Pageable.ofSize(3)).build();
    SearchHits<ElasticVectorData> dataSearchHits = this.elasticsearchRestTemplate.search(nativeSearchQuery, ElasticVectorData.class, IndexCoordinates.of(collectionName));
    List<SearchHit<ElasticVectorData>> data = dataSearchHits.getSearchHits();
    List<String> results = new LinkedList<>();
    for (SearchHit<ElasticVectorData> ele : data) {
        results.add(ele.getContent().getContent());
    }
    return CollectionUtil.join(results," ");
}

这里利用了 ElasticSearch 提供的 cosineSimilarity 余弦相似性函数。分值会在区间 [0,1] 之间，越接近 1 代表用户输入的句子和之前存储在向量中的句子非常相似。除了余弦相似性，还有 IP 点积、欧几里得距离等算法，可根据实际情况选择。

3. 构建 Prompt：向量召回 Top3 得到相似的语义文本内容后，构建 Prompt 发送给大模型。

public static String buildPrompt(String question,String context){
    return "请利用如下上下文的信息回答问题：" + "\n" +
            question + "\n" +
            "上下文信息如下：" + "\n" +
            context + "\n" +
            "如果上下文信息中没有帮助，则不允许胡乱回答！";
}

构建 Prompt 时可遵循 RTF 框架 (Role-Task-Format)：

• R-Role：指定 GPT 大模型担任特定的角色。
• T-Task：任务，需要大模型做的事情。
• F-Format：大模型返回的内容格式。

4. 调用大模型：实现 SSE 流式调用输出。

public void chat(String prompt){
    try {
        OkHttpClient.Builder builder = new OkHttpClient.Builder()
                .connectTimeout(20000, TimeUnit.MILLISECONDS)
                .readTimeout(20000, TimeUnit.MILLISECONDS)
                .writeTimeout(20000, TimeUnit.MILLISECONDS)
                .addInterceptor(new ZhipuHeaderInterceptor(this.getApiKey()));
        OkHttpClient okHttpClient = builder.build();

        ZhipuChatCompletion zhipuChatCompletion=new ZhipuChatCompletion();
        zhipuChatCompletion.addPrompt(prompt);
        // 采样温度，控制输出的随机性，必须为正数
        // 值越大，会使输出更随机，更具创造性；值越小，输出会更加稳定或确定
        zhipuChatCompletion.setTemperature(0.7f);
        zhipuChatCompletion.setTop_p(0.7f);

        EventSource.Factory factory = EventSources.createFactory(okHttpClient);
        ObjectMapper mapper = new ObjectMapper();
        String requestBody = mapper.writeValueAsString(zhipuChatCompletion);
        Request request = new Request.Builder()
                .url("https://open.bigmodel.cn/api/paas/v3/model-api/chatglm_std/sse-invoke")
                .post(RequestBody.create(MediaType.parse(ContentType.JSON.getValue()), requestBody))
                .build();
        CountDownLatch countDownLatch=new CountDownLatch(1);
        EventSource eventSource = factory.newEventSource(request, new ConsoleEventSourceListener(countDownLatch));
        countDownLatch.await();

    } catch (Exception e) {
        log.error("llm-chat 异常：{}", e.getMessage());
    }
}

SSE 流式的调用使用了 okhttp-sse 组件提供的功能快速实现。

总结

通过以上步骤，我们完成了基于 Java 语言的最小可用级别 RAG 大模型应用开发。该实践展示了如何利用 Spring Boot、ElasticSearch 以及商业大模型 API 构建一个能够理解私有知识库并进行准确问答的系统。

对于 Java 开发者而言，虽然 AI 领域目前 Python 生态更为成熟，但通过选择合适的中间件和框架，Java 完全有能力承担企业级 AI 应用的开发与集成工作。随着 Java 版本迭代（如 Java 21 引入的向量 API），未来 Java 在 AI 领域的地位将更加稳固。