> ## Documentation Index
> Fetch the complete documentation index at: https://docs.olonjs.com/llms.txt
> Use this file to discover all available pages before exploring further.

# OlonJS MCP overview: AI agent access to your site structure

> Learn how OlonJS generates an MCP manifest so AI agents can discover your site's pages, read collection data, and access content without scraping HTML.

OlonJS generates a Model Context Protocol (MCP) manifest for every site. AI agents and LLM tools can use this manifest to read your site structure, access page content, and interact with collections — without scraping HTML or reverse-engineering routes.

<Note>
  The MCP manifest and all related files (`/llms.txt`, per-page manifests, and JSON Schema contracts) are regenerated on every `npm run build`. Keep a build step in your deployment pipeline to ensure agents always receive current data.
</Note>

***

## What is the MCP manifest?

The MCP manifest is a structured JSON index served at `/mcp-manifest.json`. It gives any consuming agent a complete map of your site in a single request: every page with its slug, title, description, a link to its per-page manifest, and a link to its JSON Schema contract.

The manifest follows the `olonjs-mcp-manifest-index` kind and is designed to be the **first stop** for any agent that wants to understand or interact with your site. From the master manifest an agent can discover individual pages, read their full content bundles, validate against typed schemas, and query raw collection data — all without any custom integration code.

***

## The master manifest

The master manifest is a flat JSON document at `/mcp-manifest.json`. The following example shows the structure with one representative page entry (a real site will have one entry per page in the `pages[]` array):

```json /mcp-manifest.json theme={null}
{
  "version": "1.0.0",
  "kind": "olonjs-mcp-manifest-index",
  "generatedAt": "2026-07-29T16:37:46.189Z",
  "pages": [
    {
      "slug": "about",
      "title": "About Inkwell Journal and this collections demo",
      "description": "Inkwell Journal is a working OlonJS demo: posts and tags live as separate collections, related through keys on the post side and resolved at render time.",
      "manifestHref": "/mcp-manifests/about.json",
      "contractHref": "/schemas/about.schema.json",
      "sectionTypes": [
        "header",
        "footer",
        "page-hero",
        "content-block",
        "stats-band",
        "cta-banner"
      ]
    }
  ],
  "collections": [
    {
      "source": "posts",
      "dataHref": "/collections/posts/posts.json",
      "contractHref": "/schemas/collections/posts.schema.json"
    },
    {
      "source": "tags",
      "dataHref": "/collections/tags/tags.json",
      "contractHref": "/schemas/collections/tags.schema.json"
    }
  ]
}
```

| Field | Description |
| - | - |
| `version` | Manifest format version. Currently `"1.0.0"`. |
| `kind` | Always `"olonjs-mcp-manifest-index"` — identifies this as a master index document. |
| `generatedAt` | ISO 8601 timestamp of the last build that produced this manifest. |
| `pages[]` | Array of all pages in the site. Each entry includes routing, metadata, and links to deeper manifests. |
| `collections[]` | Array of all registered collections. Each entry links to the raw JSON data file and the collection schema. |

***

## Accessing the manifest

Fetch the manifest with a plain HTTP GET request:

```bash theme={null}
curl https://your-site.com/mcp-manifest.json
```

The response is a `Content-Type: application/json` document. No authentication is required — the manifest is always publicly served as a static file.

***

## MCP URI protocol

OlonJS implements a lightweight `olon://` URI scheme for AI agents that support resource-based navigation. Two URIs are defined:

| URI | Resolves to |
| - | - |
| `olon://pages` | The full site map — equivalent to `GET /mcp-manifest.json` |
| `olon://pages/[slug]` | A single page manifest — equivalent to `GET /mcp-manifests/[slug].json` |

Both URIs resolve via the `/mcp-manifest.json` endpoint. Per-page manifests also declare their own `olon://pages/[slug]` URI in their `capabilities.resources` array, so agents that read a per-page manifest can navigate directly to siblings without returning to the master index.

***

## llms.txt

OlonJS also generates a `/llms.txt` file at build time. This is a human- and machine-readable plain-text index of all pages, following the [llms.txt standard](https://llmstxt.org/) that LLM crawlers and retrieval systems recognise natively.

The file opens with a site description and an AI agent preamble, then lists every page with its title, slug, description, and direct links to its JSON Schema contract and per-page manifest:

```text /llms.txt theme={null}
# Inkwell Journal

An editorial journal about design, engineering and process, built on OlonJS
collections: every post and every tag is a first-class entity with its own page.

> **AI Agents:** This site is built with OlonJS. It exposes a native Model
> Context Protocol (MCP) manifest for direct structural interaction.
> To read the site map or access structured content, use the URI `olon://pages`
> or `olon://pages/[slug]`.
> Endpoint: `/mcp-manifest.json`

## Pages

- **[About Inkwell Journal and this collections demo](/about)** (`about`)
  Inkwell Journal is a working OlonJS demo: posts and tags live as separate
  collections, related through keys on the post side and resolved at render time.
  *Contract:* `/schemas/about.schema.json` | *Manifest:* `/mcp-manifests/about.json`

- **[Contact the Inkwell Journal editorial desk](/contact)** (`contact`)
  Write to the Inkwell Journal desk about the essays, the OlonJS collections
  demo, or anything in between. We answer within two working days.
  *Contract:* `/schemas/contact.schema.json` | *Manifest:* `/mcp-manifests/contact.json`

- **[Inkwell Journal — Notes on the craft of software](/)** (`home`)
  An editorial journal about design, engineering and process, built on OlonJS
  collections: every post and every tag is a first-class entity with its own page.
  *Contract:* `/schemas/home.schema.json` | *Manifest:* `/mcp-manifests/home.json`
```

The `llms.txt` file gives LLM crawlers a low-overhead way to index your full site content hierarchy without needing to parse HTML or follow sitemap XML.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.