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

> Discover the nine wiki page types LLM Wiki generates, including entities, concepts, and synthesis reports. Explore their structure and learn how they organize your knowledge base.

- Repository: [nash_su/llm_wiki](https://github.com/nashsu/llm_wiki)
- Tags: documentation
- Published: 2026-09-12

---

**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`](https://github.com/nashsu/llm_wiki/blob/main/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`](https://github.com/nashsu/llm_wiki/blob/main/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`](https://github.com/nashsu/llm_wiki/blob/main/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`](https://github.com/nashsu/llm_wiki/blob/main/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`](https://github.com/nashsu/llm_wiki/blob/main/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`](https://github.com/nashsu/llm_wiki/blob/main/src/types/wiki.ts). Every file includes standardized frontmatter:

```markdown
---
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`](https://github.com/nashsu/llm_wiki/blob/main/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`](https://github.com/nashsu/llm_wiki/blob/main/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`](https://github.com/nashsu/llm_wiki/blob/main/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:

```http
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`](https://github.com/nashsu/llm_wiki/blob/main/wiki/entities/albert_einstein.md), [`wiki/concepts/quantum_mechanics.md`](https://github.com/nashsu/llm_wiki/blob/main/wiki/concepts/quantum_mechanics.md), etc.*

### Read Specific Page Content

Fetch raw markdown including frontmatter:

```http
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:

```bash
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`](https://github.com/nashsu/llm_wiki/blob/main/src/types/wiki.ts)
- **Rust backend processing** in [`src-tauri/src/commands/page_embedding.rs`](https://github.com/nashsu/llm_wiki/blob/main/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`](https://github.com/nashsu/llm_wiki/blob/main/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`](https://github.com/nashsu/llm_wiki/blob/main/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`](https://github.com/nashsu/llm_wiki/blob/main/src-tauri/src/commands/page_embedding.rs), with path resolution handled by [`src-tauri/src/commands/project.rs`](https://github.com/nashsu/llm_wiki/blob/main/src-tauri/src/commands/project.rs).