Building an Andrej Karpathy–Style LLM Wiki for a Personal Knowledge Base

How I used Karpathy’s LLM Wiki concept to transform raw technical material into a continuously evolving personal knowledge base.

Understanding Karpathy’s LLM Wiki Concept

Most people use LLMs like search: upload documents, retrieve answers, repeat. Useful, but nothing compounds.

Karpathy’s LLM Wiki proposes a different approach: instead of repeatedly searching raw material, an LLM builds and maintains a persistent wiki that continuously integrates, organizes, and refines knowledge over time.

New sources are not just stored, they are synthesized into structured pages, linked to existing concepts, updated against prior knowledge, and turned into a growing knowledge artifact.

This shifts personal knowledge management from passive note storage to an active system for building understanding.

Why This Matters

Most people use LLMs and documents like RAG: upload files, retrieve relevant chunks, generate answers, repeat. It works, but each question starts from scratch, forcing the system to repeatedly rediscover knowledge rather than build on it. Karpathy’s core insight is that retrieval alone does not compound.

His LLM Wiki reframes this entirely: instead of querying raw material every time, the LLM incrementally transforms sources into a persistent, structured wiki that compounds over time.

For technical fields like machine learning, where knowledge is dense, fragmented, and constantly revisited, this shift is powerful. Rather than repeatedly re-reading scattered documentation, each new source strengthens an evolving system of linked concepts, refined summaries, and accumulated understanding.

RAG retrieves. LLM Wiki compounds.

To test this, I used machine learning as the knowledge domain:

• Obsidian for capturing raw material
• Claude Code for ingesting and structuring knowledge
• GitHub for versioning and long-term evolution

The result was not just a note repository, it became a continuously improving system for structured understanding.

Repository Structure

Figure 1. Repository structure of the LLM Wiki

I kept the implementation intentionally simple.

The repository follows Karpathy’s three-layer pattern: raw sources, wiki, and schema.

The raw layer stores source material such as articles, documentation, and notes. These files are treated as the source of truth and should not be rewritten by the LLM.

The wiki layer stores the structured Markdown pages generated from those sources. This is where summaries, concept explanations, comparisons, and links between ideas live.

The schema layer is defined in CLAUDE.md. It tells Claude Code how to ingest sources, update the wiki, maintain the index, and record changes in the log.

Workflow

Step 1: Knowledge enters system

Figure 2. Using Obsidian Web Clipper to capture source material

When reading technical material (for example, scikit-learn documentation on clustering), I use Obsidian Web Clipper to send source material directly into the raw/ layer of the repository.

Step 2: Knowledge becomes structured

Figure 3. Claude Code compiling raw notes into structured wiki pages

Once captured, Claude Code processes raw notes according to the repository schema (CLAUDE.md), transforming them into structured wiki pages, updating related concepts, and maintaining system-wide indexes.

Step 3: Knowledge becomes usable

Figure 4. Obsidian Graph View visualizing links between generated wiki pages

After compilation, Obsidian becomes the human-facing interface for browsing the generated wiki. The structured pages can be searched, revised, and explored through views like Graph View, making relationships between concepts visible. For deeper interaction, Claude Code can still be prompted against the repository to answer questions, update pages, connect related concepts, or extend the wiki with new material. At this stage, the system becomes both a readable knowledge base and an LLM-maintained workspace.

Key Takeaways

This was a small project to test Karpathy’s LLM Wiki idea in practice.

The main thing I learned is that the value is not just storing notes. The useful part is having an LLM turn raw material into structured, linked Markdown pages that can keep improving over time.

In my setup:

• raw/ keeps the original source material
• wiki/ stores the generated pages
• CLAUDE.md tells Claude Code how to process and maintain the wiki
• Obsidian makes the result easy to browse
• GitHub keeps the changes versioned

This is only one way to implement the idea. Other people can adapt the same pattern to their own domain, whether that is research papers, business documents, course notes, books, personal notes, or project knowledge.

The tools do not have to be the same. Different agents, folder structures, MCP tools, local search, graph databases, or even a custom app could all work. The important pattern is the same: raw sources go in, the LLM maintains a structured wiki, and the knowledge base improves over time.

Final Thought

This project was just a simple experiment with Karpathy’s LLM Wiki pattern.

I used Obsidian, Claude Code, and GitHub because they were easy to connect and already worked well with Markdown. But the idea is not tied to these tools.

The main takeaway is that an LLM Wiki gives you a way to move from scattered notes to a more organized knowledge base. Instead of asking an LLM to rediscover the same information every time, you can let it build and update a persistent set of pages that you can browse, edit, and reuse.

It does not replace search or RAG. It is just another way to organize knowledge when you want the information to compound over time.

Project Repository

The simple implementation I used for this experiment is available here: victorjongsoon/machine-learning-wiki: A practical machine learning wiki with concise notes, examples, diagrams, and revision-friendly explanations.

References

• Andrej Karpathy’s LLM Wiki idea file: https://gist.github.com/karpathy/442a6bf555914893e9891c11519de94f
• Obsidian: https://obsidian.md/
• Obsidian Web Clipper: https://obsidian.md/clipper
• Claude Code: https://claude.ai/code
• GitHub: https://github.com/