Building RAG Pipelines With Haystack and MongoDB Atlas

Pavel Duchovny4 min read • Published Sep 18, 2024 • Updated Sep 18, 2024

AI Vector Search Python Atlas

SNIPPET

Rate this quickstart

Integrating Haystack with MongoDB Atlas allows you to build powerful retrieval-augmented generation (RAG) pipelines. This introductory article will guide you through the process of setting up a Haystack-based RAG pipeline using MongoDB Atlas for vector search. Our code will use a grocery product dataset and the RAG pipeline can fetch relevant products for a user cooking request. Relevant groceries are passed to the LLM for a detailed generated guide.

All code presented in this tutorial is available in the GitHub repository.

Step 1: Install dependencies

First, install the necessary dependencies:

Code Snippet

Step 2: Set up MongoDB Atlas connection and OpenAI API key

If you have not created an Atlas cluster, follow our guide. Set the MongoDB connection string and OpenAI API key by following the guide on Open AI website.

Code Snippet

Step 3: Create a Vector Search index on collection

Create a vector index on your database and collection in MongoDB Atlas. For more information and guidance, visit our Atlas Vector Search index docs. In this tutorial, the database is “ai_shop,”, and the collection name is “test_collection.”. Ensure that the index name is vector_index and specify the following syntax:

Code Snippet

Step 4: Set up vector store and load documents

Load documents into MongoDB Atlas using the Haystack framework:

Code Snippet

from haystack import Pipeline, Document
from haystack.document_stores.types import DuplicatePolicy
from haystack.components.writers import DocumentWriter
from haystack.components.embedders import OpenAIDocumentEmbedder
from haystack_integrations.document_stores.mongodb_atlas import MongoDBAtlasDocumentStore
from bson import json_util

# Example dataset
dataset = {
    "train": [
        {"title": "Spinach Lasagna Sheets", "price": "$3.50", "description": "Infused with spinach, these sheets add a pop of color and extra nutrients.", "category": "Pasta", "emoji": "📗"},
        {"title": "Gluten-Free Lasagna Sheets", "price": "$4.00", "description": "Perfect for those with gluten intolerance, made with a blend of rice and corn flour.", "category": "Pasta", "emoji": "🍚🌽"},
        # Add more documents here...
    ]
}
insert_data = []
for product in dataset['train']:
    doc_product = json_util.loads(json_util.dumps(product))
    haystack_doc = Document(content=doc_product['title'], meta=doc_product)
    insert_data.append(haystack_doc)
document_store = MongoDBAtlasDocumentStore(
    database_name="ai_shop",
    collection_name="test_collection",
    vector_search_index="vector_index",
)
doc_writer = DocumentWriter(document_store=document_store, policy=DuplicatePolicy.SKIP)
doc_embedder = OpenAIDocumentEmbedder()
indexing_pipe = Pipeline()
indexing_pipe.add_component(instance=doc_embedder, name="doc_embedder")
indexing_pipe.add_component(instance=doc_writer, name="doc_writer")
indexing_pipe.connect("doc_embedder.documents", "doc_writer.documents")
indexing_pipe.run({"doc_embedder": {"documents": insert_data}})

Step 5: Build a RAG pipeline

Create a pipeline that will retrieve, augment, and generate a response to user questions:

Code Snippet

from haystack.components.generators import OpenAIGenerator
from haystack.components.builders.prompt_builder import PromptBuilder
from haystack.components.embedders import OpenAITextEmbedder
from haystack_integrations.components.retrievers.mongodb_atlas import MongoDBAtlasEmbeddingRetriever

# Prompt template 
prompt_template = """
    You are a chef assistant allowed to use the following context documents and only those.\nDocuments:
    {% for doc in documents %}
        {{ doc.content }}
    {% endfor %}
    \Query: {{query}}
    \nAnswer:
"""

# init a pipeline
rag_pipeline = Pipeline()

# Add embedder and vector store connected 
rag_pipeline.add_component("text_embedder", OpenAITextEmbedder())
rag_pipeline.add_component(instance=MongoDBAtlasEmbeddingRetriever(document_store=document_store, top_k=50), name="retriever")
rag_pipeline.connect("text_embedder.embedding", "retriever.query_embedding")

## Add prompt builder and connect context to prompt to LLM
rag_pipeline.add_component(instance=PromptBuilder(template=prompt_template), name="prompt_builder")
rag_pipeline.add_component(instance=OpenAIGenerator(model="gpt-4o"), name="llm")
rag_pipeline.connect("retriever", "prompt_builder.documents")
rag_pipeline.connect("prompt_builder", "llm")

Step 6: Test the pipeline

Test the pipeline with a sample query:

Code Snippet

Expected output:

Code Snippet

To cook a lasagne, you can follow this classic recipe:
### Ingredients:
#### For the meat sauce:
- 2 tablespoons olive oil
- 1 onion, finely chopped
- 2 cloves garlic, minced
- 500g ground beef
- 800g canned tomatoes, crushed
- 2 tablespoons tomato paste
- 1 teaspoon dried basil
- 1 teaspoon dried oregano
- Salt and pepper to taste
#### For the béchamel sauce:
- 4 tablespoons butter
- 4 tablespoons all-purpose flour
- 500ml milk
- A pinch of nutmeg
- Salt and pepper to taste
#### For assembly:
- 250g lasagne sheets
- 200g mozzarella cheese, shredded
- 1 cup grated Parmesan cheese
- Fresh basil leaves for garnish (optional)
### Instructions:
1. **Preheat the oven** to 375°F (190°C).
2. **Prepare the meat sauce:**
   - Heat the olive oil in a large skillet over medium heat.
   - Add the chopped onion and cook until soft and translucent, about 5 minutes.
   - Stir in the minced garlic and cook for another minute.
   - Add the ground beef and cook until browned, breaking it up with a spoon as it cooks.
   - Stir in the crushed tomatoes, tomato paste, dried basil, and dried oregano.
   - Season with salt and pepper, then reduce the heat to low.
   - Let the sauce simmer for 30 minutes, stirring occasionally.
3. **Prepare the béchamel sauce:**
   - In a medium saucepan, melt the butter over medium heat.
   - Add the flour and whisk continuously for about 2 minutes to create a roux.
   - Gradually add the milk while whisking to prevent lumps from forming.
   - Cook the mixture, whisking constantly, until it thickens, about 5-7 minutes.
   - Season with a pinch of nutmeg, salt, and pepper.
4. **Assemble the lasagne:**
   - Spread a thin layer of the meat sauce on the bottom of a 9x13 inch baking dish.
   - Place a layer of lasagne sheets over the sauce.
   - Spread another layer of meat sauce over the lasagne sheets, followed by a layer of béchamel sauce.
   - Sprinkle some shredded mozzarella cheese over the béchamel sauce.
   - Repeat the layers until all the ingredients are used, finishing with a layer of béchamel sauce and a generous topping of mozzarella and Parmesan cheese.
5. **Bake the lasagne:**
   - Cover the baking dish with aluminum foil.
   - Bake in the preheated oven for 30 minutes.
   - Remove the foil and bake for an additional 15 minutes, or until the top is golden brown and bubbling.
6. **Rest and serve:**
   - Remove the lasagne from the oven and let it rest for 10-15 minutes before slicing.
   - Garnish with fresh basil leaves if desired, and serve.
Enjoy your delicious homemade lasagne!

Conclusion

In this article, you learned how to integrate Haystack with MongoDB Atlas to build a RAG pipeline. This powerful combination allows you to leverage vector search and retrieval-augmented generation to create sophisticated and responsive applications.

To explore more topics on RAG, have a look at the following tutorials:

If you have questions or want to connect with other developers, join us in the MongoDB Developer Community. Thanks for reading.

Rate this quickstart

Article

Implementing Robust RAG Pipelines: Integrating Google's Gemma 2 (2B) Open Model, MongoDB, and LLM Evaluation Techniques

Sep 12, 2024 | 20 min read

Tutorial

Sentiment Chef Agent App with Google Cloud and MongoDB Atlas

Jun 24, 2024 | 16 min read

Article

AI Shop: The Power of LangChain, OpenAI, and MongoDB Atlas Working Together

Sep 18, 2024 | 7 min read

Tutorial

Seamless Media Storage: Integrating Azure Blob Storage and MongoDB With Spring Boot

Aug 01, 2024 | 9 min read

Step 1: Install dependencies
Step 2: Set up MongoDB Atlas connection and OpenAI API key
Step 3: Create a Vector Search index on collection
Step 4: Set up vector store and load documents
Step 5: Build a RAG pipeline
Step 6: Test the pipeline
Conclusion

Atlas

Building RAG Pipelines With Haystack and MongoDB Atlas

Step 1: Install dependencies

Step 2: Set up MongoDB Atlas connection and OpenAI API key

Step 3: Create a Vector Search index on collection

Step 4: Set up vector store and load documents

Step 5: Build a RAG pipeline

Step 6: Test the pipeline

Conclusion

Related

Implementing Robust RAG Pipelines: Integrating Google's Gemma 2 (2B) Open Model, MongoDB, and LLM Evaluation Techniques

Sentiment Chef Agent App with Google Cloud and MongoDB Atlas

AI Shop: The Power of LangChain, OpenAI, and MongoDB Atlas Working Together

Seamless Media Storage: Integrating Azure Blob Storage and MongoDB With Spring Boot

Table of Contents