Tabnas

What the tabnas MCP server does

The tabnas MCP server gives MCP clients access to the tabnas parsing engine through a TypeScript implementation published as @tabnas/mcp. It runs over stdio and exposes seven operations:

• parse checks input and returns either a parse tree or a diagnostic.
• validate_grammar checks a serialized GrammarSpec and reports validation errors with paths.
• explain_parse_error combines a parse diagnostic with the matching bundled error-code entry when one exists.
• test_grammar evaluates TSV fixture content and reports row-level expected and actual results.
• list_plugins returns the available grammar plugin descriptors.
• describe_plugin returns the complete descriptor for one plugin.
• compare_grammars examines acceptance and tree-output differences between a baseline and candidate grammar.

The MCP interface also serves bundled resources for the grammar schema, diagnostic schema, error registry, plugin list, and divergence information.

How it works

Each request creates a new engine instance. When a grammar is supplied, it is validated before loading, and parser options are applied before the grammar. Without a grammar, the engine has no rules, so parsing produces an undefined tree represented by a successful result without a tree value.

Grammar and option inputs are treated as data rather than executable code. A security firewall rejects prototype-pollution keys, references, unsupported function values, plugin declarations, and grammars exceeding 5,000 rules. Engine failures are converted into the same structured validation-error shape used by the CLI.

compare_grammars reports static findings, observed runs, changes, counterexamples, confidence, and an explanation. It does not return an unconditional compatibility verdict: language inclusion cannot be decided for every possible grammar.

Setup and configuration

Install the package globally for the CLI, or run the server directly with npx:

npm install -g @tabnas/mcp
npx --yes @tabnas/mcp

For an MCP client, configure a stdio server whose command is npx and whose arguments are --yes, a pinned @tabnas/mcp@<version> package, and mcp:

{
  "mcpServers": {
    "tabnas": {
      "command": "npx",
      "args": ["--yes", "@tabnas/mcp@<version>", "mcp"]
    }
  }
}

Pinning a published version avoids tool behavior changing underneath an installed client. The server writes JSON-RPC on stdout and does not print unrelated output there.

All grammar arguments must be serialized GrammarSpec JSON. The tools do not accept ABNF, EBNF, GBNF, or jsonic source. Compile those formats before sending them, and use a conversion step that produces a pure specification without live references. Fixture tests use TSV content with a header, an input column, and an expected JSON or error value; column positions can be changed by option.

Limitations and notes

The server does not compile grammar source and does not execute plugin code supplied through a request. Plugin declarations in options or grammars are rejected by the security boundary. Fixture specifications larger than 10,000 rows are refused.

The comparison report is evidence-based rather than a proof of universal compatibility. Static analysis only proves cases within its supported decidable subset, while observed results depend on the supplied corpus or test inputs. The package is TypeScript-only and is tooling around the engine, not a Go parity package.

The tabnas MCP server shares its core with the tabnas CLI, so MCP results and CLI --json results use the same serialized result contract. This makes the CLI useful for reproducing an agent request locally.