MCP server

SchematIaC ships a standalone Model Context Protocol server that gives an AI agent — Claude Code, Cursor, or any other MCP client — the same deterministic engine the canvas uses, for both Terraform and Bicep. Your agent can read the graph, look up what a value resolves to, trace lineage, and get a validated diff for a proposed change.

The AI comes from your agent; SchematIaC supplies the ground truth about your infrastructure code — still local, still no CLI binary.

Claude Code Cursor Terraform & Bicep Runs locally

Read and propose only — it never writes a file

Every edit tool returns a diff and the full new file text; your agent's own host decides whether to apply it. Nothing reaches disk through SchematIaC. The same discipline as the canvas — nothing is written without you saving — extended to your agent.

Install it on your agent

This is not an npm package and there is no marketplace install for the MCP server itself. The VS Code extension owns the server. One command copies the snippet your agent needs — JSON for most clients, a shell command for Claude Code. You paste that once. After that you talk to the agent in English; you do not paste JSON on every question.

Install the SchematIaC extension, then start a trial or enter a licence key so the snippet includes credentials.
Command palette: SchematIaC: Copy MCP Setup for AI Agents. Pick the client.
Paste what it copied — see the two shapes below. Reload the agent (Cursor: restart MCP / reload the window) so the tools appear.

Cursor, Claude Desktop, others

Paste the JSON into the client's MCP config. In Cursor that is Settings → MCP, or a mcp.json next to the project (.cursor/mcp.json). Merge the schematiac block if the file already has other servers.

Claude Code

Do not paste JSON. Paste the copied line into a terminal and run it. It is a ready-to-run claude mcp add at user scope — the server and licence belong to you, not to one repo.

Can you tell the AI to install it? Only after the extension has copied the snippet: drop that JSON (or the claude mcp add line) into chat and ask it to add the MCP server. Do not ask it to invent the config — the path and token come from this VS Code install, and a hand-written block will miss both.

mcp.json — Cursor / Claude Desktop. The extension fills in the real path and token.

{
  "mcpServers": {
    "schematiac": {
      "command": "node",
      "args": ["<globalStorage>/mcp.js"],
      "env": {
        "SCHEMATIAC_LICENSE": "<your token>",
        "SCHEMATIAC_MACHINE": "<machine digest>"
      }
    }
  }
}

terminal — Claude Code. One line, any shell.

claude mcp add schematiac -s user -e SCHEMATIAC_LICENSE=<your token> -- node "<globalStorage>/mcp.js"

SCHEMATIAC_MACHINE is included only for machine-bound trial keys. Node must be on the PATH. Not started a trial yet? The snippet is still copied, just without credentials — start a trial or paste a key, then run the command again.

How you use it

Once the server is registered, ask in plain language. The agent calls the tools. Point it at a Terraform or Bicep root (an absolute path, or the folder already open). It can read the graph, resolve a value, trace lineage, and return a validated diff — it never writes the file. You (or the agent's host) apply the patch if you want it.

You say

What does aws_instance.web.instance_type resolve to in this root, and if I change it from t3.micro to t3.small, show me the exact diff — do not write the file.

A typical agent then calls the tools like this (you never type this JSON yourself):

1. schematiac_resolve — what it is now

{
  "root": "/repos/acme/infra",
  "address": "aws_instance.web.instance_type"
}

2. schematiac_propose_edit — a validated patch, nothing written

{
  "root": "/repos/acme/infra",
  "kind": "setExpr",
  "node": "aws_instance.web",
  "prop": "instance_type",
  "newText": "\"t3.small\""
}

What comes back — the host may apply this; SchematIaC will not

file: main.tf
  - instance_type = "t3.micro"
  + instance_type = "t3.small"

Other useful asks: “trace everything that feeds this row,” “overview this repo before we pick a root,” “is this expression valid HCL?” The tools are listed below.

The tools

Tool	What it does
`schematiac_graph`	Parse a Terraform or Bicep root (and its local child modules) into the full graph: nodes, rows with resolved values, and the edges wiring them.
`schematiac_resolve`	Look up what one value resolves to and why — where it is declared and set, and what is blocking anything not fully known.
`schematiac_trace`	Trace one value's full lineage: everything upstream that feeds it and everything downstream it feeds.
`schematiac_overview`	The Folder Overview of a directory tree — per-directory counts and which directories compose which. Terraform-only.
`schematiac_propose_edit`	Propose re-pointing a reference or setting a value on one row. Validated in the file's own language and returned as a diff — nothing is written to disk.
`schematiac_analyze`	Rule-based rewiring suggestions from the graph itself — no model. Each suggestion is one `schematiac_propose_edit` away.
`schematiac_validate_expr`	Check whether a string is a valid HCL or Bicep expression for a property value, without touching any file.

Licensing & privacy

Each tool call is gated by an active trial or paid licence, using the token in the snippet. Setup and status always work; the licence state is reported to your agent.
The server runs locally as node <globalStorage>/mcp.js — no VS Code needs to be running, and like the canvas it makes no network calls of its own.
One root is one language; schematiac_overview and simulated-workspace reads are Terraform-only.

See how we handle your data, or read the docs. New here? Install from the Marketplace, then start with Terraform or Bicep.