Retrieval-Augmented Generation (RAG) with Atlas Vector Search

Set up the environment.

Create an interactive Python notebook by saving a file with the .ipynb extension, and then run the following code in the notebook to install the dependencies:

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

Ingest data into Atlas.

In this section, you ingest sample data into Atlas that LLMs don't have access to. The following code uses the LangChain integration and PyMongo driver to do the following:

• Load a PDF that contains MongoDB's latest earnings report.

• Split the data into chunks, specifying the chunk size (number of characters) and chunk overlap (number of overlapping characters between consecutive chunks).

• Load the nomic-embed-text-v1 embedding model from Hugging Face's model hub.

• Create vector embeddings from the data and store these embeddings in the rag_db.test collection in your Atlas cluster.

Paste and run the following code in your notebook, replacing <connection-string> with your Atlas connection string:

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"
)

Use Atlas Vector Search to retrieve documents.

In this section, you set up Atlas Vector Search to retrieve documents from your vector database. Complete the following steps:

1. Create an Atlas Vector Search index on your vector embeddings.

   Free Clusters

   Dedicated Clusters

   For free and shared clusters, follow the steps to create an index through the Atlas UI. Name the index vector_index and use the following index definition:

   {
      "fields": [
         {
            "type": "vector",
            "path": "embedding",
            "numDimensions": 768,
            "similarity": "euclidean"
         }
      ]
   }

   For dedicated clusters, you can create the index directly from your application by using the PyMongo driver. Paste and run the following code in your notebook:

   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. Configure Atlas Vector Search as a retriever.

   In your notebook, run the following code to set up your retrieval system and run a sample semantic search query by using the LangChain integration:

   # 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")

   HIDE OUTPUT

   [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.')]

Generate responses with the LLM.

In this section, you generate responses by prompting an LLM to use the retrieved documents as context. The following code uses LangChain to do the following:

• Access the Mistral 7B Instruct model from Hugging Face's model hub.

• Instruct the LLM to include the user's question and retrieved documents in the prompt by using a prompt template and chain.

• Prompt the LLM about MongoDB's latest AI announcements.

Paste and run the following code in your notebook, replacing <token> with your Hugging Face access token. The generated response might vary.

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.