A local memory vault that every AI can read and write to over MCP. One folder of markdown files on your machine. Claude, ChatGPT, Gemini, and any other MCP-aware client share it live — no service, no API key, no cloud.
pipx install "elesync[mcp]"
ele onboardInstall · Why local-first · Compared to other memory tools · Architecture · Privacy
Every AI you talk to has its own siloed memory. Claude doesn't know what you told ChatGPT. ChatGPT doesn't know your Gemini context. You repeat yourself constantly.
EleSync turns that around: the vault is yours, on your disk, and every model is a client of it. It speaks the Model Context Protocol. Claude Desktop, Cursor, Cline, and Continue connect over stdio with zero setup. ChatGPT's Developer Mode connector needs a remote transport (Streamable HTTP) instead of stdio -- EleSync supports that too, tunneled or deployed. Tested live: ChatGPT reading and writing to the same vault Claude uses, over a tunnel, today.
The vault itself is just a directory of markdown files with YAML frontmatter, an SQLite FTS5 index, and (optionally) ONNX embeddings for semantic recall. No server. No daemon. No account. You can cat your memories. You can git push them. You can encrypt the whole vault and carry it on a USB stick.
┌─────────────┐ ┌─────────────┐ ┌─────────────┐
│ Claude │ │ ChatGPT │ │ MCP client │
│ Desktop │ │ (MCP) │ │ (Cursor…) │
└──────┬──────┘ └──────┬──────┘ └──────┬──────┘
│ │ │
│ MCP over stdio │ MCP over stdio │ MCP over stdio
└──────────┬───────┴──────────┬───────┘
▼ ▼
┌──────────────────────────────┐
│ ele serve │
│ (MCP server, ~600 LOC) │
└──────────────┬───────────────┘
▼
┌──────────────────────────────┐
│ ~/EleSyncVault/ │
│ ├── notes/ *.md (truth) │
│ ├── index.sqlite (FTS5) │
│ └── vectors/ *.npy (opt.) │
└──────────────────────────────┘
The markdown files are the source of truth. The SQLite index is a derived cache rebuilt from them on demand (ele sync). If the index is ever corrupt, delete it — ele rebuilds from the markdown.
pipx install "elesync[mcp]"
ele onboard # interactive: pick a vault path, wire up Claude Desktop
ele remember "I'm a Rust developer; prefer concise code reviews without preamble"
ele recall "what languages do I use"
# > I'm a Rust developer; prefer concise code reviews without preamble (claude · fact · 2026-06-25)Restart Claude Desktop. Ask Claude: "What do you remember about me?" — it'll see what you just stored.
For the non-CLI flow (web UI, drag-and-drop import, no terminal):
ele web…opens a local dashboard at 127.0.0.1:7477.
The "AI memory" space has split into two camps. Developer infrastructure for building agents (mem0, Letta, Zep, Graphiti, LangMem) is one thing. A memory vault you own, that the AIs you already use plug into, is a different thing. EleSync is the second.
| EleSync | OpenMemory MCP | mem0 | Letta | Zep / Graphiti | |
|---|---|---|---|---|---|
| Storage | Plain markdown + SQLite | mem0 backend | Their DB | Their DB | Postgres + KG |
| What it stores | Your memories | Your memories | Memories for your agents | Tiered memory for agents | Temporal KG |
| Who it's for | You | You | Agent builders | Agent builders | Agent builders |
| Setup | pip install |
mem0 install | SDK integration | SDK integration | Docker compose |
| Encryption at rest | XSalsa20-Poly1305 + argon2id | – | – | – | – |
| Portable USB vault | ✓ | – | – | – | – |
Files inspectable in $EDITOR |
✓ | ✗ | ✗ | ✗ | ✗ |
| Temporal validity windows | – | – | – | – | ✓ |
| Knowledge graph extraction | – | – | – | – | ✓ |
| Cross-AI provenance + conflict detection | ✓ | – | – | – | – |
| Hosted option | – (local-only) | ✓ | ✓ | ✓ | ✓ |
Where EleSync is genuinely behind: no temporal model (Zep/Graphiti win at "what was true when"), no automatic entity/relationship extraction, no semantic decay. These are deliberate scope choices — files-on-disk is the constraint, and a knowledge graph in markdown stops looking like markdown fast.
Where it's genuinely ahead: you can grep your memory. You can git diff what changed last week. You can revoke your USB drive and your memory walks out the door with you, encrypted, readable on any machine with a Python install.
Requires Python 3.10+.
Recommended — pipx installs the CLI and MCP server into their own isolated environment, so nothing collides with your other Python tools:
pipx install "elesync[mcp]" # CLI + MCP server (recommended)Or with pip:
pip install "elesync[mcp]" # CLI + MCP server
pip install elesync # CLI only (the ele command; no MCP server)
pip install "elesync[semantic]" # + ONNX embeddings (BAAI/bge-small-en, ~30MB download on first use)
pip install "elesync[encryption]" # + at-rest encryption via libsodium
pip install "elesync[watch]" # + auto-import from ~/Downloads
pip install "elesync[webauth]" # + password auth for the web UI
pip install "elesync[dev]" # everything aboveThe MCP server needs the mcp extra — plain pip install elesync gives you only the ele CLI. Extras stack, e.g. pipx install "elesync[mcp,semantic,encryption]".
Or grab a standalone executable from Releases — no Python required.
After install:
ele onboard # interactive setup: vault path + MCP wiring for Claude Desktop
ele doctor # verify everything is connected
ele doctor --fix # repair fixable issues (e.g. stale/missing MCP wiring), then re-checkele onboard writes the MCP server entry into claude_desktop_config.json (or the equivalent for other clients). It backs up the existing config first. Re-running is idempotent.
EleSync exposes itself as a standard MCP server, over either of the two transports the MCP spec defines: stdio (local clients) or Streamable HTTP (remote clients).
Auto-wire for Claude Desktop:
ele onboard # writes ~/.config/Claude/claude_desktop_config.jsonManual config for everything else:
{
"mcpServers": {
"elesync": {
"command": "elesync",
"args": [],
"env": { "ELESYNC_DIR": "/Users/you/EleSyncVault" }
}
}
}ChatGPT's MCP connector (Developer Mode, shipped Sept 2025) requires a remote transport -- it can't launch a local stdio process the way Claude Desktop does. EleSync's server can switch transports with a flag:
ele serve --transport http --port 8000 --allowed-host your-tunnel-host.example--allowed-host is required for any non-localhost hostname -- the server
keeps DNS-rebinding protection on by default (CVE-2025-66416
in the underlying MCP SDK) and only widens the allow-list to hosts you
explicitly name, rather than disabling the check.
To reach it from outside your machine, put it behind a tunnel (quickest: ngrok) or a reverse proxy with TLS:
# terminal 1
ele serve --transport http --port 8000 --allowed-host xxxx.ngrok-free.dev
# terminal 2
ngrok http 8000Then in ChatGPT: Settings -> Connectors -> Advanced -> Developer Mode -> Add
custom connector, server URL https://xxxx.ngrok-free.dev/mcp. Verified
working: recall and remember both round-trip correctly, including
finding memories written earlier by Claude -- the actual point of EleSync.
For a permanent remote deployment (not just testing), put a real domain + TLS cert in front instead of a free ngrok tunnel, and add MCP-level auth (EleSync doesn't include its own auth layer -- treat the HTTP endpoint as unauthenticated and don't expose it without a reverse proxy that adds one).
| Tool | What it does |
|---|---|
recall |
Search the vault (BM25 + optional semantic) |
remember |
Write a new memory (optionally supersedes an older one) |
forget |
Delete a memory by ID |
history |
Show a memory's supersession chain — what a fact used to be, and when it changed |
memory_status |
Counts, sources, last-modified |
list_scopes |
Scope compartments this client can see, and how many memories each holds |
find_conflicts |
Cluster contradictions across sources |
audit_log |
Who read, wrote, or forgot what, and when (requires ELESYNC_AUDIT=1) |
The export landscape changed in 2026 — most providers retreated from file-based memory exports to "ask the assistant for your memories" workflows. EleSync handles both shapes.
| Source | What works today | Adapter |
|---|---|---|
| ChatGPT conversation export (Settings → Data Controls → Export Data) | The ZIP contains conversations.json — full chat history. ele import parses it. |
✓ verified |
| ChatGPT memory (the small set of explicit facts) | No file export exists in 2026. Use the in-app copy-paste prompt and save the output as text. | partial — see SETUP.md |
| Claude memory | Same copy-paste pattern as ChatGPT memory; no file export. | partial |
| Gemini | Via Google Takeout (export of conversation history, not memory). | ✓ verified |
| Grok / DeepSeek / Perplexity / Copilot | Adapter built; export availability varies by region (Grok memory is EU-blocked). | experimental |
ele import ~/Downloads/conversations.json --source chatgpt
ele import ~/Downloads/takeout-gemini.zip --source gemini
ele watch ~/Downloads # auto-detects and imports as exports arriveThe conversations.json from a full ChatGPT export can be multiple gigabytes. EleSync streams it; you don't need to unzip the full archive.
About 10,200 lines of Python, 449 tests. No third-party services. The dependencies you need:
| Layer | Dependency | Why |
|---|---|---|
| Core CLI + MCP | stdlib only | Zero required deps |
| Semantic recall | fastembed (ONNX) |
BAAI/bge-small-en, runs on CPU |
| Encryption | pynacl |
libsodium bindings, XSalsa20-Poly1305 |
| Auto-import watch | watchdog |
File system events |
ele serve boots an MCP server over stdio. ele web boots a local HTTP server (127.0.0.1 only) that exposes a JSON REST API and an embedded HTML/CSS/JS dashboard. The web UI has zero external dependencies — no CDN, no analytics, no fonts loaded from third parties.
Provenance is first-class. Every memory carries source (claude, chatgpt, gemini, manual, …) and created_at. When two sources contradict each other, find_conflicts surfaces the cluster so you can decide which one is true.
Scoped sharing lets you give one MCP client a different view of the vault than another. Useful for keeping work memories away from a coding assistant, or hiding personal context from a client you don't fully trust.
# tag memories into compartments
ele scope --grant work,coding "preferred language: Rust"
# wire a second connection with restricted view
ele onboard --client cursor --grant coding-onlyEleSync can encrypt the entire vault at rest. The encryption is real cryptography (libsodium's secretbox: XSalsa20-Poly1305 with Poly1305 MAC, keys derived via argon2id), not a base64 wrapper.
ele encrypt # one-time: convert an existing vault to encrypted form
# passphrase is hashed with argon2id, never stored
ele serve # prompts for passphrase, unlocks in memory onlyThe same vault format runs on a USB drive with a launcher script. Plug into any machine with Python, run RUN_ME.py, unlock with the passphrase, and Claude / ChatGPT on that machine talk to it:
ele usb install /Volumes/MY_DRIVE # creates encrypted vault + launcher + README
ele usb attach /Volumes/MY_DRIVE # wires Claude Desktop on this machine
ele usb detach /Volumes/MY_DRIVE # cleanly unwires before unplug
ele usb status /Volumes/MY_DRIVE # what's on the drive?ele web launches a local dashboard for non-CLI users:
Browse, search, edit, import drag-and-drop, switch between vaults (including USB), add/delete memories. The UI is one HTML file with embedded JS — no build step, no framework, no external dependencies.
Dark mode toggle (persists in localStorage). Keyboard shortcuts: / to search, N for new memory, ? for help, Esc to close panels, Ctrl+K for command palette. CSV export in addition to JSON. Mobile-responsive down to 375px with touch-friendly targets.
Self-hosted mode: ele web --host 0.0.0.0 binds to all interfaces for multi-device family/team use. A security warning is shown if you expose to the network without authentication.
By default there's no login — it binds to 127.0.0.1 only, so it's as private as anything else running on your machine. If you want a login anyway (shared machine, or you're the cautious type), add a user and it turns on automatically:
ele web adduser alice # prompts for a password, hashed with bcrypt
ele web adduser bob --role viewer # read-only account — can browse/search, can't add/edit/delete
ele web listusers
ele web removeuser bob # remove the last user and login turns back offPasswords are bcrypt-hashed, session tokens are stored as SHA-256 hashes (never plaintext) in <vault>/.web_auth/, and viewer accounts are enforced server-side, not just hidden in the UI — a viewer session gets a real 403 on any write attempt, not just a greyed-out button. This is a local-first tool, not a hardened multi-tenant server: for anything exposed past 127.0.0.1, put a real reverse proxy with TLS in front of it.
Because the vault is just files, you sync it however you sync files:
- git —
git inityour vault, push to GitHub/GitLab/Forgejo - Syncthing — peer-to-peer, no cloud
- iCloud / Dropbox / Drive — works fine, just point your vault at the synced folder
- Encrypted USB — see above
# device A
cd ~/EleSyncVault && git add . && git commit -m "memories" && git push
# device B, after pulling
ele sync # rebuilds the SQLite index from markdownThe SQLite index is gitignored by default. Only the markdown is the source of truth.
- Zero telemetry. EleSync never connects to the internet unless you tell it to (
ele importof a URL, semantic model download on first use). - Zero accounts. There is no signup. There is no server.
- Zero ads, zero tracking, zero data collection. Not "we don't do that yet". There is no business model that depends on your data.
- The vault is yours. Delete it and EleSync forgets everything.
The semantic-recall extra downloads the BAAI/bge-small-en model from HuggingFace on first use (~30MB). After that, it runs entirely locally on CPU. You can skip the download by not installing [semantic].
EleSync is at 1.13.0 (480 tests, ~10,500 LOC). The 1.x line will not break compatibility — vault format, MCP tool names, and CLI commands are stable until a 2.0.
What's planned or in design — contributions welcome on any of these:
- Knowledge graph (design phase) — lightweight entity/relation tagging where the calling AI supplies structured tags at
remember()time. No local NLP model, no API calls. Design discussion → - Temporal validity — "this fact was true from X to Y." Closes the gap with Zep/Graphiti without over-engineering the file format.
- Performance at scale — profiling and optimization for vaults with 10K+ memories.
See CONTRIBUTING.md for how to get started. First-time contributors: look for issues tagged good first issue.
MIT. See LICENSE.
- Setup guide (non-technical readers): SETUP.md
- Contributing: CONTRIBUTING.md
- Changelog: CHANGELOG.md
- Issues: GitHub Issues
- Website: elesync.dev