The Power of Integrating Ollama with MongoDB Atlas Vector Search

Why Use MongoDB Atlas Vector Search for RAG Applications?

• Efficient information retrieval: Quick retrieval of relevant information enhances the performance of RAG applications, leading to more precise & contextual responses.
• Robust management: MongoDB Atlas complements Ollama’s processing prowess, letting you easily manage & analyze large volumes of data.

What is Ollama?

Prerequisites

• Basic knowledge of Python & MongoDB.
• An environment capable of running Python programs (like a local machine or a cloud-based IDE).
• A MongoDB Atlas account & a cluster set up.
• Access to Ollama & necessary Python packages, which include
  1 langchain
  ,
  1 pymongo
  , etc.

Step-by-Step Guide to Integration

Step 1: Environment Setup

1
2
3
4
langchain
pymongo
streamlit
sentence_transformers

1
ollama pull llama2

Step 2: MongoDB Atlas Configuration

Step 3: Initialize Ollama & MongoDB Clients

1
2
3
mongo_uri = "mongodb+srv://user:password@<your-atlas-uri>/?retryWrites=true&w=majority"
db_name = "sample_mflix"
coll_name = "movies"

1
2
3
4
5
6
7
8
9
10
{
  "fields": [
    {
      "numDimensions": 384,
      "path": "plot_embedding_hf",
      "similarity": "cosine",
      "type": "vector"
    }
  ]
}

Step 4: Setting Up Embedding Vector Search

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
from sentence_transformers import SentenceTransformer
import pymongo
import config

mongo_uri = config.mongo_uri
db = config.db_name
collection = config.coll_name

# Initialize db connection
connection = pymongo.MongoClient(mongo_uri)
collection = connection[db][collection]

# Set up the transformer model
model = SentenceTransformer("sentence-transformers/all-MiniLM-L6-v2")

for doc in collection.find({"plot_embedding_hf": {"$exists": False}}, {}).limit(10):
    if "vector" not in doc.keys():
        movieid = doc["_id"]
        title = doc["title"]
        print("computing vector... title: " + title)
        text = title
        fullplot = doc.get("fullplot", None)
        if fullplot:
            text += ". " + fullplot
        vector = model.encode(text).tolist()
        collection.update_one({"_id": movieid}, {"$set": {"plot_embedding_hf": vector, "title": title, "fullplot": fullplot}}, upsert=True)
        print("vector computed: " + str(doc["_id"]))
    else:
        print("vector already computed")

Step 5: Building the Streamlit App

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
import streamlit as st
from langchain.callbacks.manager import CallbackManager
from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler
from langchain.chains import RetrievalQA
from langchain.llms import LlamaCpp
from langchain.vectorstores import MongoDBAtlasVectorSearch
from langchain.embeddings import HuggingFaceEmbeddings
import pymongo
import config
from langchain_community.llms import Ollama

# Initialize MongoDB client
uri = config.mongo_uri
client = MongoClient(uri)
db_name = config.db_name
coll_name = config.coll_name
collection = client[db_name][coll_name]

# Initialize text embedding model (encoder)
embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")
index_name = "vector_index"
vector_field_name = "plot_embedding_hf"
text_field_name = "title"

# Specify MongoDB Atlas database collection vector search
vectorStore = MongoDBAtlasVectorSearch(
    collection=collection,
    embedding=embeddings,
    index_name=index_name,
    embedding_key=vector_field_name,
    text_key=text_field_name
)

# Callbacks for token-wise streaming
callback_manager = CallbackManager([StreamingStdOutCallbackHandler()])

# Run LLM Ollama
llm = Ollama(model="llama2", callback_manager=callback_manager)

# Streamlit App
def main():
    st.title("Movies Retrieval GPT App")  
    # User input
    query = st.text_input("Enter query:")  
    # Retrieve context data
    retriever = vectorStore.as_retriever()
    # Query LLM with user input context data
    if st.button("Query LLM"):
        with st.spinner("Querying LLM..."):
            qa = RetrievalQA.from_chain_type(
                llm,
                chain_type="stuff",
                retriever=retriever
            )
            response = qa({"query": query})
            st.text("Llama2 Response:")
            st.text(response["result"])

if __name__ == '__main__':
    main()

Step 6: Performance Optimization & Troubleshooting

• Make sure to set proper indexing on your MongoDB collections to speed up retrieval times.
• For your embeddings, consider using different models based on the nature of the data (complex vs simple queries).
• Utilize caching mechanisms to speed up responses.

Conclusion: The Future of AI Applications