# Egonex-AI Knowledge Base Analyzer: Wiki Parsing and Graph Construction Explained

> Explore the Egonex-AI knowledge base analyzer. Learn how it parses wiki links from Markdown, constructs knowledge graphs, and powers interactive docs. Understand anything with this powerful tool.

- Repository: [Egonex/Understand-Anything](https://github.com/Egonex-AI/Understand-Anything)
- Tags: deep-dive
- Published: 2026-06-22

---

**The Egonex-AI knowledge base analyzer transforms code repositories into structured knowledge graphs by extracting wiki links from Markdown files, storing them in `knowledgeMeta.wikilinks`, and validating the structure through Zod schemas to power interactive documentation dashboards.**

The **Understand-Anything** repository implements a full-stack analyzer that converts source repositories into navigable knowledge graphs capturing entities, relationships, and wiki-style documentation links. According to the Egonex-AI source code, the system processes files through a five-stage pipeline—discovery, parsing, graph building, normalization, and consumption—to generate LLM-ready knowledge representations and automated onboarding guides.

## How the Knowledge Base Analyzer Pipeline Works

The analyzer follows a strict transformation pipeline defined in the core package architecture.

### File Discovery and Language Detection

The pipeline begins in [`packages/core/src/plugins/discovery.ts`](https://github.com/Egonex-AI/Understand-Anything/blob/main/packages/core/src/plugins/discovery.ts), where the system scans the repository root to identify all files and their respective languages. This plugin-driven approach determines which specialized parser handles each file type, ensuring Markdown documents route to the wiki-capable parser.

### Markdown Parsing and Wiki Link Extraction

For Markdown files, the analyzer invokes [`packages/core/src/plugins/parsers/markdown-parser.ts`](https://github.com/Egonex-AI/Understand-Anything/blob/main/packages/core/src/plugins/parsers/markdown-parser.ts). This parser performs two critical operations:

- **Section extraction**: The `extractSections` method (lines 41-70) walks the file line-by-line, skips fenced code blocks, and records ATX headings (`#` through `######`) with their name, level, and line range.
- **Reference extraction**: The `extractReferences` method (lines 23-38) uses regex to identify local file links (`[]()`) and image references (`![]()`), filtering out external URLs (those starting with `http`). It returns a `ReferenceResolution[]` array containing source path, target path, reference type, and line number.

### Graph Construction and Validation

The [`packages/core/src/analyzer/graph-builder.ts`](https://github.com/Egonex-AI/Understand-Anything/blob/main/packages/core/src/analyzer/graph-builder.ts) consumes the parser output. When processing Markdown references, the builder:

1. Creates a node of type `"article"` (or `"concept"` based on heuristics)
2. Populates `knowledgeMeta.wikilinks` with resolved target paths
3. Adds reciprocal edges (`cites`, `referenced_by`) when targets contain backlinks

Before final output, [`packages/core/src/schema.ts`](https://github.com/Egonex-AI/Understand-Anything/blob/main/packages/core/src/schema.ts) validates the graph using Zod schemas. The `KnowledgeMetaSchema` (lines 61-66) enforces the structure of wiki-specific fields, while `autoFixGraph` (lines 96-248) normalizes aliases like `wiki_page → article` and ensures missing `wikilinks` fields default to `undefined`.

## Wiki Parsing Capabilities: From Markdown to Knowledge Graph

The wiki parsing system transforms static Markdown documentation into a queryable graph structure.

### Extracting Document Structure

The `extractSections` function in [`markdown-parser.ts`](https://github.com/Egonex-AI/Understand-Anything/blob/main/markdown-parser.ts) computes precise line ranges for each heading level. This creates a hierarchical view of the document, enabling the dashboard to render collapsible sections and establishing anchor points for internal navigation.

### Resolving Local References

The `extractReferences` function specifically targets **local** file links—those pointing to other files in the repository rather than external URLs. When it encounters `[Configuration](./Config.md)`, it records the target as a candidate for a wiki link. The graph builder later resolves these relative paths into canonical node IDs, ensuring cross-document links remain valid even when files move.

### Storing Wiki Links in Graph Nodes

Wiki connectivity lives in the `knowledgeMeta` object defined in [`schema.ts`](https://github.com/Egonex-AI/Understand-Anything/blob/main/schema.ts). The `GraphNodeSchema` includes this metadata structure at lines 61-66, containing:

- `wikilinks`: Array of target node IDs this article references
- `backlinks`: Array of node IDs referencing this article
- `category`: Optional classification for wiki organization
- `content`: Raw or processed text content

This schema guarantees that any node representing a knowledge artifact maintains a predictable structure for downstream consumers.

## Code Examples: Implementing Wiki Parsing

### Direct Markdown Parser Usage

You can invoke the Markdown parser directly to extract structure and references before full graph construction:

```typescript
import { MarkdownParser } from "@understand-anything/core/src/plugins/parsers/markdown-parser";

const parser = new MarkdownParser();
const content = await Deno.readTextFile("docs/GettingStarted.md");

// Extract document sections (headings)
const sections = parser["extractSections"](content);

// Extract local file references
const refs = parser.extractReferences("docs/GettingStarted.md", content);

console.log(sections);
/*
[
  { name: "Getting Started", level: 1, lineRange: [1, 5] },
  { name: "Installation", level: 2, lineRange: [6, 9] }
]
*/

console.log(refs);
/*
[
  {
    source: "docs/GettingStarted.md",
    target: "./Config.md",
    referenceType: "file",
    line: 8
  }
]
*/

```

### Building and Validating the Knowledge Graph

To process an entire repository and generate the validated graph:

```typescript
import { buildGraph } from "@understand-anything/core/src/analyzer/graph-builder";
import { validateGraph } from "@understand-anything/core/src/schema";
import { buildOnboardingGuide } from "@understand-anything/plugin/src/onboard-builder";

(async () => {
  const rawGraph = await buildGraph({ root: "./my-project" });
  const { success, data, issues } = validateGraph(rawGraph);
  
  if (!success) {
    console.error("Graph validation failed:", issues);
    return;
  }

  // data is a fully typed KnowledgeGraph with wikilinks populated
  const guide = buildOnboardingGuide(data);
  await Deno.writeTextFile("ONBOARDING.md", guide);
})();

```

### Rendering Wiki Links in Applications

When consuming the graph in a React dashboard, access the `wikilinks` array from `knowledgeMeta`:

```tsx
function WikiNode({ node }: { node: GraphNode }) {
  const links = node.knowledgeMeta?.wikilinks ?? [];

  return (
    <div className="wiki-node">
      <h3>{node.name}</h3>
      <p>{node.summary}</p>
      {links.length > 0 && (
        <ul>
          {links.map((link) => (
            <li key={link}>
              <a href={`#node-${link}`}>🔗 {link}</a>
            </li>
          ))}
        </ul>
      )}
    </div>
  );
}

```

## Key Source Files and Architecture

| Feature | File Path | Purpose |
|---------|-----------|---------|
| **Markdown Parsing** | [`packages/core/src/plugins/parsers/markdown-parser.ts`](https://github.com/Egonex-AI/Understand-Anything/blob/main/packages/core/src/plugins/parsers/markdown-parser.ts) | Extracts sections and local references using `extractSections` and `extractReferences` |
| **Schema Definition** | [`packages/core/src/schema.ts`](https://github.com/Egonex-AI/Understand-Anything/blob/main/packages/core/src/schema.ts) (lines 61-66) | Defines `KnowledgeMetaSchema` with `wikilinks` and `backlinks` fields |
| **Alias Normalization** | [`packages/core/src/schema.ts`](https://github.com/Egonex-AI/Understand-Anything/blob/main/packages/core/src/schema.ts) (lines 16-38) | Maps `wiki_page` → `article` and other node type aliases |
| **Graph Construction** | [`packages/core/src/analyzer/graph-builder.ts`](https://github.com/Egonex-AI/Understand-Anything/blob/main/packages/core/src/analyzer/graph-builder.ts) | Creates article nodes and populates `knowledgeMeta.wikilinks` |
| **Validation** | [`packages/core/src/schema.ts`](https://github.com/Egonex-AI/Understand-Anything/blob/main/packages/core/src/schema.ts) | Contains `validateGraph`, `autoFixGraph`, and `sanitizeGraph` functions |
| **Onboarding Generation** | [`src/onboard-builder.ts`](https://github.com/Egonex-AI/Understand-Anything/blob/main/src/onboard-builder.ts) | Generates markdown wiki guides from the validated graph |

## Summary

- The **Egonex-AI knowledge base analyzer** processes repositories through discovery, parsing, building, normalization, and consumption stages.
- The **Markdown parser** in [`markdown-parser.ts`](https://github.com/Egonex-AI/Understand-Anything/blob/main/markdown-parser.ts) extracts document structure via `extractSections` and local file references via `extractReferences`.
- Wiki links are stored in the **graph schema** within `knowledgeMeta.wikilinks`, validated by Zod schemas in [`schema.ts`](https://github.com/Egonex-AI/Understand-Anything/blob/main/schema.ts) at lines 61-66.
- The **graph builder** creates `"article"` nodes for Markdown files and resolves relative paths into canonical wiki link targets.
- **Alias mapping** normalizes node types (e.g., `wiki_page` → `article`) before validation to ensure graph consistency.
- Output generators like [`onboard-builder.ts`](https://github.com/Egonex-AI/Understand-Anything/blob/main/onboard-builder.ts) transform the validated graph into human-readable documentation and interactive dashboards.

## Frequently Asked Questions

### What is the Egonex-AI knowledge base analyzer?

The **Understand-Anything** analyzer is a full-stack system that converts code repositories into structured knowledge graphs. It captures entities like files, classes, and documentation articles, along with relationships such as imports, calls, and wiki-style cross-references, enabling automated onboarding documentation and LLM-powered code understanding.

### How does the Markdown parser handle wiki links?

The parser in [`packages/core/src/plugins/parsers/markdown-parser.ts`](https://github.com/Egonex-AI/Understand-Anything/blob/main/packages/core/src/plugins/parsers/markdown-parser.ts) uses the `extractReferences` method (lines 23-38) to identify local file links while excluding external URLs. It captures the source file, target path, and line number, returning a `ReferenceResolution[]` array that the graph builder converts into `wikilinks` entries during node creation.

### Where are wiki links stored in the graph structure?

Wiki links reside in the `knowledgeMeta` object of each graph node, specifically within the `wikilinks` array. According to [`packages/core/src/schema.ts`](https://github.com/Egonex-AI/Understand-Anything/blob/main/packages/core/src/schema.ts) (lines 61-66), the `KnowledgeMetaSchema` defines this field alongside `backlinks`, `category`, and `content`, ensuring all knowledge artifacts maintain a predictable structure for validation and consumption.

### How does the analyzer validate the knowledge graph?

Validation occurs in [`packages/core/src/schema.ts`](https://github.com/Egonex-AI/Understand-Anything/blob/main/packages/core/src/schema.ts) using Zod schemas. The `validateGraph` function checks nodes against `GraphNodeSchema` and `KnowledgeMetaSchema`, while `autoFixGraph` (lines 96-248) normalizes node types using alias maps and inserts default values for optional fields like `wikilinks`. This ensures the output graph conforms to the expected TypeScript interfaces before dashboard consumption.