RAG 的完整流程是怎么样的？

最新推荐文章于 2025-09-28 14:14:17 发布

原创最新推荐文章于 2025-09-28 14:14:17 发布 · 695 阅读

4 ·

CC 4.0 BY-SA版权

文章标签：

#java

AI 专栏收录该内容

8 篇文章

订阅专栏

RAG（Retrieval-Augmented Generation，检索增强生成）是一种结合外部知识检索与大模型生成的技术方案，核心是通过检索相关知识片段来辅助大模型生成更准确、更可靠的回答。在Java开发环境中，RAG的完整流程可分为6个核心阶段，每个阶段都有对应的工具和实现方式。以下是详细流程及Java技术栈的落地细节：

一、RAG 完整流程总览

RAG的核心逻辑是“先检索、再生成”，通过外部知识弥补大模型“知识过时、幻觉（Hallucination）”等问题。完整流程包括：
数据准备 → 文本分割 → 嵌入（Embedding）生成 → 向量索引构建 → 检索 → 生成增强

二、各阶段详细说明（结合Java实现）

1. 数据准备（Data Preparation）

目标：收集、清洗并标准化原始数据源（如文档、数据库、网页等），为后续处理提供高质量输入。

数据源类型：
结构化数据（MySQL、MongoDB）、非结构化数据（PDF、Word、HTML、TXT）、半结构化数据（JSON、XML）。

Java实现工具：

文档解析：使用 Apache Tika 处理多格式文档（PDF、Word、PPT等），支持自动识别文件类型并提取文本。

// 示例：用Apache Tika解析PDF文档
Tika tika = new Tika();
try (InputStream stream = new FileInputStream("document.pdf")) {
    String text = tika.parseToString(stream); // 提取PDF中的文本内容
}

网页数据：用 Jsoup 爬取并解析HTML页面，提取正文内容（去除标签、广告等噪声）。

// 示例：用Jsoup提取网页文本
Document doc = Jsoup.connect("https://example.com/article").get();
Elements content = doc.select("div.article-content"); // 定位正文标签
String text = content.text(); // 提取文本

数据清洗：通过Java字符串工具（String 类、Pattern 正则）或 Apache Commons Text 去除冗余信息（如特殊符号、重复内容）、标准化格式（如统一大小写、日期格式）。

2. 文本分割（Chunking）

目标：将长文本拆分为短片段（Chunk），适配大模型的上下文窗口限制，同时保留片段的语义完整性。

分割策略：
- 按固定长度（如500字符）分割，避免片段过长；
- 按语义单元（句子、段落）分割，减少语义割裂（如基于标点符号或NLP工具的句子切分）。

Java实现工具：

LangChain4j（Java版RAG框架）：提供 RecursiveCharacterTextSplitter 等分割器，支持按长度和分隔符分割。

// 示例：用LangChain4j分割文本
TextSplitter splitter = RecursiveCharacterTextSplitter.builder()
    .chunkSize(500) // 片段最大长度
    .chunkOverlap(50) // 片段重叠部分（保持上下文关联）
    .build();
List<String> chunks = splitter.split(text); // 分割后的文本片段列表

自定义实现：基于 BreakIterator（Java内置的文本边界迭代器）按句子分割。

// 示例：按句子分割
List<String> sentences = new ArrayList<>();
BreakIterator iterator = BreakIterator.getSentenceInstance(Locale.ENGLISH);
iterator.setText(text);
int start = iterator.first();
for (int end = iterator.next(); end != BreakIterator.DONE; start = end, end = iterator.next()) {
    sentences.add(text.substring(start, end));
}

3. 嵌入（Embedding）生成

目标：将文本片段（Chunk）转换为高维向量（Embedding），使语义相似的文本在向量空间中距离更近，为后续检索提供数学基础。

核心逻辑：通过预训练的嵌入模型（如BERT、Sentence-BERT、OpenAI Embedding）将文本映射为向量。

Java实现工具：

调用外部API：通过Java的 HttpClient 调用OpenAI、百度文心等的Embedding接口（适合无本地模型部署资源的场景）。

// 示例：调用OpenAI Embedding API生成向量
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.openai.com/v1/embeddings"))
    .header("Content-Type", "application/json")
    .header("Authorization", "Bearer YOUR_API_KEY")
    .POST(HttpRequest.BodyPublishers.ofString("{\"model\":\"text-embedding-ada-002\",\"input\":\"" + chunk + "\"}"))
    .build();
client.sendAsync(request, HttpResponse.BodyHandlers.ofString())
    .thenApply(HttpResponse::body)
    .thenAccept(response -> {
        // 解析响应，提取向量（response为JSON格式）
        JSONArray embedding = new JSONObject(response).getJSONArray("data").getJSONObject(0).getJSONArray("embedding");
    });

本地模型部署：使用 Deeplearning4j（Java深度学习框架）加载开源嵌入模型（如Sentence-BERT的Java版本），或通过 LangChain4j 集成本地模型。

// 示例：LangChain4j集成本地嵌入模型
EmbeddingModel embeddingModel = new SentenceTransformerEmbeddingModel("all-MiniLM-L6-v2"); // 加载开源模型
List<Embedding> embeddings = embeddingModel.embedAll(chunks); // 批量生成向量

4. 向量索引构建（Vector Indexing）

目标：将文本片段的向量存储到向量数据库中，构建高效的索引结构，支持快速相似度检索。

核心需求：向量数据库需支持高维向量的近似最近邻（ANN）搜索，常见的有Milvus、Qdrant、Weaviate、Elasticsearch（需安装向量插件）。

Java实现工具：

Milvus Java SDK：Milvus是开源向量数据库，支持Java客户端操作。

// 示例：用Milvus创建集合并插入向量
MilvusClient client = new MilvusClient("http://localhost:19530");
// 1. 创建集合（定义向量维度，如384维）
client.createCollection(CreateCollectionParam.newBuilder()
    .collectionName("rag_collection")
    .addFieldType(FieldType.newBuilder()
        .name("id")
        .dataType(DataType.Int64)
        .isPrimaryKey(true)
        .build())
    .addFieldType(FieldType.newBuilder()
        .name("embedding")
        .dataType(DataType.FloatVector)
        .dimension(384)
        .build())
    .build());
// 2. 插入向量（每个向量对应一个文本片段）
List<InsertParam.Field> fields = new ArrayList<>();
fields.add(new InsertParam.Field("id", Arrays.asList(1L, 2L))); // 文本片段ID
fields.add(new InsertParam.Field("embedding", embeddings.stream()
    .map(emb -> emb.getVector()) // 提取向量数组
    .collect(Collectors.toList())));
client.insert(InsertParam.newBuilder()
    .collectionName("rag_collection")
    .fields(fields)
    .build());
// 3. 创建索引（加速检索）
client.createIndex(CreateIndexParam.newBuilder()
    .collectionName("rag_collection")
    .fieldName("embedding")
    .indexType(IndexType.IVF_FLAT) // 索引类型
    .metricType(MetricType.COSINE) // 相似度计算方式（余弦相似度）
    .build());

LangChain4j集成：LangChain4j支持多种向量数据库的封装，简化索引操作。

// 示例：LangChain4j连接Qdrant
VectorStore vectorStore = QdrantVectorStore.builder()
    .host("localhost")
    .port(6334)
    .collectionName("rag_collection")
    .build();
vectorStore.add(Document.from(chunks)); // 自动生成向量并存储（需配置embeddingModel）

5. 检索（Retrieval）

目标：针对用户输入的问题，生成问题的向量，在向量数据库中检索出与问题语义最相似的文本片段（Top-K结果）。

核心逻辑：
1. 将用户问题转换为向量（使用与文本片段相同的嵌入模型）；
2. 在向量数据库中执行相似度查询，返回Top-K（如Top5）最相关的文本片段。

Java实现工具：

向量数据库客户端：直接调用数据库的检索接口。

// 示例：Milvus检索相似向量
// 1. 生成问题的向量
Embedding queryEmbedding = embeddingModel.embed("用户的问题是什么？");
// 2. 检索Top5相似结果
SearchResults results = client.search(SearchParam.newBuilder()
    .collectionName("rag_collection")
    .vectorFieldName("embedding")
    .vectors(Collections.singletonList(queryEmbedding.getVector()))
    .limit(5)
    .metricType(MetricType.COSINE)
    .build());
// 3. 提取检索到的文本片段ID和相似度分数
List<Long> matchedIds = results.getResults().get(0).getScores().stream()
    .map(scoreInfo -> scoreInfo.getEntity().getLong("id"))
    .collect(Collectors.toList());

LangChain4j检索器：封装检索逻辑，直接返回相关文档。

Retriever<Document> retriever = vectorStore.retriever();
List<Document> relevantDocs = retriever.retrieve("用户的问题是什么？"); // 直接获取相关文本片段

6. 生成增强（Generation）

目标：将检索到的文本片段与用户问题拼接为提示词（Prompt），输入大模型，生成基于外部知识的回答。

核心逻辑：提示词需明确告知模型“基于以下知识回答问题”，避免模型依赖内部知识（减少幻觉）。

Java实现工具：

调用大模型API：通过Java HttpClient 调用OpenAI、GPT-4、讯飞星火等API。

// 示例：调用OpenAI Chat API生成回答
String prompt = "基于以下知识回答问题：\n" + 
    relevantDocs.stream().map(Document::getContent).collect(Collectors.joining("\n")) + 
    "\n问题：用户的问题是什么？";
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.openai.com/v1/chat/completions"))
    .header("Content-Type", "application/json")
    .header("Authorization", "Bearer YOUR_API_KEY")
    .POST(HttpRequest.BodyPublishers.ofString("{\"model\":\"gpt-3.5-turbo\",\"messages\":[{\"role\":\"user\",\"content\":\"" + prompt + "\"}]}"))
    .build();
// 解析响应获取回答
String response = client.send(request, HttpResponse.BodyHandlers.ofString()).body();
String answer = new JSONObject(response).getJSONArray("choices").getJSONObject(0).getJSONObject("message").getString("content");

LangChain4j LLM集成：简化大模型调用，支持链式操作。

// 示例：LangChain4j调用大模型
ChatLanguageModel llm = OpenAiChatModel.builder()
    .apiKey("YOUR_API_KEY")
    .modelName("gpt-3.5-turbo")
    .build();
// 构建RAG链：检索器 + 大模型
RAGChain ragChain = RAGChain.builder()
    .retriever(retriever)
    .llm(llm)
    .build();
// 直接获取回答
String answer = ragChain.generate("用户的问题是什么？");