Mnemoverse Memory

Persistent cross-tool agent memory whose recall ranking learns from helpful and misleading outcomes.

Stars
★ 25
Last updated
today
License
MIT
Primary language
TypeScript

At a glance

Works with
Universal · cross-platformChatGPT · Claude CodeClaude.ai (Partial support)
You'll need
npxMnemoverse API keyHosted Mnemoverse serviceShell / CLINetwork accessLocal filesystemMCP Server
Typical use
A developer moving among Claude Code, Cursor, VS Code, and ChatGPT who wants technical preferences and project decisions to survive new sessions.
Main limitation
The memory engine is a proprietary hosted service with no self-hosted build, making it unsuitable for strict on-premises requirements.

What does this agent do, and when should you use it?

Mnemoverse Memory is an MIT-licensed TypeScript MCP server that connects AI assistants to the hosted Mnemoverse memory engine. It runs as a local stdio server and makes authenticated network calls to `core.mnemoverse.com`; the server is open source, but the underlying memory engine has no self-hosted build. Its ten MCP tools write, search, and list memories, collect outcome feedback, report statistics, manage shared rooms, and list Vault secret metadata without exposing secret values. Memories tied to the same account can follow a user across connected clients including Claude Code, Cursor, VS Code, and ChatGPT. Helpful or misleading feedback changes future recall ranking through a Rescorla-Wagner prediction-error update rather than relying only on static similarity. It is a good fit for users seeking managed cross-tool continuity, but not for organizations that require memory processing and storage entirely within their own perimeter.

An MCP client launches @mnemoverse/mcp-memory-server, which forwards only explicitly supplied tool-call data to the hosted API. memory_write stores content, concepts, and a domain; memory_read searches in natural language with optional domain, time, author-exclusion, result-count, and ordering controls; memory_list_recent returns a cursor-paginated chronological feed. memory_feedback submits memory IDs, an outcome score, and an optional domain so later recall can be re-ranked. memory_create_room, memory_invite_to_room, memory_join_room, and memory_list_rooms provide explicitly authorized shared domains; memory_stats reports memory and domain information, while vault_list exposes only secret aliases and purposes. Clients may also expose the recall, save_insight, and what_do_you_know prompts, and can open an owned memory through memory://item/{memory_id}. The server does not inspect chat history or local files; after an empty search or feed, it may issue one or two authenticated, read-only room or statistics probes to explain what the result did not cover.

  1. A developer moving among Claude Code, Cursor, VS Code, and ChatGPT who wants technical preferences and project decisions to survive new sessions.
  2. A team maintaining one codebase that wants assistants to share architecture decisions, ownership details, and previously learned engineering lessons through a room.
  3. A user who repeatedly opens fresh chats and wants preferences such as frameworks, interface settings, or working habits recalled without restating them.
  4. An engineering group that records deployment practices and past mistakes, then marks recalled advice as helpful or misleading to influence future ranking.
  5. An MCP user who prefers a managed memory backend and does not want to operate a local vector database or memory service.

How do you install or deploy this agent?

Create a free API key at console.mnemoverse.com; the documented signup requires no credit card. On macOS, Linux, or Git Bash, verify it through a masked prompt so it is not placed in the command arguments:

printf 'Mnemoverse API key: '; read -rs KEY; echo
printf 'X-Api-Key: %s\n' "$KEY" | curl -s -H @- https://core.mnemoverse.com/api/v1/memory/stats; unset KEY

A JSON response containing "total_atoms" indicates that the key works. Install it for Claude Code at user scope, replacing the placeholder with the real key:

claude mcp add mnemoverse -s user \
  -e MNEMOVERSE_API_KEY=mk_live_YOUR_KEY \
  -e MNEMOVERSE_API_URL=https://core.mnemoverse.com/api/v1 \
  -- npx -y @mnemoverse/mcp-memory-server@latest

For Cursor, merge this into the global ~/.cursor/mcp.json; do not commit a real key in a project-level configuration:

{
  "mcpServers": {
    "mnemoverse": {
      "command": "npx",
      "args": [
        "-y",
        "@mnemoverse/mcp-memory-server@latest"
      ],
      "env": {
        "MNEMOVERSE_API_KEY": "mk_live_YOUR_KEY",
        "MNEMOVERSE_API_URL": "https://core.mnemoverse.com/api/v1"
      }
    }
  }
}

Restart the AI client after changing its configuration because MCP servers are loaded at startup.

How do you use this agent?

After installation and a client restart, ask the assistant to make an explicit write call:

Remember that my favourite TypeScript framework is Hono, and please call memory_write to save it.

Once storage is confirmed, open a new chat or session and ask:

What's my favourite TypeScript framework?

The assistant should call memory_read and answer “Hono.” If it does not, verify that the client was fully restarted and that mk_live_YOUR_KEY was replaced with a real key. In ongoing use, call memory_feedback to rate recalled memories, or create a room and issue scoped invitations when several users need a shared memory domain.

What are this agent's strengths and limitations?

Pros
  • One account and API key provide a shared memory layer across documented clients including Claude Code, Cursor, VS Code, and ChatGPT.
  • memory_feedback changes future ranking based on helpful or misleading outcomes, a concrete distinction from static similarity-only retrieval.
  • The managed backend removes the need to deploy and update memory infrastructure and includes a free tier.
  • Shared rooms include invitations, scopes, expiry, and configurable usage limits for team access.
  • The server has an explicit data boundary: it sends tool parameters and does not independently read conversation history or local files.
Limitations
  • The memory engine is a proprietary hosted service with no self-hosted build, making it unsuitable for strict on-premises requirements.
  • Every functional tool call depends on a valid API key, network access, and availability of the Mnemoverse service.
  • The MCP surface does not expose deletion; correcting stale information means writing a newer memory, while deletion is an administrative REST API operation.
  • The designed HDBSCAN and Von Restorff consolidation stage is currently disabled on the hosted service.
  • No reproducible benchmark results are provided, so retrieval quality and comparative performance cannot be quantified from the supplied evidence.

How does this agent compare with similar options?

Unlike repository-specific instruction files such as CLAUDE.md, .cursorrules, and AGENTS.md, Mnemoverse carries memories across projects, windows, and tools, but sends them to a hosted service. Unlike a conventional RAG vector store, it can alter ranking after a recalled item proves helpful or misleading instead of leaving similarity scores unchanged. Compared with local-first memory servers, it reduces deployment and maintenance work but cannot remain entirely inside the user's infrastructure; a local-first option is the better fit when privacy boundaries, local latency, or on-premises operation are mandatory.

Key facts side by side with the most closely related agents.

Agent Source review Stars Updated Language Full support on
Mnemoverse Memory This agent 77 · Some gaps ★ 25 today TypeScript ChatGPT · Claude Code
LinkedIn MCP Server 79 · Good ★ 3.6k 4d ago Python —
OpenContext 58 · Major gaps ★ 1.2k 3mo ago JavaScript Codex · Claude Code
Bitterbot Desktop 39 · Major gaps ★ 2.5k 1d ago TypeScript OpenAI API · Claude API

How does FollowAgents rate this agent?

FollowAgents source review · FARS-2.1
Some gaps
Why not a higher tier: Trust & safety is 17/29, below the 18/29 needed for “Good”; the tier is lowered because risk is not averaged away.
77/ 100 5-point scale 3.9 / 5
Trust 17/29
Reliability 12/14
Adaptability 16/18
Convention 16/18
Effectiveness 10/13
Verifiability 6/8
Why each dimension lost points
Trust17 / 29 · 2.9/5

The README clearly discloses the hosted-by-default service, authentication paths, shared-room boundaries, and the conditions for self-hosting. Key-entry guidance avoids shell-history exposure, while the supplied tests verify that unsafe non-TLS remote URLs are rejected before transmission and credential-bearing URLs are not echoed. The tool surface is constrained and Vault values are explicitly unavailable, but writes, feedback, room creation, and invitations still change external state without evidence of a uniform per-operation confirmation mechanism. Dependencies are few, yet no lockfile, vulnerability scan, SBOM, or dependency-update policy is supplied. User-facing deletion has been removed and no undo, recovery, or export path is documented, so rollback scores zero. Repository, author email, research, and licensing attribution are present, but the publisher identity remains unverified and no stronger identity inference is made.

Reliability12 / 14 · 4.3/5

The README, package metadata, and tests are strongly consistent about the ten tools, room isolation, feedback semantics, and error boundaries. Assembled-response tests cover empty results, failed probes, malformed responses, and name fidelity; URL-guard tests verify refusal before any request, supporting full scores for consistency and failure messaging. Dependency availability is reduced to 2 because normal operation depends on an external hosted engine, network access, authentication, and npm; the README acknowledges stuck connector sessions requiring reconnection. Daily contract-freshness checks detect drift but do not remove those dependencies.

Adaptability16 / 18 · 4.4/5

The material gives tailored configurations for Claude Code, Cursor, VS Code, Windsurf, Zed, JetBrains, Cline, Continue, and remote OAuth, while addressing personal continuity, shared rooms, and self-hosting needs. Tool descriptions and tests clearly delimit personal domains versus rooms, read-only membership, pagination, unusable filters, and importance-gated writes. Trigger precision loses one point because this repository mainly exposes tools and prompts; the broader discipline governing when an agent should proactively recall or save is delegated to a separate project rather than established here.

Convention16 / 18 · 4.4/5

The README has strong organization and concrete installation, key validation, client configuration, smoke-test, tool, prompt, resource, use-case, and troubleshooting material. Compatibility rules describe patch/minor stability, and tests constrain naming and advertised descriptions. The complete MIT text agrees with package metadata. Versioning receives 2 because PR and release-gate discipline is described, but the actual CHANGELOG contents are not included for inspection. Repository ownership, contact details, funding, and update automation are visible, though no support commitment, response policy, or independently verified responsible entity is established.

Effectiveness10 / 13 · 3.8/5

Outputs are designed for direct model and user consumption: errors are attributable, search scope is disclosed, names remain reproducible, and empty results avoid overclaiming; detailed static tests support these properties. Cross-tool persistence, shared rooms, and feedback-driven reranking offer plausible value beyond per-tool files or similarity-only retrieval, but the evidence supplies no comparative experiment or benchmark, limiting marginal value to 2. Hosted operation and a stated free tier may reduce operational cost, yet quotas, prices, latency, retention, and migration costs are absent, so cost-benefit is only adequately documented.

Verifiability6 / 8 · 3.8/5

Many client-side claims trace to README text, package metadata, workflows, or explicit test assertions. The material carefully distinguishes the open-source MCP server from the closed hosted engine, enabled from disabled features, and current facts from future benchmark claims, justifying full fact/inference separation. Deductions reflect that the hosted engine implementation, live connector parity, registry listing, research conclusions, and operational behavior cannot be independently verified from the supplied files. Cross-file corroboration exists, but the sources remain predominantly publisher-controlled rather than independent.

Risks and how to mitigate them
  • Not found in source: rollback or recovery pathBack up first, or work on a git branch or snapshot, so its changes can be undone.
  • The default path sends potentially sensitive long-term memory to an external hosted service. Verify retention, deletion, training use, residency, access-control, and compliance terms before storing personal, customer, or confidential information.
  • No user-facing deletion, undo, recovery, or export workflow is evidenced; remediation after an incorrect write or unintended share cannot be confirmed from these files.
  • Using @latest obtains new releases at startup, which helps updates but reduces deployment reproducibility. Pin and review a specific version in higher-assurance environments.
  • Shared-room invitations expand data access, while the supplied evidence does not establish that every client requires human confirmation before creation, joining, or writing.
  • The hosted engine, OAuth endpoint, registry status, and research claims were not independently verified in this static source review.
Evidence confidence: Low Reviewed Sep 24, 2026 Reviewed revision e691514ad819
See the full review method →

FAQ

Can I self-host the complete memory engine?
No. This MCP server and the separately mentioned Python SDK are MIT-licensed, but they connect to a hosted engine with a free tier, and no self-hosted engine build is provided.
Does the server read my full conversation or local files?
No. It sends only data passed to memory_* or vault_* calls. An empty search or feed may trigger authenticated, read-only room or statistics probes.
Who can access memories in a shared room?
Sharing occurs only through a room and invitation created by the user. Invites can carry a scope, expiry, and usage limit; assistants belonging to joined members can then access that room's domain.
Why does the server start and list tools while every call fails?
MNEMOVERSE_API_KEY is not required to start the server or list its tools, but it is required for every actual tool call. Check for the placeholder key, malformed, invalid, or revoked credentials, and restart the client after correcting its configuration.
Can the MCP server delete an incorrect memory?
No deletion tool is exposed. The documented correction path is to write a fresh memory; deletion is an administrative operation available through the REST API instead.
View on GitHub ↗ Install ↓

Compare agents like this one

The same FARS review applied across the shortlist this agent qualifies for.

Related agents