Construindo pipelines RAG com haystack e MongoDB Atlas

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

IA Pesquisa vetorial Python Atlas

SNIPPET

Avalie esse Início rápido

A integração dohaystack com oMongoDB Atlas permite que você crie poderosos pipelines de geração aumenta a recuperação (RAG). Este artigo introdutório guiará você pelo processo de configuração de uma pipeline RAG baseada em Pahystack usando o MongoDB Atlas para pesquisa vetorial. Nosso código usará um conjunto de dados de produtos de mercearia e o pipeline RAG pode buscar produtos relevantes para uma solicitação de preparação do usuário. Os mantimentos relevantes são passados para o LLM para um guia gerado detalhado.

Todo o código apresentado neste tutorial está disponível no repositório do GitHub.

Etapa 1: Instalar dependências

Primeiro, instale as dependências necessárias:

Trecho de código

Etapa 2: Configurar a conexão do MongoDB Atlas e a chave de API OpenAI

Se você não criou um Atlas cluster, siga nosso guia. Defina a connection string do MongoDB e a chave de API OpenAI seguindo o guia no site de Open AI.

Trecho de código

Etapa 3: crie um MongoDB Atlas Vector Search na collection

Crie um índice vetorial em seu banco de dados e collection no MongoDB Atlas. Para obter mais informações e orientações, visite nosso Atlas Vector Search Docs. Neste tutorial, o banco de dados é "ai_shop, " e o nome da collection é "test_collection. ". Certifique-se de que o nome do índice seja vector_index e especifique a seguinte sintaxe:

Trecho de código

Etapa 4: Configurar o armazenamento de vetores e carregar documentos

Carregue documentos no MongoDB Atlas usando a estrutura do haystack:

Trecho de código

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

Etapa 5: criar um pipeline RAG

Crie um pipeline que recuperará, aumentará e gerará uma resposta às perguntas do usuário:

Trecho de código

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

Etapa 6: testar o pipeline

Teste o pipeline com uma consulta de amostra:

Trecho de código

Resultado esperado:

Trecho de código

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!

Conclusão

Neste artigo, você aprendera como integrar o Hastack ao MongoDB Atlas para construir um pipeline RAG. Essa combinação poderosa permite que você aproveite a pesquisa vetorial e a geração aumentada de recuperação para criar aplicativos sofisticados e responsivos.

Para explorar mais tópicos sobre RAG, dê uma olhada nos seguintes tutoriais:

Se você tiver dúvidas ou quiser se conectar com outros desenvolvedores, Junte-se a nós na Comunidade de desenvolvedores MongoDB. Obrigado por ler.

Avalie esse Início rápido

Relacionado

Tutorial

Integração do webhook da API de negócios do Facebook com a Data API

Apr 05, 2023 | 10 min read

Tutorial

Combinando seu banco de dados com o armazenamento de blog do Azure usando o Data Federation

Aug 29, 2024 | 7 min read

Tutorial

Como escrever testes de unidade para MongoDB Atlas Functions

Sep 09, 2024 | 10 min read

Tutorial

Acessando dados do Atlas no Postman com a Data API

Aug 13, 2024 | 6 min read

Sumário

Etapa 1: Instalar dependências
Etapa 2: Configurar a conexão do MongoDB Atlas e a chave de API OpenAI
Etapa 3: crie um MongoDB Atlas Vector Search na collection
Etapa 4: Configurar o armazenamento de vetores e carregar documentos
Etapa 5: criar um pipeline RAG
Etapa 6: testar o pipeline
Conclusão