9 Types of Wiki Pages Generated by LLM Wiki: Complete Structure Guide

LLM Wiki automatically generates nine distinct markdown page types—including entities, concepts, sources, and synthesis reports—each stored in dedicated subdirectories under the wiki/ folder with standardized YAML frontmatter.

LLM Wiki (nashsu/llm_wiki) transforms raw documents into a structured, queryable personal knowledge base. Understanding the different types of wiki pages it generates is essential for navigating the architecture, tracing information back to sources, and leveraging the automated ingestion pipeline that parses content in src-tauri/src/commands/page_embedding.rs.

The 9 LLM Wiki Page Types Explained

Entity Pages

Entity pages provide canonical entries for every concrete "thing" extracted from your source documents. Stored in wiki/entities/, each file represents a person, organization, product, or other identifiable object. These pages include YAML frontmatter with cross-references to related concepts and source summaries, enabling the LLM to build a semantic graph of real-world objects.

Concept Pages

Concept pages organize abstract ideas that the LLM learns from source material. Located in wiki/concepts/, these files capture theories, methods, techniques, and principles with definitions, examples, and [[wikilinks]] to related entities. This separation of concrete entities from abstract concepts creates a clean ontological structure for the knowledge base.

Source Summary Pages

Source summary pages ensure complete traceability by maintaining a wiki/sources/ directory containing short summaries of each raw input file (PDF, DOCX, web clips). Every page includes a sources: [] field pointing back to the original file path, guaranteeing that any generated insight can be traced to its primary document. This implements the referential integrity core to the LLM Wiki architecture.

Overview Page

The overview page lives at wiki/overview.md and serves as a global dashboard. It contains an automatically-updated summary reflecting the current state of the entire wiki, including high-level topics, recent additions, and key metrics. This provides users with an at-a-glance snapshot without needing to parse individual entity or concept files.

Index Page

The index page at wiki/index.md functions as the master catalog of the knowledge base. It lists every wiki page (entities, concepts, sources, etc.) with lightweight metadata including title, path, and type. According to the source code in src/types/wiki.ts, this page serves as the primary entry point for the LLM's retrieval pipeline, enabling fast navigation and discovery.

Log Page

The log page at wiki/log.md maintains a chronological, parseable record of all ingest, delete, and update operations. Written in a machine-readable format, this audit trail supports the "lint" subsystem and allows users to track the evolution of their knowledge base over time, debugging when specific pages were added or modified.

Query Pages

Query pages are saved conversational outputs stored in wiki/queries/. When a user chooses to persist a chat answer, LLM Wiki writes it as a markdown file that can be re-ingested to enrich the knowledge graph. This type converts transient AI interactions into permanent, linkable knowledge assets.

Synthesis Pages

Synthesis pages in wiki/synthesis/ contain cross-source analytical reports generated when the LLM discovers higher-level patterns across multiple documents. Unlike simple extraction, these pages represent higher-order reasoning—such as comparative analysis or trend identification—that goes beyond surface-level fact collection.

Comparison Pages

Comparison pages stored in wiki/comparisons/ provide side-by-side markdown tables contrasting two or more entities or concepts. These specialized views make it easy to visualize differences and similarities at a glance, supporting decision-making and comparative research workflows.

Shared Structure and Frontmatter Schema

All nine page types share a common structure defined by the WikiPage TypeScript interface in src/types/wiki.ts. Every file includes standardized frontmatter:

---
type: entity | concept | source | overview | index | log | query | synthesis | comparison
title: "Human-Readable Title"
sources:
  - raw/sources/abc.pdf
  - raw/sources/xyz.md
---

# Title

Content generated by the LLM, with `[[wikilinks]]` to other pages.

The type field dictates storage location and retrieval behavior. The sources array maintains bidirectional links to raw files, while [[wikilinks]] in the body create the interconnected graph structure that powers the knowledge base.

Backend Implementation and Page Routing

The Rust backend in src-tauri/src/commands/page_embedding.rs handles the heavy lifting of page generation. When the LLM produces markdown content, this module parses the frontmatter, validates the type field, and writes the file to the appropriate subdirectory (e.g., routing type: entity to wiki/entities/).

Project-level path resolution and directory initialization occur in src-tauri/src/commands/project.rs, which ensures the wiki/ folder structure exists and is accessible to both the embedding pipeline and the local HTTP API defined in src-tauri/src/api_server.rs.

Programmatic Access via the HTTP API

LLM Wiki exposes a local HTTP API on port 19828 for interacting with generated pages. The endpoints allow listing, reading, and manually creating wiki content.

List All Wiki Pages

Retrieve the complete file tree for a project:

GET http://127.0.0.1:19828/api/v1/projects/<PROJECT_ID>/files?path=wiki/
Accept: application/json

Response includes paths such as wiki/entities/albert_einstein.md, wiki/concepts/quantum_mechanics.md, etc.

Read Specific Page Content

Fetch raw markdown including frontmatter:

GET http://127.0.0.1:19828/api/v1/projects/<PROJECT_ID>/files/content?path=wiki/entities/albert_einstein.md
Accept: application/json

Returns JSON with the content field containing the full markdown string.

Create Custom Pages Manually

Add pages programmatically for later ingestion:

curl -X POST http://127.0.0.1:19828/api/v1/projects/<PROJECT_ID>/files \
     -H "Content-Type: application/json" \
     -d '{
           "path": "wiki/entities/my_custom_entity.md",
           "content": "---\ntype: entity\ntitle: My Custom Entity\nsources: []\n---\n\n# My Custom Entity\n\nGenerated manually."

         }'

The LLM will pick up manually created files during the next ingest cycle and automatically integrate them into the knowledge graph.

Summary

• Nine distinct page types organize knowledge into entities, concepts, sources, overview, index, log, query, synthesis, and comparison pages
• Hierarchical storage places each type in dedicated subdirectories under wiki/ (e.g., wiki/entities/, wiki/concepts/)
• Standardized frontmatter requires type, title, and sources fields as defined in src/types/wiki.ts
• Rust backend processing in src-tauri/src/commands/page_embedding.rs handles parsing, validation, and file routing
• HTTP API on port 19828 enables programmatic CRUD operations against the generated markdown files
• Bidirectional traceability ensures every generated insight links back to its original source documents

Frequently Asked Questions

What is the difference between entity and concept pages in LLM Wiki?

Entity pages represent concrete objects such as people, organizations, or products stored in wiki/entities/, while concept pages capture abstract ideas like theories and methods in wiki/concepts/. Both share identical frontmatter schemas but serve different ontological purposes in the knowledge graph, with entities linking to physical instances and concepts linking to abstract frameworks.

Can I manually create wiki pages without using the LLM ingestion pipeline?

Yes. You can create custom pages via the HTTP POST endpoint or by writing markdown files directly to the filesystem, provided you include valid YAML frontmatter with a recognized type field. According to the backend logic in src-tauri/src/commands/page_embedding.rs, the next automated ingest cycle will parse these files and integrate them into the existing link graph using the [[wikilinks]] syntax.

How does LLM Wiki ensure traceability between generated content and source documents?

Every page type includes a mandatory sources: array in its frontmatter that points to original files in the raw/sources/ directory. Additionally, source summary pages in wiki/sources/ explicitly document each raw input file. This dual-linking system ensures that any claim, entity, or concept can be traced back to its original PDF, DOCX, or web clip.

Where does the page type classification logic live in the codebase?

The TypeScript interface defining valid page types resides in src/types/wiki.ts, which exports the WikiPage type with its strict type enum. The Rust implementation that parses this frontmatter and routes files to appropriate subdirectories (e.g., sending type: synthesis to wiki/synthesis/) is located in src-tauri/src/commands/page_embedding.rs, with path resolution handled by src-tauri/src/commands/project.rs.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}