AutoGineer
Generated banner for MindBase — Karpathy's LLM Wiki, as a product
Generated logo for MindBase — Karpathy's LLM Wiki, as a product

MindBase — Karpathy's LLM Wiki, as a product

LLM wiki kit

First committed by frankchu91

Published in frankchu91/mindbase-llm-wiki. Publisher page

137 GitHub stars

What it is

Karpathy's LLM Wiki idea as a product — an AI that builds and maintains a markdown wiki from your notes and sources. MCP server + web UI, runs on free local models (Ollama), no API key needed. MIT.
— the description by frankchu91

Summary from the brain’s metadata

Karpathy's LLM Wiki idea as a product — an AI that builds and maintains a markdown wiki from your notes and sources. MCP server + web UI, runs on free local models (Ollama), no API key needed. MIT. One command: starts the local server, opens the web app, and walks you through picking a free local model that fits your RAM. No API key, nothing leaves your machine. (Node 20+)

How it works

Memory model: LLM wiki

AutoGineer overview, from the brain’s own files

Memory model: LLM wiki. Folders: .github (agent config, 2 files); docs (docs, 21 files); packages (source code, 185 files). The agent writes apps/browser-ext, apps/mcp.

Folders
FolderRoleFiles
.githubagent-config2
docsdocs21
packagessource-code185
.claude-pluginfolder1
appsfolder512
schemafolder5
websitefolder7

The agent writes

Requirements

Runtimes: Node.js

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Google Antigravity, Kiro, OpenCode, Amp, Roo Code, Cline, JetBrains Junie, Devin (ex-Windsurf)

Set it up

  1. This brain runs code automatically: 1 hook (claude-code). Review apps/plugin/hooks/hooks.json before opening the folder in Claude Code. No step below turns a hook on for you.

    • apps/plugin/hooks/hooks.json: ${CLAUDE_PLUGIN_ROOT}/hooks/session-start

  2. Clone the repository at the commit AutoGineer scanned:

    git clone https://github.com/frankchu91/mindbase-llm-wiki.git && cd mindbase-llm-wiki && git checkout c5273d2336c4d686df41c2a1495f14f085707f51

  3. Claude Code reads CLAUDE.md from this folder automatically.

  4. cd mindbase-llm-wiki && claude

  5. AutoGineer scanned these files at commit c5273d2.

  6. Not scanned by AutoGineerThe author’s README also describes installing it as a Claude Code plugin marketplace. Read its install section: AutoGineer did not scan that path. https://github.com/frankchu91/mindbase-llm-wiki/blob/c5273d2336c4d686df41c2a1495f14f085707f51/README.md#install
  7. Not scanned by AutoGineerIts dependencies are installed by npm when you run it and were not scanned by AutoGineer (7 declared). https://www.npmjs.com/package/mindbase-mcp

  8. First committed by frankchu91. Published in frankchu91/mindbase-llm-wiki. Licence: MIT License.

Usage

AutoGineer’s guidance for this type of brain

Put your raw sources in the kit’s folder and ask your agent to maintain the wiki from them: the agent writes the markdown pages and you read them.

Documentation by frankchu91

MindBase — Karpathy's LLM Wiki, as a product

Image: npm Image: npm downloads Image: CI Image: License: MIT Image: Website Image: Glama score

An open-source implementation of Andrej Karpathy's LLM Wiki idea: an AI that builds and maintains a wiki from your sources. Not RAG-in-a-vector-DB. A real markdown wiki on your disk, that an LLM gardens for you between conversations.

npx mindbase-app

One command: starts the local server, opens the web app, and walks you through picking a free local model that fits your RAM. No API key, nothing leaves your machine. (Node 20+)

<p align="center"> <img alt="Demo: /contribute in the MindBase web UI — the AI shows takeaways and a checkbox plan, and writes to the LLM wiki only after approval" src="docs/assets/contribute.gif" width="880"> </p>

MindBase implements Andrej Karpathy's LLM-Wiki pattern: you feed it sources (papers, articles, thoughts); the LLM reads, cross-references, flags contradictions, and writes structured wiki pages. Later, when you ask a question, the wiki already has the synthesized answer — no vector-search re-derivation at query time.

Status: Early access, actively developed. What's new: CHANGELOG · Releases

Why MindBase

You read a lot. Papers, articles, tweets, docs. You want to remember them, connect them, form opinions from them. Today you have two bad options:

  • Notion / Obsidian / Roam: Passive containers. You do all the organizing. AI features are bolted-on generation, not maintenance.

  • NotebookLM / Perplexity Pages / ChatGPT search: RAG-based. Nothing accumulates. Every question re-derives the answer from raw sources.

MindBase is the third option: the LLM actively maintains a persistent, structured wiki as you feed it sources. Knowledge compounds. Your context.md gets sharper every time you contribute. The AI remembers you across sessions because your beliefs are written down in markdown files — not stored in a chat history that gets summarized away.

Think of it as a personal Wikipedia that an AI intern writes for you, kept up to date, cross-referenced, and honest about what it doesn't know.

How it works (30 seconds)

Three physical layers on disk (Karpathy's model):

<p align="center"> <picture> <source media="(prefers-color-scheme: dark)" srcset="docs/assets/hero-dark.svg"> <img alt="MindBase: you feed sources, the LLM gardens them into a wiki that compounds — plain markdown on your disk" src="docs/assets/hero-light.svg" width="920"> </picture> </p>

LayerWho owns itWhat lives there
sources/You — append-only, the AI never rewrites itQuick captures, full notes, PDFs, URLs
context.md + sources/research/The AI — every change human-approvedThe maintained wiki: synthesis, concept pages, [[wikilinks]]
state/ · logs/ · artifacts/Derived — always rebuildableSearch index, snapshots, lint findings, op history

Three operations run the loop: ingest (AI reads a source, discusses takeaways, you approve the wiki updates), build (regenerate context.md from everything unbuilt), lint (the AI audits its own wiki for contradictions, stale claims, and orphans).

What makes it different

  • The AI asks before writing. Every ingest shows takeaways + a checkbox plan; only what you approve gets written. No black-box edits to your knowledge.

  • You can watch the wiki absorb your notes. Every note carries a status chip — ✨ Add to wiki until digested, ✓ In wiki after.

  • It audits its own knowledge. One command re-reads the whole wiki and reports contradictions with the exact conflicting sentences quoted. Notion and NotebookLM structurally cannot do this.

  • Free and local by default. Hardware-detect wizard installs the best Ollama model for your RAM. Cloud keys optional.

  • Plain markdown on disk. Grep it, git it, open it in Obsidian, leave anytime.

Install

Browser (fastest): npx mindbase-app — shown above. Everything runs locally at localhost:4321.

Claude Code (flagship): the full Karpathy 8-step ingest with sub-agents, slash commands, and per-agent tool boundaries:

/plugin marketplace add frankchu91/mindbase-llm-wiki
/plugin install mb@mindbase

Restart when prompted, then type / — you should see /mb:contribute, /mb:build, /mb:ask, /mb:lint and 8 more. You get 5 sub-agents with strict tool allowlists (the builder has no file-write tool at all — only an atomic-write MCP call), plus a SessionStart hook that auto-injects your project context.

<p align="center"> <img alt="The core flow in Claude Code: /mb:contribute with an arXiv link — download, archive, discuss takeaways, approve, commit" src="docs/assets/terminal-contribute.png" width="880"> </p>

<details> <summary><b>Cursor</b></summary>

Add to ~/.cursor/mcp.json:

{ "mcpServers": { "mindbase": { "command": "npx", "args": ["-y", "mindbase-mcp"] } } }

Restart Cursor — the tool picker should list mindbase_contribute and 48 others. Recommended: add a conventions block to ~/.cursor/rules.md so the LLM reliably routes "add to mindbase X" to the tools — copy it from the guide.

</details>

<details> <summary><b>Windsurf</b></summary>

Cascade settings → MCP → add:

{ "mcpServers": { "mindbase": { "command": "npx", "args": ["-y", "mindbase-mcp"] } } }

Same rules-file approach as Cursor works for Cascade.

</details>

<details> <summary><b>Cline (VSCode)</b></summary>

Cline settings → MCP Servers:

{ "mcpServers": { "mindbase": { "command": "npx", "args": ["-y", "mindbase-mcp"] } } }

Cline auto-detects; every tool call gets a confirmation dialog by default.

</details>

<details> <summary><b>Continue.dev</b></summary>

~/.continue/config.json, under experimental.modelContextProtocolServers:

{ "experimental": { "modelContextProtocolServers": [ { "transport": { "type": "stdio", "command": "npx", "args": ["-y", "mindbase-mcp"] } } ] } }

MCP tools appear under @ in chat.

</details>

<details> <summary><b>Any other MCP client</b> (Zed, Aider, Goose, Claude Agent SDK…)</summary>

Point it at npx -y mindbase-mcp as a stdio server. See your client's MCP docs for the config location.

</details>

Next: create your first project and learn the four daily workflows in the Guide →

The web UI

Since 0.3 the browser app stands on its own — write notes in a full WYSIWYG editor (Cmd+N), quick-capture from anywhere (Cmd+I), and run the AI operations with approval cards: /contribute, /build, /lint, /research. Live demos on the website.

<p align="center"> <img alt="MindBase web UI — category tree on the left, the LLM-maintained context.md in the center, chat starters on the right" src="docs/assets/webui.png" width="920"> </p>

Free local models: the setup wizard detects your hardware and installs what fits — llama3.2:3b (8GB), qwen3:14b (24GB+), or Meta's Muse Glimmer 30B (32GB+ Apple Silicon, Ollama ≥ 0.32.7). Measured guidance: qwen3:14b for interactive work (~30s), Glimmer for background lint/build — slower, but its findings quote the exact conflicting sentences. The model switcher on the chat composer flips between them in two clicks.

<details> <summary><b>Feature matrix by editor</b></summary>

FeatureClaude CodeCursor / Windsurf / Cline / ContinueWeb UI
Slash commands (/mb:*)✅❌ (use natural language)✅ (/contribute, /build, /lint, /research)
MCP tools directly✅✅❌
Karpathy 8-step ingest with approval✅ (sub-agents)⚠️ Manual via prompt✅ (approval cards)
Contribute / ingest PDF & URL✅✅✅ (upload + ✨ Process)
Ask wiki with cited answers✅✅✅
Build / health check✅✅✅
Wiki tree browsing + rich editor❌❌✅
-p project-id routing✅⚠️ natural language✅ (switcher)

</details>

Where your data lives

Everything is plain markdown under ~/mindbase-data/ (override: MINDBASE_DATA_DIR):

~/mindbase-data/projects/my-research/
├── README.md                 # Ops manual — you edit, LLM reads
├── context.md                # Synthesized truth — LLM writes, you approve
├── index.yaml                # Auto-generated catalog
├── sources/
│   ├── contributors/<you>/   # Your dated entries + notes (append-only)
│   ├── research/             # LLM-authored wiki pages
│   └── raw/                  # PDFs, HTML captures
├── logs/                     # Chronological operation log
├── artifacts/                # Briefs, exports, lint findings
└── state/builder/snapshots/  # context.md snapshots for rollback

No proprietary database — what you see on disk is what MindBase knows. git init it, back it up with anything, delete a project with rm -rf.

Architecture at a glance

 Claude Code / Cursor / any MCP editor          Web UI (npx mindbase-app)
        │  MCP · sub-agents with                       │  /commands ·
        │  per-agent tool allowlists                   │  approval cards
        └─────────────┬─────────────────────────┬──────┘
                      ▼                         ▼
        ┌──────────────────────────────────────────────┐
        │  One ops engine: gather context → single     │
        │  constrained JSON completion → human         │
        │  approval → whitelisted executors → log      │
        └─────────────────────┬────────────────────────┘
                              ▼
              ~/mindbase-data/ · plain markdown
              (LLM: Ollama local models or any cloud key)

Monorepo: packages/core (TS strict library) · apps/mcp (49-tool MCP server) · apps/server + apps/web (Express + React UI) · apps/app (npx launcher) · apps/plugin (Claude Code bundle).

Docs & help

Roadmap

Next: browser extension for one-click page capture · audio input via Whisper · unified meta-tool for Cursor/Windsurf slash-like UX. Later: team projects with human-in-the-loop review · audio digests · desktop app · mobile capture.

Feedback

Beta through 2026-Q4. If you tried MindBase and gave up — please tell me why: issues or [e-mail address on the upstream page](mailto:e-mail address on the upstream page). The blockers you hit are gold.

License

MIT — do what you want, no warranty. If you build something interesting on top, I'd love to hear about it.

Built with the belief that AI's most valuable gift is not "generation on demand" but "gardening of a persistent artifact you own."

CHANGELOG.md

Changelog

0.4.6 (2026-10-09)

Added — second round from the Karpathy thread

  • Retrieval-clipping visibility — every answer now reports how much of the retrieved text actually reached the model (read 3 pages · 9.1k of 14.2k chars fit · clipped: …). A page that was found but silently cut by the context budget is no longer invisible.

  • Queries are logged — logs/<date>.md gets a line per ask (query | "…" read=N cited=M sent=S/R chars read: …), so the log now covers all three operations as the pattern specifies, and read-but-uncited pages are greppable.

  • Three more findings computed in code — broken citation (a page cites a source file that was moved or deleted), broken link (a [[wikilink]] with no page or note behind it), near duplicate (two research pages whose names are the same concept — extend, don't create). The model is told not to guess at any of these.

  • Fail-open contribute — if the model call fails after your text was saved to the daily file, the error says exactly where it is.

0.4.5 (2026-09-13)

Added — wiki integrity (ideas from the Karpathy LLM-wiki thread)

  • Sources vs wiki in answers — retrieval indexes your own notes, daily files and raw imports as a source layer alongside AI-written pages; answers prefer your material, and each citation is tagged source / wiki so you can see what is yours vs derived.

  • [@path] citations — every research page and context bullet the maintainer writes points back at the source file it came from, added deterministically even when the model forgets. Rendered as clickable chips in notes and on the wiki home. Lint gains unsourced page and uncited source findings, computed in code rather than by the model.

  • Evidence-checked lint — contradiction / stale findings must carry verbatim quotes; the server verifies each quote against the page and drops findings that don't hold up (dropped=N in the log). Cards show ✓ verified per quote.

  • Free-text contribute lands in your layer first — /contribute text is appended to sources/contributors/<you>/<date>.md before the wiki is touched, so it is citable and never lost; re-submitting the same text is a no-op. Notes cite their own path.

  • Duplicate-page guard — a plan cannot create a research page that already exists (case/separator-insensitive) or that another pending plan is about to create; the approval card says what was skipped.

  • State rule in build / contribute / research prompts: document the shape of things, never live values (SHAs, counts, "last synced").

0.4.3 (2026-08-19)

Added

  • npx mindbase-app — the web UI's first distribution channel: one command starts the bundled server + web app and opens your browser (previously clone + pnpm only). 2.8MB tarball; --port, --no-open.

  • Website — https://frankchu91.github.io/mindbase-llm-wiki/ with live demo clips, deployed from website/ via GitHub Pages.

  • Muse Glimmer recommended on 32GB+ Apple Silicon; quick model switcher on the composer badge; thinking-model reasoning streamed live in chat.

0.4.0 (2026-08-07)

Added — write full notes in the UI

  • Cmd+N (or "+" → New note) creates a real note and opens it in the full WYSIWYG editor — headings, GFM, markdown links, [[wikilink]] autocomplete, outline, backlinks. Previously every "new note" path dead-ended in the quick-capture textarea.

  • Notes live in your layer (sources/contributors/<user>/notes/), so the AI never rewrites them — it digests them into the wiki on Rebuild, or on demand. The first title you type becomes the filename.

  • Wiki-status chip replaces the old "Process" button: a note newer than the last build shows ✨ Add to wiki; while the AI works it shows Adding…; after your approval it flips to ✓ In wiki · N pages. Editing the note lights the chip up again. The status reuses the build pipeline's own newer-than-context rule — no separate state to drift.

  • Cmd+I quick capture is unchanged: log a line in 3 seconds vs sit down and write — two different verbs, now two different surfaces.

Fixed

  • WYSIWYG body edits silently saved a copy of every note into the LLM-owned sources/research/ layer (hardcoded legacy path) — user content no longer leaks across the layer boundary.

  • Renaming a contributor file doubled the user segment in the path and the failed rename crashed the server process.

  • The file tree didn't refresh after renames/creates from outside it.

0.3.0 (2026-08-06)

Added — Web UI runs the core operations

The Web UI now has the same core functionality as the MCP/plugin path, orchestrated server-side with whatever LLM you configure (cloud or the free local model):

  • /contribute in the chat composer — type / for a command menu. The AI reads your thought, streams takeaways plus a plan of wiki updates; each update is a checkbox row and only approved actions are written. Plans are held for 10 minutes.

  • /build + a real Rebuild button — regenerates context.md from unbuilt sources. Snapshots the old context first (state/builder/snapshots/), enforces a per-project lock, refreshes the page when done.

  • ✨ Process on any note — sends the note body through the same contribute approval flow.

  • /api/ops/{contribute,build} — SSE endpoints backing all of the above. One constrained JSON completion per operation (no multi-step tool loops — far more reliable on small local models). The action vocabulary is schema-limited: no action can write sources/ (contributors or raw), mirroring the plugin sub-agents' tool allowlists.

  • /lint + a rebuilt Wiki Health view — the AI reads your wiki and surfaces contradictions, orphan pages, stale claims, missing pages, missing links, and gaps as cards. Per-card: open the cited pages, Dismiss (persists), or Follow up (files into today's contributor note). Findings cached to artifacts/lint/<date>.json.

  • /research <topic> — synthesizes a cited research page from your wiki; add a Brave Search API key (Settings → Web Search) and it pulls live web results in too. No key → clearly labeled wiki-only mode.

  • Every operation appends to logs/<date>.md in the same format the plugin uses, so editor sessions and UI sessions share one history.

Fixed — ask on v2 projects

  • v2 projects had an empty search index (only v1 wiki/ paths were indexed), so chat answers cited nothing. sources/research/ and context.md are now indexed at boot and after every operation.

  • Ask's auto-save filed answers into the v1 wiki/notes/ tree; on v2 it now creates a proper research page and logs the query.

0.2.0 (2026-08-06)

Added — free local model onboarding

  • Setup wizard can configure MindBase with no subscription and no API key: detects your hardware (RAM/CPU/platform), recommends the best Ollama model that fits (llama3.2:3b < 12GB → qwen3:8b < 24GB → qwen3:14b ≥ 24GB, qwen3:30b-a3b advanced), guides the Ollama install, pulls the model with live progress (/api/ollama/pull SSE proxy), and verifies with a real 1-token generation.

  • GET /api/system (hardware report) and GET /api/ollama/status (3-state: not-installed / not-running / ready).

Fixed

  • Ollama: thinking-mode models (qwen3, deepseek-r1) returned 88s of blank output — thinking is now disabled for chat and verification (88.7s → 1.1s measured).

  • Ollama verify no longer false-positives when the service runs but the model isn't pulled.

  • Chat composer's first message was silently unsendable on empty conversations.

  • Removed v1 classify/breadcrumb chrome from v2 note pages ("Reclassify failed: note not found").

0.1.3 (2026-07-24)

Added

  • mindbase_ingest_file — first-class file ingestion for every MCP client: takes a local path or a direct URL (e.g. an arXiv /pdf/ link), downloads if remote, archives the original into sources/raw/<date>/, extracts text locally via pdfjs, writes an .extracted.md sidecar for PDFs, and returns the text for the contribute flow. 50MB cap; HTML URLs are rejected with guidance.

  • Web UI: upload button on the Raw category row + empty-state upload row; POST /api/tree/raw/upload.

  • mindbase_init_project result carries a one-time feedback note.

Fixed

  • GET /api/tree/raw/:date/:id returned utf-8 garbage for PDFs — now serves the extracted-text sidecar when present; raw listing hides sidecars.

  • Project switcher menu painted underneath the sidebar (stacking context); now portaled to <body> and fully opaque.

0.1.2 (2026-07-21)

Fixed

  • Zero-state first run: on a fresh machine with no projects, every project-scoped tool (contribute, status, gather_sources, and 8 more) now returns an actionable instruction — create a project via mindbase_init_project, or pick from the listed existing ones — instead of Invalid input: Required or a dead-end pointer to load_project.

  • mindbase_init_project writes meta.json, so plugin-created projects appear in the web UI's project list immediately.

  • Server no longer resurrects a broken v1 "Default project" on boot when empty legacy dirs are present or v2 projects already exist.

Added

  • mcpName ownership field + server.json for publishing to the official MCP Registry (registry.modelcontextprotocol.io).

0.1.0 (2026-07-11)

First public release. MindBase is an AI research assistant that builds and maintains a markdown wiki from your sources — Karpathy's LLM-Wiki pattern as a product. Ships as an MCP server (works in Claude Code, Cursor, Windsurf, Cline, Continue.dev, and any MCP-compatible client) plus an optional web UI.

Added

  • Multi-IDE support verified — MCP server tested end-to-end in Claude Code (flagship: slash commands + sub-agents) and Cursor (natural-language tool calls). Same ~/mindbase-data/ disk shared across all clients.

  • -p / --project routing flag on all slash commands (/mb:contribute, /mb:build, /mb:status, /mb:ask, /mb:lint, /mb:daily-brief, /mb:research, /mb:export) — target any project without switching the current one. /mb:load remains the single path that changes currentProjectId.

  • Self-contained plugin bundle via pnpm deploy — plugin's MCP server ships with its own node_modules, boots on a clean machine with only Node 20.

  • Rewritten README — install guides for 6 editors, feature matrix, troubleshooting, data-layout documentation.

Fixed

  • mindbase_load_project no longer silently switches the current project as a side-effect; persisting is opt-in (persist: true).

  • Plugin .mcp.json pointed at the library entry (index.js) instead of the executable (cli.js) — MCP server never started in fresh installs.

  • mindbase_init_project / load now persist currentProjectId to config.json so follow-up tool calls resolve the project automatically.

  • Sub-agent tool allowlists referenced the old mcp__mindbase__* namespace; now mcp__mb__* (matches the plugin's server key).

  • Web UI: stripped all v1 dead paths (QuickCaptureModal, DailyNoteHeader, TemplatesSettings, /api/wiki/* callers) — the first-minute 404 storm is gone. Net -648 lines.

0.1.0-beta (2026-06-09)

Added — Plugin pivot

  • apps/plugin/ — new Claude Code plugin package bundling the MCP server, slash commands, sub-agents, hooks, and templates. Install via claude --plugin-dir apps/plugin or eventually /plugin install mindbase@mindbase.

  • Per-project v2 layout (packages/core/src/plugin-layout/) — README.md + context.md + index.yaml + sources/contributors/<user>/YYYY-MM-DD.md + state/ + logs/ + artifacts/. Replaces legacy wiki/notes, wiki/concepts, wiki/sources for new projects.

  • Migration pipeline (packages/core/src/migrate/) — atomic legacy → v2-layout converter with snapshot, transforms (schema→README, INDEX→context, notes→contributors, sources→research, log split), and recovery archive. Vitest covered.

  • 12 new MCP tools in apps/mcp:

    • mindbase_init_project / mindbase_load_project — scaffold + load

    • mindbase_contribute / mindbase_validate_structure / mindbase_append_log — write + check

    • mindbase_gather_sources / mindbase_atomic_write_context / mindbase_rebuild_index — build pipeline

    • mindbase_status — dashboard JSON

    • mindbase_migrate — legacy conversion

  • 9 slash commands (apps/plugin/commands/): /mb:init, /mb:load, /mb:contribute, /mb:build, /mb:ask, /mb:lint, /mb:status, /mb:daily-brief, /mb:migrate.

  • 4 sub-agents (apps/plugin/agents/): builder, contributor, curator, migrator. Tool-restricted per agent: builder/contributor/curator cannot Edit/Write/Bash; only MCP tools.

  • SessionStart hook (apps/plugin/hooks/session-start) — auto-injects current project's README + context + index.yaml as additionalContext JSON on every Claude Code session start. Cross-platform (Claude Code / Cursor / Copilot CLI variants).

  • 9 templates (apps/plugin/templates/): README.md.template, soul.md.template, context.md.template, empty.md.template, plus 5 schema templates ported from apps/skill/.

  • apps/server v2-awareness helpers (context.ts): currentProjectIdFromConfig, projectRoot, detectLayoutVersion.

  • POST /api/compile/build — stub endpoint that tells the UI to invoke /mb:build in Claude Code (v0.1 doesn't host server-side LLM synthesis).

  • apps/web/src/lib/wikiPaths.ts — TS mirror of core's projectPaths for the bundle.

Changed

  • apps/mcp search/ask tools (search-wiki, ask-wiki) now accept both v1 (wiki/notes/) and v2 (projects/<id>/sources/...) slug paths via dual-regex.

  • apps/server compile/lint/projects routes now resolve wiki/log.md, wiki/_insights.md via the v1/v2 helper; GET /api/projects/:id surfaces layoutVersion, lastBuild, contributorsCount.

Deferred (manual follow-up before UI works on migrated data)

  • apps/server/src/routes/wiki.ts (1098 lines) — the /api/wiki/* read/write routes still serve v1 paths exclusively. After running /mb:migrate on a project, the UI's tree + page views will 404 against that project. Needs a targeted refactor (likely via a WikiCategories abstraction) to add v2 categories to the /wiki?category= API surface.

  • apps/web LeftRail/TreeRoot — depends on the above. The tree's categories are fetched from /api/wiki?category=; without v2 server support there is no v2 data to render.

  • apps/web/src/components/{NotesView,WikiView}.tsx — file names from the plan did not match the codebase. Actual components (WikiHome.tsx, etc.) were not refactored; same blockers apply.

Removed

  • apps/skill/ — legacy skill-based install (install.sh + ~/.claude/skills/mindbase/ deploy) deleted. The mindbase-synthesizer weekly-summary sub-agent was not ported (read v1 wiki/log.md; the plugin's curator + builder cover the same surface area for v2). Users with the old install must manually remove ~/.claude/{skills/mindbase, commands/mb-*.md, agents/mindbase-synthesizer.md}.

Notes

  • Pre-existing typecheck error in apps/mcp/src/tools/get-pulse.ts(94,47) was not touched; unrelated to the pivot.

  • apps/plugin/mcp-server/dist/ is gitignored; rebuild via pnpm -F @mindbase/plugin build after pulling.

512 files · 497 not served here

Advantages

  • Local-first: the memory stays in files or a database on your own machine (a rule-derived fact from the brain’s files, evidence: README.md)
  • Works with 14 MCP clients (a rule-derived fact from the brain’s files, evidence: README.md)
  • Plain markdown memory that you can read and edit yourself (a rule-derived fact from the brain’s files, evidence: README.md)
  • No API key is named in its files (a rule-derived fact from the brain’s files, evidence: README.md)
  • Open licence (MIT) (a rule-derived fact from the brain’s files)

Limitations

  • Runs code automatically: review what it runs before you open it (a rule-derived fact from the brain’s files)
  • No ZIP download: install it from its source (a rule-derived fact from the brain’s files)

Security

Risk level: Medium risk

This brain runs

Agent instructions that run or fetch something (12)

  • CLAUDE.md: MindBase implements Andrej Karpathy's **LLM-Wiki pattern** (`docs/llm-wiki.md`), turned into a product for users who can't or won't run `claude-code + obsidian + a hand-written CLAUDE.md` themselves.
  • CLAUDE.md: pnpm monorepo: `packages/core` (TS strict, vitest), `apps/server` (Express), `apps/web` (React 19 + Zustand), `apps/browser-ext`, `apps/mcp`, `apps/mobile`.
  • CLAUDE.md: Server dev: `pnpm -F @mindbase/server dev` (tsx watch).
  • CLAUDE.md: Web dev/build: `pnpm --filter @mindbase/web {dev,build,typecheck}`.
  • CLAUDE.md: After modifying `packages/core` types, `pnpm --filter @mindbase/core build` before re-typechecking dependents.
  • CLAUDE.md: Install via `claude --plugin-dir apps/plugin` for local dev or `/plugin install mindbase@mindbase` when published.
  • CLAUDE.md: `apps/skill/` was removed in 2026-06-09 — the legacy `install.sh` skill-based deploy is gone;
  • CLAUDE.md: the plugin is the only install path.
  • CLAUDE.md: Plugin builds: `pnpm -F @mindbase/plugin build` (bundles `apps/mcp` into `apps/plugin/mcp-server/dist`).
  • apps/plugin/skills/mindbase/SKILL.md: If none → tell user to run `/mb:load` or `/mb:init`
  • apps/plugin/skills/mindbase/SKILL.md: Always call `mindbase_contribute` (plan/approve/execute primitive).
  • apps/plugin/skills/mindbase/SKILL.md: Read → discuss → propose plan → execute.

MCP servers (4)

  • README.md (mindbase): npx -y mindbase-mcp
  • README.md (mindbase): npx -y mindbase-mcp
  • README.md (mindbase): npx -y mindbase-mcp
  • apps/plugin/.mcp.json (mb): npx -y mindbase-mcp

Hooks (1)

  • apps/plugin/hooks/hooks.json (SessionStart): ${CLAUDE_PLUGIN_ROOT}/hooks/session-start
  • Medium risk: runs-mcp-server-unpinned-runner (README.md:88)
  • Medium risk: runs-mcp-server-unpinned-runner (README.md:101)
  • Medium risk: runs-mcp-server-unpinned-runner (README.md:114)
  • Medium risk: runs-mcp-server-unpinned-runner (apps/plugin/.mcp.json)

Attribution and licence

First committed by
GitHub avatar of frankchu91frankchu91
Publisher
Haobing(Frank) Chu (Community)
Source
frankchu91/mindbase-llm-wiki · commit c5273d2
Licence
MIT License (files served here)
  • ATTRIBUTION.md (written by AutoGineer)
Synced
Contributors
frankchu91

AutoGineer is not affiliated with or endorsed by frankchu91.

Install from source

497 of its files are not served here, so there is no ZIP. frankchu91/mindbase-llm-wiki at c5273d2