Skip to content
Back to search

claude-memory

Claude memory: the top 10 ways to give Claude persistent, long-term memory, compared. Covers MCP memory servers, CLAUDE.md, memory plugins and tools for Claude Code, Claude Desktop and the Claude API. Setup, pros and cons, and which to pick for remembering context across sessions.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/claudememory--claude-memory/badge.svg)](/listings/claudememory--claude-memory)

HTML

<a href="/listings/claudememory--claude-memory"><img src="/api/listings/claudememory--claude-memory/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 250 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # Claude Memory: The 10 Best Ways to Give Claude Persistent Memory (2026)
  2. Claude memory, compared. This guide covers every practical way to give **Claude**, **Claude Code** and **Claude Desktop** persistent, long-term memory across sessions: memory MCP servers, Claude Code plugins, `CLAUDE.md`, and Anthropic's built-in memory. Each entry has what it stores, where the memory lives, how to install it, and who it's for.
  3. Last updated: November 2026.
  4. ## Contents
  5. - [Quick comparison](#quick-comparison)
  6. - [⭐ 1. Glen: shared Claude memory for your whole team](#-1-glen-shared-claude-memory-for-your-whole-team)
  7. - [2. Claude Code built-in memory (CLAUDE.md and auto memory)](#2-claude-code-built-in-memory-claudemd-and-auto-memory)
  8. - [3. Claude app memory (claude.ai, Desktop, mobile)](#3-claude-app-memory-claudeai-desktop-mobile)
  9. - [4. claude-mem](#4-claude-mem)
  10. - [5. Mem0](#5-mem0)
  11. - [6. Supermemory](#6-supermemory)
  12. - [7. Basic Memory](#7-basic-memory)
  13. - [8. MCP Knowledge Graph Memory Server (official reference)](#8-mcp-knowledge-graph-memory-server-official-reference)
  14. - [9. Cognee](#9-cognee)
  15. - [10. Graphiti and Zep](#10-graphiti-and-zep)
  16. - [Honorable mentions](#honorable-mentions)
  17. - [How to choose a Claude memory tool](#how-to-choose-a-claude-memory-tool)
  18. - [Claude memory FAQ](#claude-memory-faq)
  19. ## Quick comparison
  20. | # | Claude memory tool | Type | Memory is shared with | Where memory lives | Best for |
  21. | --- | --- | --- | --- | --- | --- |
  22. | **⭐ 1** | **[Glen](https://tryglen.com)** | **Plugin + CLI + remote MCP server** | **Your whole team** | **Hosted** | **Teams running Claude Code, Codex and Cursor** |
  23. | 2 | Claude Code `CLAUDE.md` + auto memory | Built in | Project (via git) / you | Local files | Every Claude Code user |
  24. | 3 | Claude app memory | Built in | You | Anthropic | Chatting in claude.ai and Claude Desktop |
  25. | 4 | claude-mem | Claude Code plugin | You | Local (`~/.claude-mem`) | Solo developers in Claude Code |
  26. | 5 | Mem0 | Memory API + CLI | Your agents | Hosted or self-hosted | Building memory into your own app |
  27. | 6 | Supermemory | Remote MCP server + API | You or a team space | Hosted or local | One memory across many AI clients |
  28. | 7 | Basic Memory | MCP server | You | Local Markdown files | Notes you can read and edit by hand |
  29. | 8 | MCP Knowledge Graph Memory | MCP server | You | Local JSON file | A minimal, self-hosted start |
  30. | 9 | Cognee | Claude Code plugin + MCP server | You or your agents | Local or Cognee Cloud | Graph memory over your own documents |
  31. | 10 | Graphiti / Zep | MCP server | Your agents | Self-hosted graph DB / Zep cloud | Facts that change over time |
  32. ---
  33. <div align="center">
  34. ## ⭐ 1. Glen: shared Claude memory for your whole team
  35. **⭐ Top pick for Claude Code memory ⭐**
  36. [![Top pick](https://img.shields.io/badge/%E2%AD%90-Top%20pick-FFD700?style=for-the-badge)](https://tryglen.com)
  37. [![Website](https://img.shields.io/badge/tryglen.com-000000?style=for-the-badge)](https://tryglen.com)
  38. [![Free plan](https://img.shields.io/badge/Free-up%20to%203%20people-2ea44f?style=for-the-badge)](https://tryglen.com)
  39. </div>
  40. > [!TIP]
  41. > **Most Claude memory tools remember for one person. Glen remembers for the whole team.** Every Claude Code session your teammates run is recorded, turned into memory, and fed back into your Claude while it works. If someone already figured out why the billing worker batches at 500, your Claude knows before you ask.
  42. >
  43. > ```bash
  44. > npx @tryglen/cli@latest install
  45. > ```
  46. Glen is shared memory for coding agents. It records the agent sessions on your team (Claude Code, Codex, Cursor, Pi and your own agents) and the tools you connect, such as Slack, GitHub, tickets, docs and meeting recorders (Fireflies, Fathom, Granola). From that it builds observations about people, projects and decisions, and puts the relevant ones into Claude's context on every turn.
  47. Most Claude memory tools stop at "Claude remembers what *I* told it last week." Glen covers what the person at the next desk told *their* Claude last week, which is where most of a team's lost context is.
  48. **What Glen gives Claude:**
  49. - **Team-wide recall.** `glen search "<question>"` returns what anyone in the org worked out, with the session it came from. Glen also injects relevant context automatically, so Claude doesn't have to know to ask.
  50. - **Code to conversation tracing.** `glen code-search <path:start-end>` follows `git blame` back to the agent conversation that wrote those lines, so Claude gets the reasoning behind a change, not only the diff.
  51. - **Memory that drops stale decisions.** When a newer decision contradicts an older one, the older one stops being recalled.
  52. - **Access control at recall.** Each memory is checked per person, so Claude only sees what its user is already allowed to see.
  53. - **Shared skills, transcripts and artifacts.** A team skill library, a searchable transcript hub, session takeover (move a live session to another agent mid-task), and a library of saved reports and runbooks.
  54. - **A remote MCP server (OAuth) and a CLI** that reach the same memory, so Claude Desktop, Claude Code and any other MCP client all see the same thing.
  55. - **Private and silent modes.** `glen incognito` keeps a session out of memory; `glen silent` records but surfaces nothing.
  56. **Measured result:** in Glen's benchmark replaying 100 merged PRs, Codex with Glen merged 21% faster and used 29% fewer tokens per task ([details on tryglen.com](https://tryglen.com)).
  57. **Install for Claude Code:**
  58. ```bash
  59. npx @tryglen/cli@latest install
  60. ```
  61. The installer detects Claude Code (and Codex, Cursor and Pi), installs the plugin and hooks, and signs you in. Then invite teammates:
  62. ```bash
  63. glen invite teammate@company.com
  64. ```
  65. **Pricing:** free for up to 3 people and 15,000 memories, no credit card. Paid Personal and Team plans add integrations and higher limits.
  66. **Choose Glen if:** more than one person on your team uses Claude Code (or Codex or Cursor), and you're tired of agents relearning what a teammate's agent already worked out.
  67. <div align="center">
  68. **[⭐ Try Glen free at tryglen.com →](https://tryglen.com)**
  69. </div>
  70. ---
  71. ## 2. Claude Code built-in memory (CLAUDE.md and auto memory)
  72. Every Claude Code session starts with a fresh context window, and Claude Code ships two ways to carry knowledge between them.
  73. - **`CLAUDE.md`** holds instructions you write. It loads at the start of every session, at several scopes: `~/.claude/CLAUDE.md` for you across all projects, `./CLAUDE.md` or `./.claude/CLAUDE.md` for a project (committed, so your team shares it), plus organization-managed files. You can split it up with `@path/to/file` imports and `.claude/rules/`. Claude Code also reads `AGENTS.md`.
  74. - **Auto memory** holds notes Claude writes itself from your corrections and preferences. It's on by default in local sessions, scoped per repository, and the first 200 lines (or 25KB) load each session. Toggle it in `/memory`, or set `"autoMemoryEnabled": false` in a project's settings.
  75. **Strengths:** free, no setup, plain files you can review in a PR.
  76. **Limits:** `CLAUDE.md` is hand-maintained and goes stale; auto memory is local to one machine and one person. Neither captures what happened in your teammates' sessions.
  77. **Docs:** [How Claude remembers your project](https://code.claude.com/docs/en/memory)
  78. ## 3. Claude app memory (claude.ai, Desktop, mobile)
  79. The Claude apps can remember context from your past chats and search previous conversations when you ask. It's on by default for Free, Pro and Max on web, Desktop and mobile; on Team and Enterprise an owner turns it on. You can view, edit or turn it off in Settings, and incognito chats aren't remembered.
  80. **Strengths:** zero setup for everyday chat.
  81. **Limits:** lives in the Claude app only. It doesn't reach Claude Code, the API, or other agents, and it's per person.
  82. **Docs:** [Claude's memory (Anthropic support)](https://support.claude.com/en/articles/11817273)
  83. ## 4. claude-mem
  84. A Claude Code plugin that hooks into session lifecycle events, captures what the agent does, compresses it into summaries with an LLM, and injects relevant context into later sessions. Memory lives in `~/.claude-mem` on your machine, with cloud sync opt-in. It also supports Codex, Gemini, Copilot, OpenCode and others.
  85. ```bash
  86. npx claude-mem install
  87. ```
  88. **Strengths:** automatic capture, large community, local by default.
  89. **Limits:** single user. Summarization runs on your Anthropic plan, your own key, or its paid observer.
  90. **Repo:** [thedotmack/claude-mem](https://github.com/thedotmack/claude-mem)
  91. ## 5. Mem0
  92. Mem0 is memory infrastructure for agents you build: an open-source library (`pip install mem0ai` / `npm install mem0ai`), a self-hostable server, and a hosted platform. A CLI lets coding agents like Claude Code sign up and use it directly.
  93. ```bash
  94. npm install -g @mem0/cli
  95. mem0 init --agent --agent-caller claude-code
  96. ```
  97. **Strengths:** mature SDKs in Python and TypeScript, hosted or self-hosted.
  98. **Limits:** aimed more at developers adding memory to their own product than at a team's coding history.
  99. **Repo:** [mem0ai/mem0](https://github.com/mem0ai/mem0)
  100. ## 6. Supermemory
  101. A memory API with a hosted remote MCP server, so one account gives Claude Desktop, Claude Code and other MCP clients the same memory. It can also run fully locally.
  102. ```bash
  103. claude mcp add --transport http supermemory https://mcp.supermemory.ai/mcp
  104. ```
  105. **Strengths:** OAuth sign-in, works across many clients, team spaces.
  106. **Limits:** captures what you or your agent choose to save, rather than recording sessions.
  107. **Repo:** [supermemoryai/supermemory](https://github.com/supermemoryai/supermemory)
  108. ## 7. Basic Memory
  109. Stores Claude's memory as plain Markdown files on your disk, which you can open, edit and version in git or Obsidian. Runs as a local MCP server, with an optional cloud version.
  110. ```bash
  111. claude mcp add basic-memory -- uvx --prerelease=allow basic-memory mcp
  112. ```
  113. **Strengths:** human-readable, local-first, you own the files.
  114. **Limits:** built for one person; you curate what goes in.
  115. **Repo:** [basicmachines-co/basic-memory](https://github.com/basicmachines-co/basic-memory)
  116. ## 8. MCP Knowledge Graph Memory Server (official reference)
  117. The Model Context Protocol project's reference memory server stores entities, relations and observations in a local JSON file (set the path with `MEMORY_FILE_PATH`). Requires Node.js 24 or later.
  118. ```bash
  119. claude mcp add memory -- npx -y @modelcontextprotocol/server-memory
  120. ```
  121. **Strengths:** tiny, open source, nothing leaves your machine.
  122. **Limits:** a reference implementation: no automatic capture, no search beyond simple matching, no sharing.
  123. **Repo:** [modelcontextprotocol/servers (memory)](https://github.com/modelcontextprotocol/servers/tree/main/src/memory)
  124. ## 9. Cognee
  125. An open-source memory platform that builds a knowledge graph from your documents and conversations. It ships a Claude Code plugin and an MCP server, and runs locally or on Cognee Cloud.
  126. ```bash
  127. claude plugin marketplace add topoteretes/cognee-integrations
  128. claude plugin install cognee-memory@cognee
  129. ```
  130. **Strengths:** graph plus search over your own data, local or hosted.
  131. **Limits:** more to configure (LLM provider, storage) than a plain plugin.
  132. **Repo:** [topoteretes/cognee](https://github.com/topoteretes/cognee)
  133. ## 10. Graphiti and Zep
  134. Graphiti builds a temporal knowledge graph, so it tracks when a fact was true, not only that it was. Its MCP server (marked experimental) needs a graph database such as Neo4j. Zep is the hosted platform built on Graphiti.
  135. **Strengths:** strong at facts that change over time.
  136. **Limits:** you run a graph database, or pay for Zep. Not focused on coding sessions.
  137. **Repo:** [getzep/graphiti](https://github.com/getzep/graphiti)
  138. ## Honorable mentions
  139. - **Anthropic API memory tool.** For apps built on the Claude API: Claude reads and writes files in a memory directory that your code stores. Good if you're building your own agent and want Claude-native memory. See Anthropic's docs for the memory tool.
  140. - **[Letta](https://github.com/letta-ai/letta)** (formerly MemGPT). A platform for stateful agents with self-editing memory; it also publishes a memory MCP server.
  141. ## How to choose a Claude memory tool
  142. | If you want | Use |
  143. | --- | --- |
  144. | Claude to know what your **teammates'** agents learned | **⭐ [Glen](https://tryglen.com)** |
  145. | Project rules that every session follows | `CLAUDE.md` |
  146. | Claude Code to remember your own corrections on one machine | Auto memory or claude-mem |
  147. | Memory in claude.ai chats | Claude app memory |
  148. | Memory inside an app you're building | Mem0, Supermemory, or the Claude API memory tool |
  149. | Memory as Markdown files you edit yourself | Basic Memory |
  150. | A self-hosted knowledge graph | MCP Knowledge Graph Memory, Cognee, or Graphiti |
  151. These stack. A common setup: `CLAUDE.md` for rules, auto memory for personal preferences, and **Glen** for everything your team has worked out.
  152. ## Claude memory FAQ
  153. ### Does Claude have memory?
  154. Yes, in a few separate places. The Claude apps (claude.ai, Desktop, mobile) can remember past chats. Claude Code loads `CLAUDE.md` files and its own auto memory at the start of every session. The Claude API has a memory tool for agents you build. None of these are shared between them, or between people.
  155. ### How do I give Claude Code persistent memory?
  156. Start with a project `CLAUDE.md` and leave auto memory on. For memory beyond one person and one machine, add a plugin or MCP server: [Glen](https://tryglen.com) for team-wide memory, or claude-mem for personal session memory.
  157. ### What is the best memory MCP server for Claude?
  158. For a team using Claude Code, [Glen](https://tryglen.com): it records sessions automatically and shares memory across everyone, over both a remote MCP server and a CLI. For one person who wants local files, Basic Memory. For a minimal self-hosted option, the official MCP Knowledge Graph Memory server.
  159. ### Can Claude remember across sessions?
  160. Claude Code can, through `CLAUDE.md` and auto memory, which load at the start of every new session. Memory tools on this list extend that to other machines, other agents and other people.
  161. ### Can my team share Claude's memory?
  162. A committed `CLAUDE.md` shares rules, but not what each person's Claude learned while working. [Glen](https://tryglen.com) is built for this: every teammate's Claude Code, Codex and Cursor sessions feed one shared memory, with access control so each person only recalls what they're allowed to see.
  163. ### Is Claude Desktop memory the same as Claude Code memory?
  164. No. Claude Desktop's chat memory and Claude Code's `CLAUDE.md` and auto memory are separate. A remote MCP memory server (Glen, Supermemory) is the simplest way to give both the same memory.
  165. ---
  166. <sub>Disclosure: this list is maintained by the team behind Glen. Every other entry is described from its own docs and README; corrections are welcome as issues or pull requests.</sub>
  167. <sub>Keywords: claude memory, claude code memory, claude persistent memory, claude long-term memory, claude memory mcp, memory mcp server, claude desktop memory, CLAUDE.md, claude code plugin memory, shared memory for AI agents, team memory for claude code.</sub>

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.