Para agentes de IA: hay un índice de documentación disponible en https://www.mongodb.com/es/docs/llms.txt — versiones en markdown de todas las páginas están disponibles agregando .md a cualquier ruta URL.
Docs Menu
Docs Home
/ /
LangChain
Docs Home
/
Desarrollo
/
Integraciones de IA
/
LangChain
Docs Home
/
Desarrollo
/
Integraciones de IA
/
LangChain

Realice la recuperación del documento principal con MongoDB y LangChain

Puedes integrar MongoDB Vector Search con LangChain para realizar la recuperación de documentos primarios. En este tutorial, completarás los siguientes pasos:

  1. Configura el entorno.

  2. Prepare los datos.

  3. Crear una instancia del recuperador de documentos principal.

  4. Crea el índice de búsqueda vectorial de MongoDB.

  5. Utilice el recuperador en una pipeline RAG.

Segundo plano

La recuperación de documentos principales es una técnica de recuperación que implica dividir grandes documentos en fragmentos más pequeños. En esta técnica, se consultan los fragmentos más pequeños antes de devolver el documento principal completo al LLM. Esto puede mejorar las respuestas de tus agentes RAG y aplicaciones al permitir búsquedas más minuciosas en fragmentos más pequeños mientras se da a los LLMs el contexto completo del documento principal.

La recuperación de documentos principales con MongoDB permite almacenar tanto documentos principales como secundarios en una única colección. Esta técnica facilita la recuperación eficiente al requerir únicamente calcular e indexar los embeddings de los documentos secundarios.

Requisitos previos

Para completar este tutorial, debes tener lo siguiente:

  • Uno de los siguientes tipos de clúster de MongoDB:

    • Un clúster de Atlas que ejecuta la versión 6.0.11, 7.0.2 o posterior de MongoDB. Es necesario garantizar que la dirección IP esté incluida en la lista de acceso del proyecto Atlas.

    • A local Atlas deployment created using Python and Docker. Install atlas-local-lib-py (pip install atlas-local-lib-py) to programmatically create and manage local deployments. To learn more, see the atlas-local-lib-py repository.

    • A MongoDB Community cluster with Search and Vector Search installed.

  • Una clave de API de Voyage AI. Para crear una clave de API, consulta Gestionar claves de API de modelos de Voyage AI.

  • Una llave de API de OpenAI. Debes tener una cuenta de OpenAI con créditos disponibles para las solicitudes de API. Para obtener más información sobre cómo registrar una cuenta de OpenAI, consulta el sitio web de la API de OpenAI.

  • Un entorno para ejecutar cuadernos interactivos de Python como Colab.

Configurar el entorno

Configura el entorno para este tutorial. Cree un cuaderno interactivo de Python guardando un archivo con la extensión .ipynb. Este cuaderno te permite ejecutar snippets de código Python de forma individual y lo utilizarás para ejecutar el código en este tutorial.

Para configurar tu entorno de notebook:

1

Instala e importa las dependencias.

Ejecuta el siguiente comando:

pip install --quiet --upgrade langchain langchain-community langchain-core langchain-mongodb langchain-voyageai langchain-openai pymongo pypdf
2

Defina variables de entorno.

Ejecuta el siguiente código, reemplazando los marcadores de posición con los siguientes valores:

  • Tu clave de API de Voyage IA y OpenAI.

  • La cadena de conexión de tu clúster de MongoDB.

import os
os.environ["VOYAGE_API_KEY"] = "<voyage-api-key>"
os.environ["OPENAI_API_KEY"] = "<openai-api-key>"
MONGODB_URI = "<connection-string>"

Nota

Se debe sustituir <connection-string> por la cadena de conexión del clúster Atlas o de la implementación local de Atlas.

Su cadena de conexión debe usar el siguiente formato:

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

Para obtener más información, consulta Conectar a un clúster a través de bibliotecas de clientes.

Su cadena de conexión debe usar el siguiente formato:

mongodb://localhost:<port-number>/?directConnection=true

Para obtener más información, consulta Cadenas de conexión.

Prepara los datos

Copia y ejecuta el siguiente código en tu notebook para cargar y dividir un PDF de muestra que contiene un reciente informe de ganancias de MongoDB.

Este código utiliza un divisor de texto para fragmentar los datos del PDF en documentos padre más pequeños. Especifica el tamaño del fragmento (número de caracteres) y la superposición de fragmentos (número de caracteres superpuestos entre fragmentos consecutivos) para cada documento.

from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_community.document_loaders import PyPDFLoader
# Load the PDF
loader = PyPDFLoader("https://investors.mongodb.com/node/12881/pdf") 
data = loader.load()
# Chunk into parent documents
parent_splitter = RecursiveCharacterTextSplitter(chunk_size=2000, chunk_overlap=20)
docs = parent_splitter.split_documents(data)
# Print a document
docs[0]

Instanciar el Recuperador

En esta sección, se instancia el recuperador de documentos principal y se utiliza para incorporar datos a MongoDB.

MongoDBAtlasParentDocumentRetriever fragmenta los documentos principales en documentos secundarios más pequeños, inserta los documentos secundarios y luego ingiere tanto los documentos principales como los secundarios en la misma colección en MongoDB. Debajo del capó, este recuperador crea lo siguiente:

  • Una instancia de MongoDBAtlasVectorSearch, un almacén de vectores que gestiona consultas de búsqueda de vectores para los documentos secundarios.

  • Una instancia de MongoDBDocStore, un almacén de documentos que gestiona el almacenamiento y la recuperación de los documentos principales.

1

Instancie el recuperador.

La forma más rápida de configurar MongoDBAtlasParentDocumentRetriever es utilizar el método from_connection_string. Este código especifica los siguientes parámetros:

  • connection_stringConéctese a su clúster usando su cadena de conexión Atlas.

  • child_splitterEl divisor de texto que se utilizará para dividir los documentos principales en documentos secundarios más pequeños.

  • embedding_modelEl modelo de incrustación a utilizar para incrustar los documentos secundarios.

  • database_name y collection_name: El nombre de la base de datos y la colección para la que se van a ingresar los documentos.

  • Los siguientes parámetros opcionales para configurar el almacén vectorial MongoDBAtlasVectorSearch:

    • text_key: El campo en los documentos que contiene el texto para insertar.

    • relevance_scorePuntaje de relevancia para utilizar en la query de búsqueda vectorial.

    • search_kwargsCuántos documentos secundarios se recuperarán en la búsqueda inicial.

from langchain_mongodb.retrievers import MongoDBAtlasParentDocumentRetriever
from langchain_voyageai import VoyageAIEmbeddings
# Define the embedding model to use
embedding_model = VoyageAIEmbeddings(model="voyage-3-large")
# Define the chunking method for the child documents
child_splitter = RecursiveCharacterTextSplitter(chunk_size=200, chunk_overlap=20)
# Specify the database and collection name
database_name = "langchain_db"
collection_name = "parent_document"
# Create the parent document retriever
parent_doc_retriever = MongoDBAtlasParentDocumentRetriever.from_connection_string(
    connection_string = MONGODB_URI,
    child_splitter = child_splitter,
    embedding_model = embedding_model,
    database_name = database_name,
    collection_name = collection_name,
    text_key = "page_content",
    relevance_score_fn = "dotProduct",
    search_kwargs = { "k": 10 },
)

Tip

2

Ingerir los datos

A continuación, ejecuta el siguiente código para cargar los documentos en Atlas usando el método add_documents de retriever. Toma los documentos principales como entrada y procesa tanto los documentos principales como los secundarios según la configuración del recuperador.

parent_doc_retriever.add_documents(docs)
3

(Opcional) Verifica tus documentos.

Después de ejecutar el código de ejemplo, puedes ver los documentos en la Interfaz de Usuario de Atlas navegando hasta la colección langchain_db.parent_document en tu clúster.

Tanto el documento principal como el secundario tienen un campo page_content que contiene el texto en fragmentos. Los child documents también tienen un campo adicional embedding que contiene las incrustaciones vectoriales del texto dividido, y un campo doc_id que corresponde a _id del documento principal.

Puedes ejecutar las siguientes queries en la Interfaz de Usuario de Atlas, reemplazando el marcador de posición <id> por un ID de documento válido:

  • Para ver documentos secundarios que comparten el mismo ID de documento primario:

    { doc_id: "<id>" }

  • Para ver el documento principal de esos documentos secundarios:

    { _id: "<id>" }

Cree el índice de búsqueda vectorial de MongoDB

Para habilitar consultas de búsqueda vectorial en la colección langchain_db.parent_document, debes crear un índice de búsqueda vectorial de MongoDB. Puedes usar el método asistente de LangChain o el método del driver PyMongo. Ejecuta el siguiente código en tu notebook para el método preferido:

# Get the vector store instance from the retriever
vector_store = parent_doc_retriever.vectorstore
# Use helper method to create the vector search index
vector_store.create_vector_search_index(
   dimensions = 1024 # The number of dimensions to index
)
from pymongo import MongoClient
from pymongo.operations import SearchIndexModel
# Connect to your cluster
client = MongoClient(MONGODB_URI)
collection = client[database_name][collection_name]
# Create your vector search index model, then create the index
vector_index_model = SearchIndexModel(
   definition={
      "fields": [
         {
         "type": "vector",
         "path": "embedding",
         "numDimensions": 1024,
         "similarity": "dotProduct"
         }
      ]
   },
   name="vector_index",
   type="vectorSearch"
)
collection.create_search_index(model=vector_index_model)

The index should take about one minute to build. While it builds, the index is in an initial sync state. When it finishes building, you can start querying the data in your collection.

Utiliza el recuperador en tu pipeline RAG

Una vez que MongoDB haya construido tu índice, puedes ejecutar consultas de búsqueda vectorial en tus datos y utilizar el recuperador en tu pipeline RAG. Pega y ejecuta el siguiente código en tu notebook para implementar un pipeline RAG de muestra que realice la recuperación del documento principal:

1

Ejecutar una query de búsqueda vectorial.

Para ver los documentos más relevantes para una query determinada, pega y ejecuta el siguiente código para realizar una consulta de búsqueda vectorial de muestra en la colección. El recuperador busca documentos hijos relevantes que sean semánticamente similares a la string AI technology, y luego devuelve los documentos padres correspondientes de los documentos hijos.

parent_doc_retriever.invoke("AI technology")

Para obtener más información sobre ejemplos de consultas de búsqueda vectorial con LangChain, consulta Ejecutar consultas de búsqueda vectorial.

2

Crear y ejecutar una pipeline RAG.

Para crear y ejecutar una pipeline RAG con el buscador del documento principal, pegue y ejecute el siguiente código. Este código realiza lo siguiente:

  • Defines a LangChain prompt template to instruct the LLM to use the retrieved parent documents as context for your query. LangChain passes these documents to the {context} input variable and your query to the {query} variable.

  • Construye una cadena que especifica lo siguiente:

    • El recuperador de documentos padre que configuraste para recuperar documentos padres relevantes.

    • La plantilla de prompt que definiste.

    • Un LLM de OpenAI para generar una respuesta consciente del contexto. Por defecto, este es el modelo gpt-3.5-turbo.

  • Solicita a la cadena una query de muestra y devuelve la respuesta. La respuesta generada puede variar.

from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import PromptTemplate
from langchain_core.runnables import  RunnablePassthrough
from langchain_openai import ChatOpenAI
# Define a prompt template
template = """
   Use the following pieces of context to answer the question at the end.
   {context}
   Question: {query}?
"""
prompt = PromptTemplate.from_template(template)
model = ChatOpenAI()
# Construct a chain to answer questions on your data
chain = (
   {"context": parent_doc_retriever, "query": RunnablePassthrough()}
   | prompt
   | model
   | StrOutputParser()
)
# Prompt the chain
query = "In a list, what are MongoDB's latest AI announcements?"
answer = chain.invoke(query)
print(answer)
1. MongoDB obtained the AWS Modernization Competency designation.
2. MongoDB launched a MongoDB University course focused on building AI applications with MongoDB and AWS.
3. MongoDB announced new technology integrations for AI, data analytics, and automating database deployments across various environments.
4. MongoDB launched the MongoDB AI Applications Program (MAAP) to help companies harness the power of data and future AI technologies.
5. Capgemini, Confluent, IBM, Unstructured, and QuantumBlack joined the MAAP ecosystem to offer customers additional integration and solution options.

Aprende observando

Sigue este video sobre la recuperación de documentos principales con LangChain y MongoDB.

Duración: 27 minutos

Volver
Búsqueda híbrida
Next
Recuperación de auto-consulta
Califique esta página

En esta página