MemNexus vs Supermemory
Typed Developer Context vs. Universal Memory Platform
Supermemory is an open-source memory infrastructure platform — 28.1k GitHub stars as of July 2026 — with a REST API, TypeScript/Python SDKs, and a real knowledge graph of typed relation edges. It's built to be universal: connectors for Google Drive, Notion, Gmail, and more, plus a Claude Code plugin for auto-capture. MemNexus is narrower by design — a fully managed memory layer purpose-built for coding agents, with a structured context taxonomy and named, versioned memories.
The Problem with Supermemory
Supermemory works for basic use cases, but developers quickly hit limitations.
Flat String Scoping, Not Structured Fields
Supermemory scopes memories with a containerTag — a single regex-matched string, capped at 100 characters — plus an optional 'Spaces' grouping. That works for tagging, but it's one dimension. There's no built-in way to say 'this memory belongs to this product, this service, and this team' without encoding it all into one string yourself.
- containerTag is a single string field (max 100 chars), not multiple typed fields
- Spaces adds one more grouping layer, but scoping logic still lives in string conventions
- No native product/service/team/role/component/repo breakdown
No Named, Versioned Memories
Supermemory's documentation covers memory creation, recall, and a forgetAfter TTL (time-to-live) field for expiring memories — but it doesn't describe named memories with a version history. If you want a single living document (like a status tracker) that updates over time with a retrievable history of prior versions, that concept isn't part of the documented API.
- No documented named/versioned memory object
- No documented history endpoint for reviewing prior memory states
- forgetAfter expires memories — it doesn't version them
5 MCP Tools vs. a Deeper Toolset
Supermemory's MCP server (mcp.supermemory.ai) ships 5 tools: memory, recall, listMemories, listProjects, and whoAmI. That covers the core create/search/list loop and works with 8+ MCP clients — Claude Desktop, Cursor, Windsurf, VS Code, OpenCode, Gemini CLI, and more. It's a lean, general-purpose set rather than one built around named memories, behavioral pattern detection, or fine-grained context queries.
- 5 MCP tools: memory, recall, listMemories, listProjects, whoAmI
- No dedicated tools for named-memory history or behavioral pattern retrieval
- Broad client support (8+ MCP clients including Claude Desktop, Cursor, Windsurf, VS Code) is a real strength here
Self-Hosting Comes With a Gap
Supermemory's core is MIT-licensed and self-hostable, which is a genuine advantage if you want to run your own instance. But the connectors (Google Drive, Notion, Gmail, and others) and the extraction models are not included in the open-source release — full functionality requires the hosted product.
- OSS core doesn't include connectors or extraction models
- Full connector suite (Google Drive, Notion, OneDrive, Gmail, GitHub, S3) is tier-gated
- Self-hostable core includes hybrid search, local embeddings, and the knowledge graph
What MemNexus Does Differently
MemNexus offers a structured context taxonomy, named/versioned memories, and a fully managed SaaS model built specifically for coding agent workflows.
Structured Context Taxonomy
Six typed fields instead of one string.
containerTag is a single regex-matched string (max 100 chars), plus optional Spaces grouping.
codeContext uses 6 typed fields — product, service, team, role, component, repo — plus an extra map for custom metadata.
Named, Versioned Memories
Living documents with retrievable history.
Documented API covers memory creation, recall, and TTL-based expiry (forgetAfter) — no documented versioning concept.
Named memories act as living documents (status trackers, reference docs) with a history endpoint to review prior versions.
Behavioral Learning
Patterns detected across sessions, not just facts stored.
Knowledge graph with typed relation edges (update/extend/derive) tracks how facts relate and change over time.
Behavioral pattern detection across sessions — surfaces recurring preferences and working patterns — alongside an entity/fact/topic/relationship knowledge graph.
Fully Managed, Simple Pricing
Zero self-hosting overhead, two paid tiers.
Four paid tiers (Pro $19/mo, Max $100/mo, Scale $399/mo, Enterprise) plus a self-hostable OSS core without connectors.
Fully managed SaaS — no infrastructure to run. Free tier (50 memories/mo), Pro at $25/mo, Enterprise custom.
Feature Comparison
← Scroll to compare →
| Feature | MemNexus | Competitor |
|---|---|---|
| Context scoping | 6 typed fields (product, service, team, role, component, repo) + extra map | Flat containerTag string (max 100 chars) + Spaces |
| MCP tools | 12 tools (create_memory, recall, get_user_profile, get_memory, search_memories, manage_memory, conversations, knowledge_graph, patterns, build_context, initialize_session, submit_feedback) | 5 tools (memory, recall, listMemories, listProjects, whoAmI) |
| Named/versioned memories | Named memories with a history endpoint | Not documented — TTL-based expiry (forgetAfter) instead |
| Behavioral learning | Pattern detection across sessions | Not part of the documented feature set |
| Knowledge graph | Entities, facts, topics, relationships | Typed relation edges (update/extend/derive) |
| Self-hosting | Not available — fully managed SaaS only | MIT-licensed OSS core self-hostable (connectors/extraction models not included) |
| Connector integrations | Agent-driven via MCP, CLI, and API (no source connectors) | Google Drive, Notion, OneDrive, Gmail, GitHub, S3 (tier-gated) |
| Pricing | Free (50 memories/mo), Pro $25/mo, Enterprise custom | Free, Pro $19/mo, Max $100/mo, Scale $399/mo, Enterprise custom |
“Supermemory is a broad, open-source memory platform built to connect to everything — your drive, your inbox, your docs, and a growing list of AI clients. MemNexus is a narrower, fully managed layer built specifically for coding agents, with deeper context structure and MCP tooling for that use case.”
When to Use Each
We believe in honest comparisons. Here's when each tool makes sense.
Use Supermemory if...
- You want to self-host your memory infrastructure on MIT-licensed OSS
- You need connectors into Google Drive, Notion, Gmail, or S3 as memory sources
- You want a knowledge graph with explicit typed relation edges (update/extend/derive)
- You're already standardized on one of its 8+ supported MCP clients and want the widest client compatibility
Use MemNexus if...
- You want multi-dimensional context scoping (product, service, team, role, component, repo) instead of a single tag string
- You need named, versioned memories with a retrievable history
- You want behavioral pattern detection across sessions, not just stored facts
- You'd rather use a deeper MCP toolset (12 tools) purpose-built for coding agent workflows
- You want simple two-tier pricing without connector or compliance-tier gating
The Bottom Line
Supermemory earns its popularity (28.1k GitHub stars as of July 2026) — it's a genuinely open, connector-rich memory platform with a real knowledge graph and broad MCP client support. MemNexus takes a narrower path: structured context fields, named/versioned memories, and behavioral learning, delivered as a fully managed layer built around how coding agents actually work. Choose based on whether you want breadth and self-hosting, or depth and simplicity for agent-specific memory.
No credit card required · 5-minute setup
Your team's memory layer — set up in 5 minutes
Sign up, install the CLI, and run mx setup. Works with Claude Code, Codex, Copilot, and Cursor.
Already have an account? Sign in →