# Mem0 for Claude Code: what it does and how to install it

> mem0ai/mem0 packages Mem0's memory layer as a Claude Code plugin: 26 skills plus 1 MCP server that store, search, and clean up memories with skills like `remember` and `search`, inject relevant ones automatically, and manage multiple projects. A handful of skills are developer reference material for wiring Mem0 into another application through its SDK, CLI, or Vercel AI SDK provider.

Canonical: https://www.flowy.sh/plugins/mem0ai-mem0/guide
Published: 2026-10-29
Updated: 2026-10-29
Author: Flowy

## What is Mem0?

mem0ai/mem0 is the repository behind Mem0 (pronounced "mem-zero"), a memory
layer that gives AI assistants and agents persistent, personalized context
across sessions. Flowy lists it under the data category, and at the last
crawl the repository carried 64,021 GitHub stars. The Claude Code plugin
Flowy indexes from it ships 27 components: 26 skills and 1 MCP server.
Flowy indexes what the repository publishes; it does not own, host, or run
any of it.

## Which everyday memory commands does Mem0 add?

This group covers the basic verbs. `remember` stores a memory verbatim when
you say something like remember this, save this, or note that, classifying
it with a type and metadata as it goes. `search` and `peek` handle
retrieval, and their descriptions are close to identical: both search
memories and return compact one-liner results, or look up a single memory
by ID, useful for a quick check on whether something was recorded or for
resolving a citation. `forget` deletes a memory by search query or by ID,
asks for confirmation first, and can undo a recent addition. `pin` protects
a specific memory, an architecture decision or a security constraint for
example, from later removal during cleanup. A related skill,
`memory-triage`, runs a similar evaluate-and-store pass, though its own
description ties it to a separate project called openclaw-mem0, closer to
a cousin of `remember` than a distinct command.

## How do I keep stored Mem0 memory clean?

Memory quality gets its own set of skills. `memory-reviewer` audits what is
already stored, flagging duplicates, contradictions, and stale entries with
recommendations, meant to run before any cleanup. `dream` is that cleanup
step: it merges duplicates, resolves contradictions, and prunes stale
entries once the memory count is high or search results start feeling
noisy. `memory-dream` covers similar ground but goes further: it also strips
noise and credentials, rewrites unclear entries, enforces expiration on
old memories, and can apparently trigger automatically, not just on
request. `stats` reports usage: counts by category, an age breakdown, and
API latency. `tour` browses everything already stored, grouped by category
with full detail, good for an overview rather than a search.

## Can Mem0 work across more than one project?

`context-loader` runs at the start of a task, searching for relevant
memories and injecting them before you begin, surfacing past decisions and
coding conventions unasked. `list-projects` lists every project with
stored memories, showing counts and last activity, and `switch-project`
points reads and writes at a different project, or turns on search across
every project and user at once. `policy` is where the extraction rules
live: what mem0 should remember or ignore for a given project, kept in a
project file called mem0.md. `export` writes everything to a portable
markdown file for backup or handoff, and `import` brings memories back
from that file, or from Claude Code's MEMORY.md, for a new project or a
restore.

## How do I set up Mem0 and check the connection?

`onboard` handles first run setup: API key configuration, MCP
authentication, pulling in existing project files, and setting up coding
categories. `health` and `status` both diagnose the same problem,
connectivity, API key validity, and whether reads and writes work, and
their descriptions barely differ, so either works when a search comes back
empty or a save fails. The plugin's one MCP server is also named `mem0`.
Flowy's index carries no separate description for it, but the skills above
check MCP connectivity and authentication by name, so it looks like the
direct path to the same memory operations the others wrap as commands.

## How do I wire Mem0 into my own application?

The remaining skills are not about managing memory inside a session at
all; they are reference material for a developer adding Mem0 to their own
product. `mem0` documents the Mem0 Platform SDK, firing on mentions of a
MemoryClient or a persistent memory layer. `mem0-cli` covers the separate
command line interface, for typing mem0 commands such as mem0 add or mem0
search directly in a terminal. `mem0-vercel-ai-sdk` documents the Mem0
provider for the Vercel AI SDK. `mem0-integrate` runs a guided, test-first
pipeline that adds Mem0 to an existing repository, detecting its language
and asking you to choose between the hosted Platform and the self-hosted
option. `mem0-test-integration` is the companion check, run afterward in
the same workspace: it installs dependencies, runs the repository's own
tests, exercises a real end-to-end flow against your API key, and produces
a scorecard. `mem0-oss-to-platform` plans and carries out a migration from
the self-hosted SDK to the hosted one.

## How do I install Mem0 in Claude Code?

Install from [the install card on the listing page](https://www.flowy.sh/listings/mem0ai-mem0#install). Flowy
indexes mem0ai/mem0 from its public repository under the data category. It
does not own, host, or modify the project, and all 27 components above
stay on the author's own releases in the source repository.

Sources: [mem0ai/mem0 on GitHub](https://github.com/mem0ai/mem0), [mem0ai/mem0 README](https://github.com/mem0ai/mem0#readme)

## Common questions

### What does the mem0ai/mem0 Claude Code plugin do?

It adds a memory layer to Claude Code sessions using Mem0. Skills like `remember`, `search`, `peek`, `forget`, and `pin` store and retrieve memories inside a project, `context-loader` injects relevant ones automatically at the start of a task, and other skills handle cleanup, multi-project scoping, and connection diagnostics. The plugin ships 26 skills and 1 MCP server in total.

### What is the difference between the search and peek skills?

Very little. Both search stored memories and return compact one-liner results, or look up a single memory by its ID, and their descriptions in the plugin are nearly word for word identical. Use whichever name comes to mind for a quick lookup or for resolving a memory citation.

### What is the difference between dream and memory-dream?

Both consolidate stored memories by merging duplicates and resolving contradictions, but `memory-dream` goes further according to its own description: it also removes noise and credentials, rewrites unclear entries, and enforces expiration on old memories, and appears able to run on its own rather than only on request. `dream` reads as the simpler, on-demand version of the same idea.

### Can I use this plugin if I'm building my own app with Mem0, not just coding in Claude Code?

Yes. Alongside the memory commands, the plugin ships reference and setup skills for developers: `mem0` for the Platform SDK, `mem0-cli` for the command line interface, `mem0-vercel-ai-sdk` for the Vercel AI SDK provider, `mem0-integrate` for a guided integration pipeline into an existing repository, `mem0-test-integration` to verify that integration, and `mem0-oss-to-platform` to migrate a project from the self-hosted SDK to the hosted one.

### How do I check whether my mem0 connection is working?

Run the `health` or `status` skill. Both diagnose the same things: connectivity, API key validity, and whether memory reads and writes actually succeed, which is useful whenever a search comes back empty or a save seems to fail silently. `onboard` covers first-time setup instead, including API key configuration and MCP authentication.

## Related

- [The listing page](https://www.flowy.sh/listings/mem0ai-mem0): Install command, components and repository
- [Alternatives to this plugin](https://www.flowy.sh/alternatives/mem0ai-mem0): Peers in its category, ranked by stars
- [The Claude Code plugin marketplace](https://www.flowy.sh/marketplace/plugins): How plugins install, and every plugin in the index
- [PostHog for Claude Code: what it does and how to install it](https://www.flowy.sh/plugins/posthog-posthog/guide): another plugin guide
- [superpowers for Claude Code: what it does and how to install it](https://www.flowy.sh/plugins/superpowers-flow/guide): another plugin guide