Introdução à integração do Haystack

Plano de fundo

Haystack é um framework para criar aplicativos personalizados com LLMs, modelos de incorporação e pesquisa vetorial. Ao integrar o Atlas Vector Search com o Haystack, você pode usar o Atlas como um banco de dados vetorial e usar o Atlas Vector Search para implementar o RAG recuperando documentos semanticamente semelhantes de seus dados. Para saber mais sobre a RAG, consulte RAG (Retrieval-Augmented Generation) com Atlas Vector Search.

Pré-requisitos

Para concluir este tutorial, você deve ter o seguinte:

• Uma conta do Atlas com um cluster executando o MongoDB versão 6.0.11, 7.0.2 ou posterior (incluindo RCs). Garanta que seu endereço IP esteja incluído na lista de acesso do seu projeto Atlas . Para saber mais, consulte Criar um cluster.

• Uma chave de API OpenAI. Você deve ter uma conta paga do OpenAI com créditos disponíveis para solicitações de API. Para saber mais sobre como registrar uma conta OpenAI, consulte o site da API OpenAI.

• Um bloco de anotações para executar seu projeto Python, como o CoLab.

  Observação

  Se estiver usando o Colab, certifique-se de que o endereço IP da sessão do notebook esteja incluído na lista de acesso do projeto Atlas.

Configurar o ambiente

Configure o ambiente para este tutorial. Crie um bloco de anotações Python interativo salvando um arquivo com a extensão .ipynb. Este bloco de anotações permite que você execute trechos de código Python individualmente, e você o usará para executar o código neste tutorial.

Para configurar seu ambiente de bloco de anotações:

os.environ["OPENAI_API_KEY"] = "<api-key>"
os.environ["MONGO_CONNECTION_STRING"]= "<connection-string>"

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

Criar o índice Atlas Vector Search Index

Nesta seção, você cria o banco de dados haystack_db e a coleção test para armazenar seus dados personalizados. Em seguida, para habilitar queries de pesquisa vetorial nos dados, você cria um índice do Atlas Vector Search.

client = MongoClient(os.environ.get("MONGO_CONNECTION_STRING"))

# Create your database and collection
db_name = "haystack_db"
collection_name = "test"
database = client[db_name]
database.create_collection(collection_name)
# Define collection
collection = client[db_name][collection_name]

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

Armazenar dados personalizados no Atlas

Nesta seção, você infunde o Atlas como um banco de banco de dados vetorial , também chamado de armazenamento de documento. Em seguida, você cria incorporações vetoriais a partir de dados personalizados e armazena esses documentos em uma coleção no Atlas. Cole e execute os seguintes trechos de código no seu notebook.

document_store = MongoDBAtlasDocumentStore(
   database_name="haystack_db",
   collection_name="test",
   vector_search_index="vector_index",
)

# Create some example documents
documents = [
   Document(content="My name is Jean and I live in Paris."),
   Document(content="My name is Mark and I live in Berlin."),
   Document(content="My name is Giorgio and I live in Rome."),
]
# Initializing a document embedder to convert text content into vectorized form.
doc_embedder = OpenAIDocumentEmbedder()
# Setting up a document writer to handle the insertion of documents into the MongoDB collection.
doc_writer = DocumentWriter(document_store=document_store, policy=DuplicatePolicy.SKIP)
# Creating a pipeline for indexing documents. The pipeline includes embedding and writing documents.
indexing_pipe = Pipeline()
indexing_pipe.add_component(instance=doc_embedder, name="doc_embedder")
indexing_pipe.add_component(instance=doc_writer, name="doc_writer")
# Connecting the components of the pipeline for document flow.
indexing_pipe.connect("doc_embedder.documents", "doc_writer.documents")
# Running the pipeline with the list of documents to index them in MongoDB.
indexing_pipe.run({"doc_embedder": {"documents": documents}})

Calculating embeddings: 100%|██████████| 1/1 [00:00<00:00,  4.16it/s]
{'doc_embedder': {'meta': {'model': 'text-embedding-ada-002',
   'usage': {'prompt_tokens': 32, 'total_tokens': 32}}},
 'doc_writer': {'documents_written': 3}}

Responda a perguntas sobre seus dados

Esta seção demonstra como implementar a RAG em seu aplicativo com o Atlas Vector Search e o Haystack.

O código a seguir define e executa um pipeline com os seguintes componentes:

• O incorporador OpenAITextEmbedder para criar incorporações a partir da sua query.

• O MongoDBAtlasEmbeddingRetriever recuperador para recuperar incorporações do seu armazenamento de documentos que sejam semelhantes à incorporação da consulta.

• Um Promptbuilder que passa um modelo de prompt para orientar o LLM a usar o documento recuperado como contexto para seu prompt.

• O gerador OpenAIGenerator to gera uma resposta sensível ao contexto usado LLM da OpenAI.

Neste exemplo, você solicita ao LLM a consulta de exemplo Where does Mark live?. O LLM gera uma resposta precisa e contextualizada a partir dos dados personalizados armazenados no Atlas.

# Template for generating prompts for a movie recommendation engine.
prompt_template = """
    You are an assistant allowed to use the following context documents.\nDocuments:
    {% for doc in documents %}
        {{ doc.content }}
    {% endfor %}
    \nQuery: {{query}}
    \nAnswer:
"""
# Setting up a retrieval-augmented generation (RAG) pipeline for generating responses.
rag_pipeline = Pipeline()
rag_pipeline.add_component("text_embedder", OpenAITextEmbedder())
# Adding a component for retrieving related documents from MongoDB based on the query embedding.
rag_pipeline.add_component(instance=MongoDBAtlasEmbeddingRetriever(document_store=document_store,top_k=15), name="retriever")
# Building prompts based on retrieved documents to be used for generating responses.
rag_pipeline.add_component(instance=PromptBuilder(template=prompt_template), name="prompt_builder")
# Adding a language model generator to produce the final text output.
rag_pipeline.add_component(instance=OpenAIGenerator(), name="llm")
# Connecting the components of the RAG pipeline to ensure proper data flow.
rag_pipeline.connect("text_embedder.embedding", "retriever.query_embedding")
rag_pipeline.connect("retriever", "prompt_builder.documents")
rag_pipeline.connect("prompt_builder", "llm")
# Run the pipeline
query = "Where does Mark live?"
result = rag_pipeline.run(
  {
      "text_embedder": {"text": query},
      "prompt_builder": {"query": query},
  });
print(result['llm']['replies'][0])

Mark lives in Berlin.

Próximos passos

O MongoDB também fornece os seguintes recursos para desenvolvedores:

• Construindo pipelines RAG com haystack e MongoDB Atlas

• Notebook Python interativo

• Espaço Hugging Face

• Repositório do GitHub para desenvolvedores do MongoDB