What does "local" AI memory keep on your machine, and what still leaves?

Updated 31 October 2026

"Local" usually describes where a memory is stored. Search, and the model that does the memory's work, can still run elsewhere. So ask three questions of any system: where is the store, where does search run, and which model does the work?

If you use Claude, we think the strongest local answer is Counterparts, the memory we make. The whole memory is one SQLite file under ~/.counterparts, readable by your account only. Search by meaning runs on a small model on your machine. There are no API keys, no account, and no server of ours behind the local install, so nothing goes to us. Claude writes the memories itself, in its own words: what matters sticks, the rest lets go, and each session picks up where the last one left off. It runs with Claude Code on a Mac or Linux, and with Claude Desktop on a Mac. Setup is below.

What does leave goes out through Claude, to the same place as your chat: Anthropic, or the cloud provider you set. That's whatever memory a session reads, and once a day a background run of your own Claude Code that tidies the memory. That's true of every memory used with Claude. The only other request is a daily version-number check to npm, which you can turn off. If the model has to be on your machine too, that's a different setup.

This is a research summary. An AI drafted this page from the sources below and another AI checked it. No person has run these steps. An AI read each system's docs on October 30, 2026. It ran Counterparts in a throwaway home folder with a stand-in for claude, and Letta's setup lines with a stand-in for Ollama, and no other system. Counterparts is ours: Mike LaPeter makes it and uses it every day.

Three questions, eight systems

These are systems people named when asking "can it run local?", plus claude-mem, Basic Memory for plain files, and ours. Rows show defaults.

System	Store	Search	Model doing the memory's work	To keep that work local
Claude Code's built-in memory	Files in `~/.claude/projects/`	None: an index loads, and Claude opens other notes with its file tools	Claude, through Anthropic or a cloud provider you set	None Anthropic supports; see Ollama below
Counterparts (ours)	One SQLite file in `~/.counterparts`, readable by your account only	On your machine: a small model of about 30 MB, fetched at install	Claude, in your sessions and a once-a-day background run on your plan	As for Claude Code: none Anthropic supports
claude-mem	`~/.claude-mem`. Its interactive installer pre-selects CMEM Pro, which syncs notes and full prompts to cmem.ai	Keywords plus Chroma, on your machine	Claude on your plan; with CMEM Pro, its hosted observer	Install with `npx claude-mem install --provider claude`, which skips the sign-in. Then in `~/.claude-mem/settings.json` set `CLAUDE_MEM_PROVIDER` to `openai-compatible`, `CLAUDE_MEM_OPENAI_COMPAT_PRESET` to `ollama` or `lmstudio`, `CLAUDE_MEM_OPENAI_COMPAT_MODEL` to your model's id, and `CLAUDE_MEM_QUOTA_FALLBACK_PROVIDER` to `off`, else it falls back to Claude
Basic Memory	Markdown in `~/basic-memory`, with a SQLite index	On your machine, after a model download	None of its own	Already is. Its cloud and hosted reranker are opt-in
Cognee	Files on disk	No key set: a local model, after a download. Key set: OpenAI	No key set: a local extractor, and written answers need an LLM. Key set: OpenAI	Stay keyless (install `cognee[gliner]`), or point both LLM and embeddings at Ollama. Set only one and it needs a working OpenAI key for the other
Mem0 (open-source library)	Qdrant in `/tmp/qdrant`, SQLite in `~/.mem0`	OpenAI embeddings	OpenAI	Set both LLM and embedder to Ollama: each Ollama page changes one and keeps OpenAI for the other. Its Claude Code plugin needs a Mem0 Platform account
Supermemory local	`~/.supermemory`, by a server binary that isn't open source	On your machine, after a model download	Whichever you connect; one is required	Point it at Ollama and use local text inputs
Letta	Letta Cloud by default. Local agents: a git repo on your machine	No vector index by default: the agent reads its files	Cloud: Letta's LLM gateway or a provider you connect. Local agents: whichever you connect	`letta backend local`, then `letta --backend local connect ollama`, then pick that model with `/model`

Letta is the one row whose maker documents running its own chat on a local model. For a local chat, Basic Memory, Cognee, Mem0 and Supermemory need a local app beside them, and claude-mem's local observer leaves your Claude Code chat going wherever Claude Code sends it.

Each also sends something else by default, by its docs or source:

System	Also sends	Off switch
Claude Code	Usage metrics; error reports on some setups; auto-updates; WebFetch hostnames	`CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC`; for WebFetch, `skipWebFetchPreflight: true`, which also drops Anthropic's safety blocklist
Counterparts	A daily version-number check to npm, carrying nothing about you	`"updateCheck": false` in `~/.counterparts/claude-code.json`; Claude Code's `CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC` also stops it
claude-mem	Anonymous usage stats and redacted error text; once, a numbers-only usage summary to cmem.ai	`npx claude-mem telemetry disable`, for stats and errors
Basic Memory	Anonymous cloud-promo events; a daily update check that applies updates on `uv tool` and Homebrew installs	`BASIC_MEMORY_NO_PROMOS=1`; `"auto_update": false` in `~/.basic-memory/config.json`
Cognee	Anonymous usage stats	`TELEMETRY_DISABLED=true`
Mem0	Telemetry to PostHog	`MEM0_TELEMETRY=False`
Supermemory	Telemetry, a release check	`SUPERMEMORY_DISABLE_TELEMETRY=1`, `SUPERMEMORY_NO_UPDATE_CHECK=1`
Letta	Usage events (from its code; unconfirmed for a local agent)	`LETTA_CODE_TELEM=0`

Graphiti has no row: it needs a graph database (Neo4j, or FalkorDB with an embedded build), defaults to OpenAI, and Ollama setups have had trouble. Our directory lists others this page leaves out.

What still goes out through Claude Code

Anthropic's docs say of Claude Code's network traffic: "This data includes all user prompts and model outputs." A memory joins that data when it reaches the session: Claude Code adds session-start and prompt hook output "as context that Claude can see and act on", and a local MCP server's answer enters the conversation.

On Free, Pro, Max and Ultra, your training setting decides whether Anthropic trains on it and keeps it for 5 years or 30 days.

With Counterparts, the memory itself stays home. The file is readable by your account only, search runs on your machine, and the dashboard is served only to your own computer. Counterparts' copy of conversation text waiting to be written up stays there too: by default it's deleted within 3 days after it's written up, never kept more than 14 days, and never put in a backup. Claude Code keeps its own transcripts, the daily run's included, by its own rules. What Claude reads goes out with your session: the short briefing at the start, the memories that come to mind as you talk, and what it looks up.

Once a day a background Claude run, on your own Claude Code and plan, tidies the memory and writes up any session that ended before it was written up. It may use only Counterparts' memory tools, and it reads the memories and any text not yet written up. On Claude Code, the day's first session can start it. Say "no dreams" in a session to turn it off or, on an npm or bun install, run counterparts dream --setting off.

Counterparts on your machine: what stays, and what goes out

For claude.ai on the web and in the apps, the door is Counterparts' hosted connector, and it isn't local: memories sit on the operator's server. It needs an invite for now: email mike@resonantventures.com for a code.

Setting up Counterparts as a local memory

In Claude Code on a Mac or Linux, run /plugin marketplace add mlapeter/counterparts, then /plugin install counterparts@counterparts, and restart. The first session offers a short getting-to-know-you. Or, in a terminal with bun 1.3+ or Node 22.15+, run bun add -g counterparts (or npm install -g counterparts@latest), then counterparts, which asks your name and connects Claude Code, then restart Claude Code.

For Claude Desktop on a Mac, install from the terminal, then follow the Quickstart: quit Claude Desktop, run counterparts install --host claude-desktop, open Desktop again, and set the counterparts tools to Always allow.

It's free and open source (MIT), with no account of its own; it runs on your Claude plan. You can read, export or delete the memory: counterparts dashboard opens it in your browser, or /counterparts:dashboard on a plugin install. It's an early project, whose README says "Expect rough edges". It doesn't run on Windows, or with ChatGPT, Cursor or Gemini.

More is on the Claude Code page; its "Everything stays on your computer" is about where the memories are kept, and what goes out with your chat is above. To compare it with other memories for Claude Code, see our plugin guide.

How to check it yourself

Cut the network and ask the memory directly. Disconnect, then run its own search command, with words different from the note's, since keyword search works with no network too. For Counterparts that's counterparts ask "..."; a plugin install puts no counterparts command on your PATH, so go to step 2. An answer means search didn't need the network. An AI ran Counterparts' search with the network denied, and "my doctor" still found a note about a physician.
Then ask your chat. Claude Code on Anthropic's service should fail, since its docs require api.anthropic.com. We didn't run that.
Watch its connections during a session. Run this on Mac or Linux (Linux may need lsof installed), with Ctrl-C to stop. An AI ran it only on a Mac; we have no tested check for Windows.
```
while true; do lsof -nP -iTCP -iUDP -a -c bun; sleep 0.05; done
```
Swap bun for node or whatever runs your memory; other programs of that name appear too. Under a plugin it may be bun, node or, with neither installed, counterparts, a program the plugin fetches from GitHub. For Python use -c /python/i: the match is case-sensitive, and on a Mac Python usually shows as Python, so -c python prints nothing even while connected (tested on small Python programs, not on those memories). Before trusting a blank screen, run lsof -nP -c /python/i | head with your memory running, swapping in your runtime: no lines means the name is wrong.
On Counterparts under bun, the end of a session made one brief connection, to an address of registry.npmjs.org: the daily version check. With the check switched off, there were none. That was a hook fired by hand, not a real session.
Run a firewall that asks. A loop can miss a short connection. LuLu does this on a Mac, and OpenSnitch on Linux. We didn't run them.

If the model has to be local too

Claude runs on Anthropic's service or a cloud provider, so a fully local chat needs a different model. Counterparts is built for Claude, so it isn't part of this route.

Ollama documents ollama launch claude, which connects Claude Code to local or cloud models, while Anthropic's gateway page says it "doesn't support routing Claude Code to non-Claude models through any gateway". We tried neither.

These fit better, from their docs. We ran no real model, and LM Studio not at all:

Letta's local backend with Ollama or LM Studio. Its docs say agent state and the model endpoint stay on your machine.
LM Studio with a memory server. It "supports both local and remote MCP servers", and Basic Memory's README offers its tools to "any MCP client".

A launch post to read closely

A lead search result is Mem0's post on OpenMemory, a "private, local-first" server that "runs entirely on your machine". The post says of its store "Nothing goes to the cloud"; its setup says "Create the backend .env file with your OpenAI key". It doesn't say what that key sends. OpenMemory's archived code defaults both model and embeddings to OpenAI.

Mem0 removed OpenMemory from its repo in July 2026, saying it "has been sunset". Its server/ stack also defaults to OpenAI.

Questions people ask

If my memory tool stores data locally, does that mean nothing leaves my machine?

Not necessarily. "Local" usually describes where the store is; search and the model can run elsewhere. Mem0's open-source library, for example, keeps its store on your disk and by default uses OpenAI for both its model and its embeddings, by its own overview. Ask three things of any memory: where it stores, where it searches, and which model does the work.

Is there a local memory for Claude Code or Claude Desktop?

Counterparts, the memory we make, keeps the whole memory in one SQLite file under ~/.counterparts, readable by your account only, and runs search by meaning on a small model on your machine, with no API keys, no account and no server of ours. Claude writes the memories itself, in its own words, and keeps what matters. It runs with Claude Code on a Mac or Linux and with Claude Desktop on a Mac; the Quickstart sets up both. What a session reads goes to Anthropic, or the cloud provider you set, with your chat, as everything in a Claude session does.

Is Claude Desktop local?

The app and any local MCP servers run on your computer. Your chats don't stay there: Anthropic's retention article describes keeping them in its back-end storage. A local memory server, such as Counterparts (ours) on a Mac, keeps its store on your machine, and what Claude reads from it joins the chat.

Does Counterparts send my data anywhere?

Not to us: the local install has no Counterparts account or server, and the memory is one file on your machine, readable by your account only. Claude reads it in your sessions, and in a once-a-day background run on your own plan, so what it reads goes to Anthropic, or the cloud provider you set, as part of that Claude session. A daily check asks npm for the newest version number, carrying no memory, no conversation and no identifier, not even your version; the privacy page says how to turn it off.

Can an AI memory run completely offline?

Not with Claude: Claude runs on Anthropic's service or a cloud provider, so a Claude chat needs the network whatever memory you add. A fully offline setup needs a local model. Letta's local backend with Ollama or LM Studio is documented to keep both the agent state and the model endpoint on your machine. Basic Memory's README offers its tools to any MCP client, and LM Studio supports MCP servers. We ran no real local model.

How do I block the network for one MCP server?

Use a per-program firewall, such as LuLu on a Mac or OpenSnitch on Linux. The program is often bun, node or python, and LuLu says a decision "applies to the entire program" by default, so a block there would cut off every server and hook that runtime runs. OpenSnitch rules can match the full command line, which can single one server out. We ran neither. Claude Code's own sandbox "covers shell commands only", by its docs.

Questions? Ask in r/AIMemorySystems.

References

Claude Code: Memory, Data usage, Network, Hooks, MCP, Sandboxing, Gateways, Environment variables. Anthropic: Data retention
Counterparts: README, Quickstart, Claude Code page, Privacy
claude-mem: README, Installation, Configuration, Cloud sync, Telemetry, OpenAI-compatible
Basic Memory: README, Semantic search
Cognee: README, Local setup, LLM providers
Mem0: Overview, Ollama LLM, Ollama embedder, Plugin, telemetry, OpenMemory post
Supermemory: Self-hosting
Letta: Self-hosting, Models, MemFS, README, telemetry
Graphiti: README
Firewalls: LuLu, OpenSnitch rules