Para agentes de IA: um índice de documentação está disponível em https://www.mongodb.com/pt-br/docs/llms.txt — as versões de markdown de todas as páginas estão disponíveis anexando .md a qualquer caminho de URL.

Integre o MongoDB ao LangGraph

Você pode integrar o MongoDB ao LangGraph para criar agentes de IA e aplicativos RAG avançados. Esta página fornece uma visão geral da integração do MongoDB LangGraph e como você pode usar o MongoDB para persistência, memória e recuperação de estado do agente em seus fluxos de trabalho do LangGraph.

Observação

Para a integração do JavaScript, consulte LangGraph JS/TS.

LangGraph é um framework especializado dentro do ecossistema LangChain, projetado para desenvolver agentes de IA e fluxos de trabalho complexos de múltiplos agentes. Grafos são os componentes centrais do LangGraph, representando o fluxo de trabalho do seu agente. A integração do MongoDB LangGraph habilita as seguintes funcionalidades:

  • MongoDB LangGraph Checkpointer: você pode persistir o estado de seus agentes LangGraph no MongoDB, fornecendo memória de curto prazo.

  • Armazenamento LangGraph do MongoDB: você pode armazenar e recuperar memória importantes para seus agentes LangGraph em uma coleção MongoDB, fornecendo memória de longo prazo.

  • Ferramentas de recuperação: você pode usar a integração do MongoDB LangChain para criar rapidamente ferramentas de recuperação para seus fluxos de trabalho LangGraph.

A integração de seus aplicativos LangGraph com o MongoDB permite consolidar os recursos de recuperação e a memória do agente em um único banco de dados, simplificando sua arquitetura e reduzindo a complexidade operacional.

O MongoDB LangGraph Checkpointer permite que você persista o estado do seu agente no MongoDB para implementar a memória de curto prazo. Esse recurso habilita humanos no loop, memória, viagem no tempo e tolerância a falhas para seus agentes LangGraph.

Para instalar o pacote para este componente:

pip install "langgraph-checkpoint-mongodb>=0.5.0"
from langgraph.checkpoint.mongodb import MongoDBSaverfrom pymongo import MongoClient # Connect to your MongoDB clusterclient = MongoClient("<connection-string>") # Initialize the MongoDB checkpointercheckpointer = MongoDBSaver(client) # Instantiate the graph with the checkpointerapp = graph.compile(checkpointer=checkpointer)

O MongoDB LangGraph Store permite armazenar e recuperar memória em uma coleção do MongoDB, o que habilita memória de longo prazo para seus agentes LangGraph. Isso permite que você crie agentes que podem se lembrar de interações passadas e usar essas informações para informar decisões futuras.

Para instalar o pacote para este componente:

pip install "langgraph-store-mongodb>=0.3.0"

O Atlas permite dois modos de incorporação:

  • Incorporação manual: Gere vetores de incorporação no lado do cliente com um modelo de incorporação que você especifica.

  • embedding automatizada: o MongoDB incorpora texto no lado do servidor sem precisar gerá-lo manualmente. Para aprender mais, consulte Embedding automatizada.

from langgraph.store.mongodb import MongoDBStore, create_vector_index_configfrom langchain_voyageai import VoyageAIEmbeddings # Vector search index configuration with client-side embeddingindex_config = create_vector_index_config( embed = VoyageAIEmbeddings(), dims = <dimensions>, fields = ["<field-name>"], filters = ["<filter-field-name>", ...] # Optional) # Store memories in MongoDB collectionwith MongoDBStore.from_conn_string( conn_string=MONGODB_URI, db_name="<database-name>", collection_name="<collection-name>", index_config=index_config ) as store: store.put( namespace=("user", "memories"), key=f"memory_{hash(content)}", value={"content": content} )

Recuperando e excluindo memória:

# Retrieve memories from MongoDB collectionwith MongoDBStore.from_conn_string( conn_string=MONGODB_URI, db_name="<database-name>", collection_name="<collection-name>", index_config=index_config) as store: results = store.search( ("user", "memories"), query="<query-text>", limit=3 ) for result in results: print(result.value) # To delete memories, use store.delete(namespace, key)# To batch operations, use store.batch(ops)

Método
Descrição

put(namespace, key, value, *, index)

Armazena um único item na loja com o namespace, chave e valor especificados.

search(namespace_prefix, /, *, ...)

Procura itens dentro de um determinado namespace_prefix. Suporta filtragem básica de valor-chave e pesquisa de query semântica se um índice de vetor estiver configurado.

O método search tem os seguintes modos:

  • Filtragem de metadados (sem query): Quando chamado sem um argumento de query, ele executa uma query filtrada padrão do MongoDB. Você pode especificar um dicionário de filtros para corresponder aos campos dentro do documento de valor armazenado.

    Por exemplo: store.search(("docs",), filter={"author": "Bob", "status": "published"})

  • Pesquisa semântica (com query): se a loja foi inicializada com um index_config e uma string de query for fornecida, ela executará uma pesquisa semântica. O método incorpora o texto da query e usa a Vector Search do MongoDB para encontrar os itens mais relevantes.

    Por exemplo: store.search(("docs",), query="information about AI assistants")

get(namespace, key, *, refresh_ttl)

Recupera um único item da loja. Opcionalmente, você pode atualizar o TTL do item após o acesso.

delete(namespace, key)

Exclui um único item do armazenamento identificado por seu namespace e chave.

list_namespaces(*, prefix, ...)

Lista namespaces exclusivos na loja. Permite a filtragem por um prefixo de caminho, sufixo e profundidade do documento .

batch(ops)

Executa uma sequência de operações (GetOp, PutOp, SearchOp, DeleteOp) em um único lote. As operações de leitura são executadas primeiro, seguidas por uma aplicação em massa de operações de gravação deduplicadas. abatch(ops) é a versão assíncrona deste método.

ensure_index_filters(filters)

Método que prepara uma lista de campos de filtro para indexação do MongoDB Vector Search .

Você pode usar perfeitamente os recuperadores do LangChain como FERRAMENTAS em seu fluxo de trabalho do LangGraph para recuperar dados relevantes do MongoDB.

A integração do MongoDB LangChain suporta nativamente pesquisa de texto completo, pesquisa vetorial, pesquisa híbrida e recuperação de documentos pai. Para obter uma lista completa dos métodos de recuperação, consulte Recuperadores do MongoDB LangChain.

  1. Para criar uma ferramenta básica de recuperação com MongoDB Vector Search e LangChain:

    from langchain.tools.retriever import create_retriever_toolfrom 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(), # Embedding model to use index_name = "vector_index", # Name of the vector search index # Other optional parameters...) # Create a retrieval toolretriever = vector_store.as_retriever()retriever_tool = create_retriever_tool( retriever, "vector_search_retriever", # Tool name "Retrieve relevant documents from the collection" # Tool description)
  2. Para adicionar a ferramenta como um nó no LangGraph:

    1. Converta a ferramenta em um nó.

    2. Adicione o nó ao grafo.

    from langgraph.graph import StateGraphfrom langgraph.prebuilt import ToolNode # Define the graphworkflow = StateGraph() # Convert the retriever tool into a noderetriever_node = ToolNode([retriever_tool]) # Add the tool as a node in the graphworkflow.add_node("vector_search_retriever", retriever_node) graph = workflow.compile()