Built for us. Shared with everyone who works like us.

_{Click the preview to watch the full-resolution demo.}

Mnemify is open-source AI context infrastructure. It turns everything you've worked on — notes, wikis, tickets, meeting transcripts — into one local, persistent knowledge map that you and your AI tools can explore, query and cite. Notion, Confluence and Obsidian ship today; Jira, Slack, Gmail and Google Meet notes are already built and landing next.

git clone https://github.com/mnemify-ai/mnemify && cd mnemify && sh setup.sh

Why we built it

Most of the people are using multiple notetaking apps, we have been using Obisidan, Notion, Google notetaking app, notepad, Confluence and so on all for different reasons. We decided to create a platform for us to put all the notes together in one space.

Mnemify brings everything meetings, personal notes, work notes, tickets into one space that runs locally on our own machines, with your personal AI support on top: a 3D map to explore it, a chat that answers from it and cites its sources, and compact context we can hand to any other AI tool. Nothing leaves the machine, and nothing is written back to the sources.

We have been using it ourselves every day for several months, found it genuinely useful, and decided to share it.

How it works

Mnemify is AI context infrastructure: a portable, persistent knowledge graph built from the tools you already work in. It runs in three tiers:

1. Harvest — pull your notes and wikis from Notion, Confluence, and Obsidian into native formats, deduplicated by content hash. Deterministic; no LLM.
2. Compile — chunk, tag, semantically cluster, and lay out the harvested content into an emergent terrain: regions and peaks are based on embedding proximity, not a fixed folder taxonomy.
3. Surface — a FastAPI server + a React app: a 3D hex map of everything you've worked on, source-grounded attention signals, chat over the compiled terrain graph, and JSON artifacts downstream AI clients can use as compact context.

Everything Mnemify generates lives in one folder on your machine, outside this repo. Nothing is written back to your sources.

Features

• Three connectors — Notion, Confluence, and Obsidian.
• 3D knowledge map — an emergent hex terrain where regions and peaks come from embedding similarity.
• Chat over your map — grounded answers that start from regions, topics, and entities, and cite the exact source passages they used.
• Attention signals — todos, risks, decisions, open questions, and owners pulled from your content, rolled into an urgency score per region and shown in the Burning overlay.
• Action items — every open todo across all sources is clustered into one list, bucketed by deadline against today's date.
• What changed — documents harvested or deleted since your last compile, so you always know what the map doesn't know yet.
• Documents browser — search and filter everything harvested, open the clean-markdown version, and view attachments in place.
• Schedules — daily updates on your documents, so your map stays fresh without you remembering to run anything.
• Bring your own model — OpenAI, a Claude subscription through the claude CLI, or a fully offline local mode; embeddings from OpenAI or an on-device model.
• Local-first — all data and keys stay in one folder on your machine; nothing is ever written back to your sources.
• Data retention — auto-purge of old raw documents and a type-to-confirm full reset, both under Settings → Data.
• Audit log — a paginated record of every harvest event, so you can see exactly what was fetched and when.
• Runs itself — starts from a desktop icon, stops after 30 idle minutes, and updates by re-running setup.

---

Install

Setup installs uv for you if it's missing, and uv brings its own Python 3.11+. Node.js 18+ is only needed if you build the web app yourself (clone or main.zip); the release download ships it prebuilt.

Setup installs the backend, builds the web app (or uses the prebuilt one from a release ZIP), creates a Mnemify icon (macOS: ~/Applications, so Launchpad and Spotlight find it; Linux: your app menu; Windows: Start Menu), asks whether to add one to your Desktop too (macOS and Windows), and opens the app on http://127.0.0.1:8783. The first run needs an internet connection to download the Python packages.

On macOS, the first time you open the Mnemify icon, macOS may ask to let Mnemify access the folder you installed it in (Documents, Desktop or Downloads). Click Allow: Mnemify runs from that folder. If you clicked Don't Allow, turn it back on under System Settings → Privacy & Security → Files & Folders → Mnemify.

On Windows, double-clicking setup.bat is fine. It runs PowerShell with -ExecutionPolicy Bypass for that one process only — nothing in your system settings is read or changed.

Start and stop

Click the Mnemify icon, or run sh mnemify.sh (Windows: mnemify.bat) from the repo folder. If it's already running, it just opens the browser again.

Mnemify stops itself after 30 idle minutes — change that, or quit it now, under Settings → General. From a terminal: cd backend && uv run mnemify stop.

Where your data lives

Your harvested documents, the compiled map, your settings and your keys live in one per-user folder outside this repo:

To put it somewhere else, set the MNEMIFY_HOME environment variable before launching. It must be set in every shell (or shortcut) that starts Mnemify, so add it to your shell profile:

# macOS / Linux — e.g. in ~/.zshrc or ~/.bashrc
export MNEMIFY_HOME="$HOME/mnemify-data"

# Windows (PowerShell) — persists for your user account
[Environment]::SetEnvironmentVariable("MNEMIFY_HOME", "D:\mnemify-data", "User")

The folder is created on first launch. The repo folder holds nothing but code: deleting it, replacing it with a fresh download, or moving it never touches your data.

Updating

1. Get the new code — unzip a newer release over the folder, git pull, or unzip a fresh main.zip.
2. Run sh setup.sh again (Windows: setup.bat).

That's the whole update story. Setup is idempotent, and your data lives elsewhere, so nothing is lost.

Connect your sources

Open Build → Sources. Mnemify harvests Notion, Confluence, and Obsidian, and each connect wizard walks you through pasting a token, validating it, and choosing what to harvest:

• Notion — an internal integration token, shared with the pages you want.
• Confluence — your Atlassian email plus an API token.
• Obsidian — the path to your vault. No token at all.
• More will be added soon.

Nothing here needs a file edited. Tokens are written to your data folder, readable only by you, and never to the repo.

Then run a harvest, then a compile, and the home page turns into a living map of everything you've worked on. (Until you compile, it shows the connect → harvest → compile onboarding screen.) How long it takes depends on the size of your sources and on API latency more than on your hardware: our own first run over ~700 Confluence pages harvested in about 1.5 minutes and compiled in about 6.5 minutes with OpenAI. After that results are cached and later runs are much faster.

AI models

The Compile step and Chat need a language model. You have three options, and Mnemify picks up whichever you have. Set keys under Settings → AI & Models:

• OpenAI (recommended) — set OPENAI_API_KEY. This is the default mode and the one we run day to day. Also provides the embeddings (multilingual, best map quality). Cost is small: our first compile of ~700 Confluence pages used about 1.8M input and 0.4M output tokens, roughly $0.40 at current gpt-6-luna list prices (under $1 on the previous gpt-5.6-luna), plus a few cents of embeddings. Recompiles reuse cached results and cost a fraction of that. Local mode is free.
• Claude Code — if the claude CLI is installed and logged in, Mnemify detects it automatically and can use your Claude subscription for compile and chat, no API key needed. An Anthropic API key (ANTHROPIC_API_KEY) works too. Anthropic has no embeddings API, so with no OpenAI key Mnemify asks before your first compile whether to run a small embedding model on your computer instead (a one-time ~67 MB download, English-only, regions group a little more coarsely).
• Local — compiles deterministically with no key and no network. Good for a first look; the map is much better with a real model.

Embeddings (what groups notes into regions) come from OpenAI when an OPENAI_API_KEY is set, and otherwise from the on-device model once you agree to the download. Switch between them any time under Settings → AI & Models → Embedding model; a change takes effect on the next recompile from scratch.

What it does (and doesn't)

Mnemify is read-only. It never edits Notion, Confluence, or any other source, and it never creates tasks or writes comments back. Your source pages stay the system of record; Mnemify is the map on top of them.

On top of the semantic map, Mnemify pulls out attention signals straight from your content — todos, risks, decisions, open questions, owners, and recent changes — and rolls them up into an urgency score for every region and topic. Flip the map into the Burning overlay and the same terrain is tinted by what needs attention, without the geography changing under you. Clicking a region or tag shows its summary, active documents, and every signal behind it, each linked back to the source page.

Chat works over the compiled map rather than over raw documents: it starts from regions, topics, entities, and attention signals, then cites only the source passages it needs to ground an answer. That keeps context small and fast, and it's the same compact context Mnemify can hand to your other AI tools.

Coming next

• You decide the regions — pin, rename, split, or merge regions and have the compiler respect your structure, not only HDBSCAN's.
• Real World map — project your knowledge onto cities, districts, and streets, and explore documents street-view style.
• Sync between sources — push selected information from one source to another, e.g. a Notion decision into a Confluence page.
• More connectors — Jira, Slack, Gmail, and Google Meet Notes are built and tested; they ship once the wizards are polished.

---

Contributing

Issues and pull requests are welcome. AGENTS.md is the orientation guide for anyone working on the code, and each package has its own README (backend/, frontend/) with setup, commands, and tests.

License

MIT — open source. Use it at work, modify it, redistribute it, and build products on top of it. Just keep the copyright notice.