# Best Practices for Integrating Mem0 with LangGraph or CrewAI

> Learn best practices for integrating Mem0 with LangGraph and CrewAI. Discover how to enhance LLM agent memory and context management for seamless workflow development.

- Repository: [Mem0/mem0](https://github.com/mem0ai/mem0)
- Tags: best-practices
- Published: 2026-03-07

---

**Mem0 acts as a persistent "memory-as-a-service" layer that integrates with LangGraph via custom tools and checkpointing, while CrewAI leverages the `memory=True` configuration with a Mem0 provider to maintain long-term user context across agent workflows.**

The mem0ai/mem0 repository provides a flexible memory layer designed for LLM applications. When building agents with LangGraph or CrewAI, integrating Mem0 allows you to persist user preferences, session history, and agent state beyond the context window, ensuring continuity across conversations.

## Architectural Overview

Mem0 sits between your LLM provider and orchestration framework, handling long-term storage while LangGraph or CrewAI manages execution flow. The architecture divides responsibilities across five key layers:

| Layer | Responsibility | Mem0 Component | Framework Component |
|-------|----------------|----------------|---------------------|
| **LLM Provider** | Generates responses | `OpenAI`, `VertexAI` adapters | LangGraph `create_react_agent` / CrewAI `Agent` |
| **Memory Store** | Persistent vector storage | `MemoryClient` (REST) or `InMemoryStore` | LangGraph `MemorySaver` / CrewAI `memory=True` |
| **Tooling** | Exposes memory operations | `create_manage_memory_tool`, `create_search_memory_tool` | LangGraph tool interface |
| **Checkpointing** | Persists graph state | Integrated via `MemorySaver` | LangGraph `MemorySaver` |
| **Orchestration** | Routes messages and tools | — | LangGraph graph / CrewAI `Crew` |

The LangGraph implementation appears in [`evaluation/src/langmem.py`](https://github.com/mem0ai/mem0/blob/main/evaluation/src/langmem.py), where Mem0 tools inject into a ReAct-style agent. The CrewAI pattern is demonstrated in [`examples/misc/voice_assistant_elevenlabs.py`](https://github.com/mem0ai/mem0/blob/main/examples/misc/voice_assistant_elevenlabs.py), configuring a Mem0-backed agent within a crew.

## LangGraph Integration Pattern

LangGraph agents interact with Mem0 through specialized tools that expose add, update, and search operations. In [`evaluation/src/langmem.py`](https://github.com/mem0ai/mem0/blob/main/evaluation/src/langmem.py) (lines 9-13 and 71-78), the integration imports `create_manage_memory_tool` and `create_search_memory_tool` from the `langmem` module, injecting them into a ReAct agent.

```python

# evaluation/src/langmem.py pattern

from langmem import create_manage_memory_tool, create_search_memory_tool
from langgraph.checkpoint.memory import MemorySaver
from langgraph.prebuilt import create_react_agent

# Initialize checkpointing for multi-turn persistence

checkpointer = MemorySaver()

# Create agent with memory tools

agent = create_react_agent(
    model="openai:gpt-4",
    tools=[
        create_manage_memory_tool(namespace=("memories",)),
        create_search_memory_tool(namespace=("memories",)),
    ],
    checkpointer=checkpointer,
)

```

**Key implementation details:**

- **Namespace scoping**: Pass `namespace=("memories", user_id)` to isolate memories per user or session
- **State management**: Combine `MemorySaver` for graph checkpointing with Mem0 tools for long-term memory retrieval
- **Prompt injection**: Retrieve memories in your prompt function using `get_store().search()` before calling the LLM

## CrewAI Integration Pattern

CrewAI integrates Mem0 declaratively through configuration rather than explicit tools. In [`examples/misc/voice_assistant_elevenlabs.py`](https://github.com/mem0ai/mem0/blob/main/examples/misc/voice_assistant_elevenlabs.py) (lines 25-31 and 64-75), the agent enables memory by setting `memory=True` and specifying the Mem0 provider in `memory_config`.

```python

# examples/misc/voice_assistant_elevenlabs.py pattern

from crewai import Agent, Crew, Process
from mem0 import MemoryClient

USER_ID = "alice"

voice_agent = Agent(
    role="Personal Voice Assistant",
    goal="Help the user while remembering preferences",
    backstory="You retain user facts across sessions.",
    memory=True,
    memory_config={
        "provider": "mem0",
        "config": {"user_id": USER_ID}
    },
)

crew = Crew(
    agents=[voice_agent],
    tasks=[task],
    process=Process.sequential,
    memory=True,
    memory_config={
        "provider": "mem0",
        "config": {"user_id": USER_ID}
    },
)

```

**Critical configuration notes:**

- The `MemoryClient` initializes automatically from the `MEM0_API_KEY` environment variable
- Both the individual `Agent` and the `Crew` accept `memory_config`, allowing flexible scoping
- CrewAI handles the memory retrieval and injection automatically during task execution

## Recommended Best Practices

**Use built-in Mem0 tools** when working with LangGraph. Import `create_manage_memory_tool` and `create_search_memory_tool` from `langmem` to ensure correct payload shapes, async handling, and telemetry capture.

**Persist graph checkpoints** by instantiating `MemorySaver()` and passing it to `create_react_agent`. This enables recovery after failures and maintains state across multi-turn conversations.

**Scope memories with namespaces** to enable multi-tenancy. Use tuples like `("memories", user_id)` or `("memories", session_id)` when creating tools to isolate data between users.

**Batch memory additions** for high-throughput applications. Collect messages locally then call `memory.add(batch, user_id=...)` in a single request to reduce API round-trips.

**Leverage vector stores** for similarity search. Configure `MemoryClient` with backends like Pinecone or Qdrant (see `mem0/vector_stores/*.py`) to improve retrieval relevance for long histories.

**Keep LLM calls stateless** by retrieving memories in your prompt builder and injecting them into the system message, rather than passing the entire conversation history to the model.

**Implement graceful fallbacks** for memory errors. Wrap `search` and `add` calls in try/except blocks that return empty results on failure, preventing memory service issues from breaking the user experience.

**Drive configuration through environment variables** (`MEM0_API_KEY`, `MODEL`, `EMBEDDING_MODEL`) rather than hardcoding credentials, ensuring portability across development and production environments.

## Security and Performance Optimization

**Never embed API keys in source code.** The `MemoryClient` automatically reads `MEM0_API_KEY` from environment variables, as implemented in [`mem0/client/main.py`](https://github.com/mem0ai/mem0/blob/main/mem0/client/main.py).

**Enable async mode** (default in recent versions) for non-blocking memory inserts. The `add()` method in `MemoryClient` supports asynchronous execution to prevent I/O bottlenecks.

**Tune retrieval parameters** by adjusting `top_k` and `limit` in `search()` calls to balance relevance against latency. Start with `top_k=3` for most conversational applications.

**Configure GCP authentication** when using Google Cloud-hosted vector stores by utilizing the utilities in [`mem0/utils/gcp_auth.py`](https://github.com/mem0ai/mem0/blob/main/mem0/utils/gcp_auth.py) for secure credential management.

## Summary

- Mem0 integrates with **LangGraph** via explicit tools (`create_manage_memory_tool`, `create_search_memory_tool`) and `MemorySaver` checkpointing
- **CrewAI** uses declarative configuration with `memory=True` and `memory_config={"provider": "mem0"}` for automatic memory handling  
- Always **scope memories with namespaces** to ensure user data isolation in multi-tenant applications
- **Batch write operations** and use **vector stores** (Pinecone, Qdrant) for production-scale similarity search
- Implement **error handling** around memory operations to ensure graceful degradation when the memory service is unavailable

## Frequently Asked Questions

### How does Mem0 differ from LangGraph's native MemorySaver?

LangGraph's `MemorySaver` persists the **graph state** (checkpoints) for recovery and multi-turn conversations, while Mem0 stores **semantic memories** (facts, preferences, user data) across sessions. Use `MemorySaver` for workflow continuity and Mem0 for long-term knowledge retrieval that spans multiple conversations or agents.

### Can I use Mem0 with CrewAI without modifying agent code?

No, you must explicitly enable memory in CrewAI by setting `memory=True` and providing `memory_config={"provider": "mem0", "config": {"user_id": ...}}` on the Agent or Crew. However, once configured, CrewAI automatically handles memory retrieval and injection without requiring manual tool calls in your task definitions.

### What vector stores are supported for Mem0 similarity search?

According to the source code in `mem0/vector_stores/`, Mem0 supports multiple backends including Pinecone, Qdrant, Weaviate, and Chroma. Configure your preferred vector store through the Mem0 client configuration to enable high-performance similarity search for memory retrieval.

### How do I handle memory errors gracefully in production?

Wrap all Mem0 client calls in try/except blocks, as demonstrated in the `search_memory` implementation pattern. Return empty strings or default contexts when `MemoryClient.add()` or `search()` fails due to network issues or quota limits, ensuring your agent continues operating even if the memory layer is temporarily unavailable.