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."

docs/testing-walkthrough.md

Testing Walkthrough — Solo Dogfooding

A concrete, step-by-step walkthrough to verify every user-visible feature works on your machine. 31 items, ~90 minutes if you do them all. Each item is self-contained — skip around freely. Tick the boxes as you go.

Prerequisites

# Server must be running (keep this in a terminal window)
pnpm -F @mindbase/server dev

# Open the web app
open http://localhost:4321

LLM proxy at localhost:3456 must be running for AI features (Tier 3, 5, 7, 8). Without it, you can still test Tiers 1, 2, 4, 6 (capture, RSS, settings, basic UI).

Browser extension must be built: pnpm -F @mindbase/browser-ext build.

Tier 1 — Web Basics (no config, 5 min)

1. Resizable left panel

  • [ ] Hover the vertical divider between left aside and main area → cursor changes to ↔

  • [ ] Drag left/right → width changes

  • [ ] Double-click the handle → resets to 320px

  • [ ] Reload the page → width persists

2. Settings full-screen

  • [ ] Click sidebar "Settings" button → entire app switches to full-screen settings

  • [ ] Left rail shows 7 sections: Provider / Daily Brief / RSS / SRS / AI Clients / Obsidian / Graph Export

  • [ ] Click each section → main area updates

  • [ ] Click "← Done" → returns to wiki list view

3. Command Palette

  • [ ] Press ⌘+K (or click the search field at top of left panel)

  • [ ] Type any keyword → fuzzy-matched wiki pages appear

  • [ ] Press Enter → opens that page

4. Article view

  • [ ] Click any wiki page from the list → enters article view

  • [ ] Scroll to bottom → see capture provenance footer (if captured) + Cards section + Save button

5. Wikilink hover preview

  • [ ] In an article body, find a [[link]] (rendered as a blue underlined link)

  • [ ] Hover for 250ms → popover appears with title + one-liner + 200-char excerpt

  • [ ] Click "Click to open →" → navigates to that page

  • [ ] Hover then move mouse away → popover closes

6. Graph View

  • [ ] Click sidebar "✦ Graph" button → force-directed canvas

  • [ ] Hubs are visibly larger than orphans

  • [ ] Top search field: type theo (or any partial slug) → matching nodes turn amber, others dim

  • [ ] Click any node → opens that article

  • [ ] Click "⟲ Reset" → re-centers + zooms to fit

Tier 2 — Editor (30s, no LLM)

7. Edit mode

  • [ ] In an article, click "Edit" button (top-right header)

  • [ ] Page swaps to CodeMirror markdown editor with syntax highlighting

  • [ ] Top bar shows "Saved …" + Save + Done buttons

8. Slash commands

  • [ ] In the editor, on a new empty line, press /

  • [ ] Floating menu appears with 5 categories (Format / Blocks / Links / AI / Templates), 19 commands

  • [ ] Type head → menu filters to Heading 1/2/3

  • [ ] Use ↑↓ to navigate, Enter to insert → # (or ## etc.) appears at cursor

9. Wikilink autocomplete

  • [ ] In the editor, type [[r (or any letter) → dropdown appears with matching wiki pages

  • [ ] ↓ to choose, Enter → inserts slug]]

10. Save behavior

  • [ ] Modify content → top bar shows "Saving…"

  • [ ] After 2 seconds → "Saved 1s ago"

  • [ ] Press ⌘+S → immediate save

  • [ ] Click "Done" → returns to read view, changes preserved

  • [ ] Reload page → changes persist

Tier 3 — Chat + Inline Citations (LLM required, 1 min)

11. Chat answer with clickable citations

  • [ ] In right-side chat panel, ask a question about something you've actually written about (e.g. 我对 RAG 的看法是什么)

  • [ ] Answer streams in. Should include [1], [2] markers between sentences

  • [ ] After answer completes, markers render as amber superscript buttons

  • [ ] Click a [1] → opens the cited wiki page in left panel

  • [ ] Below the answer, "Sources" section lists each [N] with title + clickable link

  • [ ] Auto-save: if the LLM emitted [AUTO_SAVE: ...], a "Saved to Knowledge" indicator appears under the answer

Tier 4 — AI Commands in Editor (LLM required, 1 min)

12. AI continue / summarize / expand / translate

  • [ ] Open editor on any article

  • [ ] Highlight a paragraph (or place cursor at end of text)

  • [ ] Press / → choose Continue writing → "AI thinking..." → text streams into cursor position

  • [ ] Press / → Summarize selection → replaces selection with summary

  • [ ] Press / → Expand bullet → develops a short note into a paragraph

  • [ ] Press / → Translate → English ↔ Chinese auto-detected

Tier 5 — Browser Extension Capture (5 min)

Prerequisites:

  • [ ] Extension loaded (chrome://extensions → Load unpacked → apps/browser-ext/.output/chrome-mv3/)

  • [ ] Server running

13. Pair the extension

  • [ ] Web: Devices section → copy the 8-char pair code (e.g. BU5E-MQVG)

  • [ ] Chrome toolbar: right-click MindBase icon → Options

  • [ ] Paste code + device name → Pair

  • [ ] Verify: web Devices section now lists the paired browser

14. URL capture with live status

  • [ ] Open any website (e.g. a Wikipedia article)

  • [ ] Press ⌘+Shift+M (or click the MindBase toolbar icon)

  • [ ] Form pre-fills title + URL. Add optional note + tags. Click Save

  • [ ] Popup stays open, "RECENT" section shows new entry with queued badge

  • [ ] Toolbar icon shows amber badge "1"

  • [ ] Within ~10 seconds: status updates to processing

  • [ ] Within ~60–90 seconds: status updates to compiled; badge disappears

  • [ ] Click "Open wiki →" → opens the new wiki page in MindBase

15. Selection capture

  • [ ] Highlight a paragraph on any website

  • [ ] Right-click → "Save selection to MindBase"

  • [ ] Toolbar badge increments

  • [ ] After 60–90s, the selection compiles into a wiki page (check Inbox)

16. Screenshot capture

  • [ ] Right-click any page → "Save screenshot to MindBase"

  • [ ] Visible-tab screenshot captured + uploaded

  • [ ] After 60–90s, OCR'd text becomes the wiki page body

17. Inbox view in MindBase web

  • [ ] Sidebar "Inbox" → all captures listed with status badges

  • [ ] Failed entries have "Retry" button

  • [ ] Each entry has "Delete" option

Tier 6 — Spaced Repetition (2 min)

18. Auto-extract cards from a wiki page

  • [ ] Open a content-rich wiki page (≥ a paragraph of substance)

  • [ ] Scroll to bottom → "Cards (0)" section → click Generate

  • [ ] Within 15 seconds: 1–3 Q+A cards appear

19. Review View

  • [ ] Sidebar "Review" button (with a count badge if cards are due)

  • [ ] Card displays the question

  • [ ] Press space → flip to answer

  • [ ] Press 1 / 2 / 3 / 4 = Forgot / Hard / Good / Easy

  • [ ] Card transitions out, next one appears

  • [ ] After last card → "All caught up!" empty state

20. SRS scheduling (passive check)

  • [ ] After answering "Good", the card's due_at should be 1 day from now (visible via dev tools or curl localhost:4321/api/srs/cards | jq)

  • [ ] After "Forgot", due_at resets to 1 day; repetitions = 0

  • [ ] After "Easy", due_at is 4 days

Tier 7 — RSS Auto-Ingest (5 min)

21. Subscribe to a feed

  • [ ] Settings → "RSS Feeds" section

  • [ ] Paste https://news.ycombinator.com/rss → click "Add feed"

  • [ ] Feed appears in list with auto-fetched name + 0/24h counter

22. Force refresh

  • [ ] Click "Refresh all" → server polls + ingests new entries

  • [ ] Inbox count jumps (sidebar badge)

  • [ ] Within 60s the new entries start compiling to wiki pages

23. OPML import

  • [ ] Have an .opml file from any RSS reader (Feedly, Inoreader, etc.)

  • [ ] Settings → RSS Feeds → "Import OPML" → upload file

  • [ ] Bulk subscribe; all feeds appear in list

24. Per-feed config

  • [ ] Click ⚙ on a feed → edit tags / project / enabled toggle

  • [ ] Disabled feeds aren't polled

Tier 8 — Daily Brief (10 min, optional SMTP)

25. Preview without sending
curl -s http://localhost:4321/api/brief/preview | jq -r .html | open -f -a "Safari"

  • [ ] Browser opens HTML preview with 200-word summary + clickable [N] citations

26. Real email (requires SMTP config)

  • [ ] Settings → "Daily Brief"

  • [ ] Fill: enabled toggle ON, time 09:00, timezone, recipient email

  • [ ] SMTP host (e.g. smtp.fastmail.com), port 587, secure off

  • [ ] SMTP user + password (use app-specific password for Gmail/Fastmail)

  • [ ] Click "Send test brief"

  • [ ] Email arrives within seconds → 200-word summary + each [N] is a clickable link back to wiki

Tier 9 — MCP via Claude Code / Cursor (5 min)

Prerequisites: a fresh Claude Code or Cursor session (MCP tools load at session start).

27. Tool surface

  • [ ] In new Claude Code session: /mcp or ask "what mindbase tools do you have?"

  • [ ] Should list ≥27 tools (search/ask/read + RSS + SRS + Brief + write tools)

28. ask_wiki with citations

  • [ ] Ask: "我 wiki 里对 RAG 有什么看法？"

  • [ ] Claude calls ask_wiki, response includes [N] markers + a citations list with mindbase://wiki/<slug> URIs

29. add_rss_feed
30. list_review_cards + answer_card

  • [ ] Ask: "what review cards do I have?"

  • [ ] Claude calls list_review_cards, presents cards

  • [ ] Answer "good" or "forgot" → Claude calls answer_card

31. save_chat_excerpt

  • [ ] After any substantive conversation, ask: "save this as a wiki page titled 'MCP test'"

  • [ ] Claude calls save_chat_excerpt

  • [ ] Verify the new page in MindBase web wiki list, with created_via: mcp in its frontmatter

iOS (Xcode required, 15 min)

32. iOS Simulator launch
cd apps/ios && xcodegen generate && open MindBase.xcodeproj

  • [ ] In Xcode, press ▶ Run (iPhone 16 simulator)

  • [ ] App launches, shows TabView with Voice / Inbox / Settings tabs

33. iOS pairing

  • [ ] Settings tab → "Pair this device" → modal sheet

  • [ ] Default server URL is http://localhost:4321 (Mac running server reachable from sim)

  • [ ] Get pair code from MindBase web → paste (or scan QR with iPhone real-device camera)

  • [ ] Click "Pair this device" → ✓ Paired

34. iOS Voice recorder

  • [ ] Voice tab → tap large mic button → records (allow mic permission first time)

  • [ ] Tap again to stop → upload begins

  • [ ] Status "✓ Saved to inbox" appears

  • [ ] Check MindBase web Inbox → new entry with captured_via: ios

35. iOS Inbox view

  • [ ] Inbox tab → list of captures with status badges

  • [ ] Pull-to-refresh works

36. iOS Share Extension (real device only, simulator is unreliable)

  • [ ] Real iPhone: Settings → Safari → any webpage → Share menu → More → enable "MindBase"

  • [ ] Now Share menu has MindBase → tap → capture goes to inbox

What's intentionally NOT in this list

  • Android — your machine has no JDK/Android SDK; the app exists as a code skeleton only

  • Daily Brief cron firing at 09:00 — covered by pnpm test:e2e (brief-scheduler.test.ts), not worth waiting for manually

  • Visual polish across dark/light mode — eyeball it; no acceptance criterion

  • MCP server installed in Claude Desktop — same flow as Claude Code, just edit ~/Library/Application Support/Claude/claude_desktop_config.json

When something doesn't work

For each failing item, share:

  1. The item number (e.g. "#14 URL capture")

  2. The exact step that failed and what you saw instead

  3. F12 console screenshot if it's a web/popup problem

  4. chrome://extensions → Inspect service worker → Console screenshot if it's extension polling

  5. Server log tail: tail -50 /tmp/mindbase-server.log

I'll fix.

Automated test suite (for context)

This walkthrough is the manual layer. The automated test suite covers most of the backend / API / core logic:

pnpm test:all     # ~7s — core + server + MCP + extension (Playwright-headed)
pnpm test:web     # ~14s — web UI Playwright (Chromium required)
pnpm test:ios     # ~35s — iOS XCUITest (Xcode required, kept out of test:all)

If test:all passes, the backend / capture / RSS / SRS / Daily Brief building logic is healthy. This manual walkthrough catches the things automation can't: mobile share sheets, real SMTP delivery, LLM output quality, visual polish.

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