MCP Server · v1.2.0 · Model Context Protocol native

Code generation,
handed to your agent.

MetaEngine ships a Model Context Protocol server that exposes every converter and batch type generator as a tool call. Connect it to Claude Desktop, Cursor, Cline, or any MCP-aware assistant — and let it turn "regenerate my billing client" into a real, typed, committed diff.

Install the server Browse 7 tools
7
Tools exposed
4
Source specs
11
Languages
stdio · http
Transports
How it wires together
AI AGENTClaude · Cursornatural languagetool_callMETAENGINE MCPmcp-serverstdio · http · ssedispatchCONVERTERS4 sourcesopenapi · graphql · …emitPACKAGES3 on npmtyped · shipped
stdio — local pipe (default)·http — long-lived HTTP server·sse — server-sent events for streaming
Live demo · end-to-end

A single prompt. A shippable diff.

Watch the agent orchestrate MetaEngine on a real billing-API rev. No ceremony, no templating, no copy-paste — tools compose, and the code lands.

claude-desktop · metaengine-mcp connected
Our team just rev'd the Stripe-like billing API — spec is at specs/billing.v3.yaml. Generate a typed TS client for the web app and a Python client for the workers.
Let me first load the spec. I'll initialize a generation context before dispatching.
→ calling <tool>load_spec_from_file</tool>
tool.load_spec_from_file200 OK
input
{
  "path": "specs/billing.v3.yaml"
}
output
{
  "format": "openapi",
  "version": "3.1.0",
  "types": 42,
  "operations": 68
}
Spec looks healthy: 42 types, 68 operations. Initializing a context, then generating both clients.
→ calling <tool>metaengine_initialize</tool> → calling <tool>generate_openapi</tool> (typescript) → calling <tool>generate_openapi</tool> (python)
tool.generate_openapi200 OK
input
{
  "target": "typescript-fetch",
  "scope": "billing"
}
output
{
  "files": 71,
  "size": "184.2 KB",
  "ms": 312
}
tool.generate_openapi200 OK
input
{
  "target": "python-fastapi",
  "scope": "billing"
}
output
{
  "files": 58,
  "size": "142.8 KB",
  "ms": 268
}
Done. Typed clients are in packages/billing-ts/ and services/billing-py/. Both compile under strict mode and the import graph is clean.
proposed diff · feat/billing-v3ready to commit
Files
7
Lines
+2,948
Size
327 KB
Duration
0.6s
NEW packages/billing-ts/src/client.ts342 LOC
NEW packages/billing-ts/src/models.ts1180 LOC
NEW packages/billing-ts/src/index.ts22 LOC
MOD packages/billing-ts/package.json28 LOC
NEW services/billing-py/billing/client.py412 LOC
NEW services/billing-py/billing/models.py964 LOC
MOD apps/web/src/checkout.tsx2 LOC— currency now required
Tool catalog · 7 primitives

Seven tools. Every converter addressable.

Every capability MetaEngine has — loading a spec, initializing a context, running a converter — surfaces as one MCP tool. Agents compose them like any other function.

Install · one npx away

Drop into any MCP client.

Paste the snippet into your client's config file and restart. No API key, no account — every converter in the registry is immediately addressable.

~/.claude/claude.json
{
  "mcpServers": {
    "metaengine": {
      "command": "npx",
      "args": ["@metaengine/mcp-server@latest"],
      "env": {
        "METAENGINE_SCOPE": "openapi,graphql,protobuf,sql"
      }
    }
  }
}
Architecture

Four stages. Deterministic within a version.

MetaEngine's MCP server is a thin boundary. The heavy lifting is the same compiler pipeline that powers the Converters page — same spec, same engine version, same bytes. Improvements land server-side, so regenerating after an upgrade surfaces the diff cleanly.

01
Agent emits tool_call
Your AI assistant — Claude, Cursor, Cline — picks a MetaEngine tool from its registered schema and your prompt.
02
MCP server resolves
The stdio / HTTP bridge routes the call to the right converter, validating args against the tool JSON schema.
03
Converter runs
Spec is parsed, normalized to MetaEngine IR, emitted through the language-specific target. Deterministic against a given engine version.
04
File tree returned
Output is streamed back as a structured file tree — path, bytes, language — ready to write, diff, or commit.
Runtime log — metaengine-mcp (sample) 
[14:02:18.441]  INFO   mcp transport=stdio ready pid=42811
[14:02:18.442]  INFO   registry loaded · 7 tools · 4 source specs
[14:02:19.108]  REQ    tool.load_spec_from_file { path: "specs/billing.v3.yaml" }
[14:02:19.183]  OK     load_spec_from_file → 42 types · 68 ops · 74ms
[14:02:19.201]  REQ    tool.generate_openapi { target: "typescript-fetch" }
[14:02:19.513]  OK     generate_openapi → 71 files · 184.2KB · 312ms
[14:02:19.515]  REQ    tool.generate_openapi { target: "python-fastapi" }
[14:02:19.783]  OK     generate_openapi → 58 files · 142.8KB · 268ms
[14:02:19.784]  INFO   idle · 0 in-flight · mem=34.1MB
Design tenets

Built for agentic workflows.

Free, no keys, always current

No API key, no account. The server calls the MetaEngine API over HTTP — specs and outputs aren't stored or logged. New converters and engine improvements land server-side, so you get them without bumping the package.

Fast enough to iterate

The compiler pipeline is cached and emits straight to disk — compute runs in milliseconds (≈10ms for 100 types). End-to-end round-trips finish in a few hundred ms for most specs; large enterprise specs take longer, but rarely long enough to stall a conversation.

Every target, one contract

Swap target from typescript to python and the tool signature doesn't change. Agents learn the pattern once.

Deterministic within a session

Each tool is idempotent against a given engine version: same inputs, same run, same bytes — agents retry freely without drift. Across time, engine improvements land server-side and output can evolve; commit the generated code to freeze a specific build.

Scope-gated tools

METAENGINE_SCOPE restricts which converters the agent can reach. Tighten the surface without hacking the client.

Works with any MCP client

Claude Desktop, Cursor, Cline, Continue, Zed — anywhere the protocol is spoken, MetaEngine is installable.