Don't trust us.
Check.
Every privacy page asks for your trust. This one would rather you didn't need to give it. Here is exactly what Memrith talks to over the network — and three ways to confirm it yourself, no code required.
Your entries, memory, and conversations only ever go to the AI provider you choose, in the messages you send, authenticated with your own key. The only things that talk to Memrith and its payment provider are a license check (Polar), a signed-entitlement and version check (memrith.com), and — if you opt in — crash reports. You can verify all of it from your side of the wire.
We could tell you nothing leaves your device. Instead we'll show you how to prove what does.
We won't claim “nothing ever leaves your machine,” because in cloud mode that would be false: your message goes to the AI provider you picked, and the app checks for a license and an update. A skeptic running a network monitor would catch the overstatement in a minute. So instead of a slogan, here is the precise picture — and the tools to confirm it.
Verify it yourself in a few minutes
You don't have to read our code or take our word for it. Pick any of these.
Watch your network
Turn on a network monitor — Little Snitch, your operating system's built-in firewall, or Wireshark — and use Memrith normally while you watch what it connects to.
In local mode you'll see only
localhost. In cloud mode you'll
see your AI provider's address, a license check to api.polar.sh,
and an entitlement and version check to memrith.com — and no
endpoint receiving your memory. If we were quietly shipping your data
somewhere, this is where it would show up. It doesn't. The full list is
in the table below.
Cross-check your own provider dashboard
Because you bring your own key, every request Memrith makes to the AI shows up in your account — your Anthropic or OpenAI usage page lists it.
That's third-party-verifiable proof, from a company that isn't us, of exactly what got sent and when. It's also proof of the inverse: the conversation went straight from your device to your provider on your key, so Memrith was never in a position to see it.
Open your data folder
Your memory is plain JSON and Markdown in a folder on your disk. Open it in any text editor and read it — the entries, the conversations, the memories — exactly as they're stored.
There's no encrypted blob phoning home and no second copy syncing to a server, because there is no server holding your data. What's on your disk is the whole of it.
And if you do read code: Memrith's backend is a Python package, and the handful of files that make any network call are small and named for what they do. The full walkthrough — including which files — is on the Architecture page. But the three checks above need none of that.
The strongest proof: pull the cable
Point Memrith at an AI model running on your own machine — Ollama,
llama.cpp, or LM Studio — and the chat call goes to localhost.
Embeddings and semantic search already run entirely on-device. So does the
model.
Which means you can do the one test no cloud-only tool can survive: unplug your ethernet cable, turn off Wi-Fi, and keep working. Memrith still reads your memory, still answers, still saves. Nothing is leaving, because there's nowhere for it to go.
No app that routes your thinking through someone else's servers can make that offer. This one can.
Everything that does talk to us, openly
Disclosing the boring stuff is what makes the rest credible. Here is the complete list of network calls Memrith makes — and, for each, what it can and can't see. A network monitor will show you five external hosts. These are all five; there is no sixth.
| What it talks to | Why | Does it ever see your memory? |
|---|---|---|
| Your AI provider (or localhost) |
Your chat, plus the relevant memory context, sent straight from your device on your key — to api.anthropic.com, api.openai.com, or openrouter.ai. In local mode it goes to localhost and nothing leaves at all. |
This is the one thing you choose to send your text to. Memrith has no server in this path. |
| Polar ( api.polar.sh) |
Validates your license key. Polar is Memrith's payments provider, and the app checks your key against Polar directly. It carries your license key and nothing else. | Not your entries, memory, or conversations. |
| memrith.com ( www.memrith.com) |
Two things: after the license check it issues your signed entitlement (/api/entitlement), and it serves the roughly-daily version check (/releases/latest.json). Neither sends anything identifying. |
Not your entries, memory, or conversations. |
| sentry.io | Crash reports — off by default, opt-in only, and only present if it was built into your copy. When on, it sends PII-scrubbed exception and stack traces so bugs can be fixed. | Not your memory, conversations, or keys. |
| HuggingFace ( huggingface.co, first run only) |
A one-time, ~130 MB download of the on-device embedding model. The model comes to you; it then runs locally for all semantic search. | Nothing goes out — this is a download, not an upload. |
For the record: embeddings and semantic search run entirely on your machine,
using a small on-device model (bge-small). There is no cloud
embedding service in the loop. Your data lives as plain JSON and Markdown in
a folder on your disk — there's no Memrith account and no cloud sync — and
both updates and your license are verified with Ed25519 signatures, so the
app refuses anything we didn't sign.
Why there's no catch
The usual reason an app harvests data is that the data is the business — ads, resale, a profile to monetize. Memrith is a one-time purchase: no subscription, no ads, no data product. There's no reason to collect your memory and no infrastructure built to receive it — and because you bring your own key, your provider's dashboard can confirm, independently of us, that we don't see your conversations.
Want the full technical walkthrough? Exactly what's stored where on disk, how the signing chain works, and the source files behind every claim here live on the Architecture page. This page is the short version you can verify yourself; that one is the complete map.
Common questions
Does Memrith send my data anywhere?
Your entries, memory, and conversations only ever go to the AI provider you choose, in the messages you send — straight from your device, authenticated with your own key. Memrith has no server in that path. The only other things that talk over the network are a license check to Polar (Memrith's payments provider), a signed-entitlement and roughly-daily version check to memrith.com, a one-time first-run model download from HuggingFace, and — if you opt in — crash reports. None of those carry your content. In local mode, your chat stays on the device too.
How can I verify that for myself?
Three ways, no code required. Run a network monitor (Little Snitch, your OS firewall, or Wireshark) and watch what Memrith actually connects to. Cross-check your own AI provider's dashboard — with bring-your-own-key, your usage shows up in your Anthropic or OpenAI account, which is third-party proof of exactly what was sent. And open your data folder: it's plain JSON and Markdown you can read, with no hidden cloud copy because there is no cloud.
Can I run Memrith fully offline?
Yes. Point Memrith at a local AI server — Ollama, llama.cpp, or LM Studio — and the chat call goes to localhost. Embeddings and semantic search already run entirely on your device. In that setup you can disconnect from the internet and Memrith still works, which is the clearest possible proof that nothing is leaving.
What exactly does talk to Memrith's servers?
Two things, both disclosed. After your license key is validated against Polar (Memrith's payments provider, at api.polar.sh), memrith.com issues your signed entitlement. And memrith.com serves a roughly-daily update check, which fetches the signed release manifest and sends nothing identifying. Never your entries, memory, or conversations.
Does Memrith collect crash reports?
Only if you opt in, and only if crash reporting was built into your copy. It is off by default. When on, it sends PII-scrubbed exception and stack traces to help fix bugs — never your memory, conversations, or keys.
Why should I believe you have no reason to harvest my data?
Memrith is a one-time purchase. There is no subscription, no ads, and no data product. We have no business reason to collect your memory and no infrastructure built to receive it — and because you bring your own key, your provider's dashboard can prove independently that we don't see your conversations.