OPF MCP server

@openpresentation/mcp is a Model Context Protocol server for OPF, so an agent or editor that speaks MCP can learn the format, look things up and check a deck without shelling out and parsing text. It teaches OPF (documentation, schemas, the default catalog, example decks and the six agent skills, all as resources, with a start_here tool that gives a path for a goal), and it runs the checks the CLI runs (validate_deck, convert).

It keeps no state, reads no file (everything it serves is bundled in the package, and tools work on the text you pass in), fetches nothing and has no network access. It runs two ways: locally over stdio (this page), and hosted on an edge runtime (the same server definition over Streamable HTTP; a hosted URL at openpresentation.org/mcp is coming). The local server is the only one that can measure layout with the real fonts, when @openpresentation/opf-render is installed.

Set it up#

Any MCP client that starts a local server takes a command and arguments:

{
  "mcpServers": {
    "opf": { "command": "npx", "args": ["-y", "@openpresentation/mcp"] }
  }
}

Pin a version (@openpresentation/mcp@0.27.0) to make the setup repeatable. Node 22 or later is required.

Check it with the official inspector: npx @modelcontextprotocol/inspector npx -y @openpresentation/mcp.

opf mcp of the CLI is a convenience: it runs this server when @openpresentation/mcp is installed beside the CLI or in the working directory, and otherwise prints npx -y @openpresentation/mcp and exits with 2. The CLI itself carries no MCP code.

Tools#

Every tool takes JSON arguments and returns structured JSON (structuredContent, with the same JSON as text for clients that read only text). A failure comes back with isError: true and a text report { ok: false, code, error, ... } (no structured content), with a stable code (unknown-id, invalid-document, ...) and, where it helps, a suggestion ("Did you mean two-column?"). All tools are read-only.

Resources#

Resources have stable URIs. The server lists them (resources/list) and also offers URI templates (resources/templates/list) so a client can read a URI it builds itself.

Skill scripts and agent manifests are not served; the server runs no code from them.

Prompts#

A typical session#

1. The agent calls start_here { goal: "a board update with a revenue chart" } (or reads opf://docs/format-card, or runs the learn_opf prompt).
2. It reads what the path names, finds layouts with search_catalog { kind: "layouts", query: "two columns" } and reads one with get_catalog_record.
3. It writes the deck and calls validate_deck with failOn: "warning"; each finding names a rule, a JSON Pointer and a hint. It fixes the findings and repeats until ok is true. A field it is unsure of comes from get_schema { name: "Chart" }.
4. It uses convert to hand the deck over as YAML or Markdown. Rendering and PPTX export are outside this server: the local opf convert deck.opf.json deck.pdf (or .pptx) does them.

Validation checks the file. It does not render the deck, so it is not proof of how the deck looks.

Host it#

The package is a library as well as a command. Its entries:

The two library entries import no Node builtin and read no file; documentation, examples, skills and release notes are bundled data; validation uses the precompiled validators (@openpresentation/opf/precompiled), so they run where code generation from strings is refused, such as Cloudflare Workers (the tests bundle them the way Wrangler does and run them in workerd):

import { createOpfServer } from "@openpresentation/mcp";
import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";

export default {
  async fetch(request: Request): Promise<Response> {
    const server = createOpfServer({ version: "0.27.0" });
    const transport = new WebStandardStreamableHTTPServerTransport({ sessionIdGenerator: undefined, enableJsonResponse: true });
    await server.connect(transport);
    return transport.handleRequest(request);
  },
};

createOpfServer({ version, opfVersion?, sources?, checkText? }) returns an SDK McpServer. sources replaces any of the bundled docs, examples, skills and whatsNew. checkText replaces the check behind validate_deck; opf-mcp passes the one that measures layout with the fonts opf convert draws with. Without it, layout is estimated and the report's hint says so.

The bundled data is most of the size of a Worker bundle (about 12 MB minified, 5.6 MB gzipped, of which the example decks are 7 MB and the documentation 1.4 MB). A host that must stay small imports createOpfMcpServer from @openpresentation/mcp/server, which bundles none of it (about 3.5 MB minified, 0.7 MB gzipped), and takes sources: { docs, examples, skills, whatsNew? } from wherever it keeps them (KV, R2, static assets): docs is [{ slug, title, markdown }], examples is [{ slug, category, file, deck }], skills maps a skill name to { "SKILL.md": text, ... }. defaultSources() and DOC_SLUGS (the pages served) are exported from @openpresentation/mcp.

Limits#

• Text formats only for convert. Rendering and PowerPoint need the local opf command, which can write files.
• validate_deck reads no files, so a local image path in a deck is not looked up (the CLI warns with cli/asset-missing). Pass images as data URIs or assets.
• Layout is measured with real fonts only under opf-mcp with @openpresentation/opf-render installed; checks.layout says measured or estimated.