LLM Wiki — a second brain for AI agents
Turn papers, articles, transcripts, and notes into a self-maintaining Markdown knowledge base your AI agents can search, cite, and keep current — a compounding alternative to from-scratch RAG.
Evidence shows good safety design: immutable raw/ layer, fully local semantic retrieval (no API keys, no remote text transfer), typed graph edges require explicit evidence quotes, agent-memory writes require user approval, lint findings presented as proposals. Deducted: only SKILL.md and references are auditable here — the bundled scripts (init_wiki.py, setup_wiki.py, wiki_search.py) are not in evidence, so pinned-dependency installs and model downloads cannot be statically verified; init is a mandatory install flow with no explicit rollback/uninstall path.
Docs are self-consistent and thorough: layered workflows, a --no-embed dependency-free fallback, readiness JSON checks in setup, and an honest failure-modes section (silent corruption, maintenance ratchet). Deducted: static ceiling of 10; scripts not visible, so actual error feedback quality and edge-input handling in setup/search cannot be verified.
Triggers, inputs/outputs, and non-fit boundaries (relational data should use a database) are clearly declared, with multi-agent memory-file conventions. Deducted: core semantic retrieval depends on uv and downloading BAAI/bge-small-en-v1.5 from HuggingFace, whose reachability from mainland China is doubtful and no mirror is provided; the trigger surface is broad, creating false-positive trigger risk.
Excellent layered documentation (SKILL.md → references → scripts/templates); README includes a v3.0.0 changelog, MIT license, and a clear upgrade path (/wiki:upgrade). Deducted: the Karpathy April 2026 gist provenance is self-declared and unverifiable statically; README evidence is truncated so full license/versioning governance is incomplete; publisher identity unverified.
The claimed core loop (ingest–query–lint with compounding) is logically complete with clear marginal value over manual maintenance. Deducted: static ceiling of 7; no executable representative-output evidence, and retrieval/summary quality plus the acknowledged maintenance ratchet cost remain unverified.
Auditable primary material exists (extensive design docs, independently checkable layouts and commands), with reasonable fact/inference separation. Deducted: no CI+test-suite evidence covering key paths; the Karpathy gist and 'community discussion' sources cannot be independently corroborated; static ceiling of 5.
- The embedding model BAAI/bge-small-en-v1.5 is downloaded from HuggingFace, which may be unreachable from mainland-China networks; pre-configure a mirror (e.g. HF_ENDPOINT) or use the --no-embed pure-BM25 mode.
- Init mandates installing uv, FastEmbed, sqlite-vec, PyYAML and downloading the model; review scripts/setup_wiki.py and init_wiki.py source yourself before deployment (script code was not part of this static review).
- Attribution to Karpathy's April 2026 gist and the cited community discussion are independently unverified; the docs themselves acknowledge a long-term 'maintenance ratchet' — pilot at small scale first.
- The first semantic run builds full-corpus vectors; budget for init time and disk usage on large wikis. Derived .wiki-cache files are safely deletable as a rollback path.
What does this skill do, and when should you use it?
LLM Wiki implements the pattern from Andrej Karpathy's April 2026 gist: when a new source arrives, the LLM compiles it once into a persistent structured wiki (entity pages, concept pages, cross-references), and later queries read the pre-synthesized wiki instead of re-deriving from raw chunks, so knowledge compounds over time. The repo ships as a Claude Code plugin and a standard agentskills.io skill that also runs in Codex, Cursor, Gemini CLI, OpenCode, OpenClaw, Pi, and more. v3.0 defaults to fully local semantic search (FastEmbed + sqlite-vec + BM25 fused via RRF) with no API keys or hosted vector service. Everything canonical stays in readable Markdown — editable in Obsidian — with an optional typed graph layer for relational queries.
Performs three core operations: ingest (writes the source into raw/, reads it in chunks if large, creates a source-summary page, surgically updates touched entity and concept pages via str_replace, updates index and log); query (reads the index first to find candidate pages, synthesizes an answer with [[wikilink]] citations, and can file answers back as synthesis pages); lint (detects orphan pages, broken wikilinks, oversized pages, missing frontmatter, and stale claims). It bundles eight scripts: init_wiki.py for bootstrap, setup_wiki.py for pinned-dependency install and full local embedding, wiki_search.py for local hybrid retrieval, wiki_lint.py for structural checks, wiki_stats.py for size metrics, plus graph extract/lint/query tools. An optional graph layer compiles frontmatter graph: metadata into nodes.l, edges.l, graph.sqlite, and graph.graphml, supporting neighbors, path, and fact queries.
- A researcher accumulating papers over months who wants each ingest auto-linked to existing entity pages, then asks natural-language questions with cited answers
- A consultant or account team filing customer call transcripts continuously and asking 'what does my wiki say about this client?' before the next meeting
- A personal-knowledge user comfortable with Obsidian [[wikilinks]] who wants an agent to handle linking, summarizing, and consistency upkeep of a second brain
- A developer who works across Claude Code, Codex, Cursor, or Gemini CLI and wants multiple agents reading and writing one runtime-agnostic Markdown knowledge base
- A project team that needs a repository-isolated, versionable knowledge base for decisions and research rather than chat history
- An owner of a wiki past a thousand pages who needs sharded indexes, atomic pages, and local hybrid retrieval to keep the wiki from becoming a context bottleneck
What are this skill's strengths and limitations?
- Compounding knowledge: pre-synthesized pages mean queries don't re-derive from raw chunks, and filed-back answers enrich future queries
- Fully local: FastEmbed, sqlite-vec, and BM25 run on-device — no API key, no remote text transfer, no per-query charge
- Agent-agnostic: the wiki is just a Markdown directory; ingest with one agent, query with another, edit in Obsidian
- Traceable: every claim carries a sources: frontmatter entry back to the raw file, and lint surfaces claims whose source can't be located
- Mature scaling design: atomic pages, sharded indexes, index-first navigation, and incremental embedding directly address the pattern's known context-bottleneck failure
- Init and upgrade enforce a full runtime install: downloading the embedding model and syncing all vectors makes first setup heavyweight (--no-embed is only a query-time lexical fallback, not a way to skip setup)
- Slash commands are Claude Code-only; other agents rely on natural-language triggering
- Inherent pattern risks are acknowledged in the docs themselves: silent corruption, wiki-reads-its-own-output drift, and a maintenance ratchet requiring more human supervision as the wiki grows
- Not suited to fundamentally relational data (org charts, ledgers, tens of thousands of records) — the README explicitly recommends a real database there
- No automated test suite is mentioned in the README; some of the many advertised agent integrations lack independent verification evidence
How do you install this skill?
The only prerequisite is uv (install per official instructions). Claude Code full plugin: run /plugin marketplace add praneybehl/llm-wiki-plugin, then /plugin install llm-wiki@llm-wiki. Other agents, skill-only: npx skills add praneybehl/llm-wiki-plugin -a <agent> (add -g for global install); agent values include codex, cursor, gemini-cli, opencode, openclaw, pi. For compatible runtimes not in the npx skills registry (Hermes, OMP, etc.), clone the repo and symlink or copy skills/llm-wiki/ into the agent's skills directory. First use: run /wiki:init (project wiki) or /wiki:init --global (personal wiki at ~/wiki/); initialization installs pinned dependencies, caches the local embedding model, and syncs vectors — setup is complete only when it reports "status": "ready".
How do you use this skill?
Drop a source into the configured raw root (e.g. ~/wiki/raw/), then: /wiki:ingest ~/wiki/raw/your-source.pdf to compile it; /wiki:query What does my wiki say about X? for cited answers; /wiki:lint for periodic health checks; /wiki:stats to see size and sharding thresholds; /wiki:graph neighbors|edges|path|facts for relational queries; /wiki:upgrade for older wikis. The seven slash commands are Claude Code-only; in other agents, invoke via natural language ('add this paper to my wiki', 'lint the wiki') and SKILL.md handles the rest. You can also skip commands entirely and browse or edit the generated Markdown in Obsidian or any editor.
How does this skill compare with similar options?
This is one implementation of Karpathy's LLM Wiki pattern; the README names sibling implementations vanillaflava/llm-wiki-claude-skills, skyllwt/OmegaWiki, and axoviq-ai/synthadoc. The key contrast with conventional RAG: RAG re-derives knowledge from raw chunks on every query with nothing accumulating, while this pattern compiles sources once into a persistent wiki. The v3 local retrieval was evaluated against Basic Memory (which shares FastEmbed, SQLite vector search, and incremental indexes) but keeps this project's Markdown schema, typed graph, RRF ranking, and agent-native workflows instead of adopting Basic Memory's application and MCP service. Retrieval architecture also drew on Cerebras's knowledge-base engineering article.