---
title: "Mem0 vs LangMem: Library or Service for Agent Memory"
description: "Mem0 vs LangMem compared on memory model, temporal handling, retrieval, deployment, and pricing, with a decision path for LangGraph teams."
canonical: https://past.dev/blog/mem0-vs-langmem
date: 2026-09-03
category: Research
authors: The past.dev team
---
# Mem0 vs LangMem: Library or Service for Agent Memory

Mem0 vs LangMem is a choice between two kinds of software. [LangMem](https://langchain-ai.github.io/langmem/) is a Python library from the LangChain team: memory tools and background extraction for agents, persisting through LangGraph's storage layer. [Mem0](https://docs.mem0.ai/core-concepts/memory-operations) is a standalone memory layer: a managed platform behind a REST API, or an open-source package you run yourself, callable from any framework. A team already on LangGraph can pick either. A team on anything else is picking between Mem0 and other standalone systems, and LangMem drops off the shortlist.

## Mem0 vs LangMem at a glance

The past.dev column comes from our own published docs. The other two come from each product's documentation, linked per cell, current as of September 2026.

| Dimension | Mem0 | LangMem | past.dev |
|---|---|---|---|
| Memory model | LLM extracts facts and preferences from messages; stored additively, scoped by `user_id`, `agent_id`, `run_id` ([operations](https://docs.mem0.ai/core-concepts/memory-operations)) | Semantic, episodic, and procedural memories saved as JSON items in a LangGraph store, organized by namespace ([concepts](https://langchain-ai.github.io/langmem/concepts/conceptual_guide/)) | Facts derived from raw ingested text, each tied to its sources |
| Temporal handling | Optional `timestamp` on add backdates a memory ([timestamp](https://docs.mem0.ai/platform/features/timestamp)); optional `expiration_date` hides it later ([operations](https://docs.mem0.ai/core-concepts/memory-operations)) | Store items carry timestamps and keys ([background quickstart](https://langchain-ai.github.io/langmem/background_quickstart/)); event-time semantics are left to your schema | Event time from the source timestamp, validity windows, supersession links |
| Entity handling | Graph Memory links memories that mention the same person, place, or organization; connections come from co-occurrence ([graph memory](https://docs.mem0.ai/platform/features/graph-memory)) | Developer-defined profiles and collections per memory type ([concepts](https://langchain-ai.github.io/langmem/concepts/conceptual_guide/)) | Entity resolution at ingestion links references across email, transcripts, tickets, chat |
| Retrieval | Ranked memories with one combined relevance score ([graph memory](https://docs.mem0.ai/platform/features/graph-memory)) | `create_search_memory_tool` and `store.search()` return matching items ([docs](https://langchain-ai.github.io/langmem/)) | `POST /api/v1/recall` returns ranked documents with dates and source excerpts |
| Deployment | Managed platform; or pip/npm library and self-hosted server via Docker Compose ([open source](https://docs.mem0.ai/open-source/overview)) | In-process library; persistence via your LangGraph store, `InMemoryStore` in dev, `AsyncPostgresStore` in production ([docs](https://langchain-ai.github.io/langmem/)) | Managed, or in your own cloud on an Enterprise agreement, with the same API |
| Pricing model | Free tier with 10,000 add and 1,000 retrieval requests per month; Starter $19/mo; Pro $249/mo ([pricing](https://mem0.ai/pricing)) | Open-source package; you pay for the store and LLM calls you run | Managed, or your own cloud on an Enterprise agreement; start at the [quickstart](/docs/memory-api/quickstart) |

## What LangMem provides

LangMem installs with `pip install -U langmem` and ships two kinds of machinery. The first is a pair of agent tools: `create_manage_memory_tool` lets an agent create, update, and delete its own memories mid-conversation, and `create_search_memory_tool` lets it query them ([docs](https://langchain-ai.github.io/langmem/)). The second is a background path: `create_memory_store_manager` extracts and consolidates memories from finished conversations, and `ReflectionExecutor` defers that work to avoid redundant processing on every turn ([background quickstart](https://langchain-ai.github.io/langmem/background_quickstart/)).

The [conceptual guide](https://langchain-ai.github.io/langmem/concepts/conceptual_guide/) names these two formation paths hot path and background, and sorts memories into semantic (facts, as collections or single structured profiles), episodic (past interactions kept as examples), and procedural (behavior rules refined through prompt optimization). Persistence goes through LangGraph's `BaseStore`, with namespaces separating users and agents. LangChain's current framework docs describe the same store primitives directly, as JSON documents organized by namespace and key, written and read through `runtime.store` ([long-term memory guide](https://docs.langchain.com/oss/python/langchain/long-term-memory)).

## What Mem0 provides

Mem0's `add` call runs messages through an LLM that extracts facts, decisions, and preferences. The [operations guide](https://docs.mem0.ai/core-concepts/memory-operations) states that new memories are added without overwriting or deleting existing ones; ranking at search time decides what surfaces. Setting `infer=False` skips extraction and stores raw payloads. Memories are scoped by `user_id`, `agent_id`, `app_id`, and `run_id`, and can carry metadata filters.

Three features matter most for this comparison. A [timestamp field](https://docs.mem0.ai/platform/features/timestamp) records when an event actually happened, which makes historical import possible. [Graph Memory](https://docs.mem0.ai/platform/features/graph-memory) turns the people, places, and organizations mentioned across memories into nodes and connects memories that share an entity; the docs note connections are inferred from co-occurrence rather than declared as typed relationships. And the engine is also [open source](https://docs.mem0.ai/open-source/overview): the same extraction pipeline as a library or a Docker Compose server, with your choice of vector store and LLM.

## Lock-in: LangMem runs on LangGraph's store

LangMem's stateful components, the memory tools and the store manager, read and write through LangGraph's store interface ([docs](https://langchain-ai.github.io/langmem/)). The functional core that transforms memory state has no storage dependency, so the extraction logic is portable, but the persistence and deployment story assume a LangGraph application with a configured store. Mem0 carries no framework assumption in either direction: the platform is a [REST API with SDKs](https://docs.mem0.ai/api-reference), and the open-source package embeds in any codebase. The cost runs both ways. Leaving LangGraph later means rebuilding memory plumbing that lives in LangMem. Adopting Mem0 from inside LangGraph adds a network dependency and a second vendor that an in-process library avoids.

## When a LangGraph team should still choose each

Choose LangMem when memory is an application concern you want versioned with your code: same process, same store, same deploy, and schemas you define. It fits teams that already run a Postgres-backed store and want procedural memory and prompt optimization in the same package. Choose Mem0 when memory must serve more than one graph or one language, or when you want extraction managed and metered instead of operated. Choose a system like past.dev when answers depend on when facts were true, which requires dated evidence instead of ranked snippets. See [facts that change over time](/guides/facts-that-change-over-time) for why that distinction decides real cases.

## Self-published numbers

Mem0 and past.dev both publish results on BEAM, the same long-horizon benchmark, so the two sets of figures can appear together. Mem0 reports 64.1% at 1M tokens and 48.6% at 10M ([their 2026 benchmark post](https://mem0.ai/blog/ai-memory-benchmarks-in-2026)). On BEAM's complete splits, past.dev reports 92.08% at 100K tokens, 90.65% at 1M, and 85.03% at 10M ([benchmarks](/benchmarks), setup in the [methodology](/benchmarks/methodology)). We found no published accuracy benchmarks for LangMem to cite, so evaluate it on your own data. All numbers above are vendor-reported.

## How to decide

Run five tests before committing; the full walkthrough is in [choosing a memory system](/guides/choose-memory-system).

1. Change a fact, then ask for the old and new values with dates. Systems that overwrite or only re-rank return one value.
2. Backfill a year of history with original timestamps, then ask what was known at a past date. Mem0's [timestamp field](https://docs.mem0.ai/platform/features/timestamp) covers the write side; check what retrieval does with it. In LangMem, decide up front how event time enters your item schema.
3. Give one person three identifiers (email address, chat handle, ticket ID) and check whether facts land on one entity or three.
4. Ask something the stored data cannot answer, and watch whether the system says so or improvises.
5. Price your actual volume: Mem0 meters add and retrieval requests ([pricing](https://mem0.ai/pricing)); LangMem costs whatever your store and extraction LLM cost.

## Where past.dev sits in this comparison

past.dev is a memory API that runs as a managed service or, on an Enterprise agreement, in your own cloud. `POST /api/v1/ingest` accepts timestamped source text; `GET /api/v1/ingest/{ingestionId}` reports `status: "completed"` when processing of that send completes; `DELETE /api/v1/ingest/{ingestionId}` removes source data and memory supported only by those sources. `POST /api/v1/recall` requires an identity and returns ranked documents with dates and source excerpts under project and audience visibility. SOC 2 Type II, ISO 27001, and ISO 27701 certifications are held.

If you want an in-process library versioned with a LangGraph app, LangMem is the right tool. If you want extraction-based per-user memory as a hosted service or a library you operate, Mem0 fits. If your agent needs timestamped ingestion and grouped recall documents with source excerpts, start at the [quickstart](/docs/memory-api/quickstart).

For the deeper design comparisons, see [past.dev vs Mem0](/vs/mem0), the [LangMem comparison](/compare/langmem), and the [Mem0 alternatives roundup](/blog/mem0-alternatives).