The LLM Wiki Pattern: Compiling Knowledge Instead of Searching Notes

Most personal knowledge bases fail for a boring reason: maintenance.

Collecting notes is easy. Keeping them connected, deduplicated, summarized, updated, and useful over months or years is the hard part. The result is familiar: a folder full of Markdown files, clipped articles, meeting notes, half-written ideas, and project fragments that technically contain knowledge but rarely behave like a system.

The common AI answer is retrieval: put documents into a RAG pipeline, search the chunks, and ask an LLM to synthesize an answer at runtime. That works, but it misses something important: a knowledge base should not rediscover its own structure every time you ask a question. It should accumulate structure.

That is the idea behind what I call the LLM Wiki pattern: instead of using an LLM only to search raw notes, use it to maintain a persistent, interlinked wiki that sits on top of them.

Retrieval is not accumulation

Classic retrieval-augmented generation treats your notes as a corpus to be searched. At query time, the system finds relevant chunks, sends them to the model, and asks for a synthesis.

That is useful, but the synthesis is temporary. The next time you ask a related question, the system has to rediscover the same relationships again.

In practice, this creates three problems: the same synthesis is recomputed repeatedly; cross-links are discovered at runtime instead of stored; and the knowledge base does not improve just because you used it.

A human-maintained wiki solves this, but humans are bad at the bookkeeping. We forget to update links. We do not consistently merge duplicate ideas. We postpone cleanup. Eventually the wiki drifts out of date. LLMs are very good at exactly that boring work.

Compile notes into a wiki

The LLM Wiki pattern changes the direction of work. Instead of raw notes → chunking → retrieval → temporary answer, it uses raw notes → LLM ingest → persistent wiki → query and synthesis.

The model does not merely answer questions about the notes. It maintains the knowledge layer.

When a new source is added, the LLM reads it, summarizes it, updates concept pages, adds cross-links, notes contradictions, updates the index, and logs the operation. The output is not just an answer. The output is a better knowledge base. That difference matters. The wiki compounds.

The three-layer architecture

A practical LLM Wiki has three layers.

1. Raw sources. These are the original notes, articles, documents, transcripts, meeting notes, and project fragments. They are treated as source material. In my setup, this layer follows a PARA-like structure: projects, areas, resources, and archives. The important rule is that the LLM does not casually rewrite these notes. They remain the historical record.

2. The wiki. This is the curated knowledge layer owned by the LLM. It contains source summaries, concept pages, entity pages, guides, and synthesis pages. A concept page is not a raw note. It is the current best understanding of a topic, continuously updated as new sources arrive.

3. The schema. The schema defines how the LLM is allowed to operate: frontmatter, canonical tags, ingest rules, index updates, synthesis location, and boundaries around what must never be modified. Without this layer, the wiki becomes inconsistent. With it, the LLM has operating rules.

The core operations

The system needs only a few operations.

Ingest: a source is added. The LLM reads it, creates or updates wiki pages, links related concepts, and records the operation. The important part is integration. A new note should not become just another isolated Markdown file. It should improve the pages around it.

Query: a question is asked. The LLM reads the index, selects relevant pages, and answers from the curated wiki instead of from raw fragments. If the answer is substantial, it can itself become a synthesis page. That way, valuable analysis does not disappear into chat history.

Lint: the wiki is periodically checked for problems: orphan pages, missing links, duplicated tags, contradictions, and concepts that are mentioned often but do not yet have a page. This is exactly the kind of maintenance people avoid and LLMs can perform reliably.

Why this works better than a pile of notes

The pattern works because it separates responsibilities. The human decides what matters: which sources are worth ingesting, which questions are important, and which direction the system should evolve in. The LLM handles the clerical work: summarizing, filing, linking, updating, deduplicating, and keeping the index coherent.

That division of labor is powerful. It preserves human judgment while removing the maintenance tax that usually kills personal wikis.

From private knowledge to public writing

There is another benefit: a maintained wiki becomes an editorial engine. Raw notes are usually too messy or private to publish. But a concept page or synthesis page is already halfway to an article. It has structure, sources, links, and a clear scope.

My current pipeline is: private notes → LLM Wiki → synthesis page → Ghost draft → review → publish. The blog post you are reading follows that pipeline. It started as a note about knowledge management, became a concept page in the wiki, and then became a public article.

The principle

Do not make the model rediscover your knowledge every time. Let it compile your knowledge into a durable structure.

Search is useful. Retrieval is useful. But if you care about long-term leverage, the real goal is accumulation. A second brain should not just store what you knew. It should get better every time you use it.