MindMemOS skill
Long-term memory for AI agents: a skill and the mindmemos command store facts from conversations and recall them in later sessions
- 918 ★ on the repository
- Last commit
Broad access
Why this level
- The plugin stores the conversation at the end of every turn, and messages can contain personal data, keys and work secrets
- In cloud mode sends messages to an external server and keeps the API key in `~/.mindmemos/settings.json`
- The `memory delete`, `memory update` and `skill push` commands change and delete data on the server
Install
- Works in
In your terminal, with SkillFoxx CLI
npx skillfoxx add skills/mindmemosDetects the agents on your machine, shows the access level and pins the version.
Other ways to install
Access and checks
How we reviewBroad accessThe tool can change data, run commands or handle secrets.
- The plugin stores the conversation at the end of every turn, and messages can contain personal data, keys and work secrets
- In cloud mode sends messages to an external server and keeps the API key in `~/.mindmemos/settings.json`
- The `memory delete`, `memory update` and `skill push` commands change and delete data on the server
This is third-party code. Review the repository files before installing.
What it does
MindMemOS is a long-term memory layer for AI agents. The repository ships it as a server, a Python package `mindmemos-sdk` with the `mindmemos` command, the `mindmemos-cli` skill and plugins for OpenClaw and DeepSeek Harness. An agent installs the CLI with `pip install mindmemos-sdk` (or through `pipx`, or `uv tool install`), runs `mindmemos auth` once with the service address, an API key and a user id, and then manages memory with subcommands. `memory add` sends messages to the server, which extracts durable facts and merges them with what is already stored. `memory search` returns records by meaning: the `fast` strategy searches by vectors, `agentic` reasons across several records, and the `--rerank` and `--token-budget` flags raise precision and cap the size of the answer. The rest is `get`, `update` and `delete` by id, `feedback` to correct a bad recollection and `dreaming`, a background merge and compression of what has piled up. The OpenClaw plugin calls the same CLI itself: it searches memories before each prompt and injects them, and at the end of a turn it stores the conversation. The server is available ready-made at `https://mindmemos.cn` with a key from the website, or you can run your own: `make dev` brings up `Qdrant`, `Neo4j` and `Kafka` in Docker and then FastAPI on port 8000, and `dev.yaml` sets the models for generation, embeddings and, optionally, reranking. The `mindmemos skill` subcommands register local skills, push their versions to the server and roll them back.
Who it is for. For developers who want an agent to remember user preferences and project facts between sessions and are ready to use the MindMemOS cloud service or run their own server.
Good fit when
- An agent has to remember user preferences and project decisions between sessions: `memory add` at the end of a turn, `memory search` at the start
- One memory has to serve several agents: the API key separates projects, and inside a project records are split by `--user-id`, `--app-id`, `--agent-id` and `--session-id`
- You need to inspect or clean what is stored: `memory get` with a filter and `memory delete <id> --yes`
- The agent runs in OpenClaw or DeepSeek Harness and memory should attach through a plugin without prompt edits
- You need a background cleanup of memory on a schedule: `memory dreaming` merges and compresses accumulated records
Not a fit when
- Conversations must not go to an external server and you have no resources for your own: the `mindmemos.cn` cloud receives messages, and the local server needs Docker with several services
- You want memory in local Markdown files without a server: Basic Memory is closer, it stores notes as files with a link graph
- You need a ready plugin for Claude Code: the repository has plugins only for OpenClaw and DeepSeek Harness, in other cases the agent calls the CLI itself
- You do not want to configure models: the local server requires generation and embedding models in `dev.yaml`
Example request
Remember that this project uses pnpm and never touches the legacy folder, and check this before edits in later sessionsLimitations
- The CLI works only through a server: the cloud `https://mindmemos.cn` with a key from the website or a local `http://127.0.0.1:8000`. The address and key are stored in `~/.mindmemos/settings.json`.
- The project was officially released on 30 June 2026. The MIT license is stated in the documentation, and the repository has no separate license file.
- Installing the OpenClaw plugin is not enough: without the `allowConversationAccess` parameter the store after a turn is silently blocked, while search works and the plugin looks healthy. If OpenClaw is launched from a graphical shell it may not find `mindmemos` in PATH, and then the `cli` setting needs an absolute path.
- `memory search` does not take `--user-id` from `mindmemos auth`: without the parameter the search covers the whole project bound to the key.
- The memory extraction scheme is chosen with the `algo_config.add.schema.version` parameter, `v2` by default.
How to disable. For OpenClaw disable the plugin in the settings: the `plugins.entries.mindmemos-memory` entry, the `enabled` parameter. Remove the CLI with `pip uninstall mindmemos-sdk` and delete the `~/.mindmemos` directory by hand. Memories on the server are erased with `mindmemos memory delete <id> --yes`.
FAQ
How do I give an AI agent long-term memory?
Install `mindmemos-sdk`, run `mindmemos auth` and give the agent the `mindmemos-cli` skill, which describes the `memory add` and `memory search` commands. For OpenClaw and DeepSeek Harness there are plugins that search and store memories on their own.
How do the fast and agentic search strategies differ?
`fast` searches by vectors and suits cases where speed matters. `agentic` reasons across several memories and is for answers assembled from several records. The `--rerank` flag also reorders candidates for precision.
How is memory split between users and projects?
The project is determined by the API key, and no separate parameter is needed. Inside a project records are told apart by `--user-id`, `--app-id`, `--agent-id` and `--session-id`. A search without `--user-id` covers the whole project.
Can I keep memory on my side, without the cloud?
Yes. Copy `.env.example` and `config/mindmemos/dev.example.yaml`, set the generation and embedding models, add a key to `config/mindmemos/api_keys.yaml` and run `make dev`. The server listens on port 8000, and the CLI is pointed at `http://127.0.0.1:8000`.
What does the dreaming command do?
`memory dreaming` runs a background pass that merges, compresses and reorganizes accumulated memories. Put it on a schedule rather than every turn. By default the command goes to a queue, and `--sync` waits for the result.
How do I fix a wrong memory?
If you know the id, `memory update mem_123 --content "..."` rewrites the record and `memory delete mem_123 --yes` removes it. To signal a bad recollection, `memory feedback --text "..."` hands the server the correction together with the messages of that turn.
Discussion
No questions or reviews yet.
Related
SkillsShared local memory for AI agents: Claude Code, Codex, Cursor and others find the agreements of past sessions in it and record new ones
Long-term memory for agents: a remote MCP server, plugins for Claude Code, Cursor and Codex, and an API for your own apps
A long-term memory system for AI agents: the agent stores experience and facts, then retrieves them through a built-in MCP server
A Claude Code skill that pulls memory from Memori Cloud before every non-trivial answer and writes new facts back to it
Shared semantic memory for agents: conversations are saved as markdown and recalled by search across Claude Code, Codex and other agents
Long-term memory for AI agents: Markdown files as the source of truth, a SQLite index as a cache, shared by Claude Code, Codex and others
Comparison with similar tools
Entries that share the main search query, and how they differ.
| Entry | Official | Authentication | Repository stars | Main difference |
|---|---|---|---|---|
| MindMemOS (this entry) | yes | 918 | ||
| Claude-Mem | no | 102,227 | a persistent memory plugin that saves observations from agent sessions and injects the right context into new ones | |
| Basic Memory | no | not required | 4,308 | long-term memory in local Markdown files with a link graph, semantic search and MCP access |
README in short
The repository holds a Python server, settings in `config/mindmemos`, Docker files, tests, two plugins in the `plugins` folder and a skill in `skills/mindmemos-cli` with three reference files on OpenClaw, DeepSeek Harness and the Python SDK. The documentation opens with news and a feature list, then two deployment modes and four access methods with a table of addresses, examples in curl, the SDK and the CLI, a benchmark comparison and a license section.
README badge
Original SKILL.md
--- name: mindmemos-cli description: Give an AI agent persistent, cross-session long-term memory through MindMemOS. Covers installing and authenticating the mindmemos CLI, the full command interface (add / search / get / update / delete / feedback / dreaming) with parameters and examples, guidance on which capability to use when, plus a Python SDK example. To wire memory into a specific agent host (OpenClaw, DeepSeek Harness, Codex, Claude, etc.), see references/. --- # MindMemOS CLI MindMemOS is a long-term memory layer for AI agents. The `mindmemos` CLI is the integration surface: every memory operation is a subcommand that prints either a human-readable line or, with `--json`, stable machine-readable output. Any agent or script can drive memory by shelling out to it. To connect memory to a specific agent host (e.g. an editor or assistant that supports plugins), the host calls this same CLI. Host-specific install guides live under `references/` — see [Host integrations](#host-integrations). --- ## Install the CLI The CLI ships as the Python package `mindmemos-sdk` and exposes a `mindmemos` executable. ```bash pip install mindmemos-sdk # or, isolated so it's on PATH globally (recommended): pipx install mindmemos-sdk uv tool install mindmemos-sdk ``` Authenticate once. This writes a local config (API key, default user id, base URL). Operations that require a user inherit the default user id, but `memory search` does not: omit `--user-id` for project-wide search or pass it explicitly for user-scoped search. ```bash mindmemos auth # non-interactive: mindmemos auth --api-key sk-... --user-id alice --base-url https://api.mindmemos.example.com ``` Verify: ```bash mindmemos config show # masked key, base_url, user_id mindmemos memory search "test" # confirms connectivity with a project-wide search ``` --- ## CLI interface