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/product-strategy-2026-05-25-addendum.md

Addendum: Competitive Intel Delta (2026-05-25)

External research came back with data that shortens the timeline and sharpens the threat surface from my Phase 1 strategy doc.

What changed

1. Karpathy's gist went viral 7 weeks ago

  • 16M+ views on the original tweet (Apr 3-4, 2026)

  • 5,000+ GitHub stars on the gist

  • Multiple working implementations already shipped:

    • Pratiyush/llm-wiki (Claude Code / Cursor / Codex sessions)

    • lucasastorian/llmwiki (open-source, MCP-connected)

    • ΩmegaWiki (680+ stars, v1.4.0)

    • LLM Wiki v2 gist (extending with agent memory)

  • Funded startups explicitly citing the pattern:

    • Dume.ai — desktop AI agent for non-technical users

    • remio 3.0 (Apr 2026) — connects ChatGPT/Gemini histories into queryable wiki

Implication: The pattern is no longer a niche essay. The land grab is HAPPENING. We have ~3-6 months to be the canonical implementation, not the 12-18 I estimated. Ship faster or get framed by remio / Dume.

2. The AI-native PKM velocity benchmark is brutal

  • Granola: $0 → $1.5B valuation in 36 months. $4.25M seed (May 2023) → $20M A (Oct 2024, 5k WAU) → $43M B ($250M, May 2025) → $125M C ($1.5B, Mar 2026). 250% revenue growth in the quarter before C.

  • Cursor: $400M → $50B in 18 months. ARR $0 → $2B.

Both are AI-native wedge plays (meetings / coding) that replaced a workflow incumbent. This is what's achievable when AI-native + sharp wedge align.

3. Tana is the closest funded competitor — but not Karpathy-pattern

  • $25M raised Feb 2025 ($14M A at $100M post, plus $11M seed)

  • 160K waitlist; Fortune 500 customers claimed

  • Pricing: Free / $8 / $14 per month

  • Positioning: "AI-powered knowledge graph for work"

  • Critical: Tana is block/supertag-based, not LLM-Wiki pattern. They are building structure for humans to maintain; we are building structure the LLM maintains. Different thesis.

  • They have a 12-month head start on distribution. We have to win on thesis clarity + execution speed.

4. mem.ai is the cautionary tale we must internalize

  • $29M raised → 4 years → no disclosed ARR/MAU

  • 9 employees

  • Rebuilt twice ("Mem 2.0" relaunched Oct 2025)

  • Medium piece "The $40M Second Brain Failure" circulating widely

  • Failure mode: positioned as "AI thought partner" — horizontal, no wedge, no specific workflow it dominates

This validates the strategy doc's core thesis: horizontal AI PKM does not work. Don't repeat their mistake.

5. The "PKMS is Dying" sentiment is real and growing

  • Medium article ("PKMS is Dying") widely circulated 2025

  • Reddit /r/PKMS / /r/productivity recurring "I quit PKM" posts

  • Core complaint: "too many tools storing things, none doing synthesis"

  • This is the demand signal for the Karpathy pattern, validated in the wild. People want synthesis and recall, not another place to store.

6. Specific competitor threats with hard numbers

  • NotebookLM Plus: $19.99/month in Google One AI Premium. Free tier active. 3M+ monthly visits Sep 2024. Highest threat for casual users.

  • ChatGPT Memory + Claude Memory + Gemini Memory: all shipped 2024-26. Amorphous chat memory, not structured wiki. Our differentiation holds: structured + cited + exportable beats chat-memory-vibes for serious work.

  • Notion AI: $15/user/mo Business tier; billing-trap complaints surging; "becomes a maintenance project" sentiment. Our attack surface.

7. WTP signals across wedges (sharpened)
WedgeComparableTheir pricingTheir scaleMindBase WTP estimate
ReadingReadwise$7.99/mo100k+ paying = ~$10M ARR$10-15/mo
Research / AcademicPaperpile, ReadCube$15-25/mosmaller, niche$20-30/mo
Due diligence / consultingHarvey AI (legal)$1k+/seat enterprisehigh WTP$50-200/mo solo, enterprise unbounded
Personal journalDay One$35/yrmass consumer$10-15/mo
Internal team wikiNotion Business$15/user/momassive$20-25/user/mo (self-maintaining premium)

Research wedge confirmed as highest WTP. Reading wedge has 100k+ paying user proof point (Readwise) — much more validated than I estimated.

8. Obsidian's $25M ARR with 7 people = the alternative model

Obsidian quietly built ~$25M ARR with 7 people, zero VC, via Sync + Publish subscriptions on top of a free local-first product. This is a completely viable alternative to venture-scale GTM — bootstrap profitable, never raise, keep optionality.

Implication for MindBase: bootstrap path is real and proven. Don't default to "raise capital" thinking just because Granola did.

What I'm changing in the recommendation

Tightened: timing is months, not quarters

The strategy doc said "12-18 months window." Revised: 3-6 months until the land grab is over for the Karpathy-pattern-canonical position. Dume and remio are already framing themselves as the implementation.

New action: ship the Phase 1 architectural reset in 2 weeks, not 4. Ship a demoable research wedge by end of June 2026 (~5 weeks).

Sharpened: the wedge wording matters

Old wording: "research-wiki for knowledge workers doing sustained inquiry"

Better, given the data:

"MindBase is the AI research analyst that builds your wiki. Drop 50 papers; get a navigable, cited knowledge base that grows with you."

Avoid "PKM," "second brain," "note-taking" — these are dead categories. Lead with research analyst (the job) and knowledge base (the output).

Reconsidered: reading wedge is more viable than I gave it credit

Readwise's 100k+ paying users at $7.99/mo proves consumer-scale reading-wedge PKM works. I had this rated lower-priority. Revised: Research wedge is still primary, but reading wedge becomes Phase 4 (Q3) as a second SKU on shared infra, not a much-later optional thing.

Added: defensive position against Tana

Tana's existence + funding means we cannot win on "knowledge graph for work" generally. We need to own the LLM-Wiki-pattern specifically as a clean counter-positioning:

TanaMindBase
Who writes the wiki?You (with supertag scaffolding)The LLM
Source of truthYour blocksThe raw sources
Maintenance modelManual, structured-by-youAutomatic, structured-by-LLM
Data locationCloud-firstLocal-first
Best forPower users who love structured note-takingResearchers who want a wiki without the work

Karpathy's framing IS our wedge against Tana. Lean into it explicitly in marketing.

Added: bootstrap path is now my recommended default

Strategy doc said "bootstrap to first $10k MRR, then optional seed." Given Obsidian's $25M ARR with 7-person team and no VC, the new recommendation:

Default to bootstrap. Reserve external capital for if a clear enterprise/ team SKU opportunity materializes around month 9-12.

Venture capital pulls toward growth metrics that hurt research-niche products (e.g., chasing horizontal adoption). For the research wedge specifically, profitable indie at $50-100k MRR is more sustainable and defensible than VC-backed $10M ARR with high burn.

Added: ride the Karpathy-pattern wave deliberately

The pattern is hot RIGHT NOW. Specific tactical moves:

  1. Launch the open-source SDK / CLI version FIRST. Before the polished product. Capture the developers who are already searching "how do I implement Karpathy's LLM-Wiki." Even if they don't pay, they become evangelists. Compete with the hobbyist GitHub repos for the canonical spot.

  2. Write the canonical implementation guide. A blog post (or repo README) titled "How to actually ship Karpathy's LLM-Wiki pattern." Becomes SEO + credibility. Reference the gist; extend it with what we learned.

  3. Tweet Karpathy when we ship the product. The man amplifies his own pattern's implementations.

  4. Show HN: launched on a Tuesday at 9am ET. Title: "Show HN: MindBase — Karpathy's LLM-Wiki pattern, packaged as a research tool."

Revised first-90-days plan

WeekMilestone
1-2Phase 1 architectural reset (separate wiki/concepts/, schema.md, INDEX-first, lint v0, fix compile prompt back to 10-15 actions per source).
3Project as first-class entity. Repositioned home/onboarding around research.
4Conversational ingest UX. Streaming compile that user can guide.
5Polish 5-minute demo video. Onboard 10 friendly users (PhD friends, founder peers).
6Write canonical "implementing Karpathy's pattern" blog post. Open-source SDK/CLI.
7Show HN + Twitter launch. Target: 100 sign-ups in 48 hours.
8-12Iterate based on first-50-user feedback. Ship Pro tier billing. Target $1k MRR.

If at week 8 we have < 30 active users and < 5 paying, stop and reassess the wedge. Don't fall in love with sunk cost.

The single new decision to make NOW

The pattern is viral; the window is closing. Are we sprinting or strolling?

  • Sprinting: 2-week architectural reset, ship demo June, public launch July. Single-minded focus, defer everything else.

  • Strolling: comfortable 3-month rewrite, careful internal testing, launch Q4. Miss the Karpathy moment.

I recommend sprinting. The downside of sprinting and being wrong is "we shipped a sharp v1 too early"; the downside of strolling is "remio + Dume own the category we were going to define."

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