# How to Analyze a Wiki with Understand Anything: From Markdown Files to an Interactive Knowledge Graph

> Analyze your wiki with Understand Anything. Convert Markdown files and wikilinks into an interactive knowledge graph, merging explicit and LLM-generated relationships for deeper insights.

- Repository: [Yuxiang Lin/Understand-Anything](https://github.com/Lum1104/Understand-Anything)
- Tags: how-to-guide
- Published: 2026-06-08

---

**Understand Anything converts a Karpathy-pattern LLM wiki into an interactive knowledge graph by detecting Markdown files with `[[wikilinks]]`, extracting front-matter and headings, and merging explicit links with implicit LLM-generated relationships.**

To analyze a wiki with Understand Anything, you run the knowledge-base parser against a directory that follows the Karpathy wiki convention—an [`index.md`](https://github.com/Lum1104/Understand-Anything/blob/main/index.md) table of contents plus a collection of interlinked Markdown articles. The Lum1104/Understand-Anything repository provides the [`parse-knowledge-base.py`](https://github.com/Lum1104/Understand-Anything/blob/main/parse-knowledge-base.py) and [`merge-knowledge-graph.py`](https://github.com/Lum1104/Understand-Anything/blob/main/merge-knowledge-graph.py) scripts that transform those files into a unified graph you can explore in the web dashboard, and the full skill specification is documented in [`understand-anything-plugin/skills/understand-knowledge/SKILL.md`](https://github.com/Lum1104/Understand-Anything/blob/main/understand-anything-plugin/skills/understand-knowledge/SKILL.md).

## How the Parser Detects a Karpathy-Pattern Wiki

The pipeline begins in [`understand-anything-plugin/skills/understand-knowledge/parse-knowledge-base.py`](https://github.com/Lum1104/Understand-Anything/blob/main/understand-anything-plugin/skills/understand-knowledge/parse-knowledge-base.py). This script identifies a *Karpathy wiki* by scanning for an [`index.md`](https://github.com/Lum1104/Understand-Anything/blob/main/index.md) (or [`wiki/index.md`](https://github.com/Lum1104/Understand-Anything/blob/main/wiki/index.md)), enforcing a minimum number of `.md` files, and checking for optional `raw/` and schema files. When these signals align, the directory is flagged as a wiki knowledge base and the extraction phase starts.

## Extracting Front-Matter, Headings, and Wikilinks

Once detected, every Markdown file is processed for three key data sources:

- **Front-matter** — Parsed with a lightweight YAML regex at the top of each article.
- **Wikilinks** — Explicit links in the form `[[target]]` or `[[target|display]]` are captured by the `WIKILINK_RE` pattern defined early in the parser.
- **Headings** — The category structure is read from [`index.md`](https://github.com/Lum1104/Understand-Anything/blob/main/index.md), where each section begins with a level-two heading (`##`).

These extractions supply the raw material for the nodes and edges that form the knowledge graph.

## Creating Typed Nodes for Wiki Articles

In the core schema defined in [`understand-anything-plugin/packages/core/src/schema.ts`](https://github.com/Lum1104/Understand-Anything/blob/main/understand-anything-plugin/packages/core/src/schema.ts), every parsed Markdown article becomes a node with `type: "wiki_page"`. Each node stores:

- `name` — The file stem (for example, `my-article` from [`my-article.md`](https://github.com/Lum1104/Understand-Anything/blob/main/my-article.md))
- `content` — The raw article text
- `wikilinks` — An array of explicit links extracted from the body
- `category` — The section heading derived from [`index.md`](https://github.com/Lum1104/Understand-Anything/blob/main/index.md)

This typed representation ensures that wiki concepts live alongside code entities—files, classes, and functions—inside the same graph.

## Building Explicit and Implicit Edges

The graph connects wiki articles through two edge strategies:

- **Explicit edges (`related`)** — Generated directly from each wikilink found in the article body. If [`article-a.md`](https://github.com/Lum1104/Understand-Anything/blob/main/article-a.md) contains `[[article-b]]`, the parser creates a `related` edge between the two nodes.
- **Implicit edges** — Added later by the article-analyzer agent. This agent reads the full article text and injects entities, claims, and relationships that are not already covered by an explicit wikilink.

This two-layer approach captures both the deliberate link structure of the wiki and the latent semantic connections extracted by the LLM.

## Merging and Assembling the Knowledge Graph

After parsing, [`understand-anything-plugin/skills/understand-knowledge/merge-knowledge-graph.py`](https://github.com/Lum1104/Understand-Anything/blob/main/understand-anything-plugin/skills/understand-knowledge/merge-knowledge-graph.py) combines the article nodes with any additional knowledge produced by the LLM agents. The script writes the result to [`.understand-anything/intermediate/assembled-graph.json`](https://github.com/Lum1104/Understand-Anything/blob/main/.understand-anything/intermediate/assembled-graph.json) inside the project folder. This file is the canonical graph representation consumed by the dashboard and the core query API.

## Visualizing Wikilinks in the Dashboard

When you inspect a wiki node in the web UI, the `NodeInfo` component renders its outgoing wikilinks as a dedicated field (for example, “Wikilinks (3)”). The dashboard’s language packs label this field consistently across locales, making it easy to spot densely linked articles and navigate the conceptual structure of the wiki.

## How to Run the Pipeline to Analyze a Wiki with Understand Anything

To analyze a wiki with Understand Anything, run the two-stage pipeline from the root of the target repository.

**Step 1 — Detect and parse the wiki.**

```bash
python understand-anything-plugin/skills/understand-knowledge/parse-knowledge-base.py ./my-wiki

```

This creates [`.understand-anything/intermediate/scan-manifest.json`](https://github.com/Lum1104/Understand-Anything/blob/main/.understand-anything/intermediate/scan-manifest.json).

**Step 2 — Merge explicit and implicit knowledge.**

```bash
python understand-anything-plugin/skills/understand-knowledge/merge-knowledge-graph.py ./my-wiki

```

This produces [`.understand-anything/intermediate/assembled-graph.json`](https://github.com/Lum1104/Understand-Anything/blob/main/.understand-anything/intermediate/assembled-graph.json).

After both steps finish, start the dashboard:

```bash
pnpm dev:dashboard

```

Open the web UI and the graph will show both code entities and wiki concepts—articles, wikilinks, and inferred relationships—inside the same interactive view.

If you prefer to query the graph programmatically, load the assembled output via the core TypeScript package:

```typescript
import { loadGraph } from '@understand-anything/core';

const graph = await loadGraph('./my-wiki/.understand-anything/intermediate/assembled-graph.json');
const article = graph.nodes.find(n => n.type === 'wiki_page' && n.name === 'my-article');

console.log('Wikilinks:', article?.wikilinks);

```

## Summary

- **Wiki detection** relies on [`parse-knowledge-base.py`](https://github.com/Lum1104/Understand-Anything/blob/main/parse-knowledge-base.py) scanning for [`index.md`](https://github.com/Lum1104/Understand-Anything/blob/main/index.md), a minimum `.md` file count, and optional `raw/` and schema files.
- **Extraction** captures front-matter, `[[wikilinks]]`, and `##` headings from the wiki source.
- **Nodes** are typed as `wiki_page` in the core schema and carry `name`, `content`, `wikilinks`, and `category`.
- **Edges** come from explicit wikilinks (`related`) and from implicit relationships added by the article-analyzer agent.
- **Assembly** happens in [`merge-knowledge-graph.py`](https://github.com/Lum1104/Understand-Anything/blob/main/merge-knowledge-graph.py), which outputs [`assembled-graph.json`](https://github.com/Lum1104/Understand-Anything/blob/main/assembled-graph.json) for the dashboard.
- **Visualization** renders wikilink counts in the dashboard’s `NodeInfo` component.

## Frequently Asked Questions

### What file structure does Understand Anything need to detect a wiki?

The parser expects a Karpathy-pattern wiki: an [`index.md`](https://github.com/Lum1104/Understand-Anything/blob/main/index.md) (or [`wiki/index.md`](https://github.com/Lum1104/Understand-Anything/blob/main/wiki/index.md)) serving as a table of contents, a minimum number of `.md` files, and optional `raw/` or schema files. When these signals are present, [`parse-knowledge-base.py`](https://github.com/Lum1104/Understand-Anything/blob/main/parse-knowledge-base.py) flags the folder as a wiki and begins extraction.

### What is the difference between explicit and implicit edges in the wiki graph?

Explicit edges are generated from wikilinks written directly in the Markdown, such as `[[target]]`. Implicit edges are created by the article-analyzer agent, which reads the article text and adds semantic relationships, entities, and claims that the author did not explicitly link. Together they produce a dense, navigable knowledge graph.

### Can I query the wiki graph without using the dashboard?

Yes. After [`merge-knowledge-graph.py`](https://github.com/Lum1104/Understand-Anything/blob/main/merge-knowledge-graph.py) writes [`assembled-graph.json`](https://github.com/Lum1104/Understand-Anything/blob/main/assembled-graph.json), you can load it programmatically using `@understand-anything/core`. Filter for `type === 'wiki_page'` to access article nodes and their `wikilinks` arrays directly in TypeScript or JavaScript.

### Where are the intermediate files stored during wiki analysis?

Both [`scan-manifest.json`](https://github.com/Lum1104/Understand-Anything/blob/main/scan-manifest.json) and [`assembled-graph.json`](https://github.com/Lum1104/Understand-Anything/blob/main/assembled-graph.json) are written to the `.understand-anything/intermediate/` directory inside the target wiki project. These files are consumed by the dashboard and the core graph-loading utilities.