使用 Atlas Vector Search 进行检索增强生成 (RAG)

设置环境。

1. 初始化您的 Node.js 项目。

   在终端中运行以下命令，创建名为 rag-mongodb的新目录并初始化项目：

   mkdir rag-mongodb
   cd rag-mongodb
   npm init -y

2. 安装并导入依赖项。

   运行以下命令：

   npm install mongodb langchain @langchain/community @xenova/transformers @huggingface/inference pdf-parse

3. 更新package.json文件。

   在项目的package.json文件中，按以下示例所示指定type字段，然后保存文件。

   {
      "name": "rag-mongodb",
      "type": "module",
      ...

4. 创建.env文件。

   在您的项目中，创建一个.env文件来存储 Atlas 连接字符串和 Huging Face 访问令牌。

   HUGGING_FACE_ACCESS_TOKEN = "<access-token>"
   ATLAS_CONNECTION_STRING = "<connection-string>"

   将<access-token>和<connection-string>占位符值替换为您的 Huging Face 访问令牌和 Atlas 集群的SRV连接字符串。连接字符串应使用以下格式：

   mongodb+srv://<db_username>:<db_password>@<clusterName>.<hostname>.mongodb.net

   注意

   最低 Node.js 版本要求

   Node.js v 20 .x 引入了--env-file选项。如果您使用的是旧版本的 Node.js，请将dotenv包添加到您的项目中，或使用其他方法来管理环境变量。

创建一个函数以生成向量嵌入。

在本部分中，您将创建一个函数：

• 加载 nomic-embed-text-v1 嵌入来自 Huugging Face 模型中心的模型。

• 从输入数据创建向量嵌入。

在项目中创建一个名为get-embeddings.js的文件，并粘贴以下代码：

import { pipeline } from '@xenova/transformers';
// Function to generate embeddings for a given data source
export async function getEmbedding(data) {
    const embedder = await pipeline(
        'feature-extraction', 
        'Xenova/nomic-embed-text-v1');
    const results = await embedder(data, { pooling: 'mean', normalize: true });
    return Array.from(results.data);
}

将数据导入 Atlas。

在本部分中，您将把法学硕士无权访问的样本数据导入到 Atlas 中。以下代码使用LangChain 集成和Node.js 驱动程序执行以下操作：

• 加载包含MongoDB 收益报告的 PDF。

• 将数据拆分为数据段，并指定数据段大小（字符数）和数据段重叠（连续数据段之间的重叠字符数）。

• 使用您定义的getEmbeddings函数从分块数据创建向量嵌入。

• 将这些嵌入与分块数据一起存储在 Atlas 集群的rag_db.test集合中。

在项目中创建一个名为ingest-data.js的文件，并粘贴以下代码：

import { PDFLoader } from "@langchain/community/document_loaders/fs/pdf";
import { RecursiveCharacterTextSplitter } from "langchain/text_splitter";
import { MongoClient } from 'mongodb';
import { getEmbeddings } from './get-embeddings.js';
import * as fs from 'fs';
async function run() {
    const client = new MongoClient(process.env.ATLAS_CONNECTION_STRING);
    try {
        // Save online PDF as a file
        const rawData = await fetch("https://investors.mongodb.com/node/12236/pdf");
        const pdfBuffer = await rawData.arrayBuffer();
        const pdfData = Buffer.from(pdfBuffer);
        fs.writeFileSync("investor-report.pdf", pdfData);
        const loader = new PDFLoader(`investor-report.pdf`);
        const data = await loader.load();
        // Chunk the text from the PDF
        const textSplitter = new RecursiveCharacterTextSplitter({
            chunkSize: 400,
            chunkOverlap: 20,
          });
        const docs = await textSplitter.splitDocuments(data);
        console.log(`Successfully chunked the PDF into ${docs.length} documents.`);
        // Connect to your Atlas cluster
        await client.connect();
        const db = client.db("rag_db");
        const collection = db.collection("test");
        console.log("Generating embeddings and inserting documents.");
        let docCount = 0;
        await Promise.all(docs.map(async doc => {
            const embeddings = await getEmbeddings(doc.pageContent);
            
            // Insert the embeddings and the chunked PDF data into Atlas
            await collection.insertOne({
                document: doc,
                embedding: embeddings,
            });
            docCount += 1;
        }))
        console.log(`Successfully inserted ${docCount} documents.`);
    } catch (err) {
        console.log(err.stack);
    }
    finally {
        await client.close();
    }
}
run().catch(console.dir);

然后，运行以下命令来执行代码：

node --env-file=.env ingest-data.js

使用 Atlas Vector Search 检索文档。

在本部分中，您将设置 Atlas Vector Search 以从向量数据库中检索文档。完成以下步骤：

1. 在向量嵌入上创建 Atlas Vector Search 索引。

   创建一个名为rag-vector-index.js的新文件并粘贴以下代码。此代码连接到 Atlas 集群，并在rag_db.test集合上创建vectorSearch类型的索引。

   import { MongoClient } from 'mongodb';
   // Connect to your Atlas cluster
   const client = new MongoClient(process.env.ATLAS_CONNECTION_STRING);
   async function run() {
       try {
         const database = client.db("rag_db");
         const collection = database.collection("test");
        
         // Define your Atlas Vector Search index
         const index = {
             name: "vector_index",
             type: "vectorSearch",
             definition: {
               "fields": [
                 {
                   "type": "vector",
                   "numDimensions": 768,
                   "path": "embedding",
                   "similarity": "cosine"
                 }
               ]
             }
         }
    
         // Call the method to create the index
         const result = await collection.createSearchIndex(index);
         console.log(result);
       } finally {
         await client.close();
       }
   }
   run().catch(console.dir);

   然后，运行以下命令来执行代码：

   node --env-file=.env rag-vector-index.js

2. 定义一个函数来检索相关数据。

   创建一个名为retrieve-documents.js的新文件。

   在此步骤中，您将创建一个名为getQueryResults的检索函数，用于运行查询以检索相关文档。它使用getEmbeddings函数根据搜索查询创建嵌入。然后，它运行查询以返回语义相似的文档。

   要了解更多信息，请参阅运行向量搜索查询。

   将此代码粘贴到文件中：

   import { MongoClient } from 'mongodb';
   import { getEmbeddings } from './get-embeddings.js';
   // Function to get the results of a vector query
   export async function getQueryResults(query) {
       // Connect to your Atlas cluster
       const client = new MongoClient(process.env.ATLAS_CONNECTION_STRING);
       
       try {
           // Get embeddings for a query
           const queryEmbeddings = await getEmbeddings(query);
           await client.connect();
           const db = client.db("rag_db");
           const collection = db.collection("test");
           const pipeline = [
               {
                   $vectorSearch: {
                       index: "vector_index",
                       queryVector: queryEmbeddings,
                       path: "embedding",
                       exact: true,
                       limit: 5
                   }
               },
               {
                   $project: {
                       _id: 0,
                       document: 1,
                   }
               }
           ];
           // Retrieve documents from Atlas using this Vector Search query
           const result = collection.aggregate(pipeline);
           const arrayOfQueryDocs = [];
           for await (const doc of result) {
               arrayOfQueryDocs.push(doc);
           }
           return arrayOfQueryDocs;
       } catch (err) {
           console.log(err.stack);
       }
       finally {
           await client.close();
       }
   }

3. 测试检索数据。

   创建一个名为retrieve-documents-test.js的新文件。在此步骤中，您将检查刚刚定义的函数是否返回相关结果。

   将此代码粘贴到文件中：

   import { getQueryResults } from './retrieve-documents.js';
   async function run() {
       try {
           const query = "AI Technology";
           const documents = await getQueryResults(query);
           documents.forEach( doc => {
               console.log(doc);
           }); 
       } catch (err) {
           console.log(err.stack);
       }
   }
   run().catch(console.dir);

   然后，运行以下命令来执行代码：

   node --env-file=.env retrieve-documents-test.js

   查看输出

使用 LLM 生成回复。

在本部分中，您将通过提示 LLM 使用检索到的文档作为上下文来 生成 响应。此示例使用您刚刚定义的函数从数据库中检索匹配的文档，此外：

• 访问 Mistral7 B 指令 来自 Huging Face 模型中心的模型。

• 指示法学硕士在提示中包含用户的问题和检索到的文档。

• 向法学硕士提示 MongoDB 的最新 AI 公告。

创建一个名为generate-responses.js的新文件，并将以下代码粘贴到其中：

import { getQueryResults } from './retrieve-documents.js';
import { HfInference } from '@huggingface/inference'
async function run() {
    try {
        // Specify search query and retrieve relevant documents
        const query = "AI Technology";
        const documents = await getQueryResults(query);
        // Build a string representation of the retrieved documents to use in the prompt
        let textDocuments = "";
        documents.forEach(doc => {
            textDocuments += doc.document.pageContent;
        });
        const question = "In a few sentences, what are MongoDB's latest AI announcements?";
        // Create a prompt consisting of the question and context to pass to the LLM
        const prompt = `Answer the following question based on the given context.
            Question: {${question}}
            Context: {${textDocuments}}
        `;
        // Connect to Hugging Face, using the access token from the environment file
        const hf = new HfInference(process.env.HUGGING_FACE_ACCESS_TOKEN);
        const llm = hf.endpoint(
            "https://api-inference.huggingface.co/models/mistralai/Mistral-7B-Instruct-v0.3"
           );
        
        // Prompt the LLM to answer the question using the
        // retrieved documents as the context
        const output = await llm.chatCompletion({
            model: "mistralai/Mistral-7B-Instruct-v0.2",
            messages: [{ role: "user", content: prompt }],
            max_tokens: 150,
        });
        // Output the LLM's response as text.
        console.log(output.choices[0].message.content);
    } catch (err) {
        console.log(err.stack);
    }
}
run().catch(console.dir);

然后，运行此命令以执行代码。生成的响应可能会有所不同。

node --env-file=.env generate-responses.js

MongoDB's latest AI announcements include the launch of the MongoDB
AI Applications Program (MAAP), which provides customers with
reference architectures, pre-built partner integrations, and
professional services to help them build AI-powered applications
quickly. Accenture has joined MAAP as the first global systems
integrator, establishing a center of excellence focused on MongoDB
projects. Additionally, Bendigo and Adelaide Bank have partnered
with MongoDB to modernize their core banking technology using
MongoDB's Relational Migrator and generative AI-powered
modernization tools.

设置环境。

通过保存扩展名为.ipynb的文件来创建交互式 Python 笔记本，然后在笔记本中运行以下代码以安装依赖项：

pip install --quiet pymongo langchain langchain_community langchain_mongodb langchain_huggingface pypdf sentence_transformers

将数据导入 Atlas。

在本部分中，您将把法学硕士无权访问的样本数据导入到 Atlas 中。以下代码使用LangChain 集成和PyMongo 驱动程序执行以下操作：

• 加载包含MongoDB 收益报告的 PDF。

• 将数据拆分为数据段，并指定数据段大小（字符数）和数据段重叠（连续数据段之间的重叠字符数）。

• 加载 nomic-embed-text-v1 嵌入来自 Huugging Face 模型中心的模型。

• 从数据创建向量嵌入，并将这些嵌入存储在 Atlas 集群的rag_db.test集合中。

在笔记本中粘贴并运行以下代码，将<connection-string>替换为您的 Atlas连接字符串：

from langchain_community.document_loaders import PyPDFLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_huggingface import HuggingFaceEmbeddings
from langchain_mongodb import MongoDBAtlasVectorSearch
from pymongo import MongoClient
# Load the PDF
loader = PyPDFLoader("https://investors.mongodb.com/node/12236/pdf")
data = loader.load()
# Split the data into chunks
text_splitter = RecursiveCharacterTextSplitter(chunk_size=400, chunk_overlap=20)
docs = text_splitter.split_documents(data)
# Load the embedding model (https://huggingface.co/nomic-ai/nomic-embed-text-v1")
model = HuggingFaceEmbeddings(model_name="nomic-ai/nomic-embed-text-v1", model_kwargs={ "trust_remote_code": True })
# Connect to your Atlas cluster
client = MongoClient("<connection-string>")
collection = client["rag_db"]["test"]
# Store the data as vector embeddings in Atlas
vector_store = MongoDBAtlasVectorSearch.from_documents(
    documents = docs,
    embedding = model,
    collection = collection,
    index_name = "vector_index"
)

使用 Atlas Vector Search 检索文档。

在本部分中，您将设置 Atlas Vector Search 以从向量数据库中检索文档。完成以下步骤：

1. 在向量嵌入上创建 Atlas Vector Search 索引。

   您可以使用 PyMongo 驱动程序直接从应用程序创建索引。在笔记本中粘贴并运行以下代码：

   pymongo.operations import SearchIndexModel
   # Create your index model, then create the search index
   search_index_model = SearchIndexModel(
     definition = {
       "fields": [
         {
           "type": "vector",
           "numDimensions": 768,
           "path": "embedding",
           "similarity": "cosine"
         }
       ]
     },
     name = "vector_index",
     type = "vectorSearch"
   )
   collection.create_search_index(model=search_index_model)

2. 将 Atlas Vector Search 配置为检索器。

   在您的笔记本中，运行以下代码以设置检索系统，并使用LangChain 集成运行示例语义搜索查询：

   # Instantiate Atlas Vector Search as a retriever
   retriever = vector_store.as_retriever(
      search_type = "similarity"
   )
   # Run a sample query in order of relevance
   retriever.invoke("AI technology")

   隐藏输出

   [Document(metadata={'_id': '66a910ba7f78f7ec6760ceba', 'source': 'https://investors.mongodb.com/node/12236/pdf', 'page': 0}, page_content="more of our customers. We also see a tremendous opportunity to win more legacy workloads, as AI has now become a catalyst to modernize these\napplications. MongoDB's  document-based architecture is particularly well-suited for the variety and scale of data required by AI-powered applications."),
    Document(metadata={'_id': '66a910ba7f78f7ec6760ced6', 'source': 'https://investors.mongodb.com/node/12236/pdf', 'page': 1}, page_content='artificial intelligence, in our offerings or partnerships; the growth and expansion of the market for database products and our ability to penetrate that\nmarket; our ability to integrate acquired businesses and technologies successfully or achieve the expected benefits of such acquisitions; our ability to'),
    Document(metadata={'_id': '66a910ba7f78f7ec6760cec3', 'source': 'https://investors.mongodb.com/node/12236/pdf', 'page': 0}, page_content='MongoDB  continues to expand its AI ecosystem with the announcement of the MongoDB AI Applications Program (MAAP),'),
    Document(metadata={'_id': '66a910ba7f78f7ec6760cec4', 'source': 'https://investors.mongodb.com/node/12236/pdf', 'page': 1}, page_content='which provides customers with reference architectures, pre-built partner integrations, and professional services to help\nthem quickly build AI-powered applications. Accenture will establish a center of excellence focused on MongoDB  projects,\nand is the first global systems integrator to join MAAP.')]

使用 LLM 生成回复。

在本部分中，您将通过提示 LLM 使用检索到的文档作为上下文来 生成 响应。以下代码使用 LangChain 执行以下操作：

• 访问 Mistral7 B 指令 来自 Huging Face 模型中心的模型。

• 使用 提示模板 指示 法学硕士 在提示中包含用户的问题和检索到的文档 和 链。

• 向法学硕士提示 MongoDB 的最新 AI 公告。

在笔记本中粘贴并运行以下代码，将<token>替换为您的 Huging Face 访问令牌。生成的响应可能会有所不同。

from langchain_huggingface import HuggingFaceEndpoint
from langchain.prompts import PromptTemplate
from langchain_core.runnables import RunnablePassthrough
from langchain_core.output_parsers import StrOutputParser
import os
# Authenticate to your Hugging Face account
os.environ["HF_TOKEN"] = "<token>"
# Access the LLM (https://huggingface.co/mistralai/Mistral-7B-Instruct-v0.2)
llm = HuggingFaceEndpoint(repo_id="mistralai/Mistral-7B-Instruct-v0.2")
# Create prompt and RAG workflow
prompt = PromptTemplate.from_template("""
   Answer the following question based on the given context.
   Question: {question}
   Context: {context}
""")
rag_chain = (
   { "context": retriever, "question": RunnablePassthrough()}
   | prompt
   | llm
   | StrOutputParser()
)
# Prompt the LLM
question = "In a few sentences, what are MongoDB's latest AI announcements?"
answer = rag_chain.invoke(question)
print(answer)

Answer: MongoDB recently announced the MongoDB AI Applications Program
(MAAP) as part of their efforts to expand their AI ecosystem.
The document-based architecture of MongoDB is particularly well-suited
for AI-powered applications, offering an opportunity to win more legacy
workloads. These announcements were made at MongoDB.local NYC.