# MCP Manifest Structure for Learning Paths: A Complete Technical Guide

> Explore the MCP manifest structure for learning paths in rohitg00/ai-engineering-from-scratch. Understand the JSON contract defining curriculum trajectories with key fields and optional extensions.

- Repository: [Rohit Ghumare/ai-engineering-from-scratch](https://github.com/rohitg00/ai-engineering-from-scratch)
- Tags: deep-dive
- Published: 2026-09-04

---

**The MCP manifest structure for learning paths is a JSON contract that defines curriculum trajectories in the `rohitg00/ai-engineering-from-scratch` repository, requiring fields like `schemaVersion`, `id`, `title`, `summary`, and `lessons` while supporting optional extensions for stages, readiness criteria, and portfolio proof.**

The repository implements a Model Context Protocol (MCP) runtime that consumes structured manifests to render career routes on the learning platform. Understanding the MCP manifest structure for learning paths enables curriculum authors to define machine-readable trajectories that specify lesson ordering, estimated duration, and competency requirements. All learning-path files reside in the `learning-paths/` directory and share a common schema versioned for backward compatibility.

## Core Schema and Required Fields

Every valid MCP manifest must declare five mandatory fields that establish the contract with the runtime. In [`learning-paths/using-coding-agents.json`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/learning-paths/using-coding-agents.json), these fields define the smallest valid learning path.

- **`schemaVersion`**: An integer specifying the manifest format version (currently `1`).
- **`id`**: A machine-readable identifier using kebab-case (e.g., `"agentic-ai-engineer"`).
- **`title`**: The human-readable name displayed in the web interface.
- **`summary`**: A concise description of the career route and its outcomes.
- **`lessons`**: An ordered array of lesson objects, each containing `order` (sequential integer), `path` (relative directory path), `minutes` (estimated duration), and `required` (boolean flag indicating mandatory completion).

```json
{
  "schemaVersion": 1,
  "id": "example-path",
  "title": "Example Learning Path",
  "summary": "A short description of the path.",
  "estimatedMinutes": 120,
  "lessons": [
    { "order": 1, "path": "phases/01-intro/01-welcome", "minutes": 30, "required": true },
    { "order": 2, "path": "phases/02-foundations/01-math", "minutes": 90, "required": true }
  ]
}

```

## Optional Metadata and Behavioral Fields

Advanced manifests leverage optional fields to enrich the learner experience and guide decision-making. The [`learning-paths/agentic-ai-engineer.json`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/learning-paths/agentic-ai-engineer.json) file demonstrates the full schema extension.

- **`keywords`**: Space-separated tags for searchability and filtering (e.g., `"agentic ai engineer function calling"`).
- **`decisionPrompt`**: A question presented to learners when choosing this path (e.g., `"Do you want to engineer tool-using systems...?"`).
- **`mission`**: A high-level mission statement describing the philosophical goal of the trajectory.
- **`estimatedMinutes`**: Total aggregated learning time across all lessons, calculated as an integer.
- **`readinessCriteria`**: An array of competency strings describing what the learner can demonstrate after completion (e.g., `"Can separate tool capability from policy"`).
- **`coverage`**: A structured object breaking down topics into `"strong"`, `"partial"`, and `"outsideCourse"` arrays for curriculum gap analysis.
- **`portfolioProof`**: A specification for the capstone artifact, including `title` and `description`, that validates mastery.

## Structuring Learning with Stages

The optional `stages` field groups lessons into logical phases with common outcomes and deliverables. Each stage object in the array requires `id`, `title`, `outcome`, and `lessonPaths`, with an optional `artifact` field describing the stage deliverable.

As defined in [`learning-paths/agentic-ai-engineer.json`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/learning-paths/agentic-ai-engineer.json), stages enable curriculum designers to cluster related content. The `"common-core"` stage, for example, lists specific lesson paths under `lessonPaths` and declares an `artifact` of `"A deterministic agent loop"`, creating a checkpoint before learners advance to specialized topics.

```json
{
  "stages": [
    {
      "id": "common-core",
      "title": "Common Core",
      "outcome": "Build a typed tool surface...",
      "lessonPaths": [
        "phases/13-tools-and-protocols/01-the-tool-interface",
        "phases/13-tools-and-protocols/05-tool-schema-design"
      ],
      "artifact": "A deterministic agent loop..."
    }
  ]
}

```

## Repository Integration and Runtime Consumption

The MCP manifests serve as the data layer for the curriculum's web interface. The [`site/learning-paths.js`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/site/learning-paths.js) script loads these JSON files dynamically, while [`site/learning-paths.html`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/site/learning-paths.html) renders the structured data into interactive trajectory visualizations.

Unlike static documentation, these manifests are functional contracts. The runtime validates the `lessons` array to ensure `order` values are sequential and `path` references resolve to actual lesson directories. When a learner selects a path via the `decisionPrompt`, the system enrolls them in the sequence defined by the `required` flags and `stages` boundaries.

## Summary

- The MCP manifest structure requires five core fields (`schemaVersion`, `id`, `title`, `summary`, `lessons`) to define a valid learning path in `rohitg00/ai-engineering-from-scratch`.
- Optional fields like `stages`, `readinessCriteria`, and `portfolioProof` enable granular curriculum design and competency tracking.
- The `lessons` array uses a strict schema with `order`, `path`, `minutes`, and `required` properties to sequence content.
- Repository files such as [`learning-paths/agentic-ai-engineer.json`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/learning-paths/agentic-ai-engineer.json) and [`learning-paths/using-coding-agents.json`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/learning-paths/using-coding-agents.json) demonstrate the spectrum from minimal to full-featured implementations.
- The [`site/learning-paths.js`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/site/learning-paths.js) runtime consumes these manifests to render the web interface and enforce progression logic.

## Frequently Asked Questions

### What is the minimum valid MCP manifest for a learning path?

A minimal valid manifest requires only five fields: `schemaVersion` (set to `1`), a unique `id`, a human-readable `title`, a `summary` description, and a `lessons` array containing objects with `order`, `path`, `minutes`, and `required` properties. This stripped-down structure appears in [`learning-paths/using-coding-agents.json`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/learning-paths/using-coding-agents.json) and satisfies the MCP runtime contract without optional metadata.

### How does the `stages` field differ from the `lessons` array?

The `lessons` array is a flat, ordered list of individual learning units required for path completion, while the `stages` field provides a hierarchical grouping mechanism that clusters lessons into phases with shared outcomes and optional artifacts. The `stages` object contains a `lessonPaths` array referencing directories, effectively creating logical checkpoints within the broader trajectory defined in [`learning-paths/agentic-ai-engineer.json`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/learning-paths/agentic-ai-engineer.json).

### Can a learning path exist without the `stages` field?

Yes, the `stages` field is entirely optional, as demonstrated by [`learning-paths/using-coding-agents.json`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/learning-paths/using-coding-agents.json), which omits stages entirely and relies solely on the `lessons` array for progression. Paths without stages present a linear sequence without intermediate grouping, making them suitable for shorter or less complex curricula that do not require phase-based milestones.

### What file consumes these MCP manifests in the repository?

The [`site/learning-paths.js`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/site/learning-paths.js) file loads and parses the JSON manifests from the `learning-paths/` directory, while [`site/learning-paths.html`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/site/learning-paths.html) renders the data into the user interface. This architecture separates the data contract (the manifest) from the presentation layer, allowing the MCP runtime to validate and display trajectories without hardcoding curriculum logic.