Give Claude Desktop a memory of your work

Minne remembers what you work on — as a wiki of plain markdown in ~/Minne, built from the text of the windows you use. The same binary that maintains that wiki can serve it, read-only, to any MCP client over local stdio. Add three lines to Claude Desktop's config and Claude can search your memory, read a page, and see the map of everything Minne knows — without a server, without the network, and without you having told it anything.

Most MCP memory servers store what you told the assistant. Minne's stores what you did — and that is the context an assistant actually lacks.

Isn't there already a memory server for Claude?

Yes, several, and they are good at what they do: a knowledge graph or a database where the assistant saves facts it learned during a conversation, so the next conversation starts warm. The memory is dictated. It contains what you thought to say, in the sessions where you thought to say it.

Minne's memory is not dictated. It is built from the work — the threads you answered, the doc you were in at 15:40, the decision that landed on Thursday — distilled every half hour into pages about people, projects and topics, each citing the captures it came from. When Claude reads Oslo move, it reads a page nobody wrote by hand. The two kinds of memory are complementary, and you can run both; only one of them is filled without your attention.

What the client gets

Exactly the three tools Minne's own agents use to consult the memory, and none of the ones that change it:

The write tools are never exposed. A client may read this memory; only Minne changes it. Paths are contained to the memory root — traversal, absolute paths and symlinks pointing outward are refused.

Setting it up

Install Minne, let it build a memory for an hour or two, then add the server to ~/Library/Application Support/Claude/claude_desktop_config.json and restart Claude Desktop:

{
  "mcpServers": {
    "minne": {
      "command": "/Applications/Minne.app/Contents/MacOS/minne-brain",
      "args": ["--mcp"]
    }
  }
}

That is the whole setup. The path is the brain binary inside the installed app; if Minne lives somewhere other than /Applications, change it to match. A memory moved elsewhere with MINNE_MEMORY_ROOT is served by passing the same variable in an env block — the guide shows it.

Then ask Claude what it now knows: what did I promise Ingrid last week? Where does the retry-logic work stand? It will call search_memory, read the page, and answer with the citation Minne kept.

What leaves your Mac

Nothing, from the server. It listens on no port and sends nothing anywhere; it reads files and answers on stdio. This is, though, the one place where Minne's privacy story hands off to somebody else's: what the client does with the excerpts it reads is governed by that client. Connect Claude Desktop and the pages it reads travel wherever Claude Desktop sends them. Minne's own egress ledger stays exactly as short as it was; the client's is the client's.

Any other MCP client

Anything that speaks MCP over stdio works identically: run /Applications/Minne.app/Contents/MacOS/minne-brain with the single argument --mcp and talk JSON-RPC on its stdio. Without --mcp the binary speaks Minne's own app protocol instead — the two modes never mix.

The memory itself is described in what is a personal AI memory?, and the argument for keeping it as files you can open — the reason an MCP client can read it at all — in a second brain you never have to file. Minne is free and open source; the server is a few hundred lines you can read.

Free, open source, and yours to read. macOS 14 and later.