Integrate MongoDB with LangGraph

Usage

from langgraph.checkpoint.mongodb import MongoDBSaver
from pymongo import MongoClient
# Connect to your MongoDB cluster
client = MongoClient("<connection-string>")
# Initialize the MongoDB checkpointer
checkpointer = MongoDBSaver(client)
# Instantiate the graph with the checkpointer
app = graph.compile(checkpointer=checkpointer)

Usage

Atlas supports two embedding modes:

• Manual embedding: Generate embedding vectors on the client's side with an embedding model you specify.

• Automated embedding: MongoDB embeds text on the server's side without needing to generate them manually. To learn more, see Automated Embedding.

  Important

  Automated embedding is available as a Preview feature only for MongoDB Community Edition v8.2 and later. The feature and the corresponding documentation might change at any time during the Preview period. To learn more, see Preview Features.

from langgraph.store.mongodb import MongoDBStore, create_vector_index_config
from langchain_voyageai import VoyageAIEmbeddings
# Vector search index configuration with client-side embedding
index_config = create_vector_index_config(
    embed = VoyageAIEmbeddings(),
    dims = <dimensions>,
    fields = ["<field-name>"],
    filters = ["<filter-field-name>", ...] # Optional
)
# Store memories in MongoDB collection
with 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}
     )

from langgraph.store.mongodb import MongoDBStore, create_vector_index_config
from langchain_mongodb import AutoEmbeddings
# Vector search index configuration with server-side Automated Embedding
index_config = create_vector_index_config(
    embed = AutoEmbeddings(model_name="voyage-4"),
    fields = ["<field-name>"],
    filters = ["<filter-field-name>", ...] # Optional
)
# Store memories - text is embedded server-side
with 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}
     )

Retrieving and deleting memories:

# Retrieve memories from MongoDB collection
with 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)

ttl_config = {
   "default_ttl": 3600,     # Expire documents after 1 hour
   "refresh_on_read": True, # Refresh TTL on read
}

index_config = create_vector_index_config(
    embed = <embedding-model-or-AutoEmbeddings>,
    dims = <dimensions>,  # Not required for Automated Embedding
    fields = ["<field-name>"], # field to embed
    filters = ["<filter-field-name>", ...], # optional
    name = "<index-name>" # optional, defaults to 'vector_index'
    relevance_score_fn: "euclidean" | "cosine" | "dotProduct"] # defaults to 'cosine'
    embedding_key: "<embedding-field-name>" # optional, defaults to 'embedding'
)

Usage

1. To create a basic retrieval tool with MongoDB Vector Search and LangChain:

   from langchain.tools.retriever import create_retriever_tool
   from langchain_mongodb.vectorstores import MongoDBAtlasVectorSearch
   from langchain_voyageai import VoyageAIEmbeddings
   # Instantiate the vector store
   vector_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 tool
   retriever = vector_store.as_retriever()
   retriever_tool = create_retriever_tool(
       retriever,
       "vector_search_retriever", # Tool name
       "Retrieve relevant documents from the collection" # Tool description
   )

2. To add the tool as a node in LangGraph:

   1. Convert the tool into a node.

   2. Add the node to the graph.

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