M
MCP Directory CURATED DIRECTORY
911 MCP servers indexed
中文
← Back to directory
M

Memorix

Community
Local-first shared memory layer for AI coding agents.
How to install ↓ Compare GitHub source repository ↗
Category
Dev Tools #38 of 438
Stars
★ 832 Very popular
Transport
stdio (local process) · Streamable HTTP
Runtime
Node.js >=22.18.0 · Docker
Credentials
Optional API key
License
Apache-2.0
Last commit
Tools
20
66FMRS · C

Memorix is a feature-rich, local-first MCP server designed for AI coding agents. It supports a wide range of agents and clients, offering multiple memory types and tools, making it suitable for teams needing persistent memory across sessions. Installation and configuration are relatively complex but well-documented. It is not officially maintained, but the open-source community is active.

Strongest · Documentation 16/20 Weakest · Reliability 8/20

Reliability
8/20
Security and permissions
15/20
Maintenance
14/20
Documentation
16/20
Setup experience
13/20
Why each score
Reliability 8/20
The only trustworthy evidence is the internal consistency of the manifest and README: npm package memorix 1.4.1, stdio 'serve' argument, Node >=22.18.0, Git-root project binding, a micro profile with 7 tools, and keyword fallback when embeddings are unavailable. A clean init plus tool-list handshake is plausible, but the supplied material contains no source code, no committed tests, and no CI workflow files; the CI badge and 'npm test' line are unverified README claims, and server.json declares no tools/capabilities to cross-check against real behavior. Missing verifiable execution evidence and thin error-path detail place this at the 'plausible happy path, thin tests' anchor; per the static cap and uncertainty rule, conservatively scored 8.
Security and permissions 15/20
No red-line issues are visible: the provided config examples contain no real tokens, there is no covert-exfiltration pattern, and destructive or billed operations require explicit action (uninstall requires --yes, media generation is an explicit CLI operation, MCP media generation requires MEMORIX_MCP_MEDIA_GENERATION=1). Data boundaries are well articulated: local-first SQLite/Orama, imported media hashed and kept outside the Git worktree, project-scoped search by default, cross-project portability restricted to user + portable long-term items, and API keys read from environment/config without the media library storing them. Deductions: hooks that capture prompts and tool events are installed by default for several agents (opt-out via --noHooks rather than opt-in), setup writes to many agent/editor config locations, and the sample config enables LLM formation ('active') by default, meaning memory text may be sent to model providers unless reconfigured. Score: 15.
Maintenance 14/20
Evidence shows an active, versioned project: Apache-2.0 license, a consistent 1.4.1 release across manifest and npm metadata, a changelog and docs map, a CI badge (unverified), and the repository is not archived. Stars and download badges are excluded per the scoring rules. Deductions: the supplied material contains no commit history, release dates, issue-response evidence, dependency-update cadence, or security-response channel, so sustained maintenance cadence and governance cannot be confirmed from the evidence itself. Score: 14.
Documentation 16/20
Documentation is layered and unusually thorough for this category: install commands, per-agent integration tables explaining what each setup writes, a memory-model layer table, runtime-mode matrix, TOML config examples, Docker and SDK snippets, docs map, llms.txt, changelog, and candid limitation disclosures (keyword-only fallback, 20 MiB vision cap, billed MCP media generation disabled by default, honest Lite index limits). Deductions: the actual MCP tool/parameter reference is only linked (docs/API_REFERENCE.md) rather than present, the manifest declares no tool list to verify schemas, cost guidance is partial (MiniMax and embedding lanes only), and troubleshooting content is pointed to rather than included. Score: 16.
Setup experience 13/20
The main path is short and concrete for mainstream clients: install Node >=22.18.0, npm install -g memorix, then memorix setup --agent <agent> --global per agent; a manual 5-line stdio JSON example, an HTTP path (background start with a 3211/mcp endpoint), and a Docker path are all documented, including Windows-specific paths and per-agent differences. Deductions and conservative handling: the supplied files contain no verifiable execution evidence (static cap of 15); Node 22.18.0+ is a nontrivial prerequisite; some targets require extra manual approval (e.g., Codex plugin hook review in /hooks); global hook installation is default-on for several agents; and the breadth of per-agent surfaces makes a uniform 'few-step' claim hard to generalize. Score: 13.

Static review · not runListed 2026-08-07

Read the FMRS scoring method →

Fit and risk

What it can accessReads local filesWrites / deletes local filesRuns commands or codeUses the networkConnects to a database

Best for

  • Development teams that want shared project memory across different AI coding tools.
  • Experienced developers who frequently start new sessions and lose context.
  • Projects that value preserving design decisions and reasoning.
  • Users who prefer local-first, privacy-friendly memory storage.
  • Users working with multiple MCP-compatible agents who want a unified memory layer.

Not for

  • Simple projects that only need single-session memory.
  • Users without Node.js or Git environments.
  • Teams needing cloud sync or centralized memory management (Memorix is local-first).
  • Users needing fully automatic, review-free long-term memory (long-term memory requires manual candidates and approval).
  • Beginners who are configuration-sensitive, as setup involves multiple steps.

Required permissions

  • Read and write local files (project root and memorix data directory).
  • Execute Git commands (e.g., commit history reading).
  • Start local HTTP services (if background mode is enabled).
  • Optional API keys for LLM generation and embeddings (e.g., OpenAI, OpenRouter).
  • Install agent plugins, rules, hooks, and skills (via setup command).

Risks and side effects

  • Local-first means memory is not synced to cloud; you must back it up yourself.
  • Misconfigured API keys may send data to third parties; ensure keys are secure.
  • Hooks may consume computational resources or impact performance.
  • Long-term memory requires human review, otherwise incorrect information may accumulate.
  • Orchestration may create multiple worktrees or branches, requiring careful merge conflict resolution.

Setup

Before you start

Runtime：Node.js >=22.18.0 · Docker

OPENROUTER_API_KEY optionalsecret OpenRouter API key for semantic embeddings (optional; keyword-only retrieval works without it).
MEMORIX_EMBEDDING_API_KEY optionalsecret Explicit override for the embedding API key, taking precedence over OPENROUTER_API_KEY (optional).
MINIMAX_API_KEY optionalsecret MiniMax API key for image/video generation (optional; only used for explicit CLI generation or when MEMORIX_MCP_MEDIA_GENERATION=1).
MINIMAX_CN_API_KEY optionalsecret MiniMax China-region API key, same purpose as MINIMAX_API_KEY (optional).
Other optional settings (1)
MEMORIX_MCP_MEDIA_GENERATION optional Set to 1 to allow MCP tools to request billed MiniMax generation; disabled by default (not a secret).
  1. Install Node.js >= 22.18.0 and ensure Git is available.
  2. Install Memorix globally: npm install -g memorix.
  3. Initialize configuration (optional): memorix init --global.
  4. Set up integration for your agent: memorix setup --agent <agent> --global, e.g., --agent claude, --agent codex, --agent cursor.
  5. For manual MCP configuration, add stdio config to your client: {"mcpServers":{"memorix":{"command":"memorix","args":["serve"]}}}.
  6. Optional: Start the background HTTP service: memorix background start, then point client to http://localhost:3211/mcp.
.mcp.json 
{
  "mcpServers": {
    "memorix": {
      "command": "memorix",
      "args": [
        "serve"
      ]
    }
  }
}

Shown for Claude Code. Other clients may use a different file or key (VS Code uses "servers") — the configurator below converts it.

.vscode/mcp.json
{
  "servers": {
    "memorix": {
      "command": "memorix",
      "args": [
        "serve"
      ]
    }
  }
}

Goes in your project's .vscode/mcp.json (VS Code uses a "servers" key).

Terminal
claude mcp add memorix -- memorix serve

Run it in a terminal; replace any <…> placeholders with your own values first.

Generate and validate client config

Check that it works

Run npm install -g memorix and memorix setup --agent claude --global (or manually configure the client with command "memorix" and args ["serve"]), then restart the client: tools like memorix_session_start, memorix_search and memorix_store should appear in the tool list; calling memorix_project_context and getting a brief for the current Git project confirms the connection.

Troubleshooting

  1. If MCP connection fails, check `memorix doctor agents --agent <agent>` and run `memorix repair agents --agent <agent>`.
  2. Ensure Node.js version >= 22.18.0.
  3. Verify that `memorix serve` runs without errors on the command line.
  4. Ensure the project is a Git repository, as memory is bound to the Git root.
  5. For HTTP mode, check if port 3211 is listening: `curl http://localhost:3211/health`.
  6. Check logs or run `memorix workbench` for diagnostics.

Things to try

Once connected, you can ask your AI assistant things like:

  • Search project memory for notes about the release blocker
  • Store a memory that we chose JWT for API auth because the API is stateless
  • Give me the task context brief so I can continue the previous work
  • What changed in the latest commit and why does it matter?

Tools 20

memorix_session_start read-only
Starts or binds a session to a specified project root.
memorix_project_context read-only
Gets a summary of the current project context, including relevant memories, files, and cautions.
memorix_search read-only
Searches memory entries within the project or globally.
memorix_detail read-only
Retrieves full details of a specific memory entry.
memorix_store writes
Stores new facts, fixes, gotchas, or notes into memory.
memorix_resolve read-only
Resolves references to actual files, symbols, or memory entries.
memorix_media writes
Manages controlled media assets, such as import, attach, view, and list.
memorix_checkpoint writes
Views and manages native context compaction checkpoints.
Show 12 more tools
memorix_long_term_memory writes
Manages curated long-term memory, including candidates, approval, and archiving.
memorix_reasoning read-only
Searches and stores design decisions, rationale, and trade-offs.
memorix_git_memory read-only
Extracts and stores engineering facts from Git commits.
memorix_code_memory read-only
Gets code state and symbol information to help agents understand the codebase.
memorix_context read-only
Builds a compact task-lensed brief (Memory Autopilot).
memorix_resume read-only
Resumes a previous session, loading relevant summaries and anchors.
memorix_skills read-only
Lists or retrieves reusable project skills.
memorix_promote writes
Promotes durable knowledge into project skills.
memorix_team writes
Manages team collaboration, such as task assignment and handoffs.
memorix_lock writes
Manages file locks to prevent concurrency conflicts.
memorix_task writes
Creates and manages tasks for orchestration.
memorix_workbench read-only
Opens an interactive terminal memory control plane.

Use cases

Share project knowledge across multiple agent sessions to avoid re-explanation.
Maintain consistent memory across IDEs or terminals for tool switching.
Turn Git commits into searchable engineering facts for quick impact analysis.
Preserve design decisions and rationale for future sessions.
Coordinate multi-agent parallel work with orchestration for tasks, locks, and reviews.

Supported clients

Claude Code
Codex
Cursor
Windsurf
Gemini CLI
GitHub Copilot CLI
Antigravity
OpenClaw
Hermes Agent
Oh-my-Pi
Pi
Kiro
OpenCode
Trae

Listed from the project's documentation, not tested by this site.

Overview

Memorix is an open-source, local-first, cross-agent memory layer for AI coding agents via MCP. It supports Claude Code, Codex, Cursor, Windsurf, Copilot, Gemini CLI, OpenCode, OpenClaw, Hermes Agent, Oh-my-Pi, Pi, Kiro, Antigravity, Trae, and any MCP-capable agent. The memory lives under the Git project, not inside a chat window or tool, enabling shared, searchable project memory across sessions, IDEs, and terminals. It provides Observation Memory, Reasoning Memory, Git Memory, Code Memory, Curated Long-term Memory, Compact Continuity, Memory Autopilot, orchestration, and a bundled terminal agent (memcode).

Similar servers

Context7 80 · B

Upstash's official server providing up-to-date third-party library docs for AI coding assistants

★ 62.9k · Tools 2 Compare with this →
Compare with other MCP servers

Source revision af2550290ca6 Data synced 2026-10-12 Read the FMRS scoring method