Karpathy's LLM Wiki Points in the Right Direction — But It's Still Stuck on Your Laptop

Why This Wave Matters

Andrej Karpathy's LLM Wiki gist went around the AI community this week, arguing that LLMs should compile and maintain a structured knowledge base instead of starting from scratch on every conversation. The point lands squarely on the biggest missing piece in how most people use AI today.

KnowMine has been building exactly this. It's been live for months: 11 MCP tools, pgvector semantic search, a SOUL user-profile layer. When I read the gist, my first reaction wasn't "good idea." It was "we already shipped this, and the three things his approach can't solve are already solved in ours."

This isn't a critique post. It's a thank-you note, plus a technical comparison of what shifts when you take the same insight and build it as a cloud-native, MCP-first product instead of a local gist.

Three Walls Karpathy's Approach Runs Into

First wall: scale. Karpathy notes that at around 100 sources and a few hundred pages, an index.md is enough and you don't need a vector store. At that scale he's right. But knowledge bases grow. Past 500 entries with cross-domain concepts, keyword matching and index scans start failing. You need semantic similarity. KnowMine was pgvector + text-embedding-3-small on day one. Every entry vectorizes on save; related content surfaces automatically.

Second wall: local lock-in. Karpathy's workflow needs Claude Code or Codex on your laptop, plus local Obsidian. Your knowledge base ends up bound to one machine and one session. KnowMine exposes the whole knowledge base as a remote MCP endpoint. Any MCP-compatible agent, from Claude Code to OpenCode to a custom one, reads and writes the same library from anywhere.

Third wall: human-driven. In Karpathy's flow you explicitly "ingest" sources and "query" the wiki. The LLM only moves when prompted. KnowMine's MCP tools let an AI agent proactively save knowledge mid-conversation. We call this "conversational knowledge capture": you're talking through a problem with Claude, and it stores the insight for you without breaking the thread.

Architecture Side by Side

Same philosophy, different implementation

Layer	Karpathy	KnowMine
Raw sources	Local raw/ directory	Any content via the MCP add_knowledge tool: text, URLs, voice transcripts
Knowledge base	Markdown files written by the LLM	pgvector-indexed entries with auto-tags, auto-folders, auto-embeddings
Rules / schema	CLAUDE.md / AGENTS.md	SOUL profile (AI-written user model) + folder presets

What it feels like through MCP

When an AI agent saves knowledge into KnowMine mid-conversation:

Tool: add_knowledge
Input: {
  "content": "Karpathy's LLM Wiki pattern validates...",
  "type": "insight",
  "tags": ["competitive-analysis", "knowledge-management"]
}

No filesystem. No local agent. No configuration. The entry is vectorized, tagged, and searchable instantly.

11 MCP tools, not just CRUD

• add_knowledge / update_knowledge / delete_knowledge: basic lifecycle
• search_my_knowledge: semantic vector search across your whole library
• get_related_knowledge: surface hidden connections between entries
• save_memory / recall_memory: persistent AI memory across sessions
• get_soul: pull the AI-generated user profile
• get_insight: AI-driven analysis of your knowledge patterns
• list_folders: browse how your knowledge is organized

What We're Borrowing Back

A few ideas from the gist land directly on our roadmap:

The lint pass. Periodic AI health checks over the whole knowledge base: find contradictions, orphan entries, stale claims, missing connections. KnowMine's get_insight is an early version. A full "knowledge lint" is queued up.

Good answers become new pages. This feedback loop, where a single exploration compounds into a permanent entry, is already what save_memory and add_knowledge do in conversation. Karpathy's framing as "knowledge compound interest" is the sharpest name anyone has given it.

User-tunable schema. Letting users define how their knowledge is organized is a strong design choice. Lines up cleanly with our planned folder presets.

Who Should Use What

Karpathy's approach fits you if:

• You're a developer comfortable with Claude Code or Codex
• You want data locked to a local machine
• You like Obsidian's graph view and plugins
• Your knowledge base is topic-specific, roughly 100 sources

KnowMine fits you if:

• You want AI agents to read and write your knowledge base remotely
• You need semantic search across a growing library
• You want zero setup: no local agent, no file management
• You use multiple AI tools and want a shared knowledge layer
• You want the AI to proactively capture knowledge during conversation

You can run both. Nothing stops you from using KnowMine as the compiled knowledge layer while keeping raw sources in local Obsidian. MCP is an interoperability protocol; that's the point of it.

5 Minutes to Hook It Up

1. Grab your MCP key at knowmine.ai
2. Add the MCP endpoint to your agent config:

   knowmine.ai/api/mcp?key=YOUR_KEY
   

3. Tell your agent: "Save this insight to my knowledge base." It just works.
4. Search semantically: "What do I know about knowledge management?" Related entries surface by meaning, not keywords.

Memex, Delivered

Karpathy quoted Vannevar Bush's 1945 Memex vision: a personal knowledge store where the links between documents matter as much as the documents themselves. Bush never answered who would maintain it. Karpathy says the LLM can. I agree, and the next step is obvious: make that maintained knowledge base reachable through a standard protocol, from anywhere, to every AI agent you use.

Your knowledge shouldn't be trapped in one tool or one machine. It should be a service any AI can call.