Se puede integrar MongoDB con LangChain para compilar aplicaciones de IA generativa y RAG. Esta página ofrece una visión general de la integración de LangChain MongoDB en Python y los diferentes componentes que se pueden utilizar en las aplicaciones.
EmpezarNota
Para una lista completa de componentes y métodos, consultar Referencia de API.
Para la integración de JavaScript, se puede consultar LangChain JS/TS.
Instalación y configuración
Para utilizar la búsqueda vectorial de MongoDB con LangChain, primero se debe instalar el paquete langchain-mongodb:
pip install langchain-mongodbAlmacenamiento de vectores
MongoDBAtlasVectorSearch es un almacén vectorial que le permite almacenar y recuperar incrustaciones de vectores de una colección en MongoDB. Se puede usar este componente para almacenar incrustaciones de los datos y recuperarlas usando la MongoDB Vector Search.
Este componente requiere un Índice de búsqueda vectorial de MongoDB.
Uso
Atlas admite dos modos de integración:
Incorporación manual: Generar vectores de incorporación en el lado del cliente con un modelo de incorporación que especifiques.
Incrustación automatizada: MongoDB incrusta texto del lado del servidor sin necesidad de generarlo manualmente. Para aprender más, consulta Incrustación automatizada.
La forma más rápida de instanciar el almacenamiento vectorial es utilizar la cadena de conexión para el clúster MongoDB o implementación local:
from langchain_mongodb.vectorstores import MongoDBAtlasVectorSearchfrom langchain_voyageai import VoyageAIEmbeddings
# Instantiate the vector store using your MongoDB connection stringvector_store = MongoDBAtlasVectorSearch.from_connection_string( connection_string="<connection-string>", # MongoDB cluster URI namespace="<database-name>.<collection-name>", # Database and collection name embedding=VoyageAIEmbeddings(model="voyage-3-large"), # Embedding model to use index_name="vector_index", # Name of the vector search index # Other optional parameters...)Para utilizar la incrustación automatizada, pasa una instancia de AutoEmbeddings al parámetro embedding. Esto permite que MongoDB genere y gestione vectores de incrustación automáticamente.
Con incrustaciones automatizadas:
No se requiere cálculo de integración en el lado del cliente
El texto sin procesar se envía directamente a MongoDB
Los vectores de incrustación se generan en el lado del servidor
El
embedding_keycampo no se almacena en los documentos
from langchain_mongodb.vectorstores import MongoDBAtlasVectorSearchfrom langchain_mongodb.embeddings import AutoEmbeddingsfrom langchain_core.documents import Document
# Some documents to embeddocs = [ Document(page_content="foo", metadata={"baz": "bar"}), Document(page_content="thud", metadata={"bar": "baz"}),]
# Instantiate the vector store with Automated Embeddingvector_store = MongoDBAtlasVectorSearch.from_connection_string( connection_string="<connection-string>", # MongoDB cluster URI namespace="<database-name>.<collection-name>", # Database and collection name embedding=AutoEmbeddings(model="voyage-4"), # Enable Automated Embedding index_name="vector_index", # Name of the vector search index # Other optional parameters...)
# Add documents - text is embedded server-sidevector_store.add_documents(documents=docs)
# Search - queries are embedded server-sideresults = vector_store.similarity_search("search query")La integración también ofrece soporte a otros métodos para instanciar el almacén de vectores:
Usar al cliente de MongoDB:
from langchain_mongodb.vectorstores import MongoDBAtlasVectorSearchfrom langchain_voyageai import VoyageAIEmbeddingsfrom pymongo import MongoClient # Connect to your MongoDB clusterclient = MongoClient("<connection-string>")collection = client["<database-name>"]["<collection-name>"] # Instantiate the vector storevector_store = MongoDBAtlasVectorSearch( collection=collection, # Collection to store embeddings embedding=VoyageAIEmbeddings(model="voyage-3-large"), # Embedding model to use index_name="vector_index", # Name of the vector search index # Other optional parameters...)De los documentos que se han creado:
from langchain_mongodb.vectorstores import MongoDBAtlasVectorSearchfrom langchain_voyageai import VoyageAIEmbeddingsfrom langchain_core.documents import Documentfrom pymongo import MongoClient # Some documents to embeddocument_1 = Document(page_content="foo", metadata={"baz": "bar"})document_2 = Document(page_content="thud", metadata={"bar": "baz"})docs = [document_1, document_2] # Connect to your MongoDB clusterclient = MongoClient("<connection-string>")collection = client["<database-name>"]["<collection-name>"] # Create the vector store from documentsvector_store = MongoDBAtlasVectorSearch.from_documents( documents=docs, # List of documents to embed embedding=VoyageAIEmbeddings(model="voyage-3-large"), # Embedding model to use collection=collection, # Collection to store embeddings index_name="vector_index", # Name of the vector search index)
Retrievers
Los recuperadores de LangChain son componentes que se utilizan para obtener documentos relevantes de los almacenes vectoriales. Se pueden utilizar los recuperadores son una funcionalidad incorporada de LangChain o los siguientes recuperadores de MongoDB para query y recuperar datos de MongoDB.
Recuperador de búsqueda vectorial
Después de instanciar MongoDB como un almacén de vectores, puedes utilizar la instancia de almacén de vectores como un recuperador para consultar tus datos usando MongoDB búsqueda vectorial.
Uso
from langchain_mongodb.vectorstores import MongoDBAtlasVectorSearchfrom langchain_voyageai import VoyageAIEmbeddings
# Instantiate the vector storevector_store = MongoDBAtlasVectorSearch.from_connection_string( connection_string="<connection-string>", # MongoDB cluster URI namespace="<database-name>.<collection-name>", # Database and collection name embedding=VoyageAIEmbeddings(model="voyage-3-large"), # Embedding model to use index_name="vector_index", # Name of the vector search index)
# Use the vector store as a retrieverretriever = vector_store.as_retriever()
# Define your queryquery = "some search query"
# Print resultsdocuments = retriever.invoke(query)for doc in documents: print(doc)Recuperador de texto completo
MongoDBAtlasFullTextSearchRetriever es un recuperador que realiza búsquedas de texto completo utilizando MongoDB Search. En concreto, utiliza el estándar de Lucene Algoritmo BM25.
Este impulsor requiere un MongoDB Search Índice.
Uso
from langchain_mongodb.retrievers.full_text_search import ( MongoDBAtlasFullTextSearchRetriever,)from pymongo import MongoClient
# Connect to your MongoDB clusterclient = MongoClient("<connection-string>")collection = client["<database-name>"]["<collection-name>"]
# Initialize the retrieverretriever = MongoDBAtlasFullTextSearchRetriever( collection=collection, # MongoDB Collection in Atlas search_field="<field-name>", # Name of the field to search search_index_name="<index-name>", # Name of the search index)
# Define your queryquery = "some search query"
# Print resultsdocuments = retriever.invoke(query)for doc in documents: print(doc)Nota
Recuperador de búsqueda híbrida
MongoDBAtlasHybridSearchRetriever es un recuperador que combina los resultados de búsqueda vectorial y de texto completo mediante el algoritmo de Fusión de Rango Recíproco (RRF). Para obtener más información, consulta Cómo realizar una búsqueda híbrida.
Este recuperador requiere un almacén de vectores existente, un índice de búsqueda vectorial de MongoDB y un índice de MongoDB Search.
Uso
from langchain_mongodb.retrievers.hybrid_search import ( MongoDBAtlasHybridSearchRetriever,)from langchain_mongodb.vectorstores import MongoDBAtlasVectorSearchfrom langchain_voyageai import VoyageAIEmbeddings
# Instantiate the vector storevector_store = MongoDBAtlasVectorSearch.from_connection_string( connection_string="<connection-string>", # MongoDB cluster URI namespace="<database-name>.<collection-name>", # Database and collection name embedding=VoyageAIEmbeddings(model="voyage-3-large"), # Embedding model to use index_name="vector_index", # Name of the vector search index)
# Initialize the retrieverretriever = MongoDBAtlasHybridSearchRetriever( vectorstore=vector_store, # Vector store instance search_index_name="<index-name>", # Name of the MongoDB Search index top_k=5, # Number of documents to return fulltext_penalty=60.0, # Penalty for full-text search vector_penalty=60.0, # Penalty for vector search)
# Define your queryquery = "some search query"
# Print resultsdocuments = retriever.invoke(query)for doc in documents: print(doc)Parent Document Retriever
MongoDBAtlasParentDocumentRetriever es un recuperador que ejecuta queries en los fragmentos más pequeños y luego devuelve el documento principal más grande al LLM. Este tipo de recuperación se denomina recuperación de documento principal. La recuperación de documentos principales puede mejorar las respuestas de sus agentes y aplicaciones RAG al permitir búsquedas más granulares en fragmentos más pequeños, mientras se proporciona a los LLMel contexto completo del documento principal.
Este recuperador almacena tanto los documentos principales como los documentos secundarios en una única colección de MongoDB, lo que permite una recuperación eficiente al tener que calcular y crear un índice de solo las incrustaciones de los documentos secundarios.
Internamente, este recuperador crea lo siguiente:
Una instancia de MongoDBAtlasVectorSearch para gestionar queries de búsqueda vectorial a los documentos secundarios.
Una instancia de MongoDBDocStore para gestionar el almacenamiento y la recuperación de los documentos principales.
Uso
Establezca text_key en page_content para que el almacén de vectores y el almacén de documentos padre utilicen el mismo nombre de campo para el texto del documento. Sin este parámetro, el recuperador guarda documentos principales en un campo y los lee de otro, y las queries fallan con KeyError: 'text'.
from langchain_mongodb.retrievers import MongoDBAtlasParentDocumentRetrieverfrom langchain_text_splitters import RecursiveCharacterTextSplitterfrom langchain_voyageai import VoyageAIEmbeddings
retriever = MongoDBAtlasParentDocumentRetriever.from_connection_string( connection_string="<connection-string>", # MongoDB cluster URI embedding_model=VoyageAIEmbeddings( # Embedding model to use model="voyage-3-large" ), child_splitter=RecursiveCharacterTextSplitter(), # Text splitter to use database_name="<database-name>", # Database to store the collection collection_name="<collection-name>", # Collection to store the collection text_key="page_content", # Match the key the parent document store uses # Additional vector store or parent class arguments...)
# Define your queryquery = "some search query"
# Print resultsdocuments = retriever.invoke(query)for doc in documents: print(doc)Recuperador de autoquery
MongoDBAtlasSelfQueryRetriever es un recuperador que se hace queries. El recuperador utiliza un LLM para procesar la consulta de búsqueda que se le haga con el fin de identificar posibles filtros de metadatos, forma un query de búsqueda vectorial estructurada con los filtros y luego ejecuta el query para recuperar los documentos más relevantes.
Por ejemplo, con un query como "¿Cuáles son las películas de suspenso después de 2010 con calificaciones superiores a 8?", el sistema de recuperación puede identificar filtros en los campos genre, year y rating y utilizarlos para recuperar documentos que coincidan con el query.
Este recuperador requiere un almacén de vectores existente y un Índice de búsqueda vectorial de MongoDB.
Uso
from langchain_mongodb.retrievers import MongoDBAtlasSelfQueryRetrieverfrom langchain_mongodb import MongoDBAtlasVectorSearchfrom langchain_classic.chains.query_constructor.schema import AttributeInfofrom langchain_voyageai import VoyageAIEmbeddingsfrom langchain_openai import ChatOpenAI
llm = ChatOpenAI(model="gpt-4o", temperature=0)
vector_store = MongoDBAtlasVectorSearch.from_connection_string( connection_string="<connection-string>", namespace="langchain_db.movies", embedding=VoyageAIEmbeddings(model="voyage-3-large"), index_name="vector_index",)
# Given an existing vector store with movies data, define metadata describing the datametadata_field_info = [ AttributeInfo( name="genre", description="The genre of the movie. One of ['science fiction', 'comedy', 'drama', 'thriller', 'romance', 'animated']", type="string", ), AttributeInfo( name="year", description="The year the movie was released", type="integer", ), AttributeInfo( name="rating", description="A 1-10 rating for the movie", type="float" ),]
# Create the retriever from the VectorStore, an LLM and info about the documentsretriever = MongoDBAtlasSelfQueryRetriever.from_llm( llm=llm, vectorstore=vector_store, metadata_field_info=metadata_field_info, document_contents="Descriptions of movies", enable_limit=True,)
# This example results in the following composite filter sent to $vectorSearch:# {'filter': {'$and': [{'year': {'$lt': 1960}}, {'rating': {'$gt': 8}}]}}documents = retriever.invoke("Movies made before 1960 that are rated higher than 8")print(documents)GraphRAG
GraphRAG es un enfoque alternativo al RAG tradicional que estructura los datos como un grafo de conocimiento de entidades y su relación en lugar de como incrustación vectorial. Mientras que el RAG basado en vectores encuentra documentos que son semánticamente similares a la query, GraphRAG encuentra entidades conectadas a la query y recorre las relaciones en el grafo para recuperar información relevante.
Este enfoque es particularmente útil para responder preguntas basadas en relación como "¿Cuál es la conexión entre la empresa A y la empresa B?" o "¿Quién es el administrador de la Persona X?".
MongoDBGraphStore es un componente en la integración de LangChain MongoDB que permite implementar GraphRAG al almacenar entidades (nodos) y sus relaciones (aristas) en una colección de MongoDB. Este componente almacena cada entidad como un documento con campos de relación que hacen referencia a otros documentos en su colección. Ejecutar las queries utilizando la $graphLookup etapa de agregación.
Uso
from langchain_mongodb.graphrag import MongoDBGraphStorefrom langchain_openai import ChatOpenAIfrom langchain_core.documents import Document
# Initialize the graph storegraph_store = MongoDBGraphStore( connection_string="<connection-string>", # MongoDB cluster URI database_name="<database-name>", # Database to store the graph collection_name="<collection-name>", # Collection to store the graph entity_extraction_model=ChatOpenAI( # LLM to extract entities model="gpt-4o", temperature=0 ), # Other optional parameters...)
# Add documents to the graphdocs = [ Document( page_content=( "MongoDB is a document database. " "Dev Ittycheria is the CEO of MongoDB." ) ), Document(page_content="MongoDB Atlas is the cloud platform offered by MongoDB."),]graph_store.add_documents(docs)
# Query the graphquery = "Who is the CEO of MongoDB?"answer = graph_store.chat_response(query)print(answer.content)Cachés de LLM
Las cachés se utilizan para optimizar el rendimiento de los LLM almacenando respuestas repetitivas para queries similares o repetitivas, evitando así tener que volver a calcularlas. MongoDB proporciona las siguientes cachés para las aplicaciones de LangChain.
Caché de MongoDB
MongoDBCache le permite almacenar una caché básica en una colección de MongoDB.
Uso
from langchain_mongodb import MongoDBCachefrom langchain_core.globals import set_llm_cache
set_llm_cache( MongoDBCache( connection_string="<connection-string>", # MongoDB cluster URI database_name="langchain_db", # Database to store the cache collection_name="cache", # Collection to store the cache ))Caché semántica
El caché semántico es una forma más avanzada de almacenamiento en caché que recupera las indicaciones almacenadas en caché en función de la similitud semántica entre la entrada del usuario y los resultados almacenados en caché.
MongoDBAtlasSemanticCache es un caché semántico que utiliza MongoDB búsqueda vectorial para recuperar las indicaciones almacenadas en caché. Este componente requiere un Índice de Búsqueda Vectorial de MongoDB.
Uso
from langchain_mongodb import MongoDBAtlasSemanticCachefrom langchain_core.globals import set_llm_cachefrom langchain_voyageai import VoyageAIEmbeddings
set_llm_cache( MongoDBAtlasSemanticCache( embedding=VoyageAIEmbeddings(model="voyage-3-large"), # Embedding model connection_string="<connection-string>", # MongoDB cluster URI database_name="langchain_db", # Database to store the cache collection_name="semantic_cache", # Collection to store the cache ))Sistema de archivos virtual de DeepAgents
LangChain DeepAgents es un sistema de agente diseñado para tareas de larga duración y de varios pasos. Gestiona la planificación, la gestión del contexto y delega tareas a subagentes. El arnés admite un protocolo de backend intercambiable que le permite cambiar dónde residen realmente los archivos de un agente. El paquete langchain-mongodb-deepagents-vfs es una implementación de ese protocolo: Amazon S3 almacena los archivos, un proveedor de incrustación (Amazon Web Services Bedrock o OpenAI) calcula las incrustaciones, MongoDB Atlas almacena los fragmentos y las incrustaciones, y la clase MongoFilesystemBackend enruta cada operación de archivo al controlador correcto.
Utilice este paquete cuando su agente necesite buscar un gran conjunto de archivos existentes en S3. grep se ejecuta como una única agregación de MongoDB que combina resultados de búsqueda de texto completo y búsqueda vectorial utilizando el algoritmo de fusión de rango recíproco (RRF), por lo que escalará sin cargar cada archivo en su agente para filtrarlos uno por uno. glob y ls gestionan las búsquedas de nombres de archivo y directorios directamente. Cuando un agente llama a read, write, edit, upload_files u download_files, esas llamadas van directamente a S3, donde residen sus archivos. Los archivos agregados por otras herramientas se detectan e indexan automáticamente mediante el observador del backend.
Antes de instalar el paquete, asegúrese de tener:
Una cadena de conexión de MongoDB Atlas
Credenciales de Amazon Web Services (
AWS_ACCESS_KEY_ID,AWS_SECRET_ACCESS_KEY,AWS_DEFAULT_REGION), con una política de IAM que otorga:s3:GetObjects3:PutObject,s3:ListBucketys3:DeleteObjecten su bucket S3bedrock:InvokeModelenamazon.titan-embed-text-v2:0, en la misma región queAWS_DEFAULT_REGION, necesario si utiliza el proveedor de Bedrock por defecto
Su elección de proveedor de incrustación: Bedrock (por defecto, utiliza las credenciales de Amazon Web Services anteriores) o OpenAI (establezca
EMBEDDING_PROVIDER=openaiy proporcione unOPENAI_API_KEY)
Para instalar el paquete, determine si desea que MongoDB genere incrustaciones de búsqueda utilizando AWS Bedrock u OpenAI y ejecute el comando correspondiente:
pip install "langchain-mongodb-deepagents-vfs[bedrock]"pip install "langchain-mongodb-deepagents-vfs[openai]"Uso
Instancie MongoFilesystemBackend con el nombre de su bucket S3 y la cadena de conexión de Atlas. El siguiente ejemplo escribe dos archivos en S3 y luego demuestra cada método de búsqueda:
grepbusca en el contenido del archivoglobcoincide con rutas de archivo por patrónlsenumera el contenido de un directorio
from langchain_mongodb_deepagents_vfs import MongoFilesystemBackend
# Instantiate the backendbackend = MongoFilesystemBackend( s3_bucket_name="<bucket-name>", # S3 bucket that stores your files mongodb_connection_string="<connection-string>", # MongoDB Atlas connection string)
# Write two files to S3: one .txt, one .md, so glob can demonstrate# filtering by extensionbackend.write("mongodb_vfs/docs/notes.txt", "Our authentication flow uses OAuth 2.0.")backend.write("mongodb_vfs/docs/overview.md", "This directory contains onboarding docs.")
# Search for files that mention "authentication flow"# Newly written files can take a few seconds to become searchableresult = backend.grep("authentication flow", path="mongodb_vfs/docs/")print("grep matches:")for match in result.matches or []: print(match["path"], match["line"], match["text"])
# Find files that match a glob patternresult = backend.glob("*.txt", path="mongodb_vfs/docs/")print("glob matches:", result.matches)
# List the contents of a directoryresult = backend.ls("mongodb_vfs/docs/")print("ls entries:", result.entries)
print("init_errors:", backend.init_errors)Por defecto, el backend restringe cada operación al prefijo mongodb_vfs/ de su bucket. Pase un valor s3_prefix diferente a MongoFilesystemBackend para cambiar esto, o s3_prefix="" para acceder a todo el bucket.
Nota
Para aprender a conectar este backend a un agente de DeepAgents, consulte la Guía de inicio rápido de DeepAgents.
Kit de herramientas de MongoDB Agent
El MongoDB Agent Toolkit es una colección de herramientas que se puede pasar a un agente LangGraph ReAct para que se pueda interactuar con los recursos de MongoDB.
Herramientas disponibles
Nombre | Descripción |
|---|---|
| Una herramienta para consultar una base de datos MongoDB. |
| Una herramienta para obtener metadatos sobre una base de datos de MongoDB. |
| Una herramienta para obtener los nombres de las colecciones de una base de datos de MongoDB. |
| Una herramienta que llama a un LLM para comprobar si un query de base de datos es correcto. |
Uso
from langchain_openai import ChatOpenAIfrom langgraph.prebuilt import create_react_agentfrom langchain_mongodb.agent_toolkit import ( MONGODB_AGENT_SYSTEM_PROMPT, MongoDBDatabase, MongoDBDatabaseToolkit,)
db_wrapper = MongoDBDatabase.from_connection_string( "<connection-string>", database="<database-name>")llm = ChatOpenAI(model="gpt-4o-mini", timeout=60)toolkit = MongoDBDatabaseToolkit(db=db_wrapper, llm=llm)
system_message = MONGODB_AGENT_SYSTEM_PROMPT.format(top_k=5)
test_query = "Which country's customers spent the most?"agent = create_react_agent(llm, toolkit.get_tools(), prompt=system_message)agent.step_timeout = 60events = agent.stream( {"messages": [("user", test_query)]}, stream_mode="values",)
messages = []for event in events: messages.extend(event["messages"])print(messages[-1].content)Nota
Cargador de Documentos
Cargadores de documentos son herramientas que ayudan a cargar datos para las aplicaciones de LangChain.
MongoDBLoader es un cargador de documentos que devuelve una lista de documentos desde una base de datos de MongoDB.
Uso
from langchain_mongodb.loaders import MongoDBLoader
loader = MongoDBLoader.from_connection_string( connection_string="<connection-string>", # MongoDB cluster URI db_name="langchain_db", # Database that contains the collection collection_name="documents", # Collection to load documents from filter_criteria={"category": "ai"}, # Optional document to specify a filter field_names=["title", "summary"], # Optional list of fields to include metadata_names=["category"], # Optional metadata fields to extract)
docs = loader.load()Nota
Historial de chat
MongoDBChatMessageHistory es un componente que le permite almacenar y gestionar historiales de mensajes de chat en una base de datos de MongoDB. Puede guardar tanto los mensajes generados por el usuario como los generados por la IA asociados a un identificador de sesión único. Utilice este componente para aplicaciones que rastrean interacciones a lo largo del tiempo, como los chatbots.
Uso
from langchain_mongodb.chat_message_histories import MongoDBChatMessageHistory
chat_message_history = MongoDBChatMessageHistory( session_id="<session-id>", # Unique session identifier connection_string="<connection-string>", # MongoDB cluster URI database_name="langchain_db", # Database to store the chat history collection_name="chat_history", # Collection to store the chat history)
chat_message_history.add_user_message("Hello")chat_message_history.add_ai_message("Hi")print(chat_message_history.messages)[HumanMessage(content='Hello', additional_kwargs={}, response_metadata={}), AIMessage(content='Hi', additional_kwargs={}, response_metadata={}, tool_calls=[], invalid_tool_calls=[])]Almacenamiento
Se pueden utilizar los siguientes almacenes de datos personalizados para gestionar y almacenar datos en MongoDB.
Tienda de documentos
MongoDBDocStore es un almacén de clave-valor personalizado que utiliza MongoDB para almacenar y gestionar documentos. Se pueden realizar operaciones CRUD como lo haría en cualquier otra colección de MongoDB.
Uso
from langchain_mongodb.docstores import MongoDBDocStore
# Replace with your MongoDB connection string and namespaceconnection_string = "<connection-string>"namespace = "<database-name>.<collection-name>"
# Initialize the MongoDBDocStoredocstore = MongoDBDocStore.from_connection_string(connection_string, namespace)Nota
Almacenamiento binario
MongoDBByteStore es un almacén de datos personalizado que utiliza MongoDB para almacenar y gestionar datos binarios, específicamente datos representados en bytes. Se pueden realizar operaciones CRUD con pares clave-valor donde las claves son cadenas y los valores son secuencias de bytes.
Uso
from langchain_community.storage.mongodb import MongoDBByteStore
# Instantiate the MongoDBByteStoremongodb_store = MongoDBByteStore( connection_string="<connection-string>", # MongoDB cluster URI db_name="langchain_db", # Name of the database collection_name="byte_store", # Name of the collection)
# Set values for keysmongodb_store.mset([("key1", b"hello"), ("key2", b"world")])
# Get values for keysvalues = mongodb_store.mget(["key1", "key2"])print(values)
# Iterate over keysfor key in mongodb_store.yield_keys(): print(key)
# Delete keysmongodb_store.mdelete(["key1", "key2"])[b'hello', b'world']key1key2Nota
Recursos adicionales
Para aprender cómo integrar MongoDB con LangGraph, se puede consultar Integrar MongoDB con LangGraph.
Para cuadernos interactivos de Python, se puede consultar el Repositorio de Docs Notebooks y el Repositorio de Casos de Uso de IA generativa.