<<<<书接上文

配置嵌入存储

嵌入存储（Embedding Store）是 RAG 应用的知识库，所有的向量嵌入及其相关元数据都会存储在这里。下面，我们来添加一个方法，并在主方法中调用它：

private static EmbeddingStore<TextSegment> createEmbeddingStore(MongoClient mongoClient) {
    String databaseName = "rag_app";
    String collectionName = "embeddings";
    String indexName = "embedding";
    Long maxResultRatio = 10L;
    CreateCollectionOptions createCollectionOptions = new CreateCollectionOptions();
    Bson filter = null;
    Set<String> metadataFields = new HashSet<>();
    IndexMapping indexMapping = new IndexMapping(1536, metadataFields);
    Boolean createIndex = true;
    return new MongoDbEmbeddingStore(
            mongoClient,
            databaseName,
            collectionName,
            indexName,
            maxResultRatio,
            createCollectionOptions,
            filter,
            indexMapping,
            createIndex
    );
}

让我们来研究一下我们设置的各个参数：

• 数据库名称（databaseName）:我们指定 "rag_app" 作为存储嵌入数据的数据库名称。你可以根据你的应用需求自行更改这个名称。
• 集合名称（collectionName）:集合 "embeddings" 将用于存放嵌入数据及其元数据。在 MongoDB 中，集合相当于关系型数据库中的表。
• 索引名称(indexName）:"embedding"
• 索引用于实现高效的向量搜索操作。该索引对于基于相似度评分快速检索非常关键。
• 最大结果比例（maxResultRatio）:定义在检索过程中返回的最大结果数量，用于保持返回结果的可管理性。
• 创建集合选项(createCollectionOptions)
• 可以在此自定义创建集合时的选项。例如，你可以配置特定的验证规则或分片键（shard key）。
• 过滤器（filter）:目前设置为null，但你可以根据需要为特定的检索操作定义自定义的过滤条件。
• 元数据字段（metadataFields）:一组可以与嵌入数据一起建立索引的元数据字段名称，使搜索功能更丰富，支持基于向量相似度和元数据的联合查询。
• 索引映射（indexMapping）:用于映射嵌入向量的维度（例如 OpenAI 的 text-embedding-ada-002 模型为 1536 维），确保与所使用的向量模型兼容。
• 创建索引（createIndex）:当设置为 true 时，该标志会自动创建用于向量搜索所需的索引。

在主方法中，我们调用该方法并将结果赋值给一个 EmbeddingStore 实例：

package com.mongodb;  
public class LangChainRagApp {  
    public static void main(String[] args) {  
        try {  
            // MongoDB setup  
            MongoClient mongoClient = MongoClients.create("CONNECTION_URI");  
            // Embedding Store  
EmbeddingStore<TextSegment> embeddingStore = createEmbeddingStore(mongoClient);
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
    }  
}

这个 embeddingStore 现在已经准备好用于存储、检索和管理我们的嵌入数据。

创建嵌入模型

嵌入模型是将原始文本转换为数值表示（即嵌入）的引擎。这些嵌入是数据的高维表示，能够捕捉文本的语义含义，是在检索增强生成（RAG）应用中进行相似度搜索的基础。

在本节中，我们使用 OpenAI 的 text-embedding-ada-002 模型来设置一个嵌入模型。为了配置这个嵌入模型，我们使用了LangChain4J提供的OpenAiEmbeddingModel构建器，它封装了与 OpenAI API 交互的复杂细节。以下是具体的实现方式：

package com.mongodb;  
public class LangChainRagApp {  
    public static void main(String[] args) {  
        try {  
            // ...
            // Embedding Model setup  
OpenAiEmbeddingModel embeddingModel = OpenAiEmbeddingModel.builder()  
        .apiKey("OPEN_AI_API_KEY")  
        .modelName(OpenAiEmbeddingModelName.TEXT_EMBEDDING_ADA_002)  
        .build();
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
    }  
}
// ...

• API密钥（apiKey）：该密钥用于访问OpenAI的服务。请将
• "OPEN_AI_API_KEY" 替换为你实际的 OpenAI API 密钥。
• 模型名称（modelName）：我们指定使用 OpenAiEmbeddingModelName.TEXT_EMBEDDING_ADA_002。该模型具有以下特点：
• 高维度（1536 维）：能够捕捉丰富的语义信息。
• 通用型嵌入向量：适用于多种嵌入任务，如文档检索、聚类和分类等。

配置我们的聊天模型

在检索增强生成（RAG）应用中，聊天模型充当对话引擎的角色。它根据用户的查询和检索到的内容生成具备上下文感知、类人风格的回复。

在本教程中，我们使用 OpenAI 的 GPT-4 来配置聊天模型（当然也可以选择其他 AI 模型），并通过 LangChain4J 简洁直观的 API 实现这一过程。

package com.mongodb;  
public class LangChainRagApp {  
    public static void main(String[] args) {  
        try {  
            // ...
            // Chat Model setup
            ChatLanguageModel chatModel = OpenAiChatModel.builder()
                    .apiKey("OPEN_AI_API_KEY")
                    .modelName("gpt-4")
                    .build();
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
    }  
}
// ...

就像之前一样，这里也需要替换 API 密钥。同时，我们还需要指定使用的模型名称。

在 RAG（检索增强生成）流程中，聊天模型是回答用户查询的核心组件：

• 检索相关内容：嵌入存储会根据用户的查询检索相关的文档。
• 生成响应：聊天模型利用检索到的内容作为上下文，生成详细且准确的回答。

例如，对于如下查询：

“Atlas 的向量检索是如何工作的？”

系统会从 MongoDB 的向量存储中检索出与 Atlas 向量检索相关的嵌入内容，然后 GPT-4 会基于这些上下文生成回复。

如何加载我们的数据

我们将加载一份可以从 MongoDB 的 Hugging Face 页面下载的数据。这是一组大约 600 篇来自 MongoDB Developer Center 的文章和教程集合。

我们需要将这个文件放入项目的 resources 文件夹中。

接下来，我们需要编写一个名为 loadJsonDocuments 的方法来处理数据加载的逻辑。该方法负责：

• 读取 JSON 文件；
• 提取相关内容（如标题、正文、元数据）；
• 将内容拆分为更小的片段，以便进行嵌入处理。

private static List<TextSegment> loadJsonDocuments(String resourcePath, int maxTokensPerChunk, int overlapTokens) throws IOException {
    List<TextSegment> textSegments = new ArrayList<>();
    // Load file from resources using the ClassLoader
    InputStream inputStream = LangChainRagApp.class.getClassLoader().getResourceAsStream(resourcePath);
    if (inputStream == null) {
        throw new FileNotFoundException("Resource not found: " + resourcePath);
    }
    // Jackson ObjectMapper
    ObjectMapper objectMapper = new ObjectMapper();
    BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
    // Batch size for processing
    int batchSize = 500;  // Adjust batch size as needed
    List<Document> batch = new ArrayList<>();
    String line;
    while ((line = reader.readLine()) != null) {
        JsonNode jsonNode = objectMapper.readTree(line);
        String title = jsonNode.path("title").asText(null);
        String body = jsonNode.path("body").asText(null);
        JsonNode metadataNode = jsonNode.path("metadata");
        if (body != null) {
            String text = (title != null ? title + "\n\n" + body : body);
            Metadata metadata = new Metadata();
            if (metadataNode != null && metadataNode.isObject()) {
                Iterator<String> fieldNames = metadataNode.fieldNames();
                while (fieldNames.hasNext()) {
                    String fieldName = fieldNames.next();
                    metadata.put(fieldName, metadataNode.path(fieldName).asText());
                }
            }
            Document document = Document.from(text, metadata);
            batch.add(document);
            // If batch size is reached, process the batch
            if (batch.size() >= batchSize) {
                textSegments.addAll(splitIntoChunks(batch, maxTokensPerChunk, overlapTokens));
                batch.clear();
            }
        }
    }
    // Process remaining documents in the last batch
    if (!batch.isEmpty()) {
        textSegments.addAll(splitIntoChunks(batch, maxTokensPerChunk, overlapTokens));
    }
    return textSegments;
}

文档需要被拆分成更小的片段，以满足嵌入模型的 token 限制。我们通过调用 splitIntoChunks 方法来实现这一点。在这里，我们使用 LangChain4j 提供的工具 —— DocumentSplitter，它可以将文档划分为易于处理的小片段，同时尽量保留原始上下文的信息。这种方式既保证了每段文本能够顺利进行向量化处理，又不会丢失语义上的连续性，是构建高质量检索系统的重要一环。

private static List<TextSegment> splitIntoChunks(List<Document> documents, int maxTokensPerChunk, int overlapTokens) {  
    // Create a tokenizer for OpenAI  
    OpenAiTokenizer tokenizer = new OpenAiTokenizer(OpenAiEmbeddingModelName.TEXT_EMBEDDING_ADA_002);  
    // Create a recursive document splitter with the specified token size and overlap  
    DocumentSplitter splitter = DocumentSplitters.recursive(  
            maxTokensPerChunk,  
            overlapTokens,  
            tokenizer  
    );  
    List<TextSegment> allSegments = new ArrayList<>();  
    for (Document document : documents) {  
        List<TextSegment> segments = splitter.split(document);  
        allSegments.addAll(segments);  
    }  
    return allSegments;  
}

参数说明

• maxTokensPerChunk：每个文本片段允许的最大 token 数量。这个设置确保每段文本都符合嵌入模型的 token 限制。
• overlapTokens：相邻片段之间的重叠 token 数量。通过设置重叠，可以在划分片段时更好地保留上下文信息，避免语义断裂。

接下来，把这些整合进主方法中主方法将协调整个流程，包括：

1. 加载数据：读取并处理原始 JSON 数据；
2. 嵌入生成：将文本拆分后传入嵌入模型，生成向量表示；
3. 存储嵌入：将生成的向量及其相关信息保存到嵌入存储中（embedding store）。

package com.mongodb;  
public class LangChainRagApp {  
    public static void main(String[] args) {  
        try {  
            // ...
            // Load documents
            String resourcePath = "devcenter-content-snapshot.2024-05-20.json";
            List<TextSegment> documents = loadJsonDocuments(resourcePath, 800, 200);
            System.out.println("Loaded " + documents.size() + " documents");
            for (int i = 0; i < documents.size()/10; i++) {
                TextSegment segment = documents.get(i);
                Embedding embedding = embeddingModel.embed(segment.text()).content();
                embeddingStore.add(embedding, segment);
            }
            System.out.println("Stored embeddings");
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
    }  
}

我在代码里添加了一些注释，方便我们跟踪数据导入的进度。同时，我调整了只加载前 10% 的文档。因为我之前尝试加载整个数据集时，慢速网络环境下花了 30 多分钟。

你可以根据实际情况自行调整这个比例——导入的数据越多，模型的回答通常越准确。

>>>> 未完，下一章节继续