MCP Manifest Structure for Learning Paths: A Complete Technical Guide

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, 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).

{
  "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 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, 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.

{
  "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 script loads these JSON files dynamically, while 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 and learning-paths/using-coding-agents.json demonstrate the spectrum from minimal to full-featured implementations.
• The 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 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.

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, 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 file loads and parses the JSON manifests from the learning-paths/ directory, while 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.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}