Introduction
LangMem is LangChain's open-source SDK for long-term agent memory. It extracts facts from conversations, gives agents tools to save and search their own memories, and refines prompts from past interactions. The library is MIT-licensed and connects directly to LangGraph's long-term store.
LangMem scores 5.2/10 on scored.tools. That number reflects thin independent evidence as much as the product itself. The design makes sense for teams already on LangGraph. The concerns are a slow release cadence, open bug reports around store writes, and LLM costs you can only estimate from your own traffic.
This review draws on the LangMem docs, its PyPI listing, its GitHub repo and vendor pricing pages. Scored.tools did not run the library, so claims about behaviour are attributed to those sources.
Key Features
Memory managers
The docs describe two extraction APIs. create_memory_manager is storage-agnostic: per the docs, it doesn't read or write to a database. You pass in existing memories, it returns extracted ones, and you decide how to save them. create_memory_store_manager does the searching, upserting and deleting for you against a LangGraph BaseStore.
You define memory shapes as Pydantic models, and the class docstring guides extraction. The docs also warn about a tuning problem you will own: over-extraction can reduce precision, and under-extraction can reduce recall.
Memory tools for agents
create_manage_memory_tool and create_search_memory_tool let an agent record and search memories during a live conversation. Updates land immediately, but LangMem's conceptual guide says this approach adds perceptible latency to user interactions.
Background memory processing
ReflectionExecutor moves extraction out of the reply loop. It debounces per thread, so a new message cancels the pending task and reschedules it with the fuller conversation. The docs suggest a delay of 30 to 60 minutes in practice, depending on the application.
Serverless deployments have a catch. The docs say local threads end between function invocations, so pending tasks may never finish. Their recommended fix is the remote executor on LangGraph Platform, which pulls you towards LangChain's paid hosting.
Prompt optimization
LangMem can also revise agent instructions from past conversations, with optional feedback scores. The reference docs list three optimizer kinds:
| Kind | Approach | LLM calls per the docs |
|---|---|---|
| gradient (default) | Reflection cycles that find improvements, then apply them | 2 to 10 |
| metaprompt | Meta-learning with reflection | 1 to 5 |
| prompt_memory | Single-shot pass that learns from history | 1 |
The default is the most expensive of the three, so check it before you schedule optimization runs. The same reference page gives inconsistent defaults for reflection steps, so confirm them in the source code.
LangGraph store integration
Memories sit in hierarchical namespaces that can include runtime values such as a user ID. Retrieval supports direct key access, semantic search and metadata filtering. The backend is swappable through LangGraph's store interface. The quickstart's InMemoryStore loses data on restart, and the README recommends a database-backed store such as AsyncPostgresStore for production.
Maintenance status
The latest PyPI release is version 0.0.30, published on 27 October 2025, more than a year before this review. GitHub still shows activity, with commits as recent as 3 November 2026, though the four newest are dependency updates and fixes. The repo shows 1.8k stars and 57 open issues.
A few open reports deserve a read before you commit. Issue #196, opened on 8 October 2026, reports that MemoryStoreManager.invoke() returns success when store writes or deletes fail. Issue #207 concerns trimmed messages still being marked as summarized. Both are user reports, so confirm them against your own version.
Quality and latency evidence
The sources reviewed contain no neutral head-to-head benchmark. Mem0's benchmark post lists LangMem at 58.1% judge accuracy and 60 s p95 latency, against 92.5% on LoCoMo and 1.4 s for its own platform. Mem0 sells a competing product, and the post shows no comparable setup for the LangMem row, so treat those numbers as a competitor's claim. Atlan's comparison says LangChain publishes no retrieval-latency figures for LangMem. Measure search latency on your own store and embedding model before you ship.
Pricing Breakdown
The library is free. Your real bill comes from model calls, embeddings and the storage backend. Extraction adds LLM calls on top of the agent's own, and prompt optimization adds more. No vendor figure will tell you what that costs for your traffic, so log tokens per conversation from the first day.
Hosting and observability through LangChain are optional. The pricing page lists these LangSmith plans:
| Plan | Price | What you get |
|---|---|---|
| Developer | $0 per seat a month, then pay as you go | 1 seat, 5k free traces a month, community support |
| Plus | $39 per seat a month, then pay as you go | 10k base traces a month, access to Deployment, 1 free small serverless deployment |
| Enterprise | Custom | Self-hosted or hybrid options, custom SSO, support SLA |
Deployment usage is metered at $1.00 per LSU. Published rates are 0.0675 LSU per vCPU-hour and 0.0090 LSU per GiB-hour for runtime, then 0.177 LSU per vCPU-hour and 0.025 LSU per GiB-hour for the database. Serverless deployments scale to zero when idle, while dedicated ones stay on. Resource-based billing like this is harder to forecast than a flat plan.
Here is how the hosted memory products price their entry points, per each vendor's own pages:
| Product | Free option | Paid options |
|---|---|---|
| Mem0 | $0 plan with 10,000 adds and 1,000 retrievals a month for the first 30 days, then 50,000 adds and 10,000 retrievals with your own LLM key | Custom plan, which adds graph memory and SSO |
| Zep | 10,000 credits a month, 2 projects | Flex at $125 a month for 50,000 credits, Flex Plus at $375 a month for 200,000 credits |
| Letta | $0 with 3 stateful agents | Pro at $20 a month, API Plan at $20 a month plus $0.10 per active agent |
Pros & Cons
Pros
- Free and MIT-licensed, with no vendor fee for the library.
- Fits directly into LangGraph agents and the store abstraction.
- Covers stored facts and prompt refinement in one toolkit.
- Storage is swappable, and
create_memory_managerleaves persistence entirely to you. - Supports both in-conversation and background memory formation, so you can trade freshness against latency.
Cons
- Closely tied to LangChain. The storage-agnostic API helps, but the package still declares langgraph, langchain-openai and langchain-anthropic as dependencies. Issue #142 asks for the two provider packages to become optional.
- Extraction costs extra LLM calls, which adds spend, and adds latency when it runs in the conversation.
- Still on a 0.0.x version, with no PyPI release since October 2025.
- You design the schemas, pick the store and tune retrieval yourself.
- LangChain's homepage has no LangMem-specific coverage, so details live in the separate docs at langchain-ai.github.io/langmem.
- No published latency figures from LangChain, according to Atlan, and no neutral benchmark in the sources reviewed.
Who Is It For
LangMem suits a team that already runs agents on LangGraph, already operates Postgres or a similar store, and has someone who can own memory schemas and retrieval tuning. For that team, adding memory means adding a library rather than a new vendor and a new network hop. Prompt optimization is a useful extra if you collect feedback scores.
Teams on other frameworks get far less from it. You can call the stateless API, but you still pull in the LangChain dependencies and lose the store integration that makes LangMem attractive. Teams that want a managed service with its own API should look at Mem0, Zep or Letta. Serverless teams should price the remote executor path before they start, because the local background executor is a poor fit for that environment.
Verdict
| Criterion | Score | Basis |
|---|---|---|
| Output quality | 4 | Little independent evidence on LangMem itself |
| Ease of use | 6 | Free start and courses, though the evidence concerns LangSmith |
| Pricing value | 6 | Free entry, with usage billing that is harder to predict |
| API and integration | 6 | Based on LangChain-wide platform evidence |
| Problem fit | 4 | Sources describe the broader LangChain product more than LangMem |
| Overall | 5.2/10 |
Use LangMem if you are on LangGraph and want memory inside your existing stack with no separate service. Pin the version, use a database-backed store, run extraction in the background, and add your own check that memory writes succeeded until issue #196 is resolved. Set a token budget for extraction before you turn it on for all users.
Skip it if you are on another framework, or if you want someone else to run the memory layer. A hosted product will cost more in fees and less in engineering time, and for a small team that is often the better trade. The year-old release is the main reason for caution here, so check PyPI and the issue tracker again before you commit.