Comece com a integração com o haystack

Plano de fundo

OHaystack é uma estrutura para criar aplicativos personalizados com LLMs, modelos de incorporação e pesquisa vetorial. Ao integrar o Atlas Vector Search com oHaystack, 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 o RAG, consulte Geração de Recuperação Aumentada (RAG) com Atlas Vector Search .

Pré-requisitos

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

• Um Atlas 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 acessodo seu projeto Atlas.

• Uma chave de API OpenAI. Você deve ter uma conta OpenAI paga com créditos disponíveis para solicitações de API.

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

Configurar o ambiente

Você deve primeiro configurar o ambiente para este tutorial. Crie um bloco de anotações Python interativo salvando um arquivo com a extensão .ipynb e, em seguida, execute os seguintes trechos de código no bloco de anotações:

os.environ["OPENAI_API_KEY"] = getpass.getpass("OpenAI API Key:")
os.environ["MONGO_CONNECTION_STRING"]=getpass.getpass("MongoDB Atlas 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 do haystack_db e a coleção do test para armazenar seus dados personalizados. Em seguida, para habilitar consultas de pesquisa vetorial em seus dados, crie 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ê instancia o Atlas como um banco de dados vetorial, também chamado de armazenamento de documentos . Em seguida, crie incorporações vetoriais a partir de dados personalizados e armazene esses documentos em uma coleção no Atlas. Cole e execute os seguintes trechos de código em seu bloco de anotações.

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 o RAG em seu aplicativo com o Atlas Vector Search e o Haste do hash.

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

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

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

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

• O OpenAIGenerator gerador para gerar uma resposta sensível ao contexto usando um LLM da OpenAI.

Neste exemplo, você solicita ao LLM a consulta de amostra Where does Mark live?. O LLM gera uma resposta precisa e sensível ao contexto 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

• Abraçando o espaço do face

• Repositório do GitHub para desenvolvedores do MongoDB