# The 26 Edge Types in the Egonex-AI Understand Anything Knowledge Graph Schema

> Explore the 26 core edge types in the Egonex-AI Understand Anything knowledge graph schema. Discover structural and operational relationships enforced by Zod validation.

- Repository: [Egonex/Understand-Anything](https://github.com/Egonex-AI/Understand-Anything)
- Tags: api-reference
- Published: 2026-06-13

---

**The Egonex-AI Understand Anything knowledge graph schema defines exactly 26 canonical edge types—ranging from structural dependencies like `imports` and `inherits` to operational relationships like `deploys` and `triggers`—that are enforced by a Zod validator in [`schema.ts`](https://github.com/Egonex-AI/Understand-Anything/blob/main/schema.ts).**

The **Understand Anything** repository by Egonex-AI provides a strict knowledge graph schema for modeling codebases and infrastructure. At its core, the `EdgeTypeSchema` located in [`understand-anything-plugin/packages/core/src/schema.ts`](https://github.com/Egonex-AI/Understand-Anything/blob/main/understand-anything-plugin/packages/core/src/schema.ts) accepts only a fixed enumeration of 26 string values, ensuring consistent semantic relationships across all generated graphs.

## Complete List of the 26 Edge Types

The canonical edge types are defined at lines 4‑14 of [`schema.ts`](https://github.com/Egonex-AI/Understand-Anything/blob/main/schema.ts) and grouped into six semantic categories. These types cover everything from code-level composition to deployment-time operations.

### Structural Relationships

These edge types describe static code composition and inheritance hierarchies:

- **`imports`** — A file or module imports another
- **`exports`** — A file or module exports symbols
- **`contains`** — One artifact contains another, such as a class containing a method
- **`inherits`** — Classical inheritance relationship between entities
- **`implements`** — Interface implementation relationship

### Behavioral Relationships

These capture runtime interactions and event-driven communication:

- **`calls`** — A function or method calls another
- **`subscribes`** — Event-based subscription relationship
- **`publishes`** — Event-based publication relationship
- **`middleware`** — Middleware chaining relationship

### Data-Flow Relationships

These model how data moves through the system and undergoes validation:

- **`reads_from`** — Reads data from a source such as a database or file
- **`writes_to`** — Writes data to a target destination
- **`transforms`** — Data transformation pipeline step
- **`validates`** — Validation of input or output data

### Dependency and Configuration

These express auxiliary relationships and testing coverage:

- **`depends_on`** — General dependency between components
- **`tested_by`** — Test case covering a specific unit
- **`configures`** — Configuration relationship

### Semantic Relationships

These provide higher-level knowledge graph connections:

- **`related`** — Loose semantic relation between entities
- **`similar_to`** — Similarity relation indicating conceptual proximity

### Infrastructure and Operations

These map deployment artifacts and operational concerns:

- **`deploys`** — Deployment of a service or component
- **`serves`** — Service serving a specific endpoint
- **`migrates`** — Migration operation such as a database migration
- **`documents`** — Documentation linking relationship
- **`provisions`** — Resource provisioning relationship
- **`routes`** — Routing relationship such as an API route to handler
- **`defines_schema`** — Schema definition relationship
- **`triggers`** — Event or cron trigger relationship

## Schema Validation and Enforcement

The **26 edge types are immutable** and enforced at runtime by the Zod validator. In [`understand-anything-plugin/packages/core/src/schema.ts`](https://github.com/Egonex-AI/Understand-Anything/blob/main/understand-anything-plugin/packages/core/src/schema.ts), the `EdgeTypeSchema` is defined as `z.enum([...])` containing all 26 strings exactly as listed above.

When the `validateGraph` function processes a graph, any edge containing a type not present in this enumeration is treated as invalid and dropped during validation. This strict validation guarantees that downstream graph algorithms and visualizations operate on a predictable, type-safe set of relationships.

The TypeScript type `EdgeType` defined in [`understand-anything-plugin/packages/core/src/types.ts`](https://github.com/Egonex-AI/Understand-Anything/blob/main/understand-anything-plugin/packages/core/src/types.ts) mirrors this Zod enum, providing compile-time type safety throughout the codebase.

## Working with Edge Types Programmatically

### Validating a Single Edge Type

Use the `EdgeTypeSchema` to validate that a string belongs to the allowed set:

```ts
import { EdgeTypeSchema } from "@understand-anything/core/schema";

const edge = {
  source: "node-123",
  target: "node-456",
  type: "calls" as const,
  direction: "forward" as const,
  weight: 0.9,
};

// Throws if type is not one of the 26
EdgeTypeSchema.parse(edge.type);

```

### Validating an Entire Knowledge Graph

The `validateGraph` function checks all edges in a graph structure:

```ts
import { validateGraph } from "@understand-anything/core/schema";

const result = validateGraph(myGraph);
if (result.success) {
  console.log("Graph is valid, edges use only the 26 supported types");
} else {
  console.warn("Invalid edges:", result.issues);
}

```

### Normalizing Edge Type Aliases

The schema includes an `EDGE_TYPE_ALIASES` map to handle common synonyms. For example, when a language model outputs `extends`, the library maps it to the canonical `inherits`:

```ts
import { EDGE_TYPE_ALIASES } from "@understand-anything/core/schema";

const raw = "extends";
const canonical = EDGE_TYPE_ALIASES[raw] ?? raw; // "inherits"

```

This normalization happens before Zod validation, ensuring that semantic equivalents are accepted without breaking the strict 26-type constraint.

## Summary

- The **Egonex-AI Understand Anything** knowledge graph schema defines exactly **26 canonical edge types** in [`understand-anything-plugin/packages/core/src/schema.ts`](https://github.com/Egonex-AI/Understand-Anything/blob/main/understand-anything-plugin/packages/core/src/schema.ts).
- These types cover **structural**, **behavioral**, **data-flow**, **dependency**, **semantic**, and **infrastructure** relationships.
- The `EdgeTypeSchema` Zod enum at lines 4‑14 enforces this set strictly, dropping any edges with unknown types during `validateGraph` execution.
- **Edge type aliases** like `extends` → `inherits` are resolved before validation to accommodate flexible input while maintaining a fixed schema.
- Unit tests in [`understand-anything-plugin/packages/core/src/__tests__/schema.test.ts`](https://github.com/Egonex-AI/Understand-Anything/blob/main/understand-anything-plugin/packages/core/src/__tests__/schema.test.ts) explicitly enumerate and verify all 26 types.

## Frequently Asked Questions

### What happens if I use an edge type not in the list of 26?

The Zod validator in `validateGraph` rejects any edge type not present in the `EdgeTypeSchema` enumeration. According to the validation logic in [`schema.ts`](https://github.com/Egonex-AI/Understand-Anything/blob/main/schema.ts), these invalid edges are dropped during the parsing process, ensuring only compliant relationships persist in the knowledge graph.

### How does the schema handle synonyms like "extends" for inheritance?

The `EDGE_TYPE_ALIASES` map defined in [`schema.ts`](https://github.com/Egonex-AI/Understand-Anything/blob/main/schema.ts) normalizes common synonyms to canonical types before validation occurs. For instance, `extends` is automatically mapped to `inherits`, allowing language models and other input sources to use familiar terminology while the graph stores only the 26 standardized edge types.

### Where are the 26 edge types tested in the codebase?

The complete enumeration is tested in [`understand-anything-plugin/packages/core/src/__tests__/schema.test.ts`](https://github.com/Egonex-AI/Understand-Anything/blob/main/understand-anything-plugin/packages/core/src/__tests__/schema.test.ts). The test suite explicitly iterates through all 26 edge types to verify that `EdgeTypeSchema` accepts each one and rejects invalid strings, serving as the single source of truth for schema compliance.

### Can I extend the schema to add custom edge types?

The schema is designed as a fixed vocabulary of 26 types enforced by the Zod enum and the TypeScript `EdgeType` definition. Adding custom types requires modifying the source array in [`schema.ts`](https://github.com/Egonex-AI/Understand-Anything/blob/main/schema.ts) (lines 4‑14), updating the `EdgeType` type in [`types.ts`](https://github.com/Egonex-AI/Understand-Anything/blob/main/types.ts), and adjusting the corresponding test file to maintain validation integrity.