MCP memory servers and npx: one command, six different answers
Type npx into six memory-server vendors' setup docs and something different happens every time. This article checks one specific, narrow question against each vendor's own live documentation: does a client spawn that vendor's own MCP server with npx, and if not, what does. Not a ranking of which install is "easiest" in the abstract. A look at how much work one three-letter command has been asked to do across a category, and what each vendor's own docs say it launches.
This is the written half of a video, Which MCP Memory Servers Actually Run With npx?, and the sections below follow its eight chapters in order, so anyone arriving from the end card can pick up where they stopped.
Correction, 13 September 2026. A second check of each vendor's full documentation changed several answers on this page. Supermemory's docs run npx supermemory local to stand up its own memory server, and its hosted Memory MCP is the part that stays a URL. Letta's docs launch one first-party package, letta-acp, with npx. Cognee's MCP server also starts through uvx and pip, Mem0 documents a REST server you run yourself, and Zep's docs site has no npx at all. The question is now asked the way this page answers it: does a client spawn the vendor's own MCP server with npx. Our own section now names the client restart and test that follow the npx line, and five quotations now match their pages exactly.
TL;DR
- Of six vendors checked, exactly one documents clients spawning its own MCP server with npx: Mnemoverse, gated on that path by a free API key, with no separate sign-in step after the command runs.
- The other five fail that test for five different reasons. Mem0's npx commands configure a hosted server or copy in a plugin with a local MCP server, and its self-run REST server starts with make and Docker. Letta's server comes from an npm package, its desktop app or a container, and its one documented npx package,
letta-acp, exposes an agent over the Agent Client Protocol, not MCP. Graphiti runs from a container or a Python toolchain and Zep's memory server is one URL behind a sign-in, with npx absent from Zep's docs site and, in the README of Graphiti's MCP server, only bridging one client. Cognee's three MCP setup pages never mention npx, and its MCP server starts from Docker, uvx, pip or source; where its MCP pages do mention npx, it is the mcp-remote bridge on the Claude Desktop page. Supermemory's docs runnpx supermemory localto stand up a self-hosted server that lacks the hosted MCP, while its Memory MCP pages give just a URL and a sign-in.- Disclosure: Mnemoverse is one of the six vendors compared, built by this site's publisher. Every fact here, ours included, comes from each vendor's own docs, code or package listings, checked in September 2026.
- No performance or benchmark number appears in this article, for any system; any number we publish comes with its recipe.
The mechanism npx is supposed to promise
Type npx and something is supposed to happen: code runs, on your machine, right now, no separate install step. That is the whole promise behind the word. Read as a client spawning the vendor's own MCP server, it does not hold for five of the six systems checked here, each for a different, specific, checkable reason.
Mnemoverse: the MCP server clients spawn with npx
Among the MCP memory servers in these vendors' docs, ours is the one a client spawns with npx. Add it to Claude Code, Cursor, VS Code, Claude Desktop or Windsurf, and the line each of those clients runs is the same shape: npx -y @mnemoverse/mcp-memory-server@latest, one required environment variable carrying an API key. There is no separate install step for the package; afterwards come a client restart and one test write and read (agent setup guide). What runs on your machine is the MCP server process; the memories themselves are stored server-side and reached over HTTPS, the same hosted shape as Mem0's MCP server below. The difference this section is about is the launch command, not where the data lives.
That key still has to come from somewhere: a free key from a signup page at console.mnemoverse.com, the same shape of prerequisite as Mem0's account requirement below, just without a separate sign-in step after the command runs.
The file the npx line goes into differs by client. Claude Code takes one command, Cursor's install button writes the entry with a placeholder key that you then replace in that file (Cursor setup), VS Code names the outer key servers, and our Claude Desktop page puts the remote URL first. Node is our prerequisite too, and more continuously than Mem0's: their npx line writes a config once, ours is the command the client spawns every session, so Node has to be present every time rather than once. And a key is not the only door in. Besides the keyless extension for VS Code and its forks, with browser sign-in, there is a remote connector at https://mcp.mnemoverse.com/mcp, a URL plus an OAuth sign-in and no local process at all, which is the same shape as the URL-and-sign-in installs this article describes for other vendors.
Mem0: an npx command that configures, not runs
Mem0 has an npx command too, and this is where the word starts meaning something different. Point a client at it and the command writes local configuration; it does not start anything, in the vendor's own words:
Nothing runs on your machine: the server is hosted by Mem0, and your client connects to it over HTTPS.
And connecting alone is not the finish line:
The server is authenticated, so connecting is not enough on its own.
(mem0-mcp docs). The prerequisite list above that command names four things: an account, a key from a dashboard, Node 18 or newer for npx, and a compatible client. Two of that page's seven clients are not in that command: it says Claude Desktop rejects it and has to be added by hand through its settings instead, and it sends Codex to a config file, its app or a sideloaded plugin. Mem0 also documents a server you run yourself, a REST server and dashboard started with make and Docker rather than npx (open-source setup).
Letta: the client end of MCP
In MCP terms, Letta's agents call out to external servers. Its legacy SDK docs put it like this:
MCP tools execute on external MCP servers. Unlike server tools (where the tool code runs in Letta’s sandbox) or client tools (where the tool code runs in your app), MCP tools only require registering the server URL - the tool execution happens on the MCP server.
(MCP tools, V1 SDK (legacy)). Letta connects to servers you supply, and nowhere in its documentation is Letta itself offered as an MCP server. The one npx example on that legacy page runs a general-purpose filesystem tool, not anything of Letta's. Letta's own backend does have a Node path: its self-hosting guide documents npm install -g @letta-ai/letta-code followed by letta server --backend local --listen, with the desktop app, which runs an App Server in the background on your machine, and container deployments offered alongside. The package is published as @letta-ai/letta-code with a letta binary. Exactly one Letta package in its docs launches with npx: @letta-ai/letta-acp, an adapter that lets any Agent Client Protocol client, an editor for instance, drive a Letta agent and its memory, over ACP rather than MCP.
One more thing worth naming plainly, found checking this section rather than assumed: Letta does publish its own npm package for a memory MCP server, under its own team's maintainer names on the registry, though no page of its documentation mentions it. But the package's listed README is copied wholesale from an unrelated project (the Model Context Protocol registry server), and the repository its own listing links to no longer exists. A real, published package with a mismatched README, not something this article can point a reader toward with confidence either way.
Zep and Graphiti: two products, neither launches with npx
Two products share this vendor's name, and neither one starts with npx. Graphiti, the open-source half, documents its own server starting through Docker Compose or a Python toolchain as the alternative. npx never appears on Zep's docs site, Graphiti's setup page there included. The README of Graphiti's MCP server has it in one place, the Claude Desktop bridge, and only after the real server is already running, bridging a client limitation rather than launching anything:
Claude Desktop does not natively support HTTP transport, so you'll need to use a gateway like mcp-remote.
(Graphiti MCP server README). The same README also gives Claude Desktop a direct stdio path, with no gateway at all. Zep's own hosted product, separately, has terminal commands too: some install a plug-in or a skill file for a client, and an admin command-line tool manages users, threads, context graphs and data operations. None of them starts a server: behind every client sits one URL, a seat per person, and a sign-in through the organization's identity provider (Zep memory MCP server). Two more servers sit under Zep's name, both documentation search for coding agents rather than memory, each on its own host, one of them documented as needing no key at all (Zep docs MCP server); the same word covers four servers inside one vendor's own documentation.
Cognee: zero npx on three setup pages
Cognee documents its memory server across many pages, and three of them lay out setup: an overview, a quickstart, and a local setup guide. Searched for the string npx across those three, the count comes back at zero.
The overview's Setup Options group names three paths instead, on three separate cards: Docker Quickstart, recommended for most users; API Mode (Shared), for teams; and Local Setup, for development. Each card adds one line of its own:
Get running in minutes with a pre-built container.
Connect multiple clients to a shared knowledge graph.
Install the PyPI release with uvx, or build from source for full control and latest features.
(Cognee MCP overview). A container, a shared backend, or the released Python package through uvx or a source build. None of the three is npx. Other pages add pip, and for Claude Code a plugin Cognee calls the simpler path, which starts a local Cognee API. There is a reason npx is not among them, checkable independently: Cognee's memory server is a real, published PyPI package, but the npm registry (the one npx actually reads from) returns nothing under its name. Cognee's MCP pages use npx only for a third-party bridge, on the Claude Desktop page.
Supermemory: hosted MCP is a URL, local server a binary
The setup page for Supermemory's hosted memory MCP has no command on it at all, only a URL:
Add the remote server to your MCP client:
Supermemory MCP uses OAuth. Your client opens the authorization page so you can sign in and approve access. No API key or custom header is required.
(Supermemory MCP setup). Supermemory does publish first-party npx commands, and naming them accurately matters. Its agents and MCP page lists three paths, two of them npx: npx supermemory, the CLI, for "Setup, smoke tests, agent-driven integration", and npx skills add … --skill supermemory, to "Teach the agent the real API surface". The third, docs search, is an HTTPS URL rather than an npx command. A further command, npx supermemory local, stands up Supermemory's own memory server on your machine: its self-hosting page calls it "One binary, zero config" and says "The only thing you bring is a model". That mode's comparison table keeps connectors, the hosted Supermemory MCP and the proprietary extraction models on the platform.
So Supermemory has a real npx surface, and one of those commands stands up its own memory server. What none of them launches is the hosted Memory MCP, which stays a remote URL behind OAuth.
The table
| vendor | does a client spawn their own MCP server with npx? | what actually does |
|---|---|---|
| Mnemoverse | yes | the npx line itself, gated by a free API key; then a client restart and a test write and read |
| Mem0 | no | npx configures a hosted server (sign-in happens after) or copies in a plugin with a local MCP server; its self-run REST server starts with make and Docker |
| Letta | no | an npm package (letta server), its desktop app or a container; its one documented npx package, letta-acp, exposes an agent over ACP, not MCP |
| Zep / Graphiti | no | Graphiti: Docker Compose or a Python toolchain. Zep: one URL behind a sign-in. npx is absent from Zep's docs site and only bridges one client in the README of Graphiti's MCP server |
| Cognee | no | Docker, uvx, pip or source, plus a Claude Code plugin that starts a local Cognee API; zero npx on its three setup pages |
| Supermemory | no | hosted MCP: a URL and OAuth sign-in; its docs run npx supermemory local to stand up a self-hosted server that lacks the hosted MCP |
Check your own setup
Checking this yourself takes less time than this article did to write. Open the vendor's own setup page and search the page itself for npx, not a blog post about the vendor. If it appears, read the sentence around it before typing anything: does that command start a server, or write configuration for one running somewhere else. If it doesn't appear at all, the real path is sitting one section away, a container command, a language-specific toolchain or a hosted URL, and often a second one sits on another page, so search the whole docs before counting.
This page was first checked live 2026-09-03 with full browser headers. On 2026-09-13 every absence claim was re-derived against each vendor's full documentation: the llms-full.txt exports of Mem0, Cognee and Supermemory, every sitemap page of docs.letta.com and help.getzep.com, and the getzep/graphiti main-branch tarball. Every quotation printed here was re-checked against its live page on 2026-09-17. Mnemoverse's own facts come from its agent setup guide and the per-client pages beside it. No performance or benchmark number appears in this article, for any system; any number we publish comes with its recipe.
Related
- Best AI agent memory in 2026: our commercial roundup of these systems, disclosed as such, same vendors and a different job
- What Is an MCP Memory Server? Protocol, Tools, Tokens: what happens once a client calls the server that command starts, walked through with the specification open
Mnemoverse is a persistent-memory API for AI agents. Free key: console.mnemoverse.com · Plans and limits · Docs: Getting Started