RAG 的完整流程是什么？

import org.springframework.ai.document.Document;
import org.springframework.ai.reader.TextReader;
import org.springframework.ai.transformer.splitter.TokenTextSplitter;
import org.springframework.ai.vectorstore.VectorStore;
import org.springframework.core.io.FileSystemResource;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class KnowledgeBaseService {

    private final VectorStore vectorStore;

    public KnowledgeBaseService(VectorStore vectorStore) {
        this.vectorStore = vectorStore;
    }

    /**
     * 离线阶段：解析文档 → 切分 → 向量化 → 存入 Milvus
     */
    public void buildKnowledgeBase(String filePath) {
        // 1. 文档解析：读取文本文件
        //    生产环境可用 Apache Tika 解析 PDF/Word/Excel 等
        TextReader reader = new TextReader(new FileSystemResource(filePath));
        List<Document> documents = reader.get();

        // 2. 文本切分：按 Token 切分，每个 Chunk 最多 500 Token，重叠 50
        TokenTextSplitter splitter = new TokenTextSplitter(
            500,   // defaultChunkSize：每个 Chunk 最大 Token 数
            50,    // overlap：重叠 Token 数，防止关键信息被截断
            5,     // minChunkSizeChars：最小 Chunk 字符数
            10000, // maxNumChunks：最大 Chunk 数量
            true   // keepSeparator：是否保留分隔符
        );
        List<Document> chunks = splitter.apply(documents);

        // 3 + 4. 向量化 + 存入向量库（Spring AI 自动处理）
        //    VectorStore.add() 内部会自动调用 Embedding 模型编码
        vectorStore.add(chunks);

        System.out.println("知识库构建完成，共 " + chunks.size() + " 个 Chunk");
    }
}

import org.springframework.ai.chat.client.ChatClient;
import org.springframework.ai.chat.client.advisor.QuestionAnswerAdvisor;
import org.springframework.ai.vectorstore.SearchRequest;
import org.springframework.ai.vectorstore.VectorStore;
import org.springframework.stereotype.Service;

@Service
public class RagQueryService {

    private final ChatClient chatClient;

    public RagQueryService(ChatClient.Builder builder, VectorStore vectorStore) {
        // 构建 ChatClient，挂载 QuestionAnswerAdvisor 实现 RAG
        // 核心就这一行：自动完成 "问题向量化 → 检索 → Prompt 组装 → LLM 生成"
        this.chatClient = builder
            .defaultAdvisors(
                new QuestionAnswerAdvisor(
                    vectorStore,
                    // 检索配置：返回 Top-5 相似文档，相似度阈值 0.7
                    SearchRequest.builder()
                        .topK(5)
                        .similarityThreshold(0.7)
                        .build()
                )
            )
            .build();
    }

    /**
     * 在线阶段：用户提问 → 检索 → 生成回答
     */
    public String ask(String question) {
        return chatClient.prompt()
            .user(question)
            .call()
            .content();
    }
}

import dev.langchain4j.data.document.Document;
import dev.langchain4j.data.document.DocumentParser;
import dev.langchain4j.data.document.DocumentSplitter;
import dev.langchain4j.data.document.parser.TextDocumentParser;
import dev.langchain4j.data.document.splitter.DocumentSplitters;
import dev.langchain4j.data.embedding.Embedding;
import dev.langchain4j.data.segment.TextSegment;
import dev.langchain4j.model.chat.ChatLanguageModel;
import dev.langchain4j.model.embedding.EmbeddingModel;
import dev.langchain4j.model.openai.OpenAiChatModel;
import dev.langchain4j.model.openai.OpenAiEmbeddingModel;
import dev.langchain4j.rag.content.retriever.EmbeddingStoreContentRetriever;
import dev.langchain4j.store.embedding.EmbeddingStore;
import dev.langchain4j.store.embedding.EmbeddingStoreIngestor;
import dev.langchain4j.store.embedding.milvus.MilvusEmbeddingStore;
import dev.langchain4j.service.AiServices;

import java.io.InputStream;

public class LangChain4jRagExample {

    public static void main(String[] args) {

        // ===== 1. 初始化模型 =====
        ChatLanguageModel chatModel = OpenAiChatModel.builder()
            .apiKey("your-api-key")
            .modelName("gpt-4o")
            .build();

        EmbeddingModel embeddingModel = OpenAiEmbeddingModel.builder()
            .apiKey("your-api-key")
            .modelName("text-embedding-3-small")
            .build();

        // ===== 2. 初始化向量存储（Milvus） =====
        EmbeddingStore<TextSegment> embeddingStore = MilvusEmbeddingStore.builder()
            .host("localhost")
            .port(19530)
            .collectionName("rag_docs")
            .dimension(1536)
            .build();

        // ===== 3. 离线阶段：文档解析 → 切分 → 向量化 → 入库 =====

        // 使用 EmbeddingStoreIngestor 统一处理整个离线流程
        DocumentSplitter splitter = DocumentSplitters.recursive(500, 50);
        //    参数说明：500 = 每个 Chunk 最大 Token 数，50 = 重叠 Token 数

        EmbeddingStoreIngestor ingestor = EmbeddingStoreIngestor.builder()
            .documentSplitter(splitter)
            .embeddingModel(embeddingModel)
            .embeddingStore(embeddingStore)
            .build();

        // 解析文档（这里用文本文件示例，生产环境可用 Apache Tika）
        DocumentParser parser = new TextDocumentParser();
        InputStream docStream = Thread.currentThread()
            .getContextClassLoader()
            .getResourceAsStream("产品手册.txt");
        Document document = parser.parse(docStream);

        // 一键完成：切分 → 向量化 → 入库
        ingestor.ingest(document);

        // ===== 4. 在线阶段：构建 RAG 服务 =====

        // 创建内容检索器：问题向量化 → 在向量库中检索 Top-5
        EmbeddingStoreContentRetriever retriever = EmbeddingStoreContentRetriever.builder()
            .embeddingStore(embeddingStore)
            .embeddingModel(embeddingModel)
            .maxResults(5)       // 返回 Top-5 最相似的文档片段
            .minScore(0.7)       // 最低相似度阈值
            .build();

        // 使用 AiServices 自动组装 RAG 链
        // LangChain4j 会自动：检索相关文档 → 拼入 Prompt → 调用 LLM 生成
        Assistant assistant = AiServices.builder(Assistant.class)
            .chatLanguageModel(chatModel)
            .contentRetriever(retriever)
            .build();

        // 5. 提问
        String answer = assistant.chat("产品的退换货政策是什么？");
        System.out.println(answer);
    }

    /**
     * 定义 Assistant 接口
     * LangChain4j 会自动实现这个接口，注入 RAG 检索逻辑
     */
    interface Assistant {
        String chat(String userMessage);
    }
}