---
title: Give Claude Desktop a memory of your work
description: Minne's brain doubles as a read-only MCP server. Claude Desktop, or any MCP client, can search and read a memory of your work that lives as markdown on your Mac.
---


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:

| Tool | What it does |
| --- | --- |
| `search_memory` | Search the wiki pages and the raw captures. Words are ANDed and matched whole; end a word with `*` for a prefix. |
| `read_page` | Read one file of the memory in full — `wiki/oslo-trip.md`, `index.md`, or a `sources/…` citation. |
| `list_index` | The map of the wiki: `index.md` plus every page with its type, summary and last update. |

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:

```json
{
  "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](https://docs.minne.sh/guides/mcp)
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](https://docs.minne.sh/privacy) 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?](/what-is-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](/second-brain).
Minne is [free and open source](https://github.com/mandgie/minne); the server
is a few hundred lines you can read.