Your best ideas are scattered across a dozen places right now. Notes apps. Browser tabs. Old chats with Claude that you closed and will never find again. Every time you sit down to work, you rebuild context from memory, and you forget most of it.
A second brain fixes that. It is one place that holds everything you know, with Claude sitting on top of it, reading it, connecting it, and growing it for you. You stop re-explaining yourself every session, because the system already remembers. Ask it anything you have ever written down and it answers from the whole thing.
This is the idea Andrej Karpathy popularized in April 2026 with his LLM Wiki pattern. The setup takes an evening, and unlike a chat history that rots, this one gets sharper every single day you use it.
Below is the full walkthrough, written so you can follow it even if you have never opened Claude Code or MentisDB before. Every step spells out exactly what to run and what to type.
Two tools, two jobs — but a better division of labor than the old Obsidian pattern.
MentisDB is the storage. A durable semantic memory engine that runs as a daemon on your own machine. It stores typed thoughts — Decisions, Lessons, Constraints, Corrections, Summaries — in an append-only, hash-chained log. Thoughts link to each other with typed relations (CausedBy, Corrects, Supersedes, DerivedFrom), and over time those links form a graph, a visible map of how your ideas connect. It lives on your machine, not in a company's cloud, and the chain is yours forever.
Claude is the brain on top. It searches the chain, appends new memories where they belong, links them to what is already there, and answers questions across all of it.
Here is where it already pulls ahead of Obsidian: Obsidian is a notes app for humans that you bolt onto an agent with a community REST plugin. MentisDB is a memory engine for agents — it speaks MCP natively, retrieves by semantic ranked search instead of re-reading files, and structures every memory with a type and a role so the agent can reason about what kind of memory it is, not just that it exists.
The whole thing is an append-only chain. That means it is not locked to any one AI. Point a different model at it next year and it still works, because you own the brain, not the tool. And unlike a folder of editable markdown files, nothing in the chain can be silently overwritten or deleted — not by you, not by a misbehaving agent.
Go to claude.com/download in your browser and download the desktop app for your system (Windows or Mac). Run the installer and open the app.
Sign in with your Claude account. You need a paid plan (Pro is $20/month), the free tier will not work for this.
At the top of the app you will see tabs: Chat, Cowork, and Code. Click the Code tab. This is Claude Code, the version that can actually call external tools. If it asks you to upgrade, your plan needs to be paid first.
Install Rust if you don't have it, then install the MentisDB daemon with local semantic embeddings:
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
source "$HOME/.cargo/env"
cargo install mentisdb --features local-embeddingsThe local-embeddings feature gives MentisDB a built-in ONNX embedding model for real semantic vector search — no API key, no cloud, it runs on your CPU. This is the first structural advantage over Obsidian: Obsidian has no search of its own. It relies on the agent opening and re-reading files. MentisDB runs ranked semantic search over the whole chain and returns the right few memories, even when you describe them with different words.
Start the daemon:
mentisdbIt boots a local server (default port 9471) with MCP, REST, and a dashboard built in. That folder is now your second brain's home. Everything Claude writes will land here as typed, hash-chained thoughts.
Run the setup wizard to wire it to your tools in one shot:
mentisdb wizardHere is a step the Obsidian guide needs and you do not: turn on a community REST API plugin inside Obsidian, copy an API key, keep the Obsidian desktop app running at all times or the door closes. MentisDB is a daemon — it is always on, no GUI app to babysit, no third-party plugin to trust with your data.
Tell Claude how to reach it. In the Claude Code tab, run:
claude mcp add --transport http mentisdb http://127.0.0.1:9471No API key to paste. No Bearer prefix to strip. This wires Claude to your chain through MCP, the standard way Claude talks to other services. After it runs, type this to test it: "search my memory for anything about my goals." If Claude searches the chain and comes back empty (or with your first thought), the connection works.
Right now Claude can search your chain but knows nothing about you. An empty brain is useless. Fix that first, and don't type it all out by hand. Make Claude interview you — and write the answers as typed memories, not a flat CLAUDE.md file.
Paste this:
You are setting up my second brain in MentisDB. Interview me ONE question at a time to build my profile. Ask about: who I am and what I do, my goals for this year, how I want you to talk to me, my strengths and weaknesses, and my current projects. Wait for each answer before the next question. When finished, append each answer as the correct thought type —
Decisionfor goals,Constraintfor how you should treat me,Summarywith roleCheckpointfor the profile overview — and link them withDerivedFromrelations. Then write aSummarythought that I can reload every session viamentisdb_recent_context.
Answer like you're briefing a new co-founder. The more real your answers, the more the brain knows you.
Why this beats a CLAUDE.md file: a markdown file is a blob the agent re-reads in full every session, growing slower as it grows. Typed memories are individually searchable, individually linkable, and individually retrievable. When you ask "what did I decide about my Q3 focus?", MentisDB returns that one Decision — not a 400-line profile file.
Your profile thoughts are the strategy layer. Projects are where work happens. In Obsidian, a project is a folder of files. In MentisDB, a project is an entity type (or its own branch chain) — which means the agent filters to it in a single query instead of you manually opening a sub-folder as a separate vault.
Have Claude build it. Paste:
Create a project in my chain with entity type
youtube-channel. Register the entity type withmentisdb_upsert_entity_type. Then append aDecisionthought describing what this project is, its one goal, and your specific role in helping me hit it. Interview me if you need details. Tag everything for this project withyoutube-channel.
Swap youtube-channel for whatever you're building. You now have a clean pipeline scoped by entity type: ideas land as Question/Hypothesis, work produces Decision/Insight, finished work is a TaskComplete, and results go in as Summary with feedback tags. Repeat this for every area — content, finances, clients.
The Obsidian guide tells you to physically reopen a sub-folder as a separate vault so Claude "sees only that job." That is a workaround for a storage layer with no notion of scope.
MentisDB handles this natively. To focus on one project, you (or Claude) simply filter searches by entity_type: "youtube-channel" or by tag. No vault switching, no lost context, no re-trusting folders. The big chain plans. A single project ships. And when you do want isolation — say a risky experiment you don't want polluting the main chain — you branch:
mentisdb chains branch --from <thought-id> --key youtube-experimentThe branch is born with a BranchesFrom relation. Searches on the branch transparently include ancestor-chain results. When the experiment works, merge it back. Obsidian has no equivalent — you'd be copying folders and hoping you don't lose links.
A skill is a saved workflow Claude runs on command. The Obsidian guide has you save these as markdown files in a skills/ folder. MentisDB ships a versioned skill registry — git for agent behavior, built in.
Inside a project, paste:
I want to turn this into a reusable skill. Here is how I do [the task], with an example: [paste your example or steps]. Upload this as a skill to the MentisDB skill registry with
mentisdb_upload_skill, with a clear name and a description of when to trigger it.
Next time, you just say run the [name] skill and it executes your way, instantly.
What you get over a folder of markdown: every upload to an existing skill creates a new immutable version (stored as a unified diff). Any historical version is reconstructable. Skills can be deprecated or revoked while full audit history is preserved. If you register an Ed25519 key for your agent, uploads are cryptographically signed — provenance is verifiable, not assumed. A skill checked in at the start of a project is better by the end of it, and you can prove who changed it and when.
Static memory is half the brain. Connect what changes in real time. To add Google Calendar, run this in the Claude Code terminal:
claude mcp add google-workspace uvx workspace-mcp --tools calendarFollow the Google sign-in (OAuth) it opens, and grant read access. Now you can say:
Read my calendar for today, append each meeting's commitments to my tasks project as
Decisionthoughts with entity typetasks, and flag anything without a clear next step as aQuestion.
Add Gmail, Slack, or Notion the same way. The live data lands as typed thoughts with provenance, not loose text files — which means it's searchable, linkable, and summarizable alongside everything else.
One rule you never break: keys, not prompts. The Obsidian guide says the same thing, but with Obsidian it's a hope — the agent technically can delete any file. With MentisDB it's a guarantee: the chain is append-only. No agent, no prompt, no accident can overwrite or delete a thought. The worst case is a bad append, which you can Correct with a typed relation that links back to the mistake. Integrity is structural, not linguistic.
Once your skills work, schedule them so the brain maintains itself. In Claude Desktop, open the Schedule tab in the sidebar, click + New task, and fill in:
Frequency: Daily, 7:00am
Prompt: Search my chain for thoughts appended in the last 24h.
Append a Summary with role Checkpoint covering what changed.
Flag any Question thoughts that are still unresolved.
Suggest any LessonLearned that should be promoted from recent work.
Or just tell Claude in any session: set up a daily task at 7am that summarizes what changed in my memory chain overnight.
Here's the quiet advantage: the Obsidian version schedules a daily reorganization — filing stray notes, linking orphans, cleaning up — because a folder of flat files drifts into entropy. MentisDB's structure prevents the entropy in the first place. Every thought is typed on insert. Every thought carries its relations. Near-duplicates auto-emit Supersedes when dedup is on. The brain doesn't need a nightly janitor because it was never messy.
If you would rather not wire it from scratch:
mentisdb wizardThe wizard discovers your installed AI tools, offers to configure MCP for each, boots the daemon, and opens the dashboard. One command, every integration. You can also target one explicitly:
mentisdb setup claude
mentisdb setup all --dry-run| Obsidian + MCP plugin | MentisDB | |
|---|---|---|
| Built for | Humans taking notes | Agents storing memory |
| Connection | Community REST plugin + API key, desktop app must stay open | Native MCP daemon, always on, no key |
| Storage | Editable markdown files | Append-only, hash-chained, tamper-evident |
| Structure | [[wikilinks]] (untyped) |
Typed thoughts + typed relations (CausedBy, Corrects, Supersedes…) |
| Retrieval | Agent re-reads files / keyword grep | Ranked semantic search w/ thesaurus, context bundles, federated cross-chain |
| Scope | Manually reopen sub-folders as vaults | entity_type, tags, scopes (user/session/agent) — filter in one query |
| Isolation | Copy folders and pray | Branch chains with transparent ancestor search + merge |
| Skills | Markdown files in a folder | Versioned immutable registry, signed, deprecable, revocable |
| Multi-agent | One human, one agent, one vault | Agent registry, per-agent ownership, fleet orchestration on one chain |
| Self-maintenance | Schedule a nightly reorg job | Typed-on-insert + auto-dedup — never messy to begin with |
| Integrity | "Don't delete this" (a suggestion) | Structurally cannot delete — append-only by design |
| Portability | Plain text (good) | Plain chain + crate + MCP + REST + CLI (better) |
Obsidian is a superb tool for reading your own notes. MentisDB is a memory engine for an agent that reads, reasons, and writes on your behalf. The second-brain pattern is fundamentally an agent task — so the storage layer should be agent-native.
Before this, Claude forgets you the moment you close the tab. Every session starts cold. You are the one holding all the context, and you lose most of it.
After this, Claude has a durable, typed, hash-chained memory of your entire life and work. A chain that holds everything, a model that picks up exactly where it left off via mentisdb_recent_context, a graph that grows itself while you sleep. All append-only. All yours. All running on whatever model you point at it.
Same subscription. Completely different machine.
You are not building a Claude setup. You are building your own memory, and it gets smarter every day you feed it.
Almost nobody does this. Most people will read all the steps and build nothing.
The ones who start today will search their chain in a month and freeze, because it knows things they had forgotten they knew. And they will never go back to a blank chat box again.