README.md

Awesome LLM Wiki

A curated list of foundational blueprints, functional frameworks, and technical guides for building compounding, AI-compiled knowledge bases.

Inspired by a paradigm shift in software development engineering, this architecture treats large language models not as ephemeral chat engines, but as stateful knowledge compilers. Instead of parsing fragmented document partitions dynamically at runtime via traditional RAG loops, these systems leverage autonomous agents to read static source files and systematically construct an interlinked, persistent Markdown knowledge topology.

---

Contents

• Foundations
• GitHub Gists
• Articles and Guides
  • Conceptual Primers and Comparisons
  • Tutorials and Setup Guides
  • Case Studies and Retrospectives
• Specifications and Standards
• Tools and Plugins
  • Libraries and Frameworks
  • Applications and Desktop Clients
  • Editor Extensions and Plugins
  • CLI Compilers and Builders
  • Ingestion and Synchronization Utilities
  • MCP Servers and Integrations
  • Hosting and Infrastructure Platforms
  • Agent Skills and System Rules
  • Starter Templates and Boilerplates
• Live Implementations and Reference Vaults
• Research and Papers
• Academic Courses and Lectures
• Videos
• Podcasts
  • Build With AI
  • Microsoft Cloud IT Pro Podcast
  • Working Code Podcast
• Forums and Discussions

Foundations

Foundational material from Andrej Karpathy that introduced and defined the LLM Wiki architecture.

• Andrej Karpathy's First Post on LLM Knowledge Bases - The original post by Andrej Karpathy introducing the concept of using LLMs to compile and maintain persistent, file-based knowledge bases over traditional RAG.
• Andrej Karpathy's Follow-up Post on the LLM Wiki Idea File - The follow-up post by Andrej Karpathy publishing the formal LLM Wiki gist and conceptual framework for autonomous knowledge compilation.
• Andrej Karpathy's LLM Wiki Gist - The foundational idea file laying out the core pattern, operations, and architecture for compounding AI knowledge bases.

GitHub Gists

Community blueprints, proof-of-concept system schemas, and architectural experiments published as GitHub Gists.

• Farza's Personal Wiki Skill - A functional blueprint for implementing an LLM wiki compiler using Claude Code skills, including commands for ingestion, absorption, and automated cleanup.
• graphwiki: an LLM Wiki pattern for graph databases - A conceptual blueprint mapping the LLM Wiki pattern to a property graph (Neo4j) with entity resolution benchmarks.
• LLM Wiki v2 - An architectural extension of Karpathy's blueprint focused on scale, memory lifecycles, confidence decay, and typed knowledge graphs.
• LLM Wiki v3: A State-Space Knowledge System - An architectural specification extending the LLM Wiki pattern into a probabilistic state-space model where the LLM extracts structured observations, a belief engine updates evidence states, and markdown wiki pages are rendered as deterministic views of underlying truth graphs.
• LLM Wiki V3: Segmentation - A scaling specification addressing context drift and schema overload in LLM Wikis. Proposes segmenting systems into specialized roles (Ingestor, Librarian, Linter), dual ingestion modes ('restricted section' deep curation vs. 'open stacks' shallow indexing), explicit schema triggers to minimize drifting implicit instructions, and cache rewarming to prevent multi-agent navigation bias.

Articles and Guides

Technical examinations, exhaustive architectural deep-dives, and detailed workflow overviews.

Conceptual Primers and Comparisons

High-level conceptual breakdowns, comparative studies against vector RAG, and theoretical analyses of compiled memory.

• A Home for Personal Context (Duncan Davidson on O'Reilly Radar) - An architectural essay on the hosting substrates and design principles of user-controlled agent memory. Analyzes the trade-offs of storing context vaults locally (flat-file Markdown/Git), on the web (REST/MCP over Cloudflare Workers), and on mobile devices (SwiftUI/iCloud), outlining seven core principles for durable, interoperable personal context.
• Andrej Karpathy Killed RAG. Or Did He? The LLM Wiki Pattern (Mandar Karhade) - An architectural analysis comparing traditional vector RAG pipelines against the compiled, static LLM Wiki pattern.
• Andrej Karpathy Wiki: LLM Wiki Concept Guide - A conceptual breakdown embedded inside the live Karpathy encyclopedia detailing the explicit operating models, file structures, and automated compilation loops that define a production-grade LLM Wiki setup.
• Andrej Karpathy's Fix for LLM Memory Works on Code Too (Yanli Liu on Medium) - An article analyzing the extension of the LLM Wiki pattern to software repositories. Discusses compiling codebase structure into SQLite databases via tree-sitter AST parsing and exposing symbol relationship graphs to coding agents over MCP servers.
• Andrej Karpathy's LLM Knowledge Bases Explained (Mehul Gupta on Medium) - A conceptual primer explaining the LLM Wiki pattern. Contrasts standard vector RAG (where the model remains a "tourist") with Karpathy's compiled knowledge approach (where the model acts as a "compiler"), detailing the workflow steps of collection, compilation, maintenance, and querying.
• Andrej Karpathy’s LLM Wiki: Full Breakdown and How to Build Your Own (Hari Krishna on Tech in General Substack) - A comprehensive conceptual primer detailing the limitations of stateless RAG, explaining the three-layer architecture (immutable raw sources, LLM-generated markdown notes, and system schema configuration), outlining the three core operations (Ingest, Query, Lint), and connecting the pattern to Vannevar Bush's Memex.
• Better Models Won’t Save Your Agent (Pinecone Blog) - A technical analysis on why vector search loops fail for agents, advocating for a pre-compiled context engineering layer.
• Beyond RAG: How Andrej Karpathy's LLM Wiki Pattern Builds Knowledge That Actually Compounds (Plaban Nayak in Level Up Coding) - A conceptual breakdown of the compilation loop model in LLM Wikis. Explains why stateless RAG pipelines fail to accumulate learning over time, comparing vector search to an "amnesic assistant" and detailing the three-layer layout (raw, wiki, schema) required to support self-maintaining agent knowledge bases.
• Beyond RAG: Knowledge That Compiles (Bailing Zhang on LinkedIn) - A conceptual primer examining the limits of stateless vector search and the necessity of compiled knowledge for complex agent behaviors. Reflects on a review of thirty-nine agent builds, showing that while plain RAG handles descriptive lookups, multi-step workflows require a structured, self-maintaining Markdown knowledge layer to prevent context decay.
• Building an 'Agent Only' Obsidian Vault (The Thinkers Club) - A technical architectural guide defining a human-agent sandbox paradigm. Details a methodology for isolating autonomous AI writers inside a dedicated secondary vault to compile a self-organizing wiki of consumed data, preventing context contamination and layout drift in human-authored notes.
• Commonplace - A technical framework establishing the theory of deploy-time learning for bounded AI observers, detailing semantic distillation operations, and providing automated CLI workspace management skills.
• Compounding Knowledge with LLMs: Karpathy's Wiki Pattern in Action - An architectural analysis connecting Andrej Karpathy's LLM Wiki pattern to Vannevar Bush's historical vision of the Memex. Discusses how LLMs resolve the bottleneck of active knowledge maintenance, detailing layout models, indexing processes, and scalable retrieval strategies for multi-agent environments.
• Create Your AI Brain Today - The final part of a structural context trilogy pinpointing why knowledge management setups fail at the content layer. Focuses on content architecture optimization, detailing how to engineer high-signal markdown nodes, construct type-safe frontmatter blocks for explicit entity tracking, and implement strict data compression filters to protect agent context windows from token bloat.
• From Agentic RAG to Compiled Knowledge: Why Karpathy's Wiki Idea Is Spreading (Dotzlaw Consulting) - An architectural analysis of the industry convergence on compiled knowledge engines over expensive agentic RAG loops.
• Give Your AI Unlimited Updated Context - An operational architecture guide exploring decoupled, portable text vaults. Outlines the strategic benefits of maintaining plain text markdown knowledge graphs over proprietary, model-siloed memories, detailing how to utilize root configuration files (CLAUDE.md) and automated background agent loops to keep cross-functional context updated natively.
• Inside the LLM Wiki Movement: Build Knowledge That Won't Betray You (Allen on AFFiNE Blog) - A deep conceptual primer examining the LLM Wiki movement, contrasting the four core architectures (single-file, multi-file vault, code-based, and RAG-augmented), discussing hallucination mitigation via confidence tagging, and reviewing platform trade-offs.
• Introducing OpenWiki Brains, general-purpose wiki memory for agents (LangChain Blog) - The official announcement of OpenWiki Brains, detailing how agents use flat-file local wikis as proactive long-term memory.
• Karpathy shares 'LLM Knowledge Base' architecture (VentureBeat) - The foundational tech journalism coverage analyzing Andrej Karpathy's autonomous archive philosophy. Details the engineering advantages of substituting dense vector RAG with an evolving, AI-maintained local Markdown wiki to prevent context-limit lobotomies in developer prompt streams.
• Karpathy's LLM Wiki as Agent Memory - A conceptual framework published by the Agentic AI Foundation mapping the LLM Wiki pattern to cognitive agent memory architectures. Explains how directory boundaries transform flat markdown files into distinct functional memory layers—mapping schemas to procedural execution rules, logs to episodic records, and cross-linked entity directories to semantic graph memory.
• Karpathy's LLM Wiki Pattern: When Compiled Knowledge Beats RAG (Particula Tech) - An architectural analysis contrasting runtime vector RAG pipelines against ahead-of-time LLM knowledge compilation. Explores how pre-compiled markdown structures eliminate chunk-boundary errors and embedding drift, proposing a hybrid enterprise architecture that routes stable core knowledge to a compiled wiki and volatile high-scale data to vector search.
• Karpathy's LLM Wiki v2: What to Keep - A critical architectural teardown outlining the evolution of the LLM Wiki design pattern. Details the necessary shift from manual workflows to parallel background agent pipelines, explains how to replace heavy index rewrites with vector mapping arrays, and demonstrates how to implement a targeted JSON pre-routing layer to keep API context costs minimal as local vaults grow past thousands of nodes.
• Karpathy's LLM Wiki: A Knowledge Base That Compounds (AI Builder Club) - An architectural breakdown of the LLM Wiki pattern contrasting it with standard RAG pipelines, defining the three-layer structure and three operations.
• Karpathy's LLM Wiki: The Complete Guide (Agentpedia Codes) - An exhaustive breakdown analyzing the three-layer architecture, comparing static compilation vs. traditional RAG, and detailing prompt configurations.
• LLM Markdown Wiki: A Personal Second Brain Without the Maintenance (Kiryl Bahdanovich on WAVEPILLARS) - A conceptual guide detailing how an LLM-maintained markdown wiki cuts knowledge maintenance overhead. Explores the raw/wiki/schema architecture, Obsidian graph-based hierarchy reviews, Cursor agent sync workflows, and utilizing frontmatter-first agent searches to optimize token usage.
• LLM Wiki (Kamenik Solutions) - A digital garden note summarizing the LLM Wiki pattern. Explains when to use compiled vaults over dynamic vector RAG, outlines the three core layers (raw sources, structured wiki, instruction schemas), and notes its trial as an organizational technique for agent-curated vaults.
• LLM Wiki Is Not a RAG Replacement - It's a Synthesis-Time Decision (Ranjan Kumar on Personal Blog) - An architectural deep-dive analyzing why the LLM Wiki pattern does not replace vector RAG, but rather shifts the synthesis timeline. Explains the difference between ingest-time synthesis (compiling) and query-time synthesis (interpreting), outlines the "Synthesis Horizon" scaling cliff, and proposes a stratified corpus model.
• LLM Wiki vs RAG for Internal Codebase Memory: Which Approach Should You Use? (MindStudio Blog) - A comparative guide analyzing the tradeoffs between RAG and flat-file LLM Wikis for codebase memory and agent context routing.
• LLM Wiki vs RAG: The Karpathy Concept and Enterprise Reality (Emily Winks on Atlan Blog) - A comparative analysis of Karpathy's LLM Wiki approach against enterprise RAG systems. Discusses the trade-offs in token efficiency, access control, concurrency, and data freshness pipelines, outlining the additions (such as role-based permissions and transactional layers) needed to scale markdown-based memory vaults for team collaboration.
• LLM Wiki: Karpathy's Idea for AI Knowledge Bases (Denser.ai) - An analysis of Karpathy's LLM Wiki pattern, reviewing top implementations, product principles, and RAG integration.
• LLM Wiki: The Compounding Knowledge Base, Explained (Mikko Lehtimäki on Softlandia Blog) - A conceptual primer explaining how LLM Wikis function as self-updating knowledge bases for AI agents. Compares link-based traversal against vector RAG models, outlining the minimal operational structure (sources/, wiki/, index.md, and system instructions) needed to enable compounding context.
• LLM Wiki: The Self-Updating AI Knowledge Base (Tericsoft Blog) - A conceptual primer analyzing the scaling of the LLM Wiki pattern to enterprise teams, detailing the compute cost tradeoffs (compile-time vs. query-time RAG), scheduled linting loops, access governance, version control integration, and agent memory architectures.
• LLM Wiki: Understanding the New AI Knowledge Architecture (Dario Radečić on DataCamp Blog) - A conceptual primer contrasting traditional retrieval-first systems (vector RAG) with compilation-first systems (LLM Wikis), explaining the three-layer pipeline architecture, key tradeoffs (freshness, accuracy, maintenance, scalability), and real-world agent memory benefits.
• Obsidian: Your AI Second Brain isn't Memory (Roan Brasil Monteiro) - A deep-dive system design guide mapping out the engineering mechanics of an active knowledge compiler loop over passive vector RAG. Formulates why standard semantic search layers cause context decay, providing a clean blueprint for building deterministic, git-backed file topologies in plain Markdown.
• OpenWiki 0.2 brings OKF to codebase documentation (LangChain Blog) - The official announcement of OpenWiki 0.2, detailing its integration of the Open Knowledge Format (OKF) specification.
• Pinecone Nexus: The Knowledge Engine for Agents (Pinecone Blog) - An announcement of Pinecone Nexus, a knowledge engine that compiles raw data into task-optimized markdown artifacts.
• RAG vs. Agent Memory vs. LLM Wiki: A Practical Comparison (visrow Medium) - A comparative analysis of stateless vector RAG, stateful agent memory, and pre-compiled LLM Wikis.
• RAG, LLM Wiki, Agentic Search: Differences, Costs and Use Cases (2026) (Pasquale Pillitteri) - A comparative analysis of RAG, LLM Wikis, and agentic search architectures. Details their technical evolution from 2022 to 2026, compares build/operational cost structures ($15k–$200k for enterprise RAG/agents vs. $200–$500 compilation cost for wikis), and maps out specific enterprise use cases.
• RAG, LLM Wiki, or Gbrain? How Your Agent Remembers Changes Everything (Yanli Liu on GOPUBBY) - A comparative architecture analysis contrasting traditional runtime RAG, compiled LLM Wikis, and Garry Tan's workflow-centric Gbrain framework to guide the choice of agent-optimized knowledge substrates.
• Self-Authoring LLM Knowledge Bases - A technical conceptualization extending the compilation loop to live developer conversations, transforming ephemeral terminal and editor interactions into structured, persistent memory.
• The Benefits of Using an LLM Wiki for Your AI Chatbot (Nick Kirtley on 99helpers) - A conceptual breakdown outlining the structural advantages of using compiled Markdown wikis to ground AI chatbots, covering setup simplicity, response speed, contextual consistency, and cost metrics compared to vector RAG setups.
• The Designer's LLM Wiki (Fanny on AI Product + Design) - An essay exploring the value of personal, queryable LLM Wikis for product designers. Highlights the challenge of design insights scattered across Figma, Notion, and Slack, proposing a markdown context layer to let models synthesize design learnings and onboarding flows across multi-product histories.
• The LLM Wiki at Scale: From Personal Research Tool to Production RAG (Michal Nasternak on Medium) - An architectural analysis examining how to scale the LLM Wiki pattern to enterprise production. Details the bottlenecks of single index files once vaults grow past hundreds of pages, proposing session-level on-demand wiki compilation and per-user persistent knowledge layers to optimize synthesis quality, cost efficiency, and debuggability over traditional vector RAG.
• The Missing Data Layer in LLM Knowledge Bases (Claudiu Dascalescu on Xata Blog) - An architectural primer proposing a dual-layer structure that pairs PostgreSQL (for transactional data/metrics) with a Markdown wiki (for qualitative context), detailing saved SQL queries, database branching, and agent skill configurations.
• The Real Second Brain: An Autonomous Knowledge Engine - An architectural essay defining the paradigm shift from ephemeral chat interfaces to persistent, agent-driven local wikis. It details how flat-file markdown vaults serve as a deterministic long-term memory layer for autonomous daemons, allowing collaborative, human-in-the-loop knowledge compilation and state management.
• The State of Agent Wikis (Mem0 Blog on X) - An overview by the Mem0 team analyzing the emerging landscape of model-maintained markdown vaults.
• Three Answers to Karpathy's Question: Google OKF, Tencent WeKnora, and LangChain OpenWiki (Bailing Zhang on LinkedIn) - A comparative primer examining three architectural responses to Karpathy's LLM Wiki pattern: Google's Open Knowledge Format (OKF) specification, Tencent's layout-aware WeKnora framework, and LangChain's OpenWiki engine. Explores how each manages persistent knowledge, document parsing, and agent memory.
• What Is an LLM Knowledge Base? (Emily Winks on Atlan Blog) - A foundational primer defining the architecture and component layers of external LLM knowledge stores. Distinguishes between vector, graph, and context-window models (such as Karpathy's), diagnoses the main reasons enterprise RAG systems fail (lossy source audits, conflicting schemas), and outlines best practices for upstream metadata enrichment.
• What Is an LLM Wiki — and Should You Build One? (Floatboat Blog) - A high-level primer introducing the LLM Wiki concept, detailing the three-layer architecture, highlighting Farza's personal wiki case study, and suggesting lighter alternatives for solo operators.
• What Is an LLM Wiki? A Simple Guide to Karpathy's Personal Knowledge System (Nick Kirtley on 99helpers) - An introductory conceptual guide explaining the core model of LLM Wikis, contrasting their pre-compiled markdown approach with vector-only RAG pipelines, and detailing formatting best practices (one-idea notes, header summaries).
• What Is Andrej Karpathy's LLM Knowledge Base Architecture? The Compiler Analogy Explained (MindStudio Blog) - An architectural breakdown explaining the compiler analogy for LLM Wikis, comparing raw sources to source code.
• What is LLM Wiki Pattern? Persistent Knowledge with LLM Wikis - A structural guide defining the core filesystem architecture and ingestion loops of the LLM Wiki pattern. Outlines the read/write boundaries between raw source directories and compiled wiki spaces, detailing a 5-step compilation pipeline and contrasting the pre-compiled text routing method against traditional single-pass vector RAG pipelines.
• What Is the LLM Knowledge Base Index File? How Agents Navigate Without Vector Search (MindStudio Blog) - An article explaining the design, formatting, and structural benefits of using an index.md navigation map in LLM Wikis.
• What Karpathy's LLM Wiki is Missing (And How to Fix It) (Penfield Labs) - A deep architectural critique outlining solutions for token scaling limits in file-based context stores, featuring code patterns for semantic deduplication and pre-commit syntax hooks to protect structural integrity.
• Why Karpathy is Right: RAG is Dead, Long Live the Agentic Wiki (Epsilla Blog) - An enterprise analysis comparing flat-file Markdown wikis against database semantic graphs for corporate memory.
• Wiki Memory (LangChain Blog) - An architectural examination of the emerging wiki memory pattern, comparing file-based compilation against RAG loops.
• Your AI Agent Needs a Map: LLM Wiki vs README-Driven Documentation (Roman Dykyi on Medium) - A comparative analysis examining how developers feed context to AI coding agents, contrasting project-mapping files (like README.md and CLAUDE.md) with compounding knowledge layers (LLM Wikis), and exploring token management, drift risks, and file-linking topologies.
• Your Personal Brain: A Practical Guide for Leaders, Practitioners, and Enthusiasts (Nufar Gaspar LinkedIn) - A management playbook exploring how to establish a "dump-and-housekeep" maintenance cycle for agent memory.

Tutorials and Setup Guides

Practical setup walkthroughs, implementation blueprints, and step-by-step guides for constructing personal vaults.

• Andrej Karpathy's LLM Wiki: Create your own knowledge base (Urvil Joshi on Medium) - A step-by-step setup guide for building a personal LLM Wiki, outlining the three-layer vault architecture (raw sources, wiki nodes, and CLAUDE.md guidelines) managed via the Claude Code terminal agent and visualized in Obsidian.
• Automate AI Second Brain (LLM Wiki Pattern) With Claude Code and Obsidian - An advanced guide transitioning the LLM Wiki pattern from interactive commands into an automated background operating system. Details how to orchestrate automated morning briefings and evening debriefs using Anthropic Cloud Routines, steer background agents with structured priority maps, and integrate live external context using Google Calendar and Gmail MCP servers.
• Beyond Catastrophic Forgetting: How to Build an LLM Wiki for the Long Game (Part 1 of 3) - A step-by-step guide to building a persistent, compounding markdown wiki using Claude Code and Obsidian on Windows. Outlines schema rules, ingestion pathways, and automated maintenance loops.
• Beyond RAG: How I built a serverless AI LLM Wiki engine using OKF and AWS RODA (visrow Medium) - A guide on building a browser-based, serverless OKF wiki compiler using WebLLM and AWS Registry of Open Data.
• Build an AI Second Brain (LLM Wiki Pattern) With Claude Code and Obsidian - A practical implementation blueprint executing the LLM Wiki pattern using Claude Code as a vault maintainer. Demonstrates how to configure text-based slash commands (/ingest, /query, /lint, /log) to manage the boundary lines between raw input stores and compiled concept nodes while establishing hard citation tracking across file line coordinates.
• Build an LLM Wiki for Your AI Agents with myKG and Obsidian - An implementation guide introducing the open-source myKG library to enforce type-safe ontologies in local vaults. Demonstrates how to run automated pipeline integrations for Claude Code using terminal skill configurations, establish explicit source traceability records, and configure numerical confidence tracking metrics to eliminate silent agent hallucinations.
• Building an LLM Wiki, Part 1 (Erik Evenson Blog) - A guide explaining how to implement the basic Karpathy pattern using Obsidian, its Local REST API, and Claude Code.
• Building an LLM Wiki, Part 2 (Erik Evenson Blog) - An article detailing schema linting, staleness detection, contradiction handling, and search testing for LLM Wikis.
• Compiling knowledge, not retrieving it (Roan Brasil Monteiro) - A code-level implementation guide detailing the software architecture of the llm-wiki-compiler engine. Walks through the step-by-step orchestration of a multi-model text compilation loop, local workspace linting rules, and inline source-provenance tracking without vector databases.
• How Row-Bot Uses a Local Knowledge Graph for Private AI Memory (Syd Sachar) - A technical guide explaining how Row-Bot compiles local-first memory into an Obsidian-compatible wiki graph.
• How to Build a Second Brain You Can Actually Trust Using myKG and Obsidian (Senol Isci on Medium) - A guide addressing facts and hallucination risks when extracting knowledge graphs with LLMs. Introduces myKG configurations using confidence-scoring metrics, strict source attributions, pre-extraction schema validation gates, and tunable trust thresholds to build verifiable personal Obsidian wikis.
• How to Build an AI Brain That Never Forgets - A practical implementation blueprint detailing how to build an air-gapped, local Obsidian memory vault. Walks through extracting conversational data streams from proprietary web platforms, configuring root-level orchestration instructions (CLAUDE.md), and deploying background automation scripts to sync data sources and log daily workflow progress.
• How to build an AI second brain that doesn't go stale (Scribelet Blog) - A guide adapting the CODE and PARA frameworks for AI workflows, highlighting knowledge decay, semantic auto-linking, and Model Context Protocol (MCP) integrations.
• How to Build an LLM Knowledge Base (DAIR.AI) - A practical workshop guide defining a standard local directory architecture and outlining repeatable agentic compiler patterns.
• How to Build Karpathy's LLM Wiki: The Complete Guide to AI-Maintained Knowledge Bases (Dylan Boudro on Starmorph) - A comprehensive setup walkthrough detailing the three-layer LLM Wiki architecture, outlining the ingest/query/lint workflows, and providing a production-ready CLAUDE.md schema template for Obsidian and Claude Code integration.
• How to Build Your Agentic Knowledge Base (after 16 months of running my own) (Chris Lettieri on Bits of Chris Substack) - A practical implementation guide outlining a three-layer folder structure (inbox, notes, map) to let a knowledge vault taxonomy emerge organically, detailing the standard eight components of agentic vaults and the scaling progression path.
• LLM Knowledge Bases (DAIR.AI) - A detailed breakdown of the four-phase compilation pipeline (Ingest, Compile, Query, Lint) with architecture diagrams and implementation workflows.
• LLM Wiki 1: Building a Minimal LLM Wiki (Ken Moriwaki) - A three-part implementation series on building a minimal Markdown knowledge base and maintaining it with agents.
• LLM Wiki 2: Visualising an LLM Wiki in Obsidian (Ken Moriwaki) - The second part of a practical series exploring how to visualize and inspect compiled Markdown wikis inside Obsidian.
• LLM Wiki 3: From LLM Wiki to Agentic Knowledge Maintenance (Ken Moriwaki) - The third part of a series outlining how to transition static Markdown wikis to autonomous agentic maintenance workflows.
• LLM Wiki for Notion: Building a Claude-Powered Second Brain with a 3D Knowledge Graph (IVGraph) - A guide on building a Claude-powered LLM Wiki from Notion databases using MCP and 3D knowledge graph visualizations.
• LLM Wiki Local (Local LLM) (Part 2 of 3) - A tutorial on configuring a fully local-first LLM Wiki using llama.cpp and Opencode on Windows. Demonstrates manual environment wiring, setting up AGENTS.md instructions as standard operating procedures, and deploying custom scripting gates to manage local data compilations.
• LLM Wiki Local: The Hybrid Engine and the PDF Bridge (Part 3 of 3) - A tutorial on constructing a hybrid ingestion engine for local LLM Wikis on Windows. Focuses on resolving formatting issues with large PDF documents using a custom Python script (the PDF Bridge) and routing local traffic via the Bifrost gateway.
• Standardizing Agent Memory: Building a Self-Updating Codebase Knowledge Graph with Google’s OKF (Udaykiran Estari on Medium) - A configuration guide detailing how to build a git-hook-triggered pipeline to keep an OKF knowledge graph in sync. Demonstrates how to automatically compile, link, and lint repository context with every commit to serve pre-warmed context to agents.
• Supercharging LLM Wiki with Knowledge Graphs: Build a Self-Evolving Research System (Video) - A guide and video tutorial detailing how to integrate network analysis and knowledge graphs into an LLM Wiki. Uses InfraNodus and Obsidian to identify conceptual clusters, map structural gaps, and direct agents (via custom skills in Claude Code) to formulate research questions that resolve disconnected topics.
• The Enterprise LLM Wiki: Scaling Karpathy's Pattern to Your Org (Falconer Guides) - A guide on scaling the LLM Wiki pattern to organizations, detailing tool-native ingestion and drift detection.
• Turning Karpathy's LLM Wiki Idea into a Kiro Setup (AWS Builder Center) - A configuration guide detailing how to implement Andrej Karpathy's LLM Wiki pattern in the Kiro AI IDE. Explores configuring three-layer vault directories, defining system steering instructions, automating raw source ingestion via fileCreated event hooks, and running one-click health linting to prevent structural drift.
• What Is Andrej Karpathy's LLM Wiki? How to Build a Personal Knowledge Base With Claude Code (MindStudio Blog) - A beginner-friendly tutorial for setting up a local Obsidian vault and querying it using the Claude Code terminal client.
• Your Second Brain Is a Graveyard. Make It Agent Memory. (Decoding AI) - A guide on building an AI Research OS memory layer to compile notes and web sources into a queryable wiki for agents.

Case Studies and Retrospectives

In-depth case studies, domain-specific retrospectives, and personal audits of active wiki setups in production.

• Adding Quality Control to Andrej Karpathy's LLM Wiki (Mick Yates on Yatesweb) - A case study and methodology guide introducing a quality-control 'immune system' to an Obsidian LLM Wiki. Borrows from the NUSAP epistemic framework to implement a 5-column pedigree matrix (Provenance, Rigour, Coherence, Relevance Anchors, Claim Differentiation) in YAML frontmatter, ensuring agent ingestion loops distinguish rigorous peer-reviewed papers from unverified thought experiments.
• An LLM wiki changed how I work (Casey Newton on Platformer) - A case study by tech journalist Casey Newton detailing his experience building a personal "beat wiki" inspired by Andrej Karpathy. Explores how using an LLM to process and synthesize source materials into a structured, self-updating Obsidian-compatible Markdown wiki serves as a valuable research assistant, streamlining beat reporting and productivity.
• Build your AI Brain (Leo Alexandru) - A comprehensive production case study implementing a customized Karpathy LLM Wiki using the Claude Code CLI. Outlines a five-layer folder taxonomy, a flat permanent note topology, and a twelve-part modular agent skill ecosystem (.claude/skills/) to drive automated multi-stream file compilation (/wiki-compile), structural link linting (/wiki-lint), and contextual content generation.
• Building an LLM Research Wiki: How I Turned 3,000 Pages of Philosophy into a Living Knowledge System (Medium) - A case study outlining a phased ingestion methodology and the use of epistemic markers to compile dense academic texts.
• Building my own LLM-Wiki Research Team (Dylan Tartarini on Towards AI) (GitHub) - A case study defining the DyResearch multi-agent framework, utilizing specialized agent roles (Coordinator, Professor, Librarian, Researcher, Note Taker) and a FastAPI backend to compile research notes into Obsidian.
• Context Beats Tools: Reading a Memory Back (Part 3 of 4) (Brett Washington on Medium) - Part 3 of a 4-part series analyzing the read layer of an agentic wiki, explaining why feeding structured, pre-compiled markdown contexts back into context windows outperforms multi-round tool loops, and detailing index-first query routing.
• Customizing Karpathy's LLM Wiki for Fighting Disease (Ben Kamens) - A deep-dive production case study auditing the Karpathy flat-file wiki pattern under dense medical domain data. Details custom multi-modal ingestion strategies for complex clinical trial papers, multi-agent mutation strategies to resolve overlapping disease-symptom relationships, and deterministic verification protocols to enforce absolute factual integrity without relying on external relational databases.
• Engineers use markdown wikis as lightweight memory for Codex, Claude Code, and Hermes (AI Primer) - A collection of case studies on how developers use local folders, cron jobs, and MCP servers to serve as agent memory.
• From Documents to a Living Knowledge Graph: Introducing MyKG (Senol Isci on Medium) - An introductory case study presenting myKG, an open-source Python library that transforms unstructured documents into confidence-scored, source-grounded knowledge graphs. Explains how the library induces an OWL/RDFS schema, extracts verified entities and relations, and exports the resulting network as a wikilinked Obsidian vault, JSONL, or RDF Turtle database.
• From Karpathy's LLM Wiki to a Working Second Brain: My Implementation w/ Amazon Quick Desktop - Dima Kramskoy's step-by-step production review of a local flat-file LLM wiki automated via Amazon Quick Desktop and served locally using MkDocs. Details a four-tier ontology schema (concepts, entities, projects, sources) and implements an elegant visual diff-approval ingestion pipeline that treats the agent as a local workspace code contributor while preserving absolute human state control.
• From Second Brain To LLM Wiki: How I Built a Compounding Knowledge Base with AI (Ian Forster on IMF Software Blog) - A case study describing a transition from a traditional Logseq PARA second brain to an AI-maintained compounding wiki, detailing the three-layer layout (sources, wiki, schema) and three core compiler operations (ingest, query, lint).
• From Self-Updating OKF Wiki to Production Trust System (Udaykiran Estari on Towards AI) - A technical analysis on building a production trust system for agent-generated wikis. Explores how to transition from OKF generation to trust boundaries, outlining governance policies (signed bundles, append-only audits, and human review gates) to validate AI-drafted documentation.
• HUGE update on obsidian-second-brain: The Architect (Eugeniu Ghelbur on The AI Operator) - A case study detailing Ghelbur's Architect update to the obsidian-second-brain CLI tool. Explains how the system was expanded from compiling personal notes to parsing and documenting codebases inside the Markdown vault, detailing pipeline structures and context alignment.
• I am building a private synthetic wiki factory. Here is how and why. (Victor Golovin Blog) - An article detailing a multi-model pipeline compiling technical source materials into a SQLite-managed synthetic wiki.
• I Built Karpathy's LLM Wiki Twice — Once as Code, Once as a .md (Leandro Bernardo on Towards AI) (GitHub) - A comparative case study outlining the tradeoffs between a programmatic pipeline (predictability, typed contracts, token budgets) and an agentic instruction-based Markdown setup.
• I built this for myself. Then 1,374 strangers cloned it: How I gave Claude Code memory without a vector DB (Eugeniu Ghelbur on The AI Operator) - A follow-up case study on the launch and open-source reception of the obsidian-second-brain CLI tool. Focuses on the compound effect of sharing personal AI integrations and details how to provide Claude Code with long-term memory capabilities without relying on third-party vector databases.
• I Built Two AI Second Brains From the Same Documents (Deepak Singh on Medium) - A comparative empirical case study examining the impact of knowledge organization on Claude Code reasoning. Compares a rigidly structured Obsidian vault (strict SCHEMA.md, YAML metadata) against a minimally structured one, demonstrating how over-structuring can lead to confidently incorrect answers when data is missing and outlining a progressive structuring threshold at ~300 notes.
• I Gave My AI a Memory. Here’s How I Built It (Part 1 of 4) (Brett Washington on Medium) - A senior engineering leader's case study introducing his journey to build a compounding personal knowledge system, detailing why vector search RAG decays for agent context and illustrating the initial setup of an LLM-curated memory vault.
• I Rebuilt Karpathy's LLM Wiki. Here's What I Learned (Eugeniu Ghelbur on The AI Operator) - A personal retrospective exploring the construction of the Obsidian Second Brain CLI tool. Details the practical limitations of raw vector RAG for coding agents, outlines lessons learned around prompt routing and context persistence, and offers a blueprint for building folder-native knowledge layers in plain Markdown.
• I Tested 5 'LLM Wiki' Implementations So You Don't Have To (Mike Written) - A comparative review of five open-source LLM Wiki implementations, focusing on automation and workflow integration.
• I Used Karpathy's LLM Wiki to Build a Research Brain That Updates Itself (Adi on Towards AI) - A step-by-step production case study detailing a self-updating research vault. Combines Claude Code with Obsidian to automate note compilation, discusses why standard RAG models require constant re-teaching compared to persistent wiki files, and explores Git diff reviews to mitigate model hallucination and epistemic drift.
• Karpathy Plugin for Obsidian (Learning Aloud Blog) - A personal case study exploring the setup, troubleshooting, and model tradeoffs of running a local Obsidian LLM Wiki.
• Karpathy's 'LLM Wiki' with a Single Brain (Tony Demol on Medium) - A personal methodology case study reframing the LLM Wiki pattern as a 'single-brain knowledge catalyst' rather than an outsourced second brain. Details a 4-phase workflow (Explore, Learn, Index, Enrich) where human-authored notes maintain cognitive ownership and critical thinking, while the LLM acts as an automated sidecar for indexing, active recall, and quiz generation.
• Karpathy's LLM Wiki: How We Built a 2,188-Document Personal Knowledge Base (Echofold) - A case study detailing the extraction of 1,414 research tasks from Manus AI and compiling them into a structured Obsidian vault of 2,188 quality-scored, categorised documents.
• LLM wiki for the historical research (szymonszym on dev.to) - A case study exploring the application of the LLM Wiki pattern to historical research, detailing vault organization in Obsidian, prompt configuration using AGENTS.md, OCR text processing, and model ingestion costs.
• LLM Wiki Setup: Karpathy's Knowledge Base [2026 Guide] (Kunal Ganglani Blog) - A detailed case study exploring the setup, best tools, incremental updates, and common failure modes of running a local LLM Wiki.
• The AI Knowledge Layer: 127 Pages, Zero Vector Databases, and What I Got Wrong (Sebastian Kehle on Webvise) - A production retrospective and practical guide detailing the operation of a 127-page LLM knowledge layer without vector databases. Outlines real-world operating numbers, architectural lessons across the three-layer setup, common failure modes in agent maintenance, and setup blueprints for business research and project workflows.
• The Karpathy/Wyndo Wiki: How I Built a Knowledge Base That Maintains Itself (Lee Shand on Wired Differently Substack) - A personal case study detailing the construction of a self-maintaining Obsidian wiki using Claude Code, Readwise sync, and a custom skill toolkit, exploring cold-start sparse connections, import command challenges, and LLM-tagging behaviors.
• The LLM Wiki at 490 Pages: What 3 Months of Agent-Maintained Knowledge Actually Takes (Sebastian Kehle on Webvise) - A comprehensive 3-month operations report detailing the maintenance of a 490-page, 880-commit LLM Wiki in Obsidian. Explores six discrete agent operations (ingest, update, query, lint, enrich, reorganize), deterministic 20-check pre-commit lint gates, split human-agent ownership models, and healthy page-count consolidation passes.
• The LLM Wiki: 3 Months of Letting Agents Run My Second Brain (Sebastian Kehle on X) - A detailed production review of an LLM Wiki operating over a 450-page Obsidian vault, outlining folder structures, pre-commit linter checks, and split-ownership boundaries.
• The Schema Is the Product (Part 2 of 4) (Brett Washington on Medium) - Part 2 of a 4-part series detailing why the system instructions and formatting rules (the schema) represent the true value of an agentic wiki, explaining how to write rules that force agents to capture raw facts, structure page layouts, and log contradictions.
• The Wiki Is What Makes Local Models Usable (Part 4 of 4) (Brett Washington on Medium) - Part 4 of a 4-part series exploring how an external, flat-file Markdown wiki acts as a load-bearing memory layer that compensates for the small context windows of local on-device models, enabling private and cost-efficient knowledge work.
• This Open-Source App Turns Your Documents Into a Self-Building Wiki (Kristopher Dunham on Medium) - A review and user experience case study of the nashsu/llm_wiki desktop app. Runs through the core components of automated document ingestion, entity graph linkage, and automated markdown linting, outlining a lightweight manual recipe for testing the compiler loop before installing local tools.
• Three Months of My LLM Wiki: A Follow-Up and an Update (Medium) - A follow-up case study on separating agentic reasoning from deterministic linting rules to prevent consistency drift.
• We gave our agent a memory: building an LLM Wiki over sources that never sit still (Taktile Blog) - A case study on transitioning an agent from runtime RAG to an LLM Wiki structure to reduce latency and cost.
• What My Personal Knowledge Base Made Visible That I Couldn’t See (Robin Good Substack) - An essay exploring how converting personal writings into a local LLM Wiki exposes hidden cognitive patterns, expert positioning, and missing research areas.
• When is the Karpathy Wiki Better than RAG (Learning Aloud Blog) - A follow-up case study comparing pre-compiled local wiki query outputs against direct cloud RAG query results.
• WikiMind: Building an AI Knowledge Platform Inspired by Wiki LLM (Jayashan Manodya on Medium) - A case study on building a full-stack, AI-powered knowledge platform centered on the LLM Wiki pattern. Outlines utilizing LangGraph StateGraph to orchestrate stateful agentic ingestion workflows, LangSmith for QA validation, Turso Cloud Database for cross-device context pooling, and an interactive 2D physics-based knowledge graph to visualize concept nodes.

Specifications and Standards

Official architecture blueprints, industry standards, and schema specifications formalizing flat-file, agent-ready knowledge layout structures.

Open Knowledge Format (OKF)

• How the Open Knowledge Format Can Improve Data Sharing (Google Cloud Blog) - The official announcement and contextual release brief introducing OKF v0.1. Outlines the industry-wide problem of fragmented AI context landscapes and formalizes the Karpathy LLM-wiki pattern into an enterprise-accepted format for decoupling knowledge generation from proprietary database frameworks.
• Open Knowledge Format (OKF) Specification (Version 0.2) - The official technical blueprint by Google Cloud defining an open, vendor-neutral standard for human- and agent-friendly knowledge bundles. Outlines the exact structural contracts for a file-based layout: directories of raw Markdown documents, YAML frontmatter configurations (featuring provenance, trust status, and lifecycle tags), standard horizontally linked graphs, and attested computations.
• Open Knowledge format v0.2 tackles agentic trust (Google Cloud Blog) - The official announcement and release brief introducing OKF v0.2. Focuses on the addition of queryable frontmatter metadata properties (such as source credentials, provenance, and trust ratings) and attested computations to enable automated verification of agent-managed knowledge.

Tools and Plugins

Software utilities, automation scripts, and development plugins for structuring and maintaining LLM wikis.

Libraries and Frameworks

Code-first SDKs, programmatic pipelines, and developer libraries used to orchestrate or validate local context vaults.

• agent-swarm.dev (GitHub) - An open-source multi-agent execution framework and runtime engine. Coordinates lead and worker agents (Claude Code, Codex) inside isolated Docker containers, capturing tasks from Slack, GitHub, Linear, and Jira while maintaining a shared, compounding persistent memory substrate with hybrid graph-linked recall and human-in-the-loop review gates.
• axoviq-ai/synthadoc (Demo Video) - A local-first knowledge engine compiling multi-format sources into OKF markdown wikis, with a web UI and MCP server.
• codejunkie99/agentic-stack - A framework providing a unified, portable .agent/ directory structure to standardize local memory, skills, and protocols across multiple environments (such as Claude Code, Cursor, and Windsurf). Features a multi-layered local file storage engine, an automated configuration syncing CLI, and self-improving pattern-clustering workflows that keep knowledge persistent across different development tools.
• EverMind-AI/EverOS (Website) - A local-first agent memory runtime that compiles conversations and files into Git-versioned Markdown.
• expo-llm-wiki (equationalapplications) - A cross-platform TypeScript and SQLite library for long-term agent memory, featuring background fact extraction, vector search with offline MiniSearch keyword fallback, and memory pruning. Offers full support for importing and exporting Google's Open Knowledge Format (OKF) v0.1 bundles alongside dedicated adapters for Expo, React Native, React, and Node.js.
• Graphify - A multi-modal knowledge graph compilation engine that handles codebase AST parsing via tree-sitter alongside media transcription, producing localized agentic subgraphs to yield up to a 71.5x token efficiency gain.
• JeanBaissari/llm-wiki-monorepo (PyPI) - A production-grade monorepo combining a Python CLI, MCP server, and graph engine for self-building Markdown wikis.
• LLM Research Wiki - A typed Python graph pipeline and framework engineered for complex literature mapping. Enforces a rigid 6-tier academic document topology via Pydantic schemas, features automated cross-link validation, and exports a native MCP server optimized for piping structured research vaults into Claude Code and Cursor.
• llm-wiki (krishddd) (PyPI) - A self-healing agentic knowledge engine and FastAPI service implementing the Google Open Knowledge Format (OKF) v0.1 specification. Distributes ingested documents across four memory tiers (working, episodic, semantic, procedural), executing automated bi-temporal fact tracking, Ebbinghaus memory decay, NLI-based contradiction resolution, and a staged "Review Autopilot" to verify low-confidence drafts.
• memory-arena - An open-source benchmarking suite and evaluation harness designed to test long-term agent memory strategies across interdependent, multi-session tasks. It establishes a standardized empirical testing framework comparing classical vector storage, graph-based abstractions, and flat-file architectures like the Karpathy LLM Wiki pattern—measuring recall accuracy, context degradation, and token overhead.
• obsidian-wiki - A pip-installable Python framework that transforms any local Obsidian vault into a cross-agent knowledge base. Deploys unified markdown skill primitives across Claude Code, Cursor, Windsurf, and Pi to execute automated document processing, multi-hop graph queries, structural link linting, and automated conversational history mining.
• OpenKB (Website) - An open-source Python CLI knowledge base framework that compiles multi-format documents into interlinked markdown vaults using a specialized tree-based index for vectorless long-document retrieval.
• SenolIsci/mykg - An open-source neuro-symbolic knowledge graph extraction library that converts mixed-format document folders (.pdf, .docx, .md) into confidence-scored, ontology-grounded Obsidian vaults. Features a two-pass pipeline separating RDFS/OWL schema induction from instance extraction, built-in disk-state checkpoint recovery, and a deterministic code-based validation layer to completely eradicate link hallucination.
• smgam29/knowhub - A Python library that compiles technical documents into cross-confirmed knowledge graphs, exporting to JSON, Neo4j, or OKF.

Applications and Desktop Clients

Dedicated graphical user interfaces, standalone desktop environments, and visual editor shells.

• BYO-LLM-WIKI (Lyra-stellAI) (Live Demo) - A local-first Flask web application, JSON API, and CLI utility that implements the Karpathy LLM Wiki pattern using deepagents. Features an 8-layer on-disk knowledge graph (entities, topics, synthesis), contextual HNSW retrieval, cross-session memory, bi-directional MCP server capabilities, and human-gated LangGraph skill synthesis.
• Cabinet - A free, open-source, file-based AI knowledge workspace that implements Karpathy's compilation loop, featuring git-backed auto-commits, scheduled agent automation cron-jobs, an integrated browser terminal, and embedded HTML application injection.
• CartaStudio - A desktop workbench for constructing typed, scoped, and source-grounded decision graphs in portable Markdown. Structures organizational expertise into verifiable knowledge nodes with strict citation tracing, providing deterministic, high-trust context for AI agent workflows.
• DeepWiki-Open (Grok-Wiki) (Website) - An open-source documentation engine and desktop client compiling codebases into interactive Markdown wikis, generating Mermaid diagrams and Q&A indexes with local/remote LLM support.
• jp-lorenc1o/Eva-brain (Website) - A local-first macOS desktop client and MCP server for building and browsing personal markdown knowledge vaults.
• LLM Wiki (Nash Su) - A cross-platform Tauri desktop application that turns multi-format documents into interlinked markdown vaults, featuring two-step chain-of-thought ingestion, interactive Louvain community graphs, and an async human-in-the-loop review system.
• Memento - A self-hosted, local-first engine that compiles decades of local email data into an organized knowledge base across People, Projects, and Concepts. It runs deterministic graph and parsing algorithms to map connection structures, allows text narrative enrichment via local LLMs, and exposes its underlying FTS data directly to terminal agents over structural search tools.
• Myco (cmblir) - A personal knowledge base tool that compiles unstructured files (PDFs, docs, images, media) into an organized Obsidian-compatible wiki vault. Features a local MCP server integration for Claude Desktop or Claude Code, an offline semantic search index (via BGE-M3 and llama.cpp), and an autonomous researcher agent mode that crawls notes to answer questions with citations.
• Nodus (Drakonis96) (GitHub) - A local-first desktop workspace and knowledge base application for macOS, Windows, and Linux. Organizes research into five specialized vaults (academic research, genealogy, databases, study, and teaching) with local/remote LLM support, interactive knowledge graphs, gap analysis, argument mapping, and Zotero integration.
• nohmitaina - A local-first macOS desktop Markdown editor built to implement Karpathy's LLM Wiki pattern natively alongside Claude Code or Codex, featuring automated background concept extraction, cross-reference mapping, and workspace contradiction linting.
• OpenKnowledge (Website) - An open-source, local-first IDE and markdown editor designed explicitly for co-authoring long-term memory vaults with AI agents. It features a dual-observer CRDT architecture for real-time, lossless visual text synchronization alongside automated agent updates, packages native Model Context Protocol (MCP) servers to expose folder structures to external assistants, and leverages git-backed version control to ensure complete data privacy and sovereignty.
• Row-Bot - A local-first desktop AI assistant and workbench that centers its persistent memory layer around an integrated Personal Knowledge Graph. It features background "dream cycle" compilation routines that automatically extract, deduplicate, and update local knowledge files, offering native, Obsidian-compatible wiki vault exports alongside tool orchestration hooks.
• Second Brain (PieroSierra) - A local-first personal knowledge base and desktop application wrapper that automatically processes notes into a three-tier markdown structure (raw/, wiki/, outputs/). Exposes custom skills for Claude Code, OpenAI Codex, and OpenCode alongside a downloadable macOS dashboard client.
• Silica (kiycoh) (GitHub) - A local-first transactional agent and web GUI workbench for Karpathy-style LLM Wikis and Google's Open Knowledge Format (OKF v0.2). Implements an FSM write path with post-write verification gates and rollback mechanisms, atomic graph-safe link redirects, zero-trust ingress staging, and published abstention benchmarks on LoCoMo.
• Sofie Wiki - A chat-driven AI knowledge base application that automatically writes, cross-links, and updates wiki pages from conversations, featuring local history and Model Context Protocol (MCP) integration.
• talirezun/the-curator (Companion Article) - A full-stack, locally-hosted knowledge curation application that automates the Karpathy LLM Wiki pattern via an accessible browser GUI. Features an automated Atomic Decomposition pipeline separating files into interconnected Entity, Concept, and Summary nodes, built-in Obsidian graph visualization setups, and an integrated private Model Context Protocol (MCP) server bridge to expose local vaults directly to external AI clients.
• Tolaria - An open-source, Git-first desktop markdown app and native MCP server engine built with Tauri and Rust, implementing structural file conventions, automatic AGENTS.md generation, and secure local file boundaries for agent processing.
• WeKnora (GitHub) - An open-source, self-hostable agentic knowledge platform. Features a dedicated 'Wiki Mode' where agents autonomously compile and update interlinked Markdown pages with visual graph views, alongside a multi-workspace RBAC dialog center, a CLI utility, and an official Model Context Protocol (MCP) server integration.
• whoami.wiki (GitHub) - An open-source, private life-archiving system that converts digital data dumps (photo vaults, chat logs, bank transactions, and location histories) into a local personal encyclopedia. Uses autonomous agent pipelines to cross-reference unrelated metadata timelines into highly detailed, interlinked markdown pages complete with standard Wikipedia-style information sidebars, event logs, and relationship networks.
• Wikikarp - A dedicated desktop application wrapper for the Karpathy LLM Wiki pattern. Automatically compiles raw notes and scratchpads into structured, cross-referenced markdown vaults, managing local file mutations, index building, and localized query routing directly on top of your flat-file directory.
• WikiMind (Jayashan Manodya) (GitHub) - A full-stack, AI-powered knowledge management system inspired by the LLM Wiki pattern. Converts unstructured documents into an interlinked, Wikipedia-style knowledge base featuring a 2D physics-based interactive knowledge graph, a stateful LangGraph ingestion pipeline, LangSmith validation, a zero-hallucination grounded QA assistant with click-through citations, and cross-device Turso Cloud database connectivity.
• WikiMind (Manav Gupta) (GitHub) (Companion Article) - An open-source personal knowledge OS that ingests PDFs, web articles, podcasts, and video transcripts into a structured, interlinked wiki database. Features automated claim extraction, multi-provider LLM routing, and a lightweight docling-serve sidecar architecture.
• Wikiwise (Website) - A native macOS Swift application that wraps markdown directories into a fully browsable personal wiki interface, featuring a file-watcher compilation engine, cross-link indexing graph panels, and an embedded agent shell panel.
• XTrace MemHub (GitHub) (Chrome Web Store) - A web application, context control panel, and browser extension that turns chat histories from ChatGPT, Claude, and Gemini into an interactive LLM Wiki mindmap. Extracts memories into an encrypted database and exports structured, interlinked Markdown vaults ready for Obsidian navigation with zero local CLI setup.
• yologdev/yopedia - A full-stack Next.js and TypeScript wiki application built entirely by autonomous agents. Implements a dual-surface architecture combining a human-readable Markdown layer (featuring inline citations, validation rules, and decay parameters) with an agent-consumable Model Context Protocol (MCP) server containing 28+ specialized data tools. Runs an ongoing multi-agent loop via GitHub Issues with a strict, automated shell-testing harness that handles continuous ingestion, claim linting, and automatic code reverts.

Editor Extensions and Plugins

Plugins, themes, and extensions built for IDEs, code editors, and markdown-based note-taking clients.

• Auto LLM Wiki (Obsidian Plugin) - An open-source Obsidian plugin that automates the creation and maintenance of a Karpathy-style LLM Wiki, featuring multi-format text and vision OCR ingestion, an index-first natural language chat panel with conversation history, and local vault linting.
• claude-obsidian - An open-source Claude Code plugin and knowledge engine that builds compounding Obsidian vaults, featuring hot-cache context persistence, multi-agent batch ingestion, automated 8-category vault linting, and spatial canvas orchestration.
• InfraNodus (Website) (LLM Wiki Skill) - An open-source Node.js and Neo4j-based visual network analysis tool that maps unstructured text and markdown vaults into interactive knowledge graphs. Features a dedicated Obsidian graph view plugin and an official Model Context Protocol (MCP) server to help coding agents identify content gaps, analyze topical clusters, and query relationship structures in LLM Wikis.
• Karpathy LLM Wiki (Website) - A native Obsidian community plugin implementing Andrej Karpathy's three-layer wiki memory architecture entirely client-side. It parses vault files to extract atomic entity and concept pages, builds a deterministic bidirectional link topology, features an inline conversational streaming query interface with traceably cited links, and supports full local data sovereignty when routed through Ollama or LM Studio.
• LLM Wiki (Dom Leca) (Forum Post) - A native Obsidian community plugin implementing Karpathy's compilation pattern locally via Ollama (Qwen 2.5 + Nomic Embed), featuring real-time event-driven background extraction, multi-modal hybrid search, and persistent natural language chat interfaces.
• llm-knowledge-bases (rvk7895) - An open-source Claude Code plugin and skill suite that compiles raw multi-modal source documents (papers, YouTube transcripts, images, datasets) into an interlinked Obsidian wiki. Features three query depth levels (Quick, Standard, and Deep multi-agent research), artifact export for Marp slides and charts, and automated vault health linters.
• Matryca Plumber - An enterprise-grade, local-first background AI maintenance daemon and native FastMCP server for Logseq graphs. Directly handles direct Markdown AST block mutations with integrated Optimistic Concurrency Control, featuring background dangling link healing, zero-LLM link rot lints, a local cockpit UI, and deep developer optimization for Claude Code.
• twillm - A TiddlyWiki-powered local knowledge management wrapper explicitly built around the Karpathy LLM Wiki pattern. It watches an Obsidian-compatible directory of flat-file Markdown nodes to dynamically compile live query filters and interactive dashboards, eliminating index file staleness across parallel human and AI agent editing loops.

CLI Compilers and Builders

CLI compilers, builders, and daemons that compile, link, and maintain local knowledge base structures.

• agent-wiki-cli - A CLI framework designed to build and maintain self-correcting flat-file markdown knowledge bases. Implements automated multi-format ingestion pipelines, two-pass semantic graph compiling, lint checking for broken linkages, and native slash-command hooks for AI terminal agents.
• AI Research OS - A file-driven multi-agent research framework and compilation engine. It aggregates local notes, codebase snapshots, and web captures into an immutable raw directory, generating a mirrored, highly interconnected LLM Wiki layer composed of flat markdown concept nodes and a unified YAML schema map to optimize downstream context validation.
• AKBP (rohitg00) - A Python CLI and JSONL tool server implementing the LLM Wiki pattern as a protocol surface for agent runtimes. Features schemas for request/response envelopes, local SQLite FTS5 search indexing, write safety gates (dry-runs, review approvals), portability manifests, and conformance tests to carry knowledge across sessions and agents.
• Atomic - An open-source, self-hosted personal knowledge base built in Rust that transforms freeform markdown notes into a semantically linked graph, featuring asynchronous chunking pipelines via sqlite-vec, auto-generated tag wikis with inline citations, an integrated MCP server, and a force-directed canvas.
• AutoSci - An advanced, memory-centric autonomous scientific research platform powered by Claude Code. Implements a dual-layer markdown vault architecture (SciMem) to separate long-term scientific knowledge from active project frames, featuring multi-model critique validation loops, rigid Pydantic-style front-matter schema definitions, and a continuous self-evolution pipeline.
• browzy.ai - An open-source, self-hosted TypeScript knowledge compiler designed to ingest messy digital data streams and compile them into a structured, self-organizing personal memory layer.
• ByteRover (Website) - An open-source, file-based local memory engine and interactive CLI tool that compiles codebase interactions into a hierarchical Context Tree, featuring agent-native curation, an adaptive knowledge lifecycle layer, sub-100ms hybrid text retrieval, and multi-IDE MCP portability.
• CacheZero - An automated second brain framework built directly around the Karpathy LLM Wiki pattern. It features a custom browser extension to capture web sources, an automated compilation engine that uses local LLMs to generate structured markdown vaults with explicit [[wikilinks]], and an integrated MCP server for terminal agent querying.
• cobusgreyling/llm-wiki - A Python CLI and scaffolding template implementing Karpathy's LLM Wiki pattern with built-in MCP integration.
• CodeAlmanac (GitHub) - A local codebase wiki CLI for agents. Automatically syncs agent sessions and runs local background gardening passes.
• Cosma - An open-source, command-line document graph compiler that parses local plain-text folders with [[wiki links]] and YAML metadata into interactive, self-contained HTML/JS visualization networks. Features contextual backlink maps, automated citation processing, advanced focus filtering, and zero-dependency static builds perfectly optimized for publishing agent-managed knowledge bases.
• digital-me-dream-cycle - An offline, LLM-powered knowledge distillation and maintenance compiler engineered to automate vault cleanup. Implements a background "sleep state" routine that scans local Markdown files and YAML metadata configurations to resolve cross-session information conflicts, distill fragmented daily logs into high-signal wiki nodes, and continuously repair broken links or semantic orphans.
• engram CLI (jeromeetienne) - A CLI utility for managing OKF wikis, providing validation, indexing, and link checking for Claude Code agents.
• Enzyme - A local-first memory indexer that compiles folder structures, backlinks, and tags into pre-computed concept "catalysts," providing sub-millisecond local context lookups and automated skill integration for Claude Code and Codex.
• ex-brain (Companion Article) - A personal knowledge base CLI and compiling tool inspired by Karpathy's LLM Wiki and Garry Tan's GBrain. Instead of simply appending text, it uses LLMs to digest incoming notes into an updated 'current state' (archiving old context), extracting timelines and linking entities automatically. Leverages seekdb (OceanBase's AI-native database) to execute hybrid vector-semantic and BM25 full-text search queries.
• GBrain - An open-source, markdown-first AI agent memory layer and knowledge graph compiler. It processes raw document directories, transcripts, and data captures into structured plain-text nodes, using zero-LLM entity extraction to map typed connection edges and an automated background "dream cycle" to handle profile enrichment, gap analysis, and citation repair across local agent frameworks.
• jackwu321/Quant_LLM_Wiki (PyPI) - A specialized implementation of the Karpathy LLM Wiki pattern engineered specifically for quantitative finance research. Features multi-source ingestion of trading PDFs, web links, and financial articles into a local Markdown vault using strict domain-specific metadata schemas, inline LaTeX mathematical formatting, and a dedicated "Rethink Layer" for continuous strategy auditing, validation tracking, and post-mortem charting.
• Klore - A Python-based CLI knowledge compiler that structures multi-source research inputs into markdown files, featuring native configuration rule injectors for Cursor, Windsurf, and Copilot, alongside a dedicated Claude Code slash-command plugin.
• knowledge-worker - A local-first, Python-based memory compiler designed to preserve context across separate agent sessions without database sprawl. It stores highly structured knowledge graphs inside portable, flat JSON files, utilizing a mandatory human-in-the-loop review gate and strict document-level excerpt provenance to eliminate hallucinated entity extraction and long-term memory drift.
• lat.md (GitHub) - A codebase knowledge graph format and CLI utility ("Agent Lattice") written in Markdown. Structures project context into a directory of interconnected files using wiki links and maps them back to the codebase via source code comments, featuring checks to prevent doc drift and support for offline semantic vector search.
• Lexicon - An LLM-compiled knowledge base that ingests raw data into SQLite, compiling structured Markdown articles with backlinks, auto-generated wikilinks, and manual edit preservation.
• LLM Wiki (nvk) - An open-source core engine and CLI toolkit implementing whole-topic archive lifecycle management, deep workspace linting with structural auto-repair capabilities, and platform-specific path environment diagnostics.
• LLM Wiki Compiler (ussumant) - A Claude Code and Codex-compatible plugin and CLI tool that compiles scattered Markdown files or entire repositories into local/global wikis, featuring codebase-mode auto-detection, a shared session context helper, and an interactive canvas-based knowledge graph.
• LLM Wikid - A multi-phase shell compilation framework for Obsidian vaults that implements automatic inbound media extraction, programmatic categorization routing, and mandatory cognitive bias countermeasure modules.
• llm_wiki_rag_pipeline (plaban1981) - A Python-based CLI knowledge compiler and retrieval pipeline that implements the Karpathy LLM Wiki pattern. Scaffolds local directories, ingests raw sources into interlinked Markdown files with structured YAML front matter, constructs a local cosine similarity search index via MiniLM embeddings, and runs questions through a streaming Q&A pipeline and structural validator.
• llm-wiki (hellohejinyu) (npm) - A Node.js-based CLI personal wiki manager. Scaffolds directories into a structured Markdown wiki, processes raw files into interlinked pages using LLM patches, runs questions through a multi-step ReAct agent, and performs static and semantic linting checks (orphans, dead links, contradictions) with automated stub creation.
• llm-wiki (ivankuznetsov) (Companion Article) - An open-source agent plugin and CLI manager implementing the Karpathy LLM Wiki pattern across multi-project environments, compatible with Claude Code, Codex, and Pi. Provides automated project bootstrapping, master cross-project wiki navigation boundaries, and context injection boundaries for CLAUDE.md and AGENTS.md.
• LLM-Wiki (NiharShrotri) - A Python-based CLI knowledge compiler and local web server implementing the Karpathy LLM Wiki pattern on Ollama (Qwen3-14B). Features automated structure ingestion, hybrid text retrieval (BM25 + vectors + reranking via QMD), a streaming Web UI chat interface, and a D3 force-directed knowledge graph visualization.
• llm-wiki-compiler (Atomic Memory) - A TypeScript CLI tool and MCP server that compiles raw text into structured markdown wikis, featuring paragraph-level source provenance tracking, multi-provider model routing, and a rule-based workspace linter.
• llmwiki (Lucas Astorian) - An open-source Python engine and local web dashboard that indexes directories into a local SQLite repository, serving a specialized MCP adapter to automate Claude-driven wiki compilation and citation tracking.
• lorewiki - A local-first knowledge base engine optimized for LLM-assisted development loops. It utilizes a hybrid retrieval architecture matching structural file hierarchies with local SQLite FTS5 and BM25 token search to parse and serve exact codebase context blocks without cloud databases.
• LWC (GitHub / npm) - A proactive agent memory CLI written in Rust, designed to connect local Markdown files and SQLite knowledge graphs directly to agent workspaces (Claude Code, Codex, Cursor, pi). It allows agents to autonomously recall, maintain, and update source-grounded wiki pages, citations, and links, featuring native MCP server hosting, bitemporal segmentation locators, and a bundled self-configuration installer skill.
• my-wiki - A local-first, Git-synced repository management utility for terminal AI workflows. It enforces a strict, predictable wiki/ flat-file directory contract on the local filesystem, optimizing how external tools like Claude Code and Cursor discover, parse, and commit markdown knowledge files without database overhead or proprietary lock-in.
• Oh My Wiki - A local-first Python package and CLI utility implementing an interactive management layer for Karpathy-style markdown vaults. It pairs a multi-vault SQLite registry with an interactive Socratic terminal wizard that prompts users to evaluate, refine, or reject agentic knowledge extractions before they are written to disk, preventing unstructured data corruption.
• Open Knowledge CLI (Website) - An open-source CLI, daemon, and isolated Docker runtime implementing the OKF v0.1 spec for self-maintaining repositories.
• OpenWiki (LangChain) (Introductory Blog Post) - An open-source CLI that compiles and maintains flat-file Markdown agent documentation inside the openwiki/ directory.
• Patina (Deep Dive) - A high-performance, single-binary Rust CLI tool explicitly designed around the Karpathy LLM Wiki pattern. It utilizes memory-mapped reads to parse local markdown directories and extract frontmatter metadata, compiling deterministic in-memory connection graphs with zero heavy database sidecars.
• PENgram (Penfield Labs) (Companion Article) - An open-source knowledge graph extraction pipeline. Parses raw content (code, documents, PDFs, audio transcripts) and compiles structured knowledge graphs with defined relationship types (supports, contradicts, supersedes) using a modular vocabulary, projecting to Obsidian vaults, HTML visualizations, and JSON schemas.
• quarry-kb - A configuration-driven knowledge-ingestion harness and compilation tool for Python environments. It enforces rigid structural contracts when translating raw, unstructured documents into organized flat-file notebooks, utilizing declarative schema files to programmatically handle directory sorting, standardize YAML frontmatter metadata layout, and map explicit cross-note link pathways.
• quicky-wiki (anzal1) - A Node.js-based CLI and dashboard server that compiles document vaults into confidence-scored, self-maintaining LLM wikis. Automatically extracts facts, detects contradictions, structures timelines, and serves an interactive D3 force-directed knowledge graph and Ask Wiki chat interface.
• sage-wiki (xoai) (X Article) - A Go-based graph memory and compiling engine implementing the Karpathy LLM Wiki pattern. Supports flat-file raw document ingestion, hybrid chunk-level search (BM25 + vectors + graph traversal), 19 MCP tools, an interactive terminal dashboard (TUI), and a web UI server. Features opt-in triple extraction and entity resolution to construct an evidenced graph with source provenance and per-fact citations.
• serradura/okf-gem (Website) - The complete CLI, library, and graph server harness for creating, maintaining, and visualizing OKF bundles.
• suwonleee/llmwiki - A local-first compounding engineering logbook and topic compiler featuring automatic capture and memory quizzes.
• Tesserae (GitHub / PyPI) - A local-first context engine and CLI tool that compiles project files (code, docs, PDFs) and agent session logs into a typed knowledge graph. Serves cited contexts on demand (via terminal or MCP) and automatically consolidates memory (pruning, consolidation loops) when idle, projecting knowledge into Markdown directories, Obsidian vaults, and static HTML graph sites.
• Tome (chicken-noodle-chris) - A Claude Code plugin and CLI utility that enforces vault directory contracts, runs linting, and serves Quartz views.
• Understand Anything - A highly advanced, cross-platform multi-agent compilation engine and plugin suite for Claude Code, Cursor, and Gemini CLI. Uses a deterministic Tree-sitter and LLM hybrid pipeline to synthesize directories into local, versionable knowledge-graph topologies, featuring a dedicated /understand-knowledge framework for parsing and visualizing community clusters within Karpathy-pattern markdown wikis.
• vault-curator - A local, Python-based knowledge system compiler that transforms massive Markdown vaults into self-organizing environments for AI agents. It processes flat-file directories to automatically inject structural frontmatter metadata, compute semantic connection links, and compile persistent Maps of Content (MOCs) to optimize downstream agent retrieval.
• Wenlan - A local-first Rust CLI and daemon that turns source-backed captures into maintained Markdown wiki pages, with citation-gated refresh, MCP access, agent plugins, and inspectable local Git history.
• wiki-from-code-with-llm-wiki-karpathy (balukosuri) (Companion Article) - A codebase documentation compiler template and Git post-commit hook configuration. Automatically triggers on commit to diff changes, feeding them to Claude Code, Cursor, or Codex to compile and maintain a structured Markdown wiki (architecture, APIs, user guides, decisions) alongside a pre-configured Obsidian vault.
• WikiMoth (GitHub) - A local-first deterministic memory compiler and retriever for plain-markdown wikis. Indexes and walks double-bracket wiki link graphs in code without LLMs or vector databases, reducing context size by ~99% while exposing auditable retrieval node-chains and a zero-dependency web viewer.

Ingestion and Synchronization Utilities

CLI utilities and daemons that download, sync, scrape, or extract raw documents to ingest them into the wiki format.

• codeglance - A codebase compilation utility that dynamically extracts structural maps, code blocks, and layout metadata from a local directory. It outputs a deterministic, flat-file "readable wiki" and a token-optimized AI context brief explicitly formatted for agentic ingestion.
• HemachandranD/notionwiki - A CLI bridge that pulls Notion workspace pages into a local raw Markdown directory to feed LLM wiki compilation loops.
• llm-wiki-tools - A localized Python CLI utility suite realizing the Karpathy "knowledge as code" blueprint. Operates strictly on a local three-tier directory hierarchy (updates/, raw/, wiki/) to facilitate surgical block-level patching via STDIN, featuring an integrated schema linter, automated source file archiving, and native markitdown ingestion.
• obsidian-knowledge - An open-source Python automation toolkit that tracks file configurations and packs directory trees within local Obsidian vaults into streamlined context frames optimized for terminal coding agents.
• Pieces - A local-first developer context and snippet manager driven by an on-device Long-Term Memory (LTM) engine, exposing workflow history, auto-tagged codebases, and structural metadata to external agents via an integrated MCP server.
• plasma-ai/wiki (Docs) - A Python CLI and Claude Code plugin that automates directory indexing, link validation, and frontmatter curation.
• ptonlix/beeweave (Docs) - A CLI workbench and agent skill suite designed to compile and manage captures, drafts, and markdown knowledge vaults.
• Trove (Lowside-Labs) - A local-first macOS desktop application and CLI sync utility that aggregates digital bookmarks, likes, and stars from X, Instagram, Substack, GitHub, Hacker News, Claude, and ChatGPT into a unified local workspace directory. Generates default agent instructions (CLAUDE.md, AGENTS.md, INDEX.md) for direct querying by terminal coding models.
• wikidesk (ilya-epifanov) - A companion server and infrastructure daemon for LLM Wikis written in Rust. Turns named wiki repositories into shared, multi-agent knowledge services where coding agents read local mirrors, dispatch background sandboxed research agents via MCP and REST APIs, and automatically synchronize wiki updates across session lifecycle hooks.

MCP Servers and Integrations

Model Context Protocol (MCP) servers and integrations designed to expose local knowledge graphs to external AI agents.

• Beever Atlas (Website) - An open-source, self-hostable conversational knowledge compiler and MCP server that transforms Slack, Discord, and Teams chat streams into a structured Neo4j knowledge graph and an auto-generated Markdown wiki with granular permission mirroring.
• code-review-graph (GitHub) - A local-first incremental code review compiler and MCP server. Uses tree-sitter AST parsing to map codebase structure into SQLite relationship graphs, analyzing changed-file blast radiuses and test gaps to feed precise context to review agents.
• codebase-memory-mcp (GitHub) - A high-performance code intelligence engine and MCP server written in C. Parses repository AST structures across 158 languages using tree-sitter, offering hybrid type resolution for 11 languages to build a local codebase knowledge graph. Exposes 15 MCP tools (semantic/vector search, call graphs, HTTP routes, dead code detection) and serves a built-in 3D graph visualization UI.
• CodeGraph (GitHub) - A local-first code graph compiler and MCP server powered by a Rust kernel. Parses codebase AST structures via tree-sitter, building SQLite-backed dependency and call graphs that auto-sync on file change to serve dense, surgical context to coding agents.
• frankchu91/mindbase - An MCP server and Claude Code plugin implementing/enforcing the Karpathy LLM Wiki pattern with automated context synthesis.
• GitNexus (Website) - A zero-server, client-side code intelligence engine that compiles entire repositories into a structured knowledge graph and automated markdown wiki, utilizing local WebAssembly databases and an MCP server to provide deep architectural awareness to coding agents.
• lacuna-wiki (Labhund) - A Python-based CLI utility, background daemon, and MCP server that compiles web resources, PDFs, and YouTube transcripts into Obsidian-compatible markdown vaults. Exposes a unified MCP tool (wiki) to support hybrid DuckDB-backed search, automated cross-link sweeping, claim verification audits, and topic cluster synthesis.
• Link (Website) - An open-source local memory engine and MCP server for terminal agents that compiles assets into markdown vaults, featuring built-in graph visualizations, automated structural health healing, and rigorous local security sanitization.
• Linkly AI (Website) - A lightweight local document search engine and MCP server that compiles filesystem data into an AI-ready context layer, featuring progressive outline indexing, fast multilingual fuzzy matching, and deep regex terminal grep filtering.
• llm-wiki (geronimo-iia) (crates.io) - A headless, git-backed wiki engine written in Rust that exposes 23 MCP tools and streaming ACP support for agents and IDEs. Features JSON-Schema-validated frontmatter, Tantivy full-text indexing, typed knowledge graph generation (Mermaid/DOT), and zero internal LLM dependencies.
• llm-wiki-kit (iamsashank09) - A Python-based CLI and Model Context Protocol (MCP) server that connects knowledge bases to Claude Desktop, Codex, Cursor, and Windsurf. Enables agents to ingest multi-format sources (PDFs, URLs, YouTube videos, Markdown), automatically generate cross-referenced wiki nodes, and maintain persistent memory across separate chat sessions.
• mcp-llm-wiki (np6126) (GitHub) - A Git-backed HTTP Model Context Protocol (MCP) server providing an isolated tool surface for Karpathy-style LLM Wikis. Features 8 atomic tool primitives, ETag optimistic concurrency with custom merge-drivers for index and log contention, Markdown sanitization, containerized isolation, four companion agent skills, and operator CLIs (wiki-init, wiki-clip).
• Memora - A lightweight open-source MCP memory server that decomposes markdown files into structural semantic fragments, featuring automated tool schema sanitization, real-time graph visualizations, and automated LLM-driven deduplication.
• pi-llm-wiki - A production-grade, local-first knowledge base extension and MCP server for the pi ecosystem, Claude Code, and Cursor. Converts raw files, PDFs, and links into a 4-layer Obsidian-compatible markdown topology, featuring automated cron-driven ingestion (/wiki-ingest), workspace link linting, and an opt-in trajectory distillation loop for capturing agent tool-call sequences.
• PieKBS (Docs) - A local-first knowledge search engine for agents that distills raw documents into structured Markdown wikis via LLM. Features FTS5 full-text search, graph-based document expansion via citation/support/wiki links, multi-hop tag expansion, and native MCP server integration. Pure Go binary with no external dependencies.
• QMD - A local-first, mini CLI search engine and MCP server for markdown knowledge bases that combines BM25 full-text filtering, vector semantic search, and on-device LLM re-ranking.
• SwarmVault (Website) - A local-first RAG knowledge base compiler and MCP server that maps files into an interlinked Markdown wiki and SQLite-backed knowledge graph, featuring automated linting, local graph visualizations, and a compounding "file-back" exploratory architecture.
• Synto - A 100% local, Ollama-native knowledge compiler and memory layer featuring an asymmetrical dual-model compilation pipeline, SHA-256 mutation defense to protect manual human edits, an interactive terminal review TUI (synto review), and a native 8-tool MCP server designed to pipe structured vaults into Claude Code and Cursor.

Hosting and Infrastructure Platforms

Cloud hosting platforms, remote publishing layers, and managed infrastructure services for deploying and serving file-based knowledge vaults.

• Agent Wikis - A production-deployed knowledge platform built around the "Git as a database" flat-file pattern. It hosts public, human-readable wikis that anyone can browse for free to learn from, while serving the underlying raw markdown via MCP for autonomous agent ingestion. Features a closed-loop engine that tracks missed agent queries to fuel automated research and patching workflows behind human-gated commit approvals.
• AutoWiki (Factory) - An enterprise-grade codebase wiki compilation platform that automatically generates structured Markdown wikis from repositories and syncs them to Git-backed wikis.
• Basic Memory (GitHub) - A cloud-hosted (SaaS) or local-first (AGPL-3.0) persistent memory platform and MCP server. Syncs Obsidian-compatible Markdown files across web, mobile, and IDEs, utilizing SQLite/Neon PostgreSQL and Milvus backends to provide hybrid semantic search, cross-encoder reranking, and official plugins for Claude Code, Hermes, and OpenClaw.
• Hindsight (GitHub / Obsidian Plugin) - An open-source, model-agnostic agent memory system designed to help agents learn and adapt over time rather than just recalling raw logs. It organizes memory into facts, observations, and user-curated mental models, exposing simple retain/recall/reflect APIs alongside an optional LLM wrapper and self-hosted Docker interface.
• Portable LLM Wiki - A vendor-neutral, cloud-first hosting platform that compiles personal markdown notes and profiles into portable, agent-ready context endpoints. It surfaces hosted vaults via universal URLs and QR code bundles that can be directly consumed by terminal assistants like Claude Code and Cursor, utilizing a multi-agent background linting engine to automatically audit cross-note contradictions, verify wiki-link topology, and maintain strict document-level provenance.
• second-brain-cloudflare (rahilp) (Website) (Companion Article) - A self-hostable remote memory platform and deployment stack for Cloudflare Workers (utilizing D1, Vectorize, and Workers AI). Serves a centralized persistent memory layer via MCP tools to share context across Claude Code, Cursor, and ChatGPT, featuring interactive desktop apps, Notion synchronization, iCal calendar scrapers, and automated email collectors.
• Stash (GitHub) - A self-hostable shared memory platform for coding agents. Exposes vault files and session logs via MCP or VFS.
• Stigmergy (sturlese) - A team-scale, Git-backed LLM Wiki infrastructure platform that scales Karpathy's pattern to organizations. Combines durable capture queues (Slack/CLI) with eight deterministic pre-commit code validation gates, human-stewarded entity registry minting, strict granular ACLs, and a citation-verified MCP read server with refusal guards.
• trip2g (Website) - An open-source, self-hosted web server and Obsidian plugin that publishes vaults as websites and exposes them via MCP.
• vercel-labs/openwiki (Website) - A web application and deployment platform that generates, hosts, and schedules updates for source-grounded codebase wikis.
• wikihub.md - A specialized hosting and collaboration platform designed specifically for flat-file LLM wikis. Features instant markdown publishing via Git or drag-and-drop, a robust per-file access control system using a .wikihub/acl (CODEOWNERS-pattern) schema, and an agent-native REST API that allows autonomous systems to dynamically read, query, and modify deployed knowledge vaults securely.

Agent Skills and System Rules

Procedural instructions, system schemas, and behavioral configuration definitions engineered to teach autonomous terminal models how to natively compile, link, and maintain flat-file knowledge bases.

• Engram Skill (NoobAIDeveloper) - An open-source Claude Code skill suite that captures digital touchpoints and social threads, automatically parsing and compiling them into an interlinked, structured Obsidian knowledge vault.
• hstack - A suite of Claude Code skills and agents that compile raw medical records and research into a personal disease wiki.
• karpathy-llm-wiki (Astro-Han) - An installable agent skill packaging the Karpathy LLM Wiki pattern for agentskills.io-compatible clients.
• LLM Wiki (GitHub) - A second brain plugin and skill suite for Claude Code, Codex, Cursor, Gemini, and Pi. Implements Karpathy's LLM Wiki pattern using a local PEP-723 runtime featuring on-device semantic search (FastEmbed/sqlite-vec), BM25 lexical fallback, RRF hybrid fusion, and incremental changed-section indexing.
• LLM Wiki (TrueHOOHA) - An open-source implementation focused on mitigating agent behavioral drift using rigid workflow skills. Features a triage-first ingest mechanism (wiki_import / wiki_wrapup), automated cross-page contradiction reports, a single-command wiki_fix cleanup loop, and SHA-256 source provenance tracking.
• LLM Wiki Agent (SamurAIGPT) - An open-source agent skill suite that automates raw document ingestion, contradiction detection, and graph generation.
• LLM Wiki Knowledge Base (adamziel) (GitHub) - An installable agent skill conforming to the agent-skills standard that configures LLM client workflows (Ingest, Query, Lint) for managing personal vaults, specifying raw/wiki boundaries, bi-directional linking rules, contradiction handling, and logs.
• LLM Wiki Knowledge Base (FelipeOFF) (GitHub) - An installable Claude Code agent skill that configures automated ingestion, structured query, and vault health linting for Obsidian knowledge bases. Implements Portuguese and English natural language triggers, a 5-tier taxonomy (entities, concepts, syntheses, comparisons, patterns), YAML frontmatter metadata schemas, and incremental change logging.
• llm-wiki-skill (lewislulu) - An agent skill suite featuring a Node.js preview server and Obsidian audit plugin for human-in-the-loop wiki review.
• llm-wiki-skills (vanillaflava) - An open-source agent skill suite conforming to the agent-skills standard. Features a crystallize operation to compile active chat sessions back to the vault, automated source confidence tagging, and a template-driven system for scaffolding structured markdown nodes across Obsidian and Logseq.
• MehmetGoekce/llm-wiki (Companion Article) - A production-grade implementation of the Karpathy LLM Wiki pattern for Claude Code with out-of-the-box support for Logseq and Obsidian. Implements a dual-layer hardware cache model that splits knowledge into hot system memory (L1 via CLAUDE.md) and an on-demand on-disk filesystem (L2), complete with automated shell ingestion, multi-stage search routing, an index eviction engine, and a 11-rule automated semantic linter.
• Memory OS - A 7-layer local memory operating system built for Hermes Agent. It unifies trust-scored SQLite facts, session histories, and local vector retrieval with an automated, self-curating LLM Wiki pipeline that compiles system insights directly into flat markdown notes, allowing users to manually audit and edit their agent's long-term memory structures using desktop markdown editors like Obsidian.
• NousResearch/hermes-agent (Research Wiki Skill) - A first-party, natively bundled system skill that brings the Karpathy LLM Wiki pattern to the Hermes Agent ecosystem. Features batched parallel ingestion, strict bi-directional [[wikilink]] creation rules, automatic file size splitting thresholds, and explicit contradiction handling protocols that isolate conflicting claims for human review while maintaining out-of-the-box compatibility with Obsidian and Logseq vaults.
• Obsidian Second Brain - A powerful cross-CLI skill suite for Claude Code, Codex, and Gemini that updates, reconciles, and rewrites existing vault notes dynamically to enforce a compounding local knowledge graph, featuring 34 terminal commands and write-time document validation.
• owledge - An open-source automation framework and behavioral runtime configuration package for agent frameworks. It enforces structured memory execution boundaries through system lifecycle hooks, utilizing strict namespace profiling and context-lane mappings to ensure independent multi-agent daemons read, write, and cross-link flat markdown concept nodes without creating directory collisions or unstructured data drift.
• sametbrr/llm-wiki-manager - A production-grade implementation of the Karpathy LLM Wiki pattern packaged as a native Claude Code and agentskills.io skill. Bundles a suite of dependency-free, idempotent Python scripts for automated workspace scaffolding, index catalog synchronization, transaction ledger logging, and semantic linting capable of parsing standard markdown links and Obsidian double-bracket nodes.
• Second Brain (NicholasSpisak) - An open-source agent skill suite installable via the agent-skills standard, featuring a guided vault setup wizard, automated raw document compiler, query utility with qmd search integration, and consistency check linter.
• sniperunder123/okf-knowledge - A portable Claude Code skill and validation suite to initialize, query, lint, and visualize OKF bundles.
• TencentDB Agent Memory (npm) - A layered memory engine and plugin for OpenClaw and Hermes that unifies SQLite storage with human-readable markdown layers. Implements an L0–L3 semantic memory pyramid (conversation logs, atomic facts, scenario blocks, user personas) alongside symbolic short-term memory that offloads tool traces to external files and injects compact Mermaid graphs.
• Wiki Builder (DAIR.AI) - An open-source Claude Code plugin path that automates directory scaffolding, handles multi-flavor workspace indexing, and leverages localized markdown configuration files to govern agent compilation boundaries.
• wiki-builder (Hyperagent Skill) - A reusable agentic skill for the HyperAgent platform designed to initialize, query, and maintain structured research wikis.
• wiki-skills (kfchou) - An open-source Claude Code skill suite implementing Karpathy's LLM Wiki pattern, featuring a bootstrapping tool, automated backlink resolution, validation checkers, and parallel citation auditing (with adversarial verification in strong mode).
• XBlueSky/cortexes (Website) - A personal knowledge vault plugin for Claude Code featuring session capturing, memory distillation, and hybrid search.

Starter Templates and Boilerplates

Forkable workspace repositories, directory boilerplates, and prompt templates designed to initialize and scaffold a pre-configured personal LLM Wiki environment.

• copilot-llm-wiki (SriSatyaLokesh) (Website) - A forkable template and prompt suite configuring GitHub Copilot Chat in VS Code to build and maintain Karpathy-style markdown wikis. Utilizes dedicated VS Code prompt files (.github/prompts/) and repository instructions to orchestrate batch ingestion, progressive concept linking, and automated vault linting.
• LLM Wiki Template (Bashir Aziz) - A structured personal knowledge base workspace template for terminal assistants. Scaffolds a three-layer directory (immutable sources, agent-maintained wiki, local session transcripts), pre-configuring layout guidelines and auto-export session hooks for Claude Code (CLAUDE.md), Codex CLI (AGENTS.md), and Aider.
• llm-knowledge-base (arturseo-geo) - A formal AGENTS.md schema and starter template suite for building Obsidian-compatible LLM knowledge bases. Introduces a dedicated learning layer featuring FSRS-powered spaced repetition review queues, automated flashcard generation, gap tracking for detected open questions, and Socratic evaluation loops.
• llm-wiki-karpathy (balukosuri) (Companion Article) - A self-maintaining personal knowledge base template and schema configured for Cursor and Obsidian. Uses a custom operating manual (CLAUDE.md) to guide autonomous agents through ingest, query, and lint operations side-by-side with live visual graph previews.
• sturlese/hippocampus - A zero-dependency personal knowledge base template built for Claude Code using the Open Knowledge Format (OKF).
• The PM Wiki (AliMahmoud15486) - A system schema and ruleset template that teaches coding agents how to compile and maintain product management wikis.
• Zissa Wiki (MetamusicX) - A Claude Code research wiki template. Implements a three-layer navigation cascade and a deterministic Python linter.

Live Implementations and Reference Vaults

Production-deployed examples and open-source markdown templates demonstrating the LLM Wiki pattern in active human-agent workflows.

• Andrej Karpathy Wiki - A live, self-growing encyclopedia mapping Karpathy's public work using a markdown-first, Cognee-backed knowledge vault. It acts as an operational reference blueprint for the LLM Wiki pattern, featuring background query-synthesis workflows that autonomously format, link, and compile source inputs back into flat markdown files.
• Karpathy Wiki - A live reference portal explaining and illustrating the Karpathy LLM Wiki pattern, featuring structured documentation directories, RAG-vs-wiki comparison matrices, and detailed tool guides.
• LLM Wiki (Ian Forster) - A live, self-compiling implementation of the LLM Wiki pattern focused on mapping the agentic AI landscape, containing synthesized concepts, framework comparisons, cost optimization guides, and multi-agent orchestration analyses.
• LLM Wiki (Pratiyush) (GitHub) - A live demo of a local knowledge base compiled from agent sessions, showcasing heatmaps, comparisons, and tool charts.
• LlmWikis.org - A public handbook and interactive toolkit for building and governing LLM Wikis, featuring a step-by-step setup wizard, starter template bundles, schema definitions, and trust-label specifications.
• Security KB (99helpers) - A live cybersecurity knowledge wiki compiled from 11 industry security sources (MITRE ATT&CK, MITRE D3FEND, NIST CSF 2.0, CIS Controls v8). Features 33 interlinked topic summaries, deep dives, and entity pages alongside an interactive knowledge graph visualization and grounded Q&A search assistant.

Research and Papers

Peer-reviewed scientific literature, algorithmic formalizations, and empirical benchmark evaluations of compilation-based knowledge loops.

• Beyond Memory: A Templated Substrate for Heterogeneous Collaborative Knowledge Work with LLM Agents - A research paper formalizing a templated LLM Wiki substrate for collaborative knowledge work across multi-human, multi-agent, and multi-domain environments. Details how an append-only convention preserves dead ends, negative results, and walked-back claims, introducing empirical case studies on retroactive evidence audits, failure-path preservation, and agent honesty.
• Beyond RAG: LLM Wikis as Living Semantic Memory: Patterns, Empirical Findings, and Open Problems - A position paper analyzing the LLM Wiki pattern as compiled semantic memory, detailing scale limits and symbolic logic integration.
• ByteRover: Agent-Native Memory Through LLM-Curated Hierarchical Context - A preprint proposing an agent-native memory architecture that organizes knowledge into a hierarchical Context Tree (Domain, Topic, Subtopic, Entry) on the local filesystem. Integrates an Adaptive Knowledge Lifecycle (importance scoring, recency decay) and 5-tier progressive retrieval, achieving state-of-the-art results on LoCoMo without external vector databases or embedding services.
• Codebase-Memory: Tree-Sitter-Based Knowledge Graphs for LLM Code Exploration via MCP (Vogel et al.) - A research paper formalizing the design and evaluation of Codebase-Memory. Explores constructing tree-sitter based AST call and dependency graphs exposed via MCP, demonstrating a 10x token reduction and 2.1x fewer tool calls compared to standard codebase explorers.
• DeepRefine: Agent-Compiled Knowledge Refinement via Reinforcement Learning - A foundational paper addressing compounding structural decay in long-lived agent knowledge bases. Proposes a reinforcement learning framework that interacts with a pre-constructed wiki to perform abductive error diagnosis and localized refinement actions, optimized via a Gain-Beyond-Draft (GBD) reward policy to heal broken links, coreferences, and factual anomalies.
• From Answers to Intermediaries: LLM Wikis as Knowledge Organization Layers in AI-Mediated Information Access - A scholarly paper framing LLM Wikis through library and information science (LIS) theory as semi-persistent knowledge organization layers. Contrasts answer-centered RAG with wiki-mediated search across four core functions (representational scaffolding, exploratory navigation, provenance exposure, and human-AI knowledge maintenance) to support accountable, inspectable scholarly discovery.
• Knowledge Compounding: An Empirical Economic Analysis of Self-Evolving Knowledge Wikis under the Agentic ROI Framework - An empirical econometrics study applying the Agentic ROI framework to evaluate the compounding token economics of LLM Wikis on Qing Claw (a C# multi-agent runtime). Treats tokens as capital assets rather than consumables, detailing how a persistent markdown layer achieves 84.6% cumulative query token savings over classic RAG.
• Knowledge-Centric Information Systems - A theoretical position paper framing the architectural shift from traditional data engineering to "knowledge architecture" for AI agents. Outlines a taxonomy mapping classical guarantees (ETL, CDC, materialized views, lineage) to agent-ready patterns (knowledge ingestion, change detection, knowledge views, provenance), positioning LLM Wikis and OKF as foundational examples.
• LLM-Compiled Wikis for Cross-Institutional Policy Retrieval: A Benchmark on Chinese University Grant Policies - An empirical study introducing the T3a benchmark to evaluate LLM-compiled wikis on tabular, cross-institutional policy comparisons, demonstrating superior data consistency and completeness (the 4C framework) over standard vector RAG.
• Progressive Disclosure for LLM-Maintained Wiki Knowledge Bases: a Preregistered Ablation - A preregistered ablation study testing progressive disclosure patterns on a 709-page markdown wiki. Demonstrates that structuring wikis with compact indexes and one-line summaries yields a 33% to 50%+ query cost reduction with non-inferior answer quality, as agents take fewer tool turns and fetch more targeted pages.
• Retrieval as Reasoning: Self-Evolving Agent-Native Retrieval via LLM-Wiki - The foundational paper formalizing the Karpathy LLM Wiki design pattern into a production architecture. Introduces the Three Principles of Agent-Native Retrieval (Compilability, Composability, Evolvability) and details a system that converts unstructured documents into interlinked markdown pages, utilizing a persistent "Error Book" loop for cross-batch structural self-correction and multi-hop tool traversal.
• Streaming Knowledge Compilation: Proactive Materiality-Scored Pinning for Time-Evolving LLM Wikis - A research paper formalizing Streaming Knowledge Compilation (SKC) to manage continuous document streams inside a static token cache budget. Introduces a materiality scoring algorithm ($\phi_t$) to proactively cache relevant updates, validating it across financial volatility and Wikipedia edit streams to resolve pre-training evaluation biases.
• TrajWiki: Source-Grounded Memory Trajectories for Long-Horizon Dialogue Agents - A research paper proposing an evolution trajectory memory framework for dialogue agents. Introduces an intermediate Memory Wiki layer that incrementally compiles conversational history into structured, interlinked wiki pages, utilizing explicit claim mutation operations (ADD, REVISE, DEPRECATE) and hierarchical routing to ground answers on LoCoMo and MedMT benchmarks.
• Vector RAG vs LLM-Compiled Wiki: A Preregistered Comparison on a Small Multi-Domain Research Corpus - A preregistered empirical benchmark evaluating a chunk-vector RAG baseline against an LLM-compiled Markdown Wiki. Demonstrates that while the Wiki architecture exhibits an extreme query-time token cost asymmetry, it provides vastly superior cross-paper synthesis and unprecedented claim-level citation accuracy compared to single-round similarity lookup frameworks.
• WiCER: Wiki-memory Compile, Evaluate, Refine Iterative Knowledge Compilation for LLM Wiki Systems - A foundational paper characterizing the "compilation gap" and attention dilution in long-context KV cache LLM Wiki deployments. Proposes an iterative, CEGAR-inspired compilation loop that automatically evaluates workspaces against diagnostic probes, isolates dropped facts, and injects them as cumulative structural preservation constraints, reducing catastrophic failure rates by 55%.
• WikiKV: Schema-Evolving Path-Indexed Storage for Hierarchical Knowledge Navigation (Tencent/WeChat) - A foundational database-tier paper formalizing the storage, optimization, and evolution constraints of LLM-curated hierarchical wikis. It introduces a path-as-key encoding model to achieve single-round-trip lookups, details automated continuous structural evolution through programmatic split and merge operators, and demonstrates production validation backing the WeChat Assistant framework.
• WikiLoop: Jointly Learning to Build and Navigate Agent-Native Wikis with Downstream Feedback - A research paper introducing a feedback-coupled framework that jointly trains a dual-role policy (Builder and Navigator) to construct and query agent-native linked-page wikis. Uses utility difference rewards and downstream navigation signals to evaluate candidate wiki edits, demonstrating substantial accuracy gains across AuthTrace, HotpotQA, and MuSiQue without external databases.

Academic Courses and Lectures

Syllabi, lecture slides, notes, and academic materials from university-level courses exploring generative AI workflows, agent memory, and knowledge organization.

• MAE-6291: Generative AI for Engineering Research (Lorena A. Barba at George Washington University) (Lecture Video) (Lecture Notes PDF) - A graduate-level course teaching engineering PhD students to utilize generative AI as a research accelerator. The final session focuses on the LLM Wiki pattern as compiled semantic memory, comparing it with standard RAG, defining the raw/wiki/schema layers, and discussing how personal wikis scaffold metacognition.

Videos

Visual walkthroughs, conceptual code execution guides, and theoretical video essays.

• 10 Easy Ways to Enhance Your LLM Wiki or Knowledge Base (Tonbi's AI Garage) - A masterclass tutorial breaking down 10 core enhancements for file-based knowledge stores. Features an architectural breakdown contrasting the embedding mathematics of Vector RAG against the agentic compilation loops of LLM Wikis, alongside live setups for DataView dashboards, native Mermaid flowcharts, and background MCP Vault integration.
• Andrej Karpathy's Wiki Idea Was Just Shipped by Pinecone (The AI Automators) - A video analysis of how Pinecone Nexus maps to Andrej Karpathy's LLM Wiki pattern.
• Build An AI Second Brain Knowledge Base (Step-By-Step) (Matt Wolfe) - A step-by-step video walkthrough showing how to build an active, compounding personal second brain using Obsidian, the Obsidian Web Clipper, and AI coding agents. Demonstrates clipping web articles and YouTube transcripts into raw storage, guiding autonomous agents to synthesize cross-referenced wiki notes, and navigating the resulting knowledge graph.
• Build an OKF Brain Like Mine! (Deep Dive) (Marie Haynes) - A practical video case study exploring a live implementation of Google's Open Knowledge Format as a sovereign personal memory engine. The walkthrough demonstrates an automated ingestion pipeline that splits inbound web references into atomic markdown concept nodes, uses persistent playbooks to guide downstream agent behavior, and leverages human-in-the-loop review boundaries to prevent data corruption.
• Finally, an Open Standard for the Karpathy LLM Wiki is HERE (Cole Medin) - A technical analysis of Google's Open Knowledge Format (OKF) and how it formalizes the Karpathy LLM Wiki pattern.
• Google's OKF: The New Way to Structure Your Knowledge for Agents (Marie Haynes) - A high-level technical analysis of Google's Open Knowledge Format (OKF) specification. Explains how the standard formalizes the Karpathy LLM Wiki pattern into a cross-organizational directory structure of plain-text markdown files, enforcing strict YAML frontmatter metadata and atomic concept-splitting to optimize downstream agent traversal.
• How To Build LLM Wiki In Obsidian? (Wanderloots) - The definitive video tutorial mapping out the core 3-tier local memory architecture, showcasing how to build a file-based ingestion pipeline, implement a Git-backed maintenance loop, and deploy an agentic vault firewall wrapper.
• I Built a Digital Brain Upload Using Karpathy's LLM Knowledge Base (Tonbi's AI Garage) - A deep dive video applying the Karpathy LLM Wiki pattern to private, multi-platform personal communication trails. Demonstrates how to write custom scripts to parse Google Takeout .mbox archives, agent logs, and .jsonl interactive terminal loops into an air-gapped, local Obsidian twin, mapping the user's stylistic voice patterns and tracking operational frustration loops over time.
• I Built Karpathy’s LLM Wiki in Obsidian (Cody Bontecou) - A video guide showcasing how to implement Andrej Karpathy's LLM Wiki pattern in Obsidian using custom scripts.
• I Built Self-Evolving Claude Code Memory w/ Karpathy's LLM Knowledge Bases (Cole Medin) - A video guide showing how to build a self-evolving memory engine that compiles Claude Code logs into an Obsidian wiki.
• I Trained an AI on Everything I've Ever Said Online (Semi Autistic Vibe Coder) - A detailed implementation video showing how to ingest personal multimedia histories into a Karpathy-pattern local wiki. Integrates OpenAI's Whisper and Claude Code to parse raw video transcripts and JSON archives, compiling the data into a flat Obsidian folder topology (concepts/, entities/, sources/) utilizing automated meta-logging hooks and structural schema policies.
• Introducing OpenWiki, an Open-Source Agent for Repo Documentation (LangChain) - A video walkthrough introducing OpenWiki, demonstrating how it compiles Git logs and comments into a codebase wiki.
• Is Karpathy's viral LLM wiki helpful? Kinda yeah. Feedback one month in. (Companion Article) - A deep-dive 30-day technical review tracking a 760-page agent-managed knowledge vault built on top of Quartz. Explores the explicit scaling limits of the pattern, detailing the setup of background monitoring crons, automated append-only ledgers, and strict linting rules that treat uncited text blocks as structural pipeline errors.
• Karpathy's LLM Wiki - Full Beginner Setup Guide (Teacher's Tech) - A comprehensive beginner video guide walking through the end-to-end setup of a local Obsidian and Claude Code LLM Wiki. Covers creating the three-layer directory structure (raw/, wiki/, schema), writing CLAUDE.md operating guidelines, automating raw document ingestion, exploring concept connections in graph view, and running periodic health linting routines.
• Karpathy's LLM Wiki: What It Means & How to Build One (Tonbi's AI Garage) - A practical video guide on bootstrapping an LLM Wiki from scratch inside Claude Code, demonstrating automated multi-agent ingestion loops, backfill routines for external web research, and visual chart integrations.
• LLM Knowledge Bases: a practical guide (Ben Holmes at AI Engineer World's Fair 2026) - A presentation from the AI Engineer World's Fair 2026 detailing how to construct high-reliability agent knowledge bases. Outlines standardizing on plain Markdown raw directories, enforcing strict source-grounding where claims are one click away from their references, utilizing controlled vocabularies and tag ontologies, and deploying the Hubble open-source note-taking app to host agent pipelines.
• LLM Wikis and how to give your agents memory (LangChain) - A discussion featuring Harrison Chase, Brace Sproul, and Devin Stein on the design and efficiency of LLM Wikis.
• LLM Wikis change everything (Andrej Karpathy's method) (Ben Holmes) - A developer-focused video guide walking through an automated, local-first ingestion and compilation architecture for flat-file wikis. It demonstrates how to combine on-device voice transcriptions and web clippers into an unformatted raw data directory, details a background cloud runner script using Docker and headless Obsidian sync to dynamically enrich metadata via markdown-based master tags, and highlights building custom HTML/JS interactive graph visualizations over native wiki-link topologies.
• OpenWiki 0.2 is adopting the OKF spec (LangChain) - An update video announcing OpenWiki 0.2's adoption of the Open Knowledge Format (OKF) specification for wiki metadata.
• OpenWiki Brains, general-purpose memory for agents (LangChain) - A walkthrough introducing OpenWiki 0.1.0, showing how to configure a personal brain with Notion and Gmail connectors.
• This New Google Format Gives Your AI Agent a Second Brain (The AI Automators) - A walkthrough of Google's Open Knowledge Format (OKF) standard for organizing information into sovereign, flat-file markdown vaults.
• Turn 10,994 Notes Into Memory - AI Research OS Workshop (AI Engineer) - A comprehensive technical walkthrough breaking down a file-driven AI memory architecture. The presentation details how to construct an intentional three-layer LLM Wiki using flat markdown directories and a central YAML indexing schema to completely bypass vector database complexity while enforcing an ultra-token-efficient agent retrieval loop.
• Why LLM Wiki? Future Of Knowledge For Agentic AI & Humans (Wanderloots) - A visual guide explaining the mechanics of nodes, edges, and triples, the token-efficiency of GraphRAG over standard RAG, and a workflow for sandboxing human vs. agentic Obsidian vaults.

Podcasts

Audio-first breakdowns, developer interviews, and strategic discussions exploring the design, implementation, and everyday use of LLM Wiki architectures.

Build With AI

• Episode 156: Build Karpathy's Second Brain With Obsidian + Claude Code - A podcast episode featuring Nicholas Spisak walking through a live, 20-minute setup of an Obsidian second brain using Claude Code. Covers directory structures (raw, wiki, sessions), the automatic session transcript index, and setting up automated ingestion scripts.
• Episode 163: I Built the ULTIMATE AI Second Brain (Karpathy's LLM Wiki Setup Guide) - A solo podcast episode outlining the deployment of an Obsidian-compatible second brain using Hermes and its native LLM Wiki skill. Breaks down the three-layer knowledge base layout (raw, wiki, schema), VPS deployment on Hostinger, Telegram bot connection, and using the Markdownload Chrome extension to feed sources.

Microsoft Cloud IT Pro Podcast

• Episode 429: Getting started with LLM Wikis - An operational teardown of the LLM Wiki architecture tailored for enterprise environments. Explores how to wire up Obsidian Web Clipper and automated RSS monitors to create active collection channels, utilizes Copilot Cowork background loops to handle daily inbox synthesis, and provides an analysis of the compliance risks of decoupling text assets from corporate Data Loss Prevention (DLP) and sensitivity governance.

Working Code Podcast

• Episode 260: Reinventing the Wiki - A discussion analyzing the utility of personal LLM Wikis when models already ingest the web. Covers patterns for co-maintaining markdown vaults with agents, running private offline diaries with local models (Qwen), and compiling product Q&A/support tickets into custom wikis.

Forums and Discussions

Community message boards, discussion threads, and collaborative critiques discussing pattern design and tradeoffs.

• LLM Wiki – example of an "idea file" (Hacker News Thread) - A viral community discussion thread containing developer critiques, architecture comparisons (RAG vs. compiled markdown files), context limits debate, and links to several open-source community implementations.

---

Contributing

Contributions are welcome! Please ensure all pull requests strictly follow the formatting guidelines specified in the repository workflow files.