# Mnemoverse — Persistent Memory API for AI Agents

> One memory. Every AI tool. Write once, recall anywhere. This file is the short contract. If you need deep reference (full endpoint schemas, error catalogue, production code examples), also fetch https://mnemoverse.com/docs/llms-full.txt (about 3 MB, support pages first). The two files are intended to be read together.

Mnemoverse is a persistent memory API for LLM agents. Store preferences, decisions, lessons, and context once — recall them from Claude Code, Claude Desktop, Cursor, VS Code, Devin Desktop, ChatGPT, Python, or any HTTP client. Same memories across every tool: one account, connected with an API key or OAuth. Not a vector database. It learns from outcomes: ratings re-rank what comes back next, and unhelpful memories are out-ranked rather than erased.

## In one screen

- Write: `POST https://core.mnemoverse.com/api/v1/memory/write`, header `X-Api-Key: mk_live_YOUR_KEY`, body `{"content": "Prefers email over Slack", "domain": "user:alice"}`.
- Read: `POST https://core.mnemoverse.com/api/v1/memory/read`, same header, body `{"query": "how to contact this user?", "domain": "user:alice"}`. Over MCP: `memory_write` and `memory_read`, same fields.
- Per-user memory: there is no `user_id` field. Pass `"domain": "user:<user_id>"` on every write and read. A domain separates results but is not an access boundary: every key of the account reaches all its domains, so keep the key on your server and set the domain there.
- Free plan: 1,000 queries/day (reads, writes and feedback combined), 10,000 atoms, 60 req/min, no credit card. Setup per client: Quick Start below.

## Quick Start

Three steps from zero to a working memory. Pick the client that matches yours. Claude Code, Claude Desktop, claude.ai, Cursor, VS Code and ChatGPT can use the hosted server, which signs in through the browser and needs no key and nothing installed: for those, skip step 1. The key is the same for all key-based paths.

1. **Get an API key (key-based paths only: the local package, Python, plain HTTP).** Sign up at https://console.mnemoverse.com/sign-up?utm_source=llms&utm_medium=index&utm_campaign=quickstart (free, no credit card). Once logged in, create a key from the console — it starts with `mk_live_`. The MCP server starts without it and lists its tools, but every tool call needs it; the HTTP API returns `401 UNAUTHORIZED`. (Skip this step for the OAuth connector below — it authenticates with a browser sign-in.)

2. **Install for your client** (one-time setup):
   - **Claude Code** — the hosted server, no key, nothing to install: `claude mcp add --scope user --transport http mnemoverse https://mcp.mnemoverse.com/mcp`. Keep `--scope user`: without it the server is added for the current directory only. A Claude Code session that was running when the command ran does not load the server, so start `claude` again, run `/mcp`, select `mnemoverse` and choose Authenticate. The plugin route is on https://mnemoverse.com/docs/api/install-by-host#claude-code. Local package with an API key instead (Node.js 18 or later): `claude mcp add mnemoverse --scope user -e MNEMOVERSE_API_KEY=mk_live_YOUR_KEY -- npx -y @mnemoverse/mcp-memory-server@latest`
   - **Claude Desktop / claude.ai / remote MCP clients (one-click OAuth, no key)** — add a custom connector with URL `https://mcp.mnemoverse.com/mcp`. This is the ONLY URL that goes into an MCP connector field — never paste the REST base there. In Claude, the link https://claude.ai/customize/connectors?modal=add-custom-connector&connectorName=Mnemoverse&connectorUrl=https%3A%2F%2Fmcp.mnemoverse.com%2Fmcp opens the Add custom connector dialog on claude.ai with the name and URL filled in (Free plans allow one custom connector). Sign-in works for allowlisted hosts (Claude, ChatGPT, major editors); a client served from your own domain is refused by design (reach it at localhost, use the local package with an API key, or ask us to add your host). Docs: https://mnemoverse.com/docs/api/remote-mcp-server
   - **Claude Desktop / Cursor / VS Code / Devin Desktop** — paste the JSON snippet from the [MCP Server](#mcp-server) section into the config file for your client (paths listed there). Restart the client after saving. Keyless instead: VS Code + GitHub Copilot users can one-click install the [Mnemoverse Agent Memory extension](https://marketplace.visualstudio.com/items?itemName=Mnemoverse.mnemoverse-vscode) and click Sign In; Cursor users can click [Add to Cursor](https://cursor.com/install-mcp?name=mnemoverse&config=eyJ1cmwiOiJodHRwczovL21jcC5tbmVtb3ZlcnNlLmNvbS9tY3AifQ==) (adds `https://mcp.mnemoverse.com/mcp` to `~/.cursor/mcp.json`), then click Connect next to `mnemoverse` in Customize.
   - **OpenCode** — the hosted server, no key: in `~/.config/opencode/opencode.json`, add under `mcp` the entry `"mnemoverse": {"type": "remote", "url": "https://mcp.mnemoverse.com/mcp"}`. OpenCode asks for a browser sign-in the first time the server is used; `opencode mcp auth mnemoverse` starts it by hand, and `opencode mcp list` shows the sign-in state. These steps come from OpenCode's documentation; Mnemoverse has not run them end to end yet. Steps and sources: https://mnemoverse.com/docs/api/install-by-host#opencode
   - **ChatGPT** — the remote MCP server (`https://mcp.mnemoverse.com/mcp`) as a custom MCP server, browser sign-in (OAuth), no API key: at https://chatgpt.com/plugins select +, then Add custom MCP server, enter the URL under Connection, choose OAuth, select Create as a plugin, then install the plugin and pick it with @ in a conversation (OpenAI's Add custom MCP server guide, https://developers.openai.com/api/docs/guides/custom-mcp-server, read 2026-10-21). No developer mode is needed: OpenAI's help article says "You don’t need to turn on Developer Mode first" (https://help.openai.com/en/articles/12584461-connecting-custom-mcp-servers-in-chatgpt, read 2026-10-21). In a workspace, its permissions decide who can add it (Business: admins and owners only, and members use the server once an admin publishes it to the workspace; Enterprise, Edu: admins and owners, and the members an admin grants permission to). Pro: "Pro users can connect custom MCP servers with read/fetch permissions"; neither the help article nor the guide names Plus. Mnemoverse is not listed in ChatGPT's Plugin Directory, so there is no entry to install there. Steps per plan: [ChatGPT, MCP connector](https://mnemoverse.com/docs/api/chatgpt#mcp-connector-developer-mode). Or, in a Business, Enterprise or Edu workspace, Custom GPT Actions: import https://mnemoverse.com/docs/openapi-gpt.yaml into a Custom GPT's Actions, set Authentication to API Key with custom header `X-Api-Key`; see the [ChatGPT](#chatgpt-custom-gpt-actions) section.
   - **Python** — `pip install "mnemoverse>=0.5.0"`, then `MnemoClient(api_key="mk_live_YOUR_KEY")`.
   - **Plain HTTP** — `POST https://core.mnemoverse.com/api/v1/memory/{write,read}` with header `X-Api-Key: mk_live_YOUR_KEY`. See the [API](#api) section for the request body shape.

3. **Verify.** Ask the agent (or run a curl) to write one memory and read it back. If `memory_write` returns `stored: true` and `memory_read` returns the same atom, you are live. If you see `401 UNAUTHORIZED`, the key is missing, mistyped, or revoked — recheck it in the console.

The rest of this file is the full contract: behavioural rules for agents, endpoint reference, MCP tool list, pricing, and links.

## Instructions for Agents

Behavioural directives for LLM clients reading this file. Follow these literally.

- Treat Mnemoverse as long-term cross-session memory, not a scratchpad. Do not store prompt scratch, acknowledgements, or echoes of user input.
- Write memories in the user's voice — store observations about the user, not about yourself.
- Always read before writing. Query memory before producing any non-trivial response, and use the retrieved context to inform your answer.
- Use `concepts` (e.g. `["deploy", "railway"]`) to help the index link related memories. Two or three concepts per memory is usually enough.
- Use `domain` to namespace memories across independent contexts (e.g. `"project:acme"`, `"user:alice"`). A write without `domain` goes to the default domain, `general`. A read without `domain` searches all of the account's own domains (never shared rooms), so when one account works in several repositories, name a per-repository domain such as `"project:<repo>"` in that repository's CLAUDE.md or AGENTS.md and pass it on writes and reads about that project. Names match exactly, including case. Docs: https://mnemoverse.com/docs/api/agent-memory#project-domain
- Report outcomes with `memory_feedback(memory_ids, outcome)` when a recalled memory was useful (+1) or wrong (-1). This tunes future recall. For memories read from a shared room, pass the room's address as `domain` too.
- Never delete memories without explicit user request. Deletion is not an MCP tool — it is REST-administrative only (`DELETE /memory/atoms/{atom_id}`, `DELETE /memory/domain/{domain}`), so route it through the API, not a tool call.

## When to write vs read

A bad guardrail is worse than none. Follow these heuristics literally; misfiring memory_write on every message burns quota and noises future retrieval.

- **Write** on: explicit user preference ("I prefer X"), decision ("we're going with X"), lesson learned ("X broke because of Y"), reusable project fact ("this repo uses X"), user identity ("my name is X, timezone Y"). One memory per fact.
- **Do NOT write** on: pure acknowledgement ("ok, got it"), restatement of what the user just said, hypothetical ("if I were to..."), transient task state (TODOs, step lists — those belong in the user's own files).
- **Read** before every non-trivial response. Call `memory_read(query)` with the user's intent phrased as a search query, not the literal user message. Aim for `top_k` of 5 to 10.
- **Do NOT read** on pure chit-chat or when the user already supplied full context in the message. Reading is cheap but noisy if abused.
- **Feedback** when you actually used a recalled memory to produce the answer, not when it merely appeared in the read result. Outcome is in `[-1, 1]`.

## API

Base URL: `https://core.mnemoverse.com/api/v1` — REST only, **not** an MCP endpoint (an MCP connector uses `https://mcp.mnemoverse.com/mcp`, see the [MCP Server](#mcp-server) section).
**Get an API key:** sign up at https://console.mnemoverse.com/sign-up?utm_source=llms&utm_medium=index&utm_campaign=api-key — create and manage keys from the console. Free tier (1,000 queries/day, 10,000 atoms, 60 req/min) is enabled on signup, no credit card required. Without a key the API returns `401 UNAUTHORIZED` and every MCP tool call is refused (the server itself starts without a key).
Auth: `X-Api-Key: mk_live_YOUR_KEY` header (or `Authorization: Bearer mk_live_YOUR_KEY`). API keys are hashed with **SHA-256** before storage; comparison is constant-time via `secrets.compare_digest` to prevent timing attacks.

```bash
# Store a memory
curl -X POST https://core.mnemoverse.com/api/v1/memory/write \
  -H "X-Api-Key: mk_live_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"content": "User prefers Railway for deploys", "concepts": ["deploy","railway"]}'

# Recall memories
curl -X POST https://core.mnemoverse.com/api/v1/memory/read \
  -H "X-Api-Key: mk_live_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"query": "how does the user deploy?", "top_k": 5}'
```

Python SDK (`pip install "mnemoverse>=0.5.0"`, v0.5.0 live on PyPI):

```python
from mnemoverse import MnemoClient, MnemoRateLimitError

client = MnemoClient(
    api_key="mk_live_YOUR_KEY",
    timeout=10.0,  # seconds, default: 10
)

client.write("User prefers Railway for deploys", concepts=["deploy", "railway"])

try:
    results = client.read("how does the user deploy?", top_k=5)
except MnemoRateLimitError as e:
    print(f"Rate limited. Retry after {e.retry_after}s")
```

## Endpoints

- [POST /memory/write](https://mnemoverse.com/docs/api/reference#post-memory-write): Store one memory. Body: `{content, concepts?, domain?, metadata?, external_ref?, supersedes?}`.
- [POST /memory/read](https://mnemoverse.com/docs/api/reference#post-memory-read): Search memories by a natural-language query. Body: `{query, top_k?, domain?, min_relevance?, include_associations?, include_history?}`.
- [POST /memory/feedback](https://mnemoverse.com/docs/api/reference#post-memory-feedback): Rate usefulness of retrieved memories. Body: `{atom_ids, outcome}`, outcome in `[-1.0, 1.0]`.
- [GET /memory/stats](https://mnemoverse.com/docs/api/reference#get-memory-stats): Total atoms, association edges, domains, health.
- [POST /memory/write-batch](https://mnemoverse.com/docs/api/reference#post-memory-write-batch): Store **up to 500 memories** in one request.
- [POST /memory/read-batch](https://mnemoverse.com/docs/api/reference#post-memory-read-batch): Run up to 50 queries in one request.
- [POST /memory/consolidate](https://mnemoverse.com/docs/api/reference#post-memory-consolidate): Designed to merge similar memories; switched off on the hosted service (responds `503`).
- [DELETE /memory/atoms/{atom_id}](https://mnemoverse.com/docs/api/reference): Permanently delete one atom by `atom_id`. Idempotent — deleting an already-gone atom returns `200` with `deleted: 0`.
- [DELETE /memory/domain/{domain}](https://mnemoverse.com/docs/api/reference): Wipe every atom in a domain. Returns `{deleted, domain}`. **Note:** the REST route has no `confirm`-style interlock of its own, and no MCP wrapper exists to gate it either. Treat as destructive client-side.

Errors: HTTP **429 `RATE_LIMITED`** with `Retry-After` and `X-RateLimit-Reset` headers when rate-limited; **`401 UNAUTHORIZED`** for missing/invalid/expired API key (the `code` is uniformly `UNAUTHORIZED`; the `message` field distinguishes missing key / invalid key / expired token); `403 FORBIDDEN` when the key lacks permission for the requested action; `400 VALIDATION_ERROR` (or `422` for some Pydantic-level failures) with structured error body for malformed payload; `500 INTERNAL` for retryable server-side errors. Cross-tenant access does NOT raise 403 — it returns an empty result set (rows are scoped, not gated). The Python SDK surfaces rate limits as `MnemoRateLimitError`, with the retry delay exposed on `e.retry_after`.

## Rooms (Beta)

A **room** is a memory pool shared across Mnemoverse accounts. Members write to and read from it by passing the room address `xroom:<room_id>` in the existing `domain` field of `POST /memory/write` and `POST /memory/read` (and the MCP `memory_write` / `memory_read` `domain` parameter) — no new endpoint. Membership is checked on every request; room usage is billed to the authenticated caller, never the room owner. A room is its own bucket: an atom written to a room lives in the room, not in the writer's account, and joining a room exposes nothing from your private memory. Create / invite / join / list are self-service via the four Beta MCP tools. The console supports room and member management, email invitations, and browser redemption, but does not mint share codes. Docs: https://mnemoverse.com/docs/api/rooms

## MCP Server

The [`@mnemoverse/mcp-memory-server`](https://www.npmjs.com/package/@mnemoverse/mcp-memory-server) npm package exposes **core memory tools, Beta shared-room tools and `vault_list`** (every one is listed under "Tools exposed" below) to any MCP-compatible client (Claude Code, Claude Desktop, Cursor, VS Code + Copilot Chat Agent Mode, Devin Desktop, and anything else that speaks Model Context Protocol). It is listed on the [official MCP Registry](https://registry.modelcontextprotocol.io/v0/servers?search=mnemoverse).

Two ways to connect it:

- **Remote connector (hosted, OAuth)** — URL `https://mcp.mnemoverse.com/mcp`, streamable HTTP, browser sign-in, no API key. This is the URL for any "add custom connector / MCP server URL" field; in Claude Code, `claude mcp add --scope user --transport http mnemoverse https://mcp.mnemoverse.com/mcp`. Exposes the same tools as the local package: the core memory tools, the Beta room tools, and `vault_list`. One declared exception: in ChatGPT it does not offer `vault_list` (https://mnemoverse.com/docs/api/tool-availability). A client that cannot complete the sign-in but can send a fixed header can use the same URL with an API key as `Authorization: Bearer mk_live_YOUR_KEY` (accepted since 2026-10-19; `X-Api-Key` is not read there). A client that runs only local (stdio) servers reaches the same URL without a key through the third-party `mcp-remote` bridge, `npx -y mcp-remote@latest https://mcp.mnemoverse.com/mcp` (Node.js 20.18.1 or later), which opens the same browser sign-in on first start (https://mnemoverse.com/docs/api/install-by-host#any-other-mcp-client). Docs: https://mnemoverse.com/docs/api/remote-mcp-server
- **Local stdio server (npx)** — the config snippets below; authenticated by `MNEMOVERSE_API_KEY`. Its optional `MNEMOVERSE_API_URL` env var is the REST backend it calls (`https://core.mnemoverse.com/api/v1`) — never paste that value into a connector-URL field.

Tools exposed:

- `memory_write(content, concepts?, domain?)` — store a preference, decision, or lesson.
- `memory_read(query, top_k?, domain?, order_by?, since?, until?, exclude_author?)` — search memories by natural-language query; `order_by: "recency"` returns newest first, `since`/`until` bound creation time (ISO-8601, naive = UTC), `exclude_author` skips one author's entries (rooms: "only what others wrote").
- `memory_list_recent(domain?, since?, until?, exclude_author?, limit?, cursor?)` — the newest memories first with no query: a catch-up feed, complete by construction. Same time and author filters as `memory_read`; `since` is the novelty watermark and the returned cursor pages older entries without skips or duplicates.
- `memory_feedback(memory_ids, outcome, domain?)` — rate usefulness. Outcome in `[-1, 1]`; `domain` is the room address when the memories came from a shared room.
- `memory_stats()` — inspect how many memories are stored and their distribution.
- `memory_graph(seeds, depth?, domain?, min_weight?, limit?)` — read the association edges around 1-20 seed concepts, up to 3 hops (`depth`), each with its weight, valence and count; `domain` is a room address to read that room's graph. Read-only.
- `memory_create_room(name)` — Beta: create a shared cross-account memory room.
- `memory_invite_to_room(room_id, scope?, expires_in_days?, max_uses?)` — Beta: mint an invite code (`mnvr_...`), single-use unless `max_uses` allows more.
- `memory_join_room(invite_code)` — Beta: join a room from an invite code.
- `memory_list_rooms()` — Beta: list the rooms you own or have joined, with each room's `domain` address (re-find rooms in a new session).
- `vault_list()` — list the ALIASES of secrets you have stored. Values are never returned by any listing; this answers *which* secrets exist, not what they are.

Also exposed, for clients that support them: four prompts, `recall`, `save_insight` and `what_do_you_know`, each a one-line shortcut to the tools above, and `setup_memory`, which returns memory rules for the user to place in their agent's instructions (CLAUDE.md, AGENTS.md, a Cursor rule, or Instructions for Claude; https://mnemoverse.com/docs/api/agent-memory), and one resource, `memory://item/{memory_id}`, which opens a saved memory from your own store by the id a `memory_read` result shows; a memory read from a shared room cannot be opened this way.

Members then read/write the shared pool by passing `domain: "xroom:<room_id>"` on `memory_write` / `memory_read` — no new endpoint. Docs: https://mnemoverse.com/docs/api/rooms

The install command is the same for every MCP client — only the config-file location changes:

```bash
npx -y @mnemoverse/mcp-memory-server@latest
```

Config paths by client:

- **Claude Code** (one-liner, no file; the hosted server above needs no key): `claude mcp add mnemoverse --scope user -e MNEMOVERSE_API_KEY=mk_live_YOUR_KEY -- npx -y @mnemoverse/mcp-memory-server@latest`
- **Claude Desktop — macOS**: `~/Library/Application Support/Claude/claude_desktop_config.json`
- **Claude Desktop — Windows**: `%APPDATA%\Claude\claude_desktop_config.json`
- **Claude Desktop — Linux**: `~/.config/Claude/claude_desktop_config.json`
- **Cursor — per-project**: `.cursor/mcp.json` (committable, scoped to the repo)
- **Cursor — global**: `~/.cursor/mcp.json` (applies to every project on the machine)
- **VS Code + GitHub Copilot Chat Agent Mode** (VS Code 1.102+): install the [Mnemoverse Agent Memory extension](https://marketplace.visualstudio.com/items?itemName=Mnemoverse.mnemoverse-vscode) for keyless setup (browser sign-in; the setting `mnemoverse.connection: hosted` needs no Node.js), or use the manual `.vscode/mcp.json` config below. The extension is also on [Open VSX](https://open-vsx.org/extension/mnemoverse/mnemoverse-vscode): VSCodium, Positron and Theia use the same VS Code MCP API; in Cursor it adds the hosted server to editor windows and offers Add to Cursor (all windows) for the Agents Window; Kiro, Windsurf / Devin Desktop and Trae get only a Copy MCP Config command. Per-editor details: https://mnemoverse.com/docs/api/vs-code#where-the-extension-works
- **VS Code — manual**: `.vscode/mcp.json` (same shape as Cursor's file)
- **Devin Desktop (formerly Windsurf)**: `~/.config/devin/mcp_config.json` (Windows: `%APPDATA%\devin\mcp_config.json`; project, only you: `.devin/mcp_config.local.json`, gitignored; `.devin/mcp_config.json` is committed, so keep keys out of it). An older `~/.codeium/windsurf/mcp_config.json` entry is still imported by default. Sign-in to the remote connector from its Devin Local agent is not verified yet, so use the API-key snippet below.

JSON snippet shared by every config-file client (Cursor, VS Code manual, Devin Desktop, Claude Desktop; only the key name differs, `mcpServers` vs `servers`):

```json
{
  "mcpServers": {
    "mnemoverse": {
      "command": "npx",
      "args": ["-y", "@mnemoverse/mcp-memory-server@latest"],
      "env": { "MNEMOVERSE_API_KEY": "mk_live_YOUR_KEY" }
    }
  }
}
```

Restart the client after saving the file — MCP servers are only picked up on client startup. The `@latest` suffix forces a registry metadata lookup on every session start so you always get the newest release.

## ChatGPT (Custom GPT Actions)

The main ChatGPT path is the remote MCP server added as a custom MCP server (see Install, step 2). Custom GPT Actions are the alternative: GPT creation needs a Business, Enterprise or Edu workspace, and OpenAI has scheduled custom GPTs to retire on Dec 11, 2026, with GPT custom actions not carried over by its migration (https://help.openai.com/en/articles/20001519-custom-gpt-retirement-and-migration-faq).

- Import the [OpenAPI 3.1.0 spec](https://mnemoverse.com/docs/openapi-gpt.yaml) into your Custom GPT's Actions configuration.
- Auth type: API Key, header name `X-Api-Key`, value `mk_live_YOUR_KEY`.
- Full walk-through: [ChatGPT setup guide](https://mnemoverse.com/docs/api/chatgpt).

## Pricing

Live tiers — [sign up and upgrade](https://console.mnemoverse.com/sign-up?utm_source=llms&utm_medium=index&utm_campaign=pricing).

| Plan | Queries/day | Atoms | Rate limit | Price |
|------|-------------|-------|------------|-------|
| Free | 1,000 | 10,000 | 60 req/min | $0 |
| Pro | 50,000 | 500,000 | 600 req/min | $29/mo |
| Team | 500,000 | 5,000,000 | 3,000 req/min | $149/mo |
| **Enterprise** | Custom | Custom | Custom | contact sales |

**Enterprise** includes: custom query, atom and rate limits, dedicated infrastructure, **SSO**, **audit logs**, SLA, and custom data residency. Contact sales via https://console.mnemoverse.com.

## Links

- [Full documentation dump](https://mnemoverse.com/docs/llms-full.txt): about 3 MB of flat text: the API and setup pages, the technology and benchmark pages, and every library article. Support essentials come first (getting started, pricing, request limits, troubleshooting, install, security), so a client with a small budget can read only the beginning. It is meant for single-file upload into Claude Projects, a ChatGPT Custom GPT knowledge file, or a Cursor or Devin Desktop `@Docs` picker.
- [Website docs](https://mnemoverse.com/docs/): HTML with interactive navigation and per-page copy-as-markdown.
- [API reference](https://mnemoverse.com/docs/api/reference): full endpoint schemas, error catalogue, rate limits, response examples.
- [Security whitepaper](https://mnemoverse.com/docs/api/security): isolation model, key storage (SHA-256 + constant-time compare), threat model.
- [Python SDK on PyPI](https://pypi.org/project/mnemoverse/): `pip install "mnemoverse>=0.5.0"`, v0.5.0 live since 2026-10-06 (first release 0.1.0 on 2026-04-09).
- [MCP server on npm](https://www.npmjs.com/package/@mnemoverse/mcp-memory-server): `@mnemoverse/mcp-memory-server`, MCP Registry listed.
- [Mnemoverse Agent Memory — VS Code extension](https://marketplace.visualstudio.com/items?itemName=Mnemoverse.mnemoverse-vscode): one-click install on Marketplace + [Open VSX](https://open-vsx.org/extension/mnemoverse/mnemoverse-vscode) (v0.3.0 since 2026-09-23). Source: [github.com/mnemoverse/mnemoverse-vscode](https://github.com/mnemoverse/mnemoverse-vscode).
- [Console (sign up)](https://console.mnemoverse.com/sign-up?utm_source=llms&utm_medium=index&utm_campaign=links): free API key, no credit card.
- [GitHub organization](https://github.com/mnemoverse): open-source components.
- [awesome-agent-memory](https://github.com/mnemoverse/awesome-agent-memory): curated index of the agent-memory category, covering managed APIs, open-source engines, MCP memory servers, benchmarks and papers. Maintained by Mnemoverse; entries include competing products.

## Setup guides

Step-by-step pages on the docs site, one per client or task.

- [Getting started](https://mnemoverse.com/docs/api/getting-started): free API key, then store, query and rate a first memory with curl against the REST API.
- [MCP server](https://mnemoverse.com/docs/api/mcp-server): the `@mnemoverse/mcp-memory-server` npm package, its tools, and config for any MCP client.
- [Cursor, VS Code and Devin Desktop](https://mnemoverse.com/docs/api/editors): the three editors on one page: keyless Add to Cursor, the keyless VS Code extension, or `mcp.json` with an API key.
- [Cursor](https://mnemoverse.com/docs/api/cursor): keyless Add to Cursor with browser sign-in, or `~/.cursor/mcp.json` with an API key.
- [Claude Code](https://mnemoverse.com/docs/api/claude): one `claude mcp add` command, plus the tools Claude calls each session.
- [Devin Desktop (formerly Windsurf)](https://mnemoverse.com/docs/api/windsurf): `~/.config/devin/mcp_config.json` with an API key.
- [Python SDK](https://mnemoverse.com/docs/api/python-sdk): the `mnemoverse` package on PyPI, with sync and async clients for write, read, feedback and stats.
- [Troubleshooting](https://mnemoverse.com/docs/api/troubleshooting): fixes for the most common connection failures in Claude Code and claude.ai.
- [Pricing](https://mnemoverse.com/docs/api/pricing): Free, Pro, Team and Enterprise plans with their daily query, atom storage and rate limits.

## Related products

- [Sigma](https://sigma.mnemoverse.com/): Mnemoverse's code reviewer for GitHub pull requests, closed beta.
- [Sigma documentation](https://sigma.mnemoverse.com/docs): setup, review workflows, and troubleshooting for Sigma.

## Research

Mnemoverse memory architecture is grounded in published research.

- **SLoD — Semantic Level of Detail** ([arXiv:2603.08965](https://arxiv.org/abs/2603.08965)): the research operator for multi-scale memory representation via heat kernel diffusion on hyperbolic manifolds — research-stage: production does not yet run native hyperbolic geometry. Explains the multi-scale design behind memory storage and recall (consolidation is switched off on the hosted service).
- [Full SLoD page](https://mnemoverse.com/docs/technology/slod): implementation details and benchmarks.
- [Benchmarks](https://mnemoverse.com/docs/technology/benchmarks): how we read a memory benchmark + the LoCoMo matrix (vs mem0/supermemory/zep), with per-benchmark pages for [BEAM](https://mnemoverse.com/docs/technology/benchmarks/beam), [HotpotQA](https://mnemoverse.com/docs/technology/benchmarks/hotpotqa), [MuSiQue](https://mnemoverse.com/docs/technology/benchmarks/musique), and [LongMemEval](https://mnemoverse.com/docs/technology/benchmarks/longmemeval).

## Compare

Honest, side-by-side comparisons with other AI agent memory tools — on the main site, not under /docs. Every competitor is described by its real design choices; claims are founder-reviewed.

- [Compare hub](https://mnemoverse.com/compare): how Mnemoverse compares, and which tool fits which job.
- Head-to-head: [vs Mem0](https://mnemoverse.com/compare/mnemoverse-vs-mem0) · [vs Zep](https://mnemoverse.com/compare/mnemoverse-vs-zep) · [vs Cognee](https://mnemoverse.com/compare/mnemoverse-vs-cognee) · [vs Letta](https://mnemoverse.com/compare/mnemoverse-vs-letta) · [vs LangMem](https://mnemoverse.com/compare/mnemoverse-vs-langmem) · [vs Supermemory](https://mnemoverse.com/compare/mnemoverse-vs-supermemory).
- [Best AI agent memory in 2026](https://mnemoverse.com/compare/alternatives): a fair roundup — Mem0, Zep, Letta, Cognee, and where Mnemoverse fits.
- [The memory landscape](https://mnemoverse.com/compare/landscape): a 2x2 map — managed vs self-hosted, cross-tool vs platform-bound.

## Library

Long-form, source-backed deep-dives on AI agent memory — 116 articles across 7 topics. Each topic links its hub page, then every article under it.

### Agent Memory
Topic hub: https://mnemoverse.com/docs/library/agent-memory

- [What cross-IDE persistent context platforms are available for engineering teams?](https://mnemoverse.com/docs/library/cross-ide-context-platforms-for-teams)
- [Can Retrieval Tell Which Source to Trust?](https://mnemoverse.com/docs/library/retrieval-which-source-to-trust)
- [If persistence is not permission, where would you have drawn the line: cards only, or the entire turn?](https://mnemoverse.com/docs/library/revoked-access-chat-history)
- [What options exist for connecting an AI agent memory layer across both ChatGPT web interfaces and localized coding environments?](https://mnemoverse.com/docs/library/agent-memory-across-chatgpt-and-coding-tools)
- [AI assistant keeps giving outdated answers after codebase refactoring, how to update its learned knowledge?](https://mnemoverse.com/docs/library/ai-assistant-outdated-answers-after-refactoring)
- [Explain how an importance gate prevents noise accumulation in persistent agent memories](https://mnemoverse.com/docs/library/agent-memory-write-gate)
- [How to handle continuous context retention for autonomous software engineering bots?](https://mnemoverse.com/docs/library/agent-memory-catch-up-read)
- [How can I implement long-term associative memory in Python for autonomous agents?](https://mnemoverse.com/docs/library/long-term-associative-memory-in-python)
- [My AI tool recommendations don't get smarter based on whether their previous output worked](https://mnemoverse.com/docs/library/outcome-reranking-agent-memory)
- [Agent Memory Consolidation Compared](https://mnemoverse.com/docs/library/agent-memory-consolidation-compared)
- [Agent Memory Deletion: What Survives a Delete](https://mnemoverse.com/docs/library/agent-memory-deletion)
- [Why AI Coding Assistants Repeat Fixed Mistakes: Who Takes an Outcome?](https://mnemoverse.com/docs/library/stop-agent-repeating-fixed-mistakes)
- [Agent Memory Knowledge Graphs Compared: Does a Read Change the Graph?](https://mnemoverse.com/docs/library/agent-memory-knowledge-graphs-compared)
- [MCP Memory Servers for Claude Code and Cursor (2026): Which Client, and Whose Memory](https://mnemoverse.com/docs/library/mcp-memory-servers-claude-code-and-cursor)
- [Python SDK for Agent Memory, Compared: Eleven Packages, Twelve Rows](https://mnemoverse.com/docs/library/python-sdk-agent-memory-compared)
- [My LLM agents forget conversation history when I restart them, how do I fix this?](https://mnemoverse.com/docs/library/what-survives-when-ai-agents-restart)
- [Anthropic's Memory API Has No Ranked Retrieval](https://mnemoverse.com/docs/library/anthropic-memory-api-no-ranked-retrieval)
- [MCP Memory Servers and npx (2026): One Command, Six Different Answers](https://mnemoverse.com/docs/library/mcp-servers-npx-setup-compared)
- [MCP Servers That Share State Across IDEs (2026): One Mechanism, Six Ways It Quietly Stops](https://mnemoverse.com/docs/library/mcp-servers-sharing-state-across-ides)
- [AI Memory APIs That Prune Low-Value Context (2026): Two Mechanisms, Six Systems](https://mnemoverse.com/docs/library/ai-memory-apis-prune-low-value-context)
- [Best Persistent Memory APIs for AI Agents (2026): Six Questions, Six Systems](https://mnemoverse.com/docs/library/best-persistent-memory-apis-compared)
- [Hindsight vs Graphiti: Two Answers to the Same Question About Agent Memory](https://mnemoverse.com/docs/library/hindsight-vs-graphiti)
- [Memory API Response Shape: Nowhere to Put a Disagreement](https://mnemoverse.com/docs/library/memory-response-shape)
- [How does persistent memory for AI agents differ from standard RAG or vector databases?](https://mnemoverse.com/docs/library/rag-vs-agent-memory)
- [Knowledge Graph vs Retrieval for AI Agent Memory](https://mnemoverse.com/docs/library/agent-memory-knowledge-graph-vs-retrieval)
- [Why does my LLM agent keep suggesting outdated library patterns after being corrected?](https://mnemoverse.com/docs/library/agent-memory-evidence-vs-policy)
- [Agent memory feedback: the missing signal](https://mnemoverse.com/docs/library/agent-memory-feedback-dilemma)
- [What Is an Agent OS? AIOS, MemGPT and LLM OS Compared](https://mnemoverse.com/docs/library/what-is-an-agent-os)
- [The Missing Layer: No Protocol Says What Agents Know](https://mnemoverse.com/docs/library/agent-memory-interop-gap)
- [AI Introspection: Why a Voice Is Not an Audit](https://mnemoverse.com/docs/library/ai-introspection-voice-not-audit)
- [Claude's Global Workspace: Why AI Memory Lives Outside](https://mnemoverse.com/docs/library/global-workspace-memory-outside)
- [Knowledge-Graph Memory for AI Agents](https://mnemoverse.com/docs/library/knowledge-graph-memory-for-agents)
- [AI Agent Memory: What It Is](https://mnemoverse.com/docs/library/ai-agent-memory)
- [The A2A Agent Card: How Agents Discover Each Other](https://mnemoverse.com/docs/library/a2a-agent-card)
- [A2A Integration How-To (Python)](https://mnemoverse.com/docs/library/a2a-integration-howto)
- [A2A Protocol (Agent2Agent), Explained](https://mnemoverse.com/docs/library/a2a-protocol-explained)
- [A2A vs MCP: How They Differ (and Compose)](https://mnemoverse.com/docs/library/a2a-vs-mcp)
- [Hebbian memory for AI agents](https://mnemoverse.com/docs/library/hebbian-memory-for-ai-agents)
- [Is Mnemoverse a vector database?](https://mnemoverse.com/docs/library/not-a-vector-database)
- [Rescorla-Wagner for agent memory](https://mnemoverse.com/docs/library/rescorla-wagner-agent-memory)
- [Shared Memory for Multi-Agent Systems](https://mnemoverse.com/docs/library/shared-memory-for-multi-agent-systems)

### Secrets & Trust
Topic hub: https://mnemoverse.com/docs/library/agent-secrets

- [Did you find a clean way to let the agent commit without giving it write access to the shared config?](https://mnemoverse.com/docs/library/coding-agent-git-commit-hooks)
- [Shared Memory Poisoning: One Bad Write, Many Agents](https://mnemoverse.com/docs/library/shared-memory-poisoning)
- [How Do AI Agents Trust Each Other? A2A, OAuth and mTLS](https://mnemoverse.com/docs/library/how-ai-agents-trust-each-other)
- [Least Privilege for AI Agents](https://mnemoverse.com/docs/library/least-privilege-ai-agents)
- [Prompt Injection Is a Credential-Exfiltration Attack](https://mnemoverse.com/docs/library/prompt-injection-credential-exfiltration)
- [The Trust-Model Spectrum for AI Agent Secrets](https://mnemoverse.com/docs/library/trust-model-spectrum-agent-secrets)
- [Credential the LLM Never Sees for MCP Tools](https://mnemoverse.com/docs/library/credential-llm-never-sees)
- [Memory Poisoning: The Patient Path to Your API Keys](https://mnemoverse.com/docs/library/memory-poisoning-secret-leak)
- [AI Agent Secrets: Why the Nagging Won't Save You](https://mnemoverse.com/docs/library/why-ai-agents-nag-about-secrets)

### Memory Science
Topic hub: https://mnemoverse.com/docs/library/memory-science

- [Continual learning algorithms: EWC, GEM, iCaRL](https://mnemoverse.com/docs/research/memory/architectures/continual-learning-algorithms)
- [Why Your AI Agent Repeats the Same Mistakes](https://mnemoverse.com/docs/library/agent-repeats-mistakes)
- [How to implement context decay so an AI agent forgets stale or incorrect instructions over time?](https://mnemoverse.com/docs/library/why-agents-need-to-forget)
- [Attention as a Hopfield Network](https://mnemoverse.com/docs/library/hopfield-attention-equivalence)
- [Memory, From DRAM to Agents: One Word, Twelve Worlds](https://mnemoverse.com/docs/library/memory-across-the-computing-stack)
- [Transactive Memory: Who Remembers What in a Team](https://mnemoverse.com/docs/research/memory-science/transactive-memory)
- [What is memory consolidation in long-term AI memory systems?](https://mnemoverse.com/docs/library/agent-memory-consolidation)
- [Multimodal Memory Integration: Cross-Modal Binding in AI](https://mnemoverse.com/docs/research/memory/architectures/multimodal-memory-integration)
- [Self-Organizing Memory: ART, SOM & Growing Neural Gas](https://mnemoverse.com/docs/research/memory/architectures/self-organizing-memory-systems)
- [Episodic vs Semantic Memory: Tulving for AI Agents](https://mnemoverse.com/docs/research/memory/cognitive-models/episodic-semantic-memory)
- [Types of Memory: Why So Many Names?](https://mnemoverse.com/docs/research/memory-science/kinds-of-memory)
- [Schema Formation: How Memory Builds Reusable Structure](https://mnemoverse.com/docs/research/memory-science/schema-formation)
- [Working Memory: Capacity, Models, and AI Context](https://mnemoverse.com/docs/research/memory-science/working-memory)
- [Bernard Widrow: From the LMS Rule to Cognitive Memory](https://mnemoverse.com/docs/research/memory-science/bernard-widrow-cognitive-memory)
- [Geoffrey Hinton: The Boltzmann Machine and Generative Memory](https://mnemoverse.com/docs/research/memory-science/geoffrey-hinton-boltzmann-machine)
- [Jeff Hawkins: Memory Exists to Predict](https://mnemoverse.com/docs/research/memory-science/jeff-hawkins-hierarchical-temporal-memory)
- [Hopfield Networks: The Memory Model That Became Attention](https://mnemoverse.com/docs/research/memory-science/hopfield-associative-memory)

### Benchmark Wars
Topic hub: https://mnemoverse.com/docs/library/benchmark-wars

- [How Are AI Code Review Tools Benchmarked, and Can You Trust the Results?](https://mnemoverse.com/docs/library/ai-code-review-benchmarks)
- [RAGAS Metrics Explained: Reference-Free RAG Evaluation](https://mnemoverse.com/docs/research/evaluation/ragas-framework-deepdive)
- [BLEU vs ROUGE vs F1 vs SARI: Pick the Right Metric](https://mnemoverse.com/docs/research/evaluation/bleu-rouge-f1-sari-explained)
- [Can You Trust an LLM Judge? A Field Manual](https://mnemoverse.com/docs/library/llm-judge-field-manual)
- [AI Memory Benchmarks: A Field Guide](https://mnemoverse.com/docs/research/evaluation/ai-memory-benchmarks-field-guide)
- [LLM-as-Judge Variance in AI Memory Benchmarks](https://mnemoverse.com/docs/research/evaluation/judges-good-and-evil)
- [DeepEval: Pytest for LLMs — G-Eval, DAG & RAG Triad](https://mnemoverse.com/docs/research/evaluation/deepeval-framework-deepdive)
- [Hugging Face Evaluate Library: load(), compute() Guide](https://mnemoverse.com/docs/research/evaluation/huggingface-evaluate-deepdive)
- [How to Evaluate AI Agent Memory](https://mnemoverse.com/docs/research/evaluation/evaluating-agent-memory)
- [LLM-as-a-Judge: Bias, Leniency & the LoCoMo Number](https://mnemoverse.com/docs/research/evaluation/llm-as-judge-patterns)
- [LangChain & LangSmith Evaluation: The Memory Blind Spot](https://mnemoverse.com/docs/research/evaluation/langchain-evaluation-deepdive)

### Context Builder & Orchestration
Topic hub: https://mnemoverse.com/docs/library/context-orchestration

- [Why does my vector DB retrieval keep returning duplicate noise for my chat agent, and how to fix it?](https://mnemoverse.com/docs/library/vector-search-duplicate-results)
- [Cursor Memory Bank: What Actually Loads](https://mnemoverse.com/docs/library/cursor-memory-bank-what-loads)
- [Memory Coherence in MCP: What Happens When Two Clients Write](https://mnemoverse.com/docs/library/mcp-memory-coherence)
- [AGENTS.md: What Supported Actually Means, Tool by Tool](https://mnemoverse.com/docs/library/agents-md-supported)
- [Why does my code editor AI keep overriding custom repository guidelines every session?](https://mnemoverse.com/docs/library/claude-md-agents-md-cursor-rules)
- [What Is an MCP Memory Server? Protocol, Tools, Tokens](https://mnemoverse.com/docs/library/what-is-an-mcp-memory-server)
- [What Breaks Prompt Caching: The Stable Prefix Contract](https://mnemoverse.com/docs/library/prompt-cache-stable-prefix)
- [13 Memory MCP Servers Compared (2026): Local-First or Hosted](https://mnemoverse.com/docs/library/memory-mcp-servers-compared)
- [How do I give my LLM workflow persistent context across independent client connections?](https://mnemoverse.com/docs/library/stateless-mcp-agent-memory)
- [Context Budgeting: Zones, Allocation & Eviction](https://mnemoverse.com/docs/research/agents/context-budgeting)
- [Context Optimizer: Cache, Budget & Placement](https://mnemoverse.com/docs/research/agents/context-optimizer)
- [Context Compiler vs Orchestration](https://mnemoverse.com/docs/research/agents/context-compiler-vs-orchestration)
- [Deterministic vs LLM Context Assembly](https://mnemoverse.com/docs/research/agents/deterministic-vs-llm-context-assembly)
- [Context Engineering Needs a Compiler](https://mnemoverse.com/docs/research/agents/context-compiler)
- [Memory MCP: How to Give AI Agents Persistent Memory](https://mnemoverse.com/docs/library/memory-mcp)
- [Federated MCP: How MCP Federation Works in 2026](https://mnemoverse.com/docs/research/mcp/federated/architecture)
- [Prompt-Cache Keys: Stable Prefix, KV-Cache Hit Rate](https://mnemoverse.com/docs/research/agents/kv-cache-context-engineering)

### World Representation
Topic hub: https://mnemoverse.com/docs/library/world-representation

- [Agent Memory Deduplication: The Missing Error Rate](https://mnemoverse.com/docs/library/agent-memory-deduplication)
- [Is Memory Hyperbolic? What Neuroscience Shows](https://mnemoverse.com/docs/library/is-memory-hyperbolic)
- [The Independence Illusion: When AI Agents Agree](https://mnemoverse.com/docs/library/independence-illusion)
- [Who Wins When Agents Disagree? The Authority Problem](https://mnemoverse.com/docs/library/who-wins-when-agents-disagree)
- [Bitemporal Memory for AI Agents: The Missing Axis](https://mnemoverse.com/docs/library/bitemporal-memory-for-ai-agents)
- [Agent Memory Provenance: Who Wrote It, Not Only When](https://mnemoverse.com/docs/library/provenance-in-agent-memory)
- [Graph Memory MCP Servers: What Agents Actually Get](https://mnemoverse.com/docs/library/graph-memory-mcp-tools)
- [The GraphRAG Tax: When a Knowledge Graph Doesn't Pay](https://mnemoverse.com/docs/library/graphrag-tax)
- [How AI Agents Navigate Knowledge Graphs](https://mnemoverse.com/docs/library/navigating-knowledge-graphs)
- [Hypergraph vs Hyperbolic Graph for AI Memory](https://mnemoverse.com/docs/library/hypergraph-vs-hyperbolic-graph)
- [Building Memory That Scales](https://mnemoverse.com/docs/research/building-memory-that-scales)

### Light Reading
Topic hub: https://mnemoverse.com/docs/library/light-reading

- [What are the leading dedicated AI agent memory layer platforms?](https://mnemoverse.com/docs/library/best-ai-agent-memory-2026)
- [Mem0 vs Zep vs Letta vs Cognee vs Supermemory (September 2026)](https://mnemoverse.com/docs/library/ai-memory-solutions-2026-q3)
- [Ontology vs Schema vs Topology: One Idea, Many Dialects](https://mnemoverse.com/docs/library/ontology-schema-topology-dialects)
- [Workflow Intelligence Ships as a Primitive](https://mnemoverse.com/docs/library/workflow-intelligence-ships-as-a-primitive)
- [Memory Is Becoming a Procurement Decision](https://mnemoverse.com/docs/library/memory-is-becoming-a-procurement-decision)
- [Agent Memory Is Not a Database](https://mnemoverse.com/docs/library/agent-memory-is-not-a-database)
- [AI Agent Memory Crisis: Why Bigger Context Fails](https://mnemoverse.com/docs/research/ai-agent-memory-crisis)
- [AI Agent Memory: The 2026 Landscape](https://mnemoverse.com/docs/research/ai-memory-landscape-2026)
- [When AI Cites What Doesn't Exist](https://mnemoverse.com/docs/research/when-ai-cites-what-doesnt-exist)
- [AI Memory & Context-Management Market: 2025 Update](https://mnemoverse.com/docs/research/market-landscape)

## Optional

Secondary information that clients with tight context budgets can skip.

- [Manifesto](https://mnemoverse.com/docs/vision/manifesto): why persistent memory matters for AI agents.
- [Use cases](https://mnemoverse.com/docs/api/use-cases/): concrete integration patterns for coding assistants, chat extensions, conversational agents, and agent frameworks.
- [API section index](https://mnemoverse.com/docs/api/): the pages in the API section, listed A to Z.
- [Platform section index](https://mnemoverse.com/docs/platform/): the platform overview and the multi-tenant setup guide.
- [Technology section index](https://mnemoverse.com/docs/technology/): SLoD, tensor-hyperbolic graphs, and the benchmark cards behind every published number.
- [Vision section index](https://mnemoverse.com/docs/vision/): the manifesto, the design language, and the bibliography they rest on.
- [Legal section index](https://mnemoverse.com/docs/legal/): terms of use, privacy, cookies, and refunds.