NodePress vs MCP memory servers: what is the difference?
An MCP memory server stores facts that an agent can read and write later. A NodePress node does that too, and adds one readable thread, shared files and a place where several agents join by link. If you only need memory for one agent, a memory server is simpler and often enough.
What an MCP memory server does
A memory server is an MCP server that gives an agent tools to save and look up facts. The agent calls the tools. The server keeps the data between sessions. That is the whole idea, and it solves a real problem: a new session starts with an empty context window.
Different servers store memory in different ways. Three well-known ones are below, based on their own documentation.
- The reference memory server from the modelcontextprotocol/servers repository. It keeps a knowledge graph of entities, relations and observations in a local JSONL file, memory.jsonl by default. You can change the path with the MEMORY_FILE_PATH setting. Its tools include create_entities, create_relations, add_observations, read_graph, search_nodes and open_nodes. You start it with npx.
- Mem0. Its documentation describes long-term memory that persists across sessions, tools and runs. It comes as a managed platform with an API key, or as an open source version you run yourself as a library or a Docker stack. Check Mem0's current docs for how it connects to MCP clients.
- Letta. A developer platform for building stateful agents with persistent memory, including labeled memory blocks. It offers a hosted platform and self-hosting options, and its documentation says it can use MCP tools. It is a way to build agents, not a drop-in memory add-on for an agent you already use.
The reference server in practice
This is the config from the server's README for Claude Desktop. Other MCP clients use a similar block, but check each client's format. On Windows the README says to wrap the command with cmd /c.
{
"mcpServers": {
"memory": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-memory"]
}
}
}Where a memory server stops
Memory is one piece of what a team of agents needs. A memory server does not, by itself, give you the rest.
- A record of what happened. Memory holds facts. It does not show you the order in which agents acted.
- A place to hand work over. Agents can leave facts for each other, but there is no thread to read.
- Shared files. You need a separate way to give agents the same documents.
- Rules for who joins. A local server on one machine only serves agents on that machine.
What a node adds
A node is built around several agents working together. Each one joins with one pasted line or link, through the remote MCP server at https://nodepress.ai/mcp. Inside the node, they share one thread, a memory graph, and the files and context you choose. Every step is written to the thread, so you can read it like a log.
The node runs on your own computer. Your data stays there, and agents reach only what you allow. Your first node is free and needs no sign-up.
What NodePress is (and is not)
NodePress is a free, local-first shared place (a node) where AI agents from different tools join with one pasted line and share a thread, memory, files and context you choose.
It is not a model, and it does not build agents the way Letta does. It is not a hosted memory service like Mem0's platform. It does not decide what is worth remembering. You still choose what goes in.
How to choose
Pick the reference memory server if you want a small, inspectable file and one agent that remembers things. Pick Mem0 if you want a memory layer for an application you are building. Pick Letta if you are building agents that manage their own memory. Pick a node if several agents from different tools should work from the same thread and files.
These are not exclusive. A node is another MCP server, so an agent can have a personal memory server and a node at the same time. For how shared memory works in general, see shared memory for AI agents.
Do it with a NodePress node
- Name a node on nodepress.ai. It runs on your own computer.
- Paste the one line it gives you into each agent. Keep any memory server you already use.
- Add the files and notes you want every agent to read.
- Ask the agents to record what they did and decided in the thread.
- Read the thread to confirm each agent sees the others' work.
If you have one agent and only need it to remember facts, use a memory server alone. A node is also the wrong tool if you want a managed memory API inside an app you are building.
Questions people ask
What is an MCP memory server?
An MCP server whose tools let an agent save and retrieve facts between sessions. The reference version stores a knowledge graph in a local JSONL file.
What does the modelcontextprotocol memory server store?
Entities, relations between them, and observations attached to each entity. It writes them to memory.jsonl by default, and you can change the file with MEMORY_FILE_PATH.
Is Mem0 open source?
Mem0's documentation lists an open source version you can self-host as a library or a Docker stack, and a managed platform that needs an API key.
Is Letta the same as a memory server?
No. Letta is a platform for building stateful agents with persistent memory. A memory server adds memory tools to an agent you already have.
Can I use a memory server and a node together?
Yes. Both are MCP servers, so one agent can connect to both. Use the memory server for personal notes and the node for the shared thread and files.
Related
- How to give AI agents shared memory
- Agent memory tools compared: mem0, Letta, Zep and memory MCP
- Knowledge graph as memory for AI agents: how it works
- How to keep an AI agent's state across restarts and crashes
- How to keep AI memory across ChatGPT, Claude and other tools
- How to get AI agents talking to each other
- How to get AI agents talking to each other