1729 words | Esment
A local MCP memory server.
A local MCP memory server keeps memories on your machine, but search and the LLM may run elsewhere. Check all three layers before you pick one.
╌╌╌╌
A local MCP memory server is a program on your own computer that stores what your assistant should remember and hands it back through the Model Context Protocol. In MCP terms, "local" only means the server runs on the same machine as the app that uses it, usually over stdio. It says nothing about where your text goes next.
So ask three separate questions: where the memories live, where search and embeddings run, and where the LLM runs. A tool can be local on the first and not on the other two. For the smallest setup, use the reference knowledge graph server. For notes you can read yourself, use Basic Memory. For local vector search with a path to remote access, use mcp-memory-service. Details and trade-offs are below.
The three layers of local
1. Where memories live
This is the layer most people mean: a file or database on your disk that you can back up, inspect and delete. It is also the easiest to check. Find the file. If you cannot say where it is, you do not yet know how local the tool is.
2. Where search and embeddings run
Semantic search turns your text into vectors with an embedding model. Some tools run that model on your machine. Others call a hosted API, which means the text of your memories leaves the computer to be indexed, even though the database stays on your disk. Keyword search avoids the question because it needs no model at all.
3. Where the LLM runs
This is the layer that surprises people. If you connect a local server to Claude Desktop or Cursor, the server is local, but the model usually is not. Whatever the assistant retrieves goes into a prompt and is processed by that vendor under its own policy. A local memory server limits what is stored elsewhere. It does not stop retrieved text from being read by the model you chose. To keep this layer on your machine too, you need a local model in an MCP-capable client.
Some memory tools also use an LLM of their own, to extract facts from conversations or to summarise. That is a fourth place text can go, so check it separately from the assistant.
How five tools compare
Checked against each project's own documentation on 6 November 2026. These projects change quickly, so confirm anything you depend on.
| Tool | Where memories live | Search and embeddings | LLM in the server | Reaching web assistants |
|---|---|---|---|---|
| Reference knowledge graph server | A JSONL file on disk | Matches names, types and observations. No embeddings mentioned | None | stdio only, so it needs a bridge you set up |
| Basic Memory | Markdown files plus a local SQLite index | FastEmbed on your machine by default. OpenAI is optional | None for core use. An optional hosted reranker exists | Its paid cloud offers a hosted endpoint |
| mcp-memory-service | SQLite locally. Cloudflare, hybrid and Milvus are options | Local ONNX embeddings | None for core use. Optional features can use one, including Ollama | Remote MCP over HTTPS with OAuth, which you host |
| OpenMemory by Mem0 | Launched as local Docker containers. The current page does not say | The launch setup asked for an OpenAI key | See the note below | Not stated on the current page |
| Esment Mac app | A .esment folder in your home folder | Local. Your own OpenAI key is optional | None for search. The in-app Assistant and import need a model you choose | A tunnel from the app, or the separate cloud |
What each one is good at
The reference server is the simplest way to see what MCP memory feels like. It suits a small set of facts and a person who is happy to read a JSONL file. Set the file path yourself. By default the file sits in the server's own directory, and under npx that is inside node_modules, where an update can wipe it. It needs Node.js 24 or later.
{
"mcpServers": {
"memory": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-memory"],
"env": {
"MEMORY_FILE_PATH": "/path/to/memory.jsonl"
}
}
}
}Basic Memory fits people who want to own plain text. Your notes are Markdown, so they open in any editor and work with Git or Syncthing, and they outlive the tool. It is open source under AGPL-3.0, and the local version needs no account. Treat it as a knowledge base you and your agents maintain together.
mcp-memory-service fits people who are comfortable running a service. It is Apache-2.0, keeps embeddings local, and offers an HTTP API and dashboard. It binds to 127.0.0.1 by default and warns that exposing it needs authentication and TLS or a VPN. Its hybrid and Cloudflare backends are not fully local, so choose deliberately.
The gotcha: web assistants cannot reach stdio
A stdio server is started by an app on the same machine. ChatGPT on the web and claude.ai run on their vendors' servers, so there is no local process for them to start and no way to see your localhost.
- Claude: Anthropic says custom connectors are reached from its cloud, so the server must be reachable over the public internet. Servers set up in claude_desktop_config.json are not available on claude.ai.
- ChatGPT: OpenAI asks for a public HTTPS endpoint, or its Secure MCP Tunnel, where a client you run makes an outbound connection to reach a private server. Access depends on your plan and workspace permissions, so check OpenAI's current documentation.
That leaves three choices: stay with desktop apps and accept that web assistants are out of reach, keep the data at home and open a tunnel, or host the memory somewhere public. A tunnel keeps your storage local, but it gives your memory a public address, and that address needs real authentication. Your computer also has to stay on for it to work.
Where Esment fits
Esment is our product, so weigh this section with that in mind. It is a memory layer rather than an assistant or a model, packaged as a Mac app for people who would rather not run a server.
On the three layers: with sync off, memories are stored in a .esment folder on your Mac and do not reach Esment's servers. Search models ship in the app and work offline, unless you choose your own OpenAI key for embeddings. The LLM is whichever assistant you connect, and that vendor processes what it reads. Our privacy page lists everything that can leave the Mac.
The app bundles a stdio server, esment-mcp, and also serves Streamable HTTP on your Mac only. Desktop apps such as Claude Desktop, Claude Code and Cursor can be configured from the app. Other clients can use the snippet from the MCP reference:
{
"mcpServers": {
"esment": {
"url": "http://127.0.0.1:8080/mcp",
"headers": { "Authorization": "Bearer <admin-token>" }
}
}
}For web assistants, the app can open a temporary tunnel that forwards requests to your Mac through Cloudflare without copying memories to a server. The app must stay open, and the address changes when the tunnel restarts. Esment Cloud gives a stable address instead, but that memory is hosted, so it is no longer local on layer one or two.
The limits are worth stating plainly. The Mac app needs a paid plan, and it needs the network to validate your license, so the standard app is not an offline product. The Free plan is web only. Esment is Mac only for local use, and it is not open source, so you cannot audit it the way you can audit the tools above. Air-gapped use is limited to Enterprise.
How to choose
- You want to read and own the files, or need open source: Basic Memory.
- You want a small experiment at no cost: the reference server.
- You run your own services and want local vector search: mcp-memory-service.
- You want one memory across desktop and web assistants on a Mac without running a server, and a paid closed-source app is acceptable: Esment.
- You use one coding tool on one project: possibly no memory server at all. A reviewed CLAUDE.md or AGENTS.md file is simpler and easier to trust.
Whichever you pick, test recall early. With MCP, the model decides when to call a memory tool, so a server can be connected and still go unused. A short instruction telling the assistant when to search usually helps, and some apps support hooks that load memory without relying on that choice.
Common questions
Can a local MCP memory server work with no internet at all?
Out:The memory side can, if storage and embeddings both run on your machine. The reference server, Basic Memory and mcp-memory-service can all work that way once installed and once any embedding model has downloaded. The assistant still needs a connection unless you also run a local model. The standard Esment Mac app needs the network to validate its license.
Does a local memory server keep my data away from Anthropic or OpenAI?
Out:Only partly. It keeps the full store on your machine, but anything the assistant retrieves is sent to the model as part of the conversation, and the vendor processes it under its own policy. Only a local model avoids that.
Can I connect a local memory server to ChatGPT?
Out:Not over stdio. ChatGPT needs a public HTTPS endpoint or OpenAI's Secure MCP Tunnel, so a local server has to be exposed through a tunnel or a bridge, with authentication in place. Which ChatGPT plans allow custom MCP servers can change, so check OpenAI's current documentation.
Do I need Docker to run a local MCP memory server?
Out:No. The reference server runs through npx, and Basic Memory installs as a Python tool with uv. Docker is optional for the reference server, and it is how OpenMemory's launch setup ran.
Written by the team that builds Esment, so we are not a neutral party. Tools change quickly: check each one before you rely on it.
Get the next chapter by email.
One email per new chapter. Nothing else.