Using MCP as Your Second Brain

Using MCP as your second brain means keeping your notes in one place and putting a Model Context Protocol server in front of them, so any AI client — Claude, ChatGPT, Cursor — can search, read, and write those notes on demand. The simplest way to run this pattern is Hjarni, a knowledge base with a built-in MCP server.

A second brain used to be a thing you maintained for future you to reread. That version mostly turned into a graveyard, for reasons covered in the AI-native take on the second brain. This post is about the version that works now: not a folder you reread, but a store your AI reads for you — and the protocol that makes that boring and standard is MCP.

The rest of this is the pattern in detail: what "MCP second brain" actually means, why MCP is the right substrate for it, a reference architecture you can copy, the loop it runs on day to day, and where it isn't the right tool.

What "using MCP as your second brain" means

The pattern has exactly three parts.

A store. Your notes, in Markdown, organized into a handful of folders with a few tags. Decisions and why you made them, project context, research you don't want to redo, the things you re-explain every week. This is the brain.

An MCP server in front of the store. MCP is an open protocol — introduced by Anthropic in late 2024, now adopted across the major AI clients — that lets an AI assistant call external tools through one uniform interface. An MCP server in front of your notes exposes a small set of tools: search the notes, read one, create one, update one, list folders and tags. The assistant calls those tools the way a browser fetches a URL.

An MCP client as the reader and writer. Claude, ChatGPT, Cursor, Copilot, or any other MCP-capable client connects to the server once and from then on can reach your notes mid-conversation. It searches when it needs context. It writes a note back when a conversation produces something worth keeping.

Put together: you stop pasting context into chat windows. The assistant fetches what it needs from your brain and writes new knowledge back into it. The store is the source of truth; the chat is just the place you happen to be talking.

The important word is protocol. Because MCP is a standard rather than one app's feature, the same store serves every client at once. That is the whole difference between "a notes app with an AI button" and "a second brain your AI reads."

Why MCP is the right substrate for a second brain

There are several other common ways to give an AI memory. Each works; each gives something up that MCP keeps. The full survey is in the best ways to give your AI memory — the short version of why MCP wins for a brain:

One store, every client. Built-in memory in ChatGPT lives in ChatGPT. A Claude Project lives in Claude. A Custom GPT's knowledge lives in that GPT. MCP is client-agnostic by design, so one knowledge base is read and written by Claude, ChatGPT, Cursor, and whatever you use next year. You are not re-keying your context into each new app. Write a note in Claude, read it in ChatGPT — that cross-client case is the point of one knowledge base for ChatGPT and Claude.

Read and write, not just retrieve. A retrieval-only system can answer from your notes. An MCP server with write tools lets the assistant add to the brain — capture a decision, file a research summary, update a stale note — so the brain compounds instead of going stale.

Human-readable, not a black box. Built-in memory and most "memory API" products store extracted fragments you can't fully see. An MCP second brain stores the actual notes. You can open them, fix a wrong one, and reorganize them yourself. Memory you can read is memory you can trust.

Nothing to build. The do-it-yourself alternative is a RAG pipeline: chunk your documents, embed them, stand up a vector database, write a retrieval layer, keep it in sync. That is real engineering, and it locks the result to whatever app you wired it into. A hosted MCP server replaces all of it with one URL. (If you want the RAG background, what is RAG covers it; the practical point is that you no longer have to assemble that stack yourself.)

MCP doesn't make the idea of a second brain new. People have wanted external memory since the memex. MCP makes the plumbing standard, which is what finally makes the idea boring enough to actually keep using.

The reference architecture

This is the part to copy. A second brain over MCP doesn't need a beautiful taxonomy — the assistant searches, it doesn't browse your folders. It needs enough structure that retrieval is reliable and write-back has an obvious home. Here is the reference layout.

/About me
  - Profile            (who you are, how you work, preferences)
  - Current goals

/Projects
  /Project A
    - Overview
    - Decisions        (each decision + the reasoning behind it)
    - Open questions

/Knowledge
  - Sources            (articles, papers, links + your takeaways)
  - Topics             (synthesized notes that outlive any one source)

/Log
  - Changelog          (what changed, dated; the brain's running history)

Four choices make this layout work as an AI second brain, each deliberate rather than decorative — and agent-legible knowledge is the deeper essay on why these properties matter:

Flat enough to search, structured enough to file. A few folders, not a deep container hierarchy — they exist so the assistant knows where to put a new note, while cross-cutting tags do the rest of the filing.

Every note carries a one-line summary. It's what search ranks on and what the assistant reads first; a note without one is a note the brain half-forgets.

Notes link to each other. Wiki-links let the assistant traverse from a note to its neighbors instead of guessing, turning a pile of notes into a graph it can walk.

Instructions travel with the folders. Per-folder AI instructions are plain-language rules the assistant applies when it writes — "in /Knowledge, write a two-sentence summary and tag by topic" — so you set the conventions once instead of restating them every session.

You don't have to build this by hand. The Knowledge Wiki template ships exactly this shape — sources, topics, open questions, a changelog, and the AI instructions for each folder. Paste the link into Claude or ChatGPT and it creates the structure for you. If you'd rather assemble it yourself with a client connected, the step-by-step is how to build an LLM wiki with Claude or ChatGPT; this section is the schema that guide builds toward.

The loop it runs on

A second brain over MCP isn't a project you finish. It's a loop you run, mostly without noticing. Four moves:

Capture cheaply. When you read, decide, or learn something you'll want later, it lands as a note. No formatting tax — a title, a body, a one-line summary is enough. Often you just tell the assistant: "save the useful part of this as a note in /Knowledge."

Retrieve on demand. In any conversation, the assistant searches the brain for what's relevant and answers in context. You stop re-explaining your stack, your project, your last decision. It already has them, through long-term memory over MCP.

Write back. When a conversation produces something durable — a conclusion, a plan, a decision and its reasoning — you have the assistant write it back as a new note or an update to an existing one. The brain grows out of the work you were already doing.

Let the assistant do the upkeep. Because the filing rules live on the folders, whenever the assistant writes a note it tags, summarizes, links, and files it the way you specified — you don't restate the conventions each session. The rereading and upkeep that killed human-run second brains is the part a model does cheaply and without fatigue, the point Karpathy's LLM wiki makes about wikis generally.

Run that loop for a few weeks and the assistant stops needing you to set the scene: it pulls the relevant decision, project state, or source from the brain before it answers, because it has been reading the same notes you have.

What it replaces

An MCP second brain sits where several other tools try to sit. Here's the honest split.

The workspace comparison is the one people weigh most. Notion is a great place for humans to build pages and databases; it is not a knowledge base an external assistant reads and writes over an open protocol. That split — workspace vs. AI-readable brain — is the whole of Hjarni vs Notion. For the broader field of dedicated memory servers, the best MCP memory servers compares the document-style brains against the extraction-style memory APIs.

Where it isn't the right tool

Honest limits, because a reference should state them.

• You want zero capture effort. An MCP second brain rewards a little deliberate writing — you or the assistant decide what's worth keeping. If you want memory that silently mines every conversation with no input from you, built-in memory or an extraction memory API fits better.
• You need a full workspace. Databases, kanban boards, dashboards, docs wikis for a whole org. That's Notion's job. A second brain is a focused knowledge layer, not a workspace.
• You require fully local, offline files. A hosted MCP server needs a connection. If notes-on-disk and offline access are non-negotiable, a local-first setup (plain Markdown plus a local MCP server) is the better pick — at the cost of the everywhere-and-every-client property that makes the hosted version compound.

If none of those are dealbreakers, the MCP second brain is the version that keeps working past month three.

Hjarni as the reference implementation

The pattern is tool-agnostic — anything that puts an MCP server in front of readable notes qualifies. Hjarni is the reference implementation of it: a hosted Markdown knowledge base with the MCP server built in, so there's nothing to assemble.

Concretely, Hjarni is the architecture above, shipped:

• Markdown notes, folders (containers), tags, and wiki-links — the reference layout, native.
• A built-in MCP server at hjarni.com/mcp. One URL connects Claude, ChatGPT, Cursor, Copilot, or any MCP client.
• Per-folder AI instructions so the assistant files new notes to your standard.
• Read and write tools, so any connected assistant captures back into the brain, not just reads from it.
• Notes you can export as Markdown anytime — it's your brain, not a lock-in.

If you're building memory into agents rather than chatting with an assistant, the same store works there too; the agent-facing version of this pattern is a knowledge base for AI agents.

The fastest way to see it is to run the loop once. Create a free account, write one note about a project you're tired of re-explaining, connect it to Claude or ChatGPT, and ask a question only your notes would know. Start here — the free tier includes full MCP access, no credit card.

Stop pasting your context into every chat. Put it in one place, point your AI at it over MCP, and let the brain do the remembering.