Memory is a Developer Tools MCP server that lets Claude Code, Cursor, Windsurf and any MCP-compatible AI agent knowledge graph for persistent entity storage. Install in 1 minute with mcpizy install memory.
Developer Tools
Knowledge graph for persistent entity storage
mcpizy install memorynpx -y @modelcontextprotocol/server-memoryMemory MCP (official Anthropic) is a knowledge-graph store that lets agents persist entities and relationships across sessions. Tools include `create_entities`, `create_relations`, `add_observations`, `search_nodes`, `read_graph`, `delete_entities`. The data lives in a local JSON file by default; some forks support backing stores like SQLite or remote graph DBs. The conceptual model is a property graph: entities have names and observations; relations connect entity A to entity B with a verb (`uses`, `reports_to`, `prefers`).
We use Memory MCP for two workflows. First, personal knowledge graphs that survive across Claude conversations — Claude remembers that "Hugo runs Brandyze, prefers TypeScript, uses Cloudflare DNS" and pulls this in via `search_nodes` at the start of new chats. Second, project state for agent loops — an agent running over multiple sessions to triage a backlog stores its progress (which issues have been reviewed) as entities + observations. Token cost is per-search; `search_nodes` returns matched entities + their observations, typically ~500-2k tokens.
Compared to a vector-DB-backed RAG setup (Qdrant, Pinecone), Memory MCP wins on structure (relations, not just embeddings) and on simplicity (no embeddings to manage). It loses on semantic search quality — `search_nodes` is keyword/substring, not vector. Compared to writing to a Notion page or local file, Memory wins because the graph structure forces the agent to think in entities, which makes retrieval more reliable. The honest trade-off: the JSON file backing store doesn't scale past tens of thousands of entities; for production use, swap to a real graph DB.
Entity name collisions are silent. Creating an entity "John" twice doesn't dedupe — the second creation either overwrites or creates a duplicate depending on the fork. Always have the agent `search_nodes` before `create_entities`.
The graph file lives on local disk by default. If the agent runs in different containers / machines, the memory doesn't follow. For persistent memory across sessions, configure a shared path or switch to a remote backing store.
`search_nodes` is substring-matched, not semantic. "John" matches "Johnson" — agents that expect exact-match semantics will be surprised. Have the system prompt clarify.
The graph can grow unboundedly. Without periodic pruning, the JSON file balloons; eventually `read_graph` becomes slow. Have the agent occasionally consolidate (`delete_entities` on stale ones).
Honest pros/cons against the closest developer tools MCP servers.
| Server | Strengths | Trade-offs |
|---|---|---|
| mem0 MCP (community) | Vector-backed semantic memory, better recall on fuzzy queries | Costs per embedding, more infrastructure |
| Notion MCP (as memory) | Human-readable, edit via UI, no separate system | Worse retrieval — Notion search is weak for short facts |
| Custom Postgres pgvector | Full control, scales to millions of memories | You build it yourself — no MCP, more code |
If Memory doesn't fit your stack, these Developer Tools MCP servers solve similar problems.
The Memory MCP server is an Developer Tools Model Context Protocol server that lets Claude Code, Cursor, Windsurf, VS Code with Copilot, and other MCP-compatible AI agents knowledge graph for persistent entity storage. It exposes Memory's capabilities as tools the AI can call directly from your editor or CLI.
The fastest way is the MCPizy CLI: run `mcpizy install memory` and MCPizy will add the server to your `.claude.json` automatically. You can also install it manually by adding an entry under `mcpServers` in `.claude.json` with the command `npx -y @modelcontextprotocol/server-memory` and restarting Claude Code.
Yes. The Memory MCP server is free and open source (see the GitHub repository linked on this page). You may still need a Memory account or API key to connect the server to the underlying service, but the MCP layer itself has no MCPizy subscription cost.
Yes. Any MCP-compatible client works — including Claude Code, Claude Desktop, Cursor (via `.cursor/mcp.json`), Windsurf, VS Code with Copilot Chat, and custom agents built on the MCP SDK. The same install command targets all of them; only the config file path differs.
Once installed, your AI agent can knowledge graph for persistent entity storage directly inside your conversation. Typical use cases include asking Claude Code or Cursor to run Memory operations, inspect results, chain Memory with other MCP servers (see our Workflow Recipes), and automate repetitive developer tools tasks without leaving your editor.