com.kernelcad/kernelcad

Official45 toolsLive

by w1ne · TypeScript

Agent-first CAD: editable .kcad.ts source, deterministic review, OpenCASCADE kernel.

kernelCAD MCP Server (com.kernelcad/kernelcad)

kernelCAD is an MCP server for an agent-first CAD workflow that produces editable .kcad.ts source, deterministic review evidence, and exportable manufacturing artifacts. It uses OpenCASCADE (Replicad/OpenCASCADE described as the kernel layer) to evaluate models, validate outcomes deterministically, and support guided revision and export.

🛠️ Key Features

Agent-first CAD workflow
Source-first loop producing editable .kcad.ts files
Deterministic validation and review evidence
Export package for manufacturing artifacts
Tool set: 45 tools

🚀 Use Cases

Converting a design brief into editable CAD source (.kcad.ts)
Generating deterministic evidence for review
Validating CAD designs and iterating via guided revision
Exporting manufacturing artifacts from evaluated models

⚡ Developer Benefits

Deterministic review and validation outputs
Editable, versionable .kcad.ts CAD source
Kernel layer based on OpenCASCADE; workflow layer adds history, diagnostics, validation, and variants

⚠️ Limitations

Described as not a browser clone of Fusion, Onshape, or SolidWorks

Topics

3d-modelingai-agentscadmcpmodel-context-protocolnurbsopencascade

Captured live from the server via tools/list.

review_paint_peek_latest

Return the newest brush-painted review packet from a Studio session. After sharing a /p/<slug> link, the user can open it in the browser and paint marks over the 3D viewport to give visual feedback. Call this tool with the `slug` from that link to see the strokes — screenshot + mask + struck part names plus an optional one-line note and intent tags (e.g. "too thick", "missing", "wrong angle") describing WHAT is wrong — and act on the feedback. The slug is the capability: no OAuth required when passing `slug`; private projects require the owner to be signed in. Omit `slug` to fetch your own latest packet from your signed-in account (requires OAuth). By default returns short-lived signed Storage URLs for the screenshot + mask + meta.json plus the struck part names — small and context-friendly. Pass `paths_only: false` to also base64-inline the PNGs for clients that cannot fetch the signed URLs over HTTP.

Parameters3

slug	string	optional	Project slug from open_in_studio/get_project/a /p/<slug> link. When given, returns the latest brush packet painted on that project's page — works without OAuth; the slug is the capability. Omit to use your signed-in account's latest packet.
freshness_sec	integer	optional	Maximum packet age in seconds. Default 1800 (30 min). Use a smaller value for "what did I just paint" or a larger one for "earlier today".
paths_only	boolean	optional	Controls PNG delivery. Default (omitted or true): return only signed URLs + struck part names — the small, context-friendly response; fetch the bytes via the signed URLs. Set false to also base64-inline the screenshot + mask PNGs for clients that cannot fetch the URLs over HTTP (larger response).

Raw schema

{
  "type": "object",
  "properties": {
    "slug": {
      "type": "string",
      "description": "Project slug from open_in_studio/get_project/a /p/<slug> link. When given, returns the latest brush packet painted on that project's page — works without OAuth; the slug is the capability. Omit to use your signed-in account's latest packet."
    },
    "freshness_sec": {
      "type": "integer",
      "description": "Maximum packet age in seconds. Default 1800 (30 min). Use a smaller value for \"what did I just paint\" or a larger one for \"earlier today\".",
      "minimum": 1
    },
    "paths_only": {
      "type": "boolean",
      "description": "Controls PNG delivery. Default (omitted or true): return only signed URLs + struck part names — the small, context-friendly response; fetch the bytes via the signed URLs. Set false to also base64-inline the screenshot + mask PNGs for clients that cannot fetch the URLs over HTTP (larger response)."
    }
  },
  "additionalProperties": false
}

open_in_studio

Use this when the user wants to SEE or share the model — it persists the current kernelCAD model and returns a one-click link that opens it in the kernelCAD Studio web app, where the user can view and share it. Pass the full `.kcad` source you have been building as `code`. `code` is OPTIONAL: if you just called `evaluate_script` you can omit it and this reuses that last evaluated source automatically (no need to re-send the whole script). Pass `code` explicitly to override, or whenever you have not evaluated this exact source yet. The result includes a `slug` — pass that `slug` on every subsequent call to UPDATE the same project in place: the user's open Studio tab re-renders live, so they can watch the model evolve as you iterate. Omit `slug` only for a new, separate model (each omission creates a new project and link). Trigger phrases: "open it in Studio", "let me see it", "show me the model"; also call it after you finish a build, and after each meaningful revision while iterating.

Parameters4

code	string	optional	The full .kcad source of the model to open in Studio (the script you have been editing). Optional: omit to reuse the source from your most recent evaluate_script call.
title	string	optional	Optional human-readable title for the model (shown in Studio). Defaults to "Model from Claude".
parameters	array	optional	Optional list of the model's editable parameters, so Studio can render parameter controls. Each item is one control derived from the .kcad params.
slug	string	optional	Slug returned by a previous open_in_studio call. When given, updates that existing project in place (live-updating the user's open Studio tab) instead of creating a new one.

Raw schema

{
  "type": "object",
  "properties": {
    "code": {
      "type": "string",
      "description": "The full .kcad source of the model to open in Studio (the script you have been editing). Optional: omit to reuse the source from your most recent evaluate_script call.",
      "minLength": 1
    },
    "title": {
      "type": "string",
      "description": "Optional human-readable title for the model (shown in Studio). Defaults to \"Model from Claude\"."
    },
    "parameters": {
      "type": "array",
      "description": "Optional list of the model's editable parameters, so Studio can render parameter controls. Each item is one control derived from the .kcad params.",
      "items": {
        "type": "object",
        "properties": {
          "name": {
            "type": "string",
            "minLength": 1,
            "maxLength": 40,
            "description": "Parameter identifier as used in the script (e.g. \"width\")."
          },
          "defaultValue": {
            "oneOf": [
              {
                "type": "number"
              },
              {
                "type": "boolean"
              },
              {
                "type": "string"
              }
            ],
            "description": "Current/default value of the parameter; type matches `kind`."
          },
          "kind": {
            "type": "string",
            "enum": [
              "number",
              "integer",
              "boolean",
              "string"
            ],
            "description": "Control type Studio should render for this parameter."
          },
          "unit": {
            "type": "string",
            "maxLength": 8,
            "description": "Optional unit label shown next to the control (e.g. \"mm\", \"deg\")."
          },
          "min": {
            "type": "number",
            "description": "Optional inclusive lower bound (numeric params)."
          },
          "max": {
            "type": "number",
            "description": "Optional inclusive upper bound (numeric params)."
          },
          "step": {
            "type": "number",
            "description": "Optional slider/step increment (numeric params)."
          },
          "description": {
            "type": "string",
            "maxLength": 200,
            "description": "Optional human-readable explanation of the parameter."
          }
        },
        "required": [
          "name",
          "defaultValue",
          "kind"
        ]
      }
    },
    "slug": {
      "type": "string",
      "description": "Slug returned by a previous open_in_studio call. When given, updates that existing project in place (live-updating the user's open Studio tab) instead of creating a new one.",
      "minLength": 1
    }
  },
  "required": [],
  "additionalProperties": false
}

get_project

Use this when you need to reopen a saved project or browse what the user has saved — it fetches a kernelCAD Studio project, or lists the signed-in user's saved projects. Pass `slug` (from a /p/<slug> link or a prior listing) to fetch that project's full .kcad source and metadata — then edit and open_in_studio with the same slug so the user's open tab updates live. Private projects require their owner's OAuth connection. OMIT `slug` to list the signed-in user's saved projects (most recently updated first); that listing mode requires the OAuth connection.

Parameters1

slug

string

optional

The project slug from a listing or a /p/<slug> Studio link. Omit to list the signed-in user's saved projects.

Raw schema

{
  "type": "object",
  "properties": {
    "slug": {
      "type": "string",
      "description": "The project slug from a listing or a /p/<slug> Studio link. Omit to list the signed-in user's saved projects.",
      "minLength": 1
    }
  },
  "additionalProperties": false
}

get_project_revision

Fetch the exact immutable .kcad source and parameters captured at a prior `open_in_studio` version. Use this to read-after-write verify a release: pass the returned `slug` and `version`, then hash or inspect the returned source. Public/unlisted projects use the slug as capability; private projects require the owner's OAuth connection.

Parameters2

slug	string	required	Project slug returned by open_in_studio.
version	integer	required	Positive immutable revision version returned by open_in_studio.

Raw schema

{
  "type": "object",
  "properties": {
    "slug": {
      "type": "string",
      "minLength": 1,
      "description": "Project slug returned by open_in_studio."
    },
    "version": {
      "type": "integer",
      "minimum": 1,
      "description": "Positive immutable revision version returned by open_in_studio."
    }
  },
  "required": [
    "slug",
    "version"
  ],
  "additionalProperties": false
}

get_latest_render

Render a project's current model server-side and return it as an inline image so you can SEE what you built. Use this after open_in_studio (or any /p/<slug> link): call with that `slug` to inspect whether the build looks right. CRITICAL — the image is rendered from the MODEL on the server; it does NOT reflect the user's Studio camera, zoom, or screen. NEVER ask the user to rotate, zoom, pan, move the camera, close a slider, or change their view to help you see — you cannot affect their screen and it cannot affect this render. To see a different angle, call this tool again with a different `view`. By DEFAULT (omit `view`, or `view:"all"`) it returns a CONTACT SHEET of all six canonical views in one labeled image — a 3×2 grid, top row [iso, front, right], bottom row [back, left, top] — so you can judge the model from every side regardless of its orientation (e.g. to find which side has the doors). Pass a single `view` (iso/front/back/left/right/top) for one large render of that angle. DETERMINISTIC: the same model + view always returns the same bytes — identical bytes are NOT a stale/lagging snapshot. If you changed the model, push it with open_in_studio FIRST, then re-render to see the change. The image is always current and never a blank capture. Colors and shading match Studio (same palette / base-material color). The slug is the capability: no OAuth for public/unlisted; private projects require the owner signed in. The PNG is base64-inlined as a real image block by default; pass `paths_only: true` for metadata only. No renderable geometry or a mesh failure → { ok: false, error, hint }, never a blank image.

Parameters3

slug	string	required	Project slug from open_in_studio/get_project/a /p/<slug> link. The slug is the capability — public/unlisted projects need no OAuth; private projects require the owner to be signed in.
view	string	optional	View to render. Default "all" = a labeled contact sheet of every canonical angle (iso/front/back/left/right/top) — best for judging the whole model. Pass a single view name for one large render of that angle.
paths_only	boolean	optional	Controls PNG delivery. Default false: base64-inline the rendered PNG so clients that cannot fetch a URL over HTTP (e.g. a sandboxed agent) can still see it. Set true to return only metadata (smaller response).

Raw schema

{
  "type": "object",
  "properties": {
    "slug": {
      "type": "string",
      "description": "Project slug from open_in_studio/get_project/a /p/<slug> link. The slug is the capability — public/unlisted projects need no OAuth; private projects require the owner to be signed in.",
      "minLength": 1
    },
    "view": {
      "type": "string",
      "enum": [
        "all",
        "iso",
        "front",
        "back",
        "left",
        "right",
        "top"
      ],
      "description": "View to render. Default \"all\" = a labeled contact sheet of every canonical angle (iso/front/back/left/right/top) — best for judging the whole model. Pass a single view name for one large render of that angle."
    },
    "paths_only": {
      "type": "boolean",
      "description": "Controls PNG delivery. Default false: base64-inline the rendered PNG so clients that cannot fetch a URL over HTTP (e.g. a sandboxed agent) can still see it. Set true to return only metadata (smaller response)."
    }
  },
  "required": [
    "slug"
  ],
  "additionalProperties": false
}

get_model_mesh

Return the raw per-feature triangle mesh (positions/indices/normals) of a project's current model, by slug. For the in-chat 3D viewer widget to render geometry; delivered over the MCP Apps bridge. The slug is the capability: public/unlisted need no OAuth; private requires the owner signed in.

Parameters1

slug

string

required

Project slug from open_in_studio/get_project.

Raw schema

{
  "type": "object",
  "properties": {
    "slug": {
      "type": "string",
      "minLength": 1,
      "description": "Project slug from open_in_studio/get_project."
    }
  },
  "required": [
    "slug"
  ],
  "additionalProperties": false
}

lookup_authoring_skill

Return the kernelcad-authoring SKILL.md body — conventions for writing .kcad.ts scripts (imports, parameters, evaluation contract, common pitfalls). Use this tool BEFORE generating CAD code if your MCP client does not list resources. Clients that do list resources should instead read `kernelcad://skills/authoring` directly — the contents are identical. INPUT: none. OUTPUT: { uri, mimeType, text } where `text` is the SKILL.md body.

Parameters

No parameters.

Raw schema

{
  "type": "object",
  "properties": {}
}

mesh_summary

Mesh a kernelCAD .kcad.ts source server-side and return a COMPACT geometry summary — overall bounds plus, per feature, its id, kind, triangle count, and bounding box. Use this to INSPECT a model's geometry without a viewer: confirm a part is the size/shape you expect, see how many triangles each feature contributes, or check that every feature produced geometry. This runs the full server-side OCCT pipeline (the same one the Studio renderer uses), so it evaluates modern sources (assembly, path, .material, …) that the legacy client worker cannot. INPUT: `source` (required) the .kcad.ts script text; `fileName` (optional) a label for diagnostics; `params` (optional) a map of parameter-name → number overrides applied before meshing (stateless slider recompute). OUTPUT: { ok, bounds, featureCount, features: [{ id, kind, triangleCount, bbox: { min:[x,y,z], max:[x,y,z] } }], failedFeatureIds, diagnostics }. `ok` is true when every feature meshed; `failedFeatureIds` lists features that failed to compile (and `ok` is then false). Raw vertex/index/normal arrays are NEVER returned — this is a summary only. To SEE the rendered model, use open_in_studio + get_latest_render instead.

Parameters3

source	string	required	The .kcad.ts script source to mesh.
fileName	string	optional	Optional file-name label used in diagnostics (does not affect geometry).
params	object	optional	Optional map of parameter-name → numeric value, applied as overrides before meshing (stateless slider recompute).

Raw schema

{
  "type": "object",
  "properties": {
    "source": {
      "type": "string",
      "description": "The .kcad.ts script source to mesh.",
      "minLength": 1
    },
    "fileName": {
      "type": "string",
      "description": "Optional file-name label used in diagnostics (does not affect geometry)."
    },
    "params": {
      "type": "object",
      "description": "Optional map of parameter-name → numeric value, applied as overrides before meshing (stateless slider recompute).",
      "additionalProperties": {
        "type": "number"
      }
    }
  },
  "required": [
    "source"
  ],
  "additionalProperties": false
}

evaluate_script

Use this when you need to run a script and check it compiles. Run a kernelCAD .kcad.ts script and report pass/fail + feature count + diagnostics. When the scene is assembly-built (assembly().part(...) → .model()/.solvedModel()), also returns a parts summary { count, names }. Pass either { file: "<path>" } or { code: "<inline source>" }. Set { dryRun: true } for fast validation while iterating: transpile + capture + capture-light checks WITHOUT OCCT lowering, DFM gates, or meshing — milliseconds instead of seconds (100x+ on boolean/fillet-heavy scripts). A dry run catches script throws, capture-time API misuse, and assembly validity-gate failures, but NOT lowering failures or dfmSpec diagnostics; it leaves the active session untouched, so finish with a full (non-dry) evaluate_script before using session-dependent tools.

Parameters3

file	string	optional	Path to a .kcad.ts script file.
code	string	optional	Inline kernelCAD script source.
dryRun	boolean	optional	Fast validation only: skip OCCT lowering, DFM gates, and meshing. Does not set or clear the active session.

Raw schema

{
  "type": "object",
  "properties": {
    "file": {
      "type": "string",
      "description": "Path to a .kcad.ts script file."
    },
    "code": {
      "type": "string",
      "description": "Inline kernelCAD script source."
    },
    "dryRun": {
      "type": "boolean",
      "description": "Fast validation only: skip OCCT lowering, DFM gates, and meshing. Does not set or clear the active session."
    }
  }
}

diff_scripts

Use this when you need to see exactly what changed between two script versions. Structured geometric delta between two versions of a kernelCAD script — a baseline ({ baseFile } or { baseCode }) and a revision ({ file } or { code }). Returns agent-readable JSON: per-part added/removed/renamed/changed (volume mm³ + exact bbox deltas, numbers matching inspect({ of: 'part-stats' })), total interference-volume delta with per-pair detail, mate-graph changes (added/removed/changed mates incl. type, connectors, pose, limits), and param changes (value/min/max). Single-shape scripts diff as one "(root)" pseudo-part. Use after editing a script to verify exactly what changed physically before re-rendering. Read-only — never touches the active session.

Parameters4

baseFile	string	optional	Baseline script — path to a .kcad.ts file.
baseCode	string	optional	Baseline script — inline source.
file	string	optional	Revised script — path to a .kcad.ts file.
code	string	optional	Revised script — inline source.

Raw schema

{
  "type": "object",
  "properties": {
    "baseFile": {
      "type": "string",
      "description": "Baseline script — path to a .kcad.ts file."
    },
    "baseCode": {
      "type": "string",
      "description": "Baseline script — inline source."
    },
    "file": {
      "type": "string",
      "description": "Revised script — path to a .kcad.ts file."
    },
    "code": {
      "type": "string",
      "description": "Revised script — inline source."
    }
  }
}

inspect

Use this when you need to read facts about a model. One reader, selected by `of`: - 'assembly' — physical assembly inventory (parts, bboxes, connectors, mates, disconnected solids). - 'robot' — URDF/SDFormat export preview (links, joints, planning groups, end-effectors, issues). - 'step' — inspect an imported STEP file. - 'shape' — volume / surfaceArea / bbox for one feature ({ feature_id? }). - 'features' — features captured by the script (kind, id, params, transforms, suppression). - 'assemblies' — assembly intent (assemblies, parts, connectors, joints). - 'topology' — canonical face names + edge count for a feature ({ feature_id? }). - 'edges' — edges of a shape with optional EdgeQuery ({ feature_id?, query? }); returns @kc[...] refs. - 'face-edges' — boundary edges of a named canonical face ({ feature_id?, face_name }). - 'faces' — faces of a shape with optional FaceQuery ({ feature_id?, query? }); returns @kc[...] refs. - 'face-labels' — user-applied labels visible in the script. - 'mates' — mates captured by the script. - 'constraints' — sketch constraints captured by the script. - 'part-stats' — bundled parts-catalog statistics. - 'bend-table' — sheet-metal bend table for a flattened pattern. - 'params' — declared model parameters. - 'part-categories' — top-level part-catalog categories available in the bundled (and configured remote) catalog. - 'part-families' — part families within a category ({ category? }); count + exemplar ids per family. All params except `of` are subject-specific and forwarded verbatim. Most subjects accept { file | code }.

Parameters8

of	string	required	Which facts to read.
file	string	optional	Path to a .kcad.ts script file.
code	string	optional	Inline kernelCAD script source.
assembly	string	optional	of:'assembly'\|'robot' — assembly name; defaults to the first captured assembly.
feature_id	string	optional	of:'shape'\|'topology'\|'edges'\|'faces'\|'face-edges'\|'face-labels' — FeatureId; defaults to the last returned shape.
face_name	string	optional	of:'face-edges' — canonical face name (required for that subject).
query	object	optional	of:'edges'\|'faces' — optional EdgeQuery/FaceQuery filter.
category	string	optional	of:'part-families' — optional top-level category to filter families by.

Raw schema

{
  "type": "object",
  "properties": {
    "of": {
      "type": "string",
      "enum": [
        "assembly",
        "robot",
        "step",
        "shape",
        "features",
        "assemblies",
        "topology",
        "edges",
        "face-edges",
        "faces",
        "face-labels",
        "mates",
        "constraints",
        "part-stats",
        "bend-table",
        "params",
        "part-categories",
        "part-families"
      ],
      "description": "Which facts to read."
    },
    "file": {
      "type": "string",
      "description": "Path to a .kcad.ts script file."
    },
    "code": {
      "type": "string",
      "description": "Inline kernelCAD script source."
    },
    "assembly": {
      "type": "string",
      "description": "of:'assembly'|'robot' — assembly name; defaults to the first captured assembly."
    },
    "feature_id": {
      "type": "string",
      "description": "of:'shape'|'topology'|'edges'|'faces'|'face-edges'|'face-labels' — FeatureId; defaults to the last returned shape."
    },
    "face_name": {
      "type": "string",
      "enum": [
        "top",
        "bottom",
        "left",
        "right",
        "front",
        "back"
      ],
      "description": "of:'face-edges' — canonical face name (required for that subject)."
    },
    "query": {
      "type": "object",
      "description": "of:'edges'|'faces' — optional EdgeQuery/FaceQuery filter."
    },
    "category": {
      "type": "string",
      "description": "of:'part-families' — optional top-level category to filter families by."
    }
  },
  "required": [
    "of"
  ]
}

verify

Use this when you need to check a design against a rule set. One verifier, selected by `check`: - 'assembly' — mate-aware assembly validator on the active session (run evaluate_script first). - 'urdf' — structural validity of a .urdf file ({ urdf_path }). - 'dfm' — print-readiness gates declared by dfmSpec() ({ file | code }). - 'dfm-preflight' — sheet-metal flat pattern vs a job-shop's ordering rules ({ vendor, material, thicknessIn|thicknessMm, ... }). - 'swept-collision' — sweep declared joint range(s) and report colliding poses. - 'reachable' — inverse-kinematics reachability for an end-effector ({ tip_link, target_position, ... }). - 'mounting-holes' — fastened mates expose matching hole diameters on both sides. - 'load-capacity' — closed-form Euler-Bernoulli beam stress / safety-factor check ({ loads, materials, ... }). All params except `check` are check-specific and forwarded verbatim; each check fails closed on its own missing required params.

Parameters28

check	string	required	Which verification to run.
file	string	optional	Path to a .kcad.ts script (assembly/dfm/dfm-preflight/swept-collision/reachable/mounting-holes/load-capacity).
code	string	optional	Inline kernelCAD script source (same checks as `file`).
assembly	string	optional	Assembly name; defaults to the first captured assembly.
urdf_path	string	optional	check:'urdf' — path to the .urdf file.
dxf	string	optional	check:'dfm-preflight' — path to a DXF file.
featureId	string	optional	check:'dfm-preflight' — FeatureId to scope to.
vendor	string	optional	check:'dfm-preflight' — vendor SKU (required for that check).
material	string	optional	check:'dfm-preflight' — material SKU (required for that check).
thicknessIn	number	optional	check:'dfm-preflight' — material thickness in inches.
thicknessMm	number	optional	check:'dfm-preflight' — material thickness in millimeters.
service	string	optional	check:'dfm-preflight' — service.
refreshCatalog	boolean	optional	check:'dfm-preflight' — force vendor catalog refresh.
joint	string	optional	check:'swept-collision' — joint to sweep; omit to sweep every declared joint.
range	array	optional	check:'swept-collision' — [lower, upper, step] in joint-native units.
collision_tolerance_mm3	number	optional	check:'swept-collision' — BREP intersection volume tolerance (mm^3).
tip_link	string	optional	check:'reachable' — end-effector part name (required for that check).
target_position	array	optional	check:'reachable' — target [x, y, z] mm (world frame).
target_orientation	array	optional	check:'reachable' — target XYZ Euler angles in radians.
position_tolerance_mm	number	optional	check:'reachable' — position tolerance in mm.
orientation_tolerance_rad	number	optional	check:'reachable' — orientation tolerance in radians.
prefer_solver	string	optional	check:'reachable' — force the IK path ('auto' default).
max_iterations	number	optional	check:'reachable' — numeric-path iteration cap.
seed	object	optional	check:'reachable' — numeric IK seed pose (joint name -> deg/mm).
loads	object	optional	check:'load-capacity' — partName -> { force?: [Fx,Fy,Fz] N, torque?: [Tx,Ty,Tz] N*m }.
materials	object	optional	check:'load-capacity' — partName -> material declaration.
mode	string	optional	check:'load-capacity' — 'beam' (default) or 'stub'.
safety_factor_threshold	number	optional	check:'load-capacity' — pass/fail safety-factor floor (default 1.5).

Raw schema

{
  "type": "object",
  "properties": {
    "check": {
      "type": "string",
      "enum": [
        "assembly",
        "urdf",
        "dfm",
        "dfm-preflight",
        "swept-collision",
        "reachable",
        "mounting-holes",
        "load-capacity"
      ],
      "description": "Which verification to run."
    },
    "file": {
      "type": "string",
      "description": "Path to a .kcad.ts script (assembly/dfm/dfm-preflight/swept-collision/reachable/mounting-holes/load-capacity)."
    },
    "code": {
      "type": "string",
      "description": "Inline kernelCAD script source (same checks as `file`)."
    },
    "assembly": {
      "type": "string",
      "description": "Assembly name; defaults to the first captured assembly."
    },
    "urdf_path": {
      "type": "string",
      "description": "check:'urdf' — path to the .urdf file."
    },
    "dxf": {
      "type": "string",
      "description": "check:'dfm-preflight' — path to a DXF file."
    },
    "featureId": {
      "type": "string",
      "description": "check:'dfm-preflight' — FeatureId to scope to."
    },
    "vendor": {
      "type": "string",
      "description": "check:'dfm-preflight' — vendor SKU (required for that check)."
    },
    "material": {
      "type": "string",
      "description": "check:'dfm-preflight' — material SKU (required for that check)."
    },
    "thicknessIn": {
      "type": "number",
      "description": "check:'dfm-preflight' — material thickness in inches."
    },
    "thicknessMm": {
      "type": "number",
      "description": "check:'dfm-preflight' — material thickness in millimeters."
    },
    "service": {
      "type": "string",
      "enum": [
        "laser",
        "cnc-router",
        "waterjet",
        "bending"
      ],
      "description": "check:'dfm-preflight' — service."
    },
    "refreshCatalog": {
      "type": "boolean",
      "description": "check:'dfm-preflight' — force vendor catalog refresh."
    },
    "joint": {
      "type": "string",
      "description": "check:'swept-collision' — joint to sweep; omit to sweep every declared joint."
    },
    "range": {
      "type": "array",
      "items": {
        "type": "number"
      },
      "minItems": 3,
      "maxItems": 3,
      "description": "check:'swept-collision' — [lower, upper, step] in joint-native units."
    },
    "collision_tolerance_mm3": {
      "type": "number",
      "description": "check:'swept-collision' — BREP intersection volume tolerance (mm^3)."
    },
    "tip_link": {
      "type": "string",
      "description": "check:'reachable' — end-effector part name (required for that check)."
    },
    "target_position": {
      "type": "array",
      "items": {
        "type": "number"
      },
      "minItems": 3,
      "maxItems": 3,
      "description": "check:'reachable' — target [x, y, z] mm (world frame)."
    },
    "target_orientation": {
      "type": "array",
      "items": {
        "type": "number"
      },
      "minItems": 3,
      "maxItems": 3,
      "description": "check:'reachable' — target XYZ Euler angles in radians."
    },
    "position_tolerance_mm": {
      "type": "number",
      "description": "check:'reachable' — position tolerance in mm."
    },
    "orientation_tolerance_rad": {
      "type": "number",
      "description": "check:'reachable' — orientation tolerance in radians."
    },
    "prefer_solver": {
      "type": "string",
      "enum": [
        "analytical",
        "numeric",
        "auto"
      ],
      "description": "check:'reachable' — force the IK path ('auto' default)."
    },
    "max_iterations": {
      "type": "number",
      "description": "check:'reachable' — numeric-path iteration cap."
    },
    "seed": {
      "type": "object",
      "description": "check:'reachable' — numeric IK seed pose (joint name -> deg/mm)."
    },
    "loads": {
      "type": "object",
      "description": "check:'load-capacity' — partName -> { force?: [Fx,Fy,Fz] N, torque?: [Tx,Ty,Tz] N*m }."
    },
    "materials": {
      "type": "object",
      "description": "check:'load-capacity' — partName -> material declaration."
    },
    "mode": {
      "type": "string",
      "enum": [
        "stub",
        "beam"
      ],
      "description": "check:'load-capacity' — 'beam' (default) or 'stub'."
    },
    "safety_factor_threshold": {
      "type": "number",
      "description": "check:'load-capacity' — pass/fail safety-factor floor (default 1.5)."
    }
  },
  "required": [
    "check"
  ]
}

why_did_this_fail

Use this when you need to trace why a feature failed. Walk the upstream chain of a failing feature. Returns the diagnostics of the requested feature plus the diagnostics of every upstream feature in topological order (the requested feature is the last entry). Per-code hints are inline on every diagnostic — call lookup_diagnostics for the full catalogue. Pass { file?, code?, feature_id? }.

Parameters3

file	string	optional
code	string	optional
feature_id	string	optional

Raw schema

{
  "type": "object",
  "properties": {
    "file": {
      "type": "string"
    },
    "code": {
      "type": "string"
    },
    "feature_id": {
      "type": "string"
    }
  }
}

set_param

Use this when you need to edit a param() default value in a kernelCAD script. Returns the modified code as text plus diagnostics from re-evaluating the result. Caller persists the new code via standard file-write tools (this tool has no side effects).

Parameters3

code	string	required	The .kcad.ts source code.
param_name	string	required	The string literal name of the param (first arg to param()).
new_value	any	required	The new default value. Either a number for a numeric param (e.g. 12.5), or a string expression evaluated in the script (e.g. "width/2 + 3").

Raw schema

{
  "type": "object",
  "properties": {
    "code": {
      "type": "string",
      "description": "The .kcad.ts source code."
    },
    "param_name": {
      "type": "string",
      "description": "The string literal name of the param (first arg to param())."
    },
    "new_value": {
      "oneOf": [
        {
          "type": "number"
        },
        {
          "type": "string"
        }
      ],
      "description": "The new default value. Either a number for a numeric param (e.g. 12.5), or a string expression evaluated in the script (e.g. \"width/2 + 3\").",
      "examples": [
        12.5,
        "width/2 + 3"
      ]
    }
  },
  "required": [
    "code",
    "param_name",
    "new_value"
  ]
}

add_feature

Use this when you need to insert a new feature line into a script. Insert a new feature line into a kernelCAD script before the last top-level return statement. Returns the modified code as text plus diagnostics from re-evaluating the result. Side-effect-free. Primitives that accept faceLabels (box, cylinder, extrudeRect, extrudeCircle, extrudePolygon, extrudeRoundedRect) can receive `opts.faceLabels` in the inserted code — use `lookup_api` to see `featureKindFaceLabels` for the full value schema.

Parameters2

code	string	required	The .kcad.ts source code.
feature_code	string	required	Single-statement source line to insert (e.g. `const hole = cylinder(5, 2).translate(10, 10, -1);`).

Raw schema

{
  "type": "object",
  "properties": {
    "code": {
      "type": "string",
      "description": "The .kcad.ts source code."
    },
    "feature_code": {
      "type": "string",
      "description": "Single-statement source line to insert (e.g. `const hole = cylinder(5, 2).translate(10, 10, -1);`)."
    }
  },
  "required": [
    "code",
    "feature_code"
  ]
}

add_surface

Use this when you need to author a NURBS Surface into the user's .kcad.ts. One authoring path, selected by `kind`: - 'nurbs' — insert a nurbsSurface(...) / surfaceFromCurves(...) call. Pass either { controls, degree, weights?, knots?, periodic? } for direct construction, OR { section_sketch_ids } for skinning. Slice-1 limitation: weights are accepted but currently ignored (TColStd_Array2OfReal not exposed in WASM bindings); surfaces are non-rational. - 'boundary' — insert a surfaceFromBoundary([c1,c2,c3,c4], opts?) call: one NURBS face through 4 boundary Curve3D refs (bottom, right, top, left in loop order; adjacent endpoints must coincide within 1e-6 mm) via OCCT BRepOffsetAPI_MakeFilling. The returned Surface produces no Shape until you chain .thicken(t) or .toShape() (do that via add_feature on the binding name). Returns the modified code + diagnostics. Each kind fails closed on its own missing required params.

Parameters12

kind	string	required	Which surface-construction path to use.
code	string	required	Current .kcad.ts source.
controls	array	optional	kind:'nurbs' — control-point grid for direct construction (controls[u][v] = [x, y, z], mm).
weights	array	optional	kind:'nurbs' — optional rational weights, same grid shape as controls. Ignored in slice-1.
degree	object	optional	kind:'nurbs' — degrees in U and V; each in [1, nU-1] / [1, nV-1].
knots	object	optional	kind:'nurbs' — optional explicit knot vectors; missing => clamped uniform inferred.
periodic	object	optional	kind:'nurbs' — optional periodic flags per parametric direction.
section_sketch_ids	array	optional	kind:'nurbs' — existing sketch FeatureIds (2 or more) to skin a surface through, in order.
curve_bindings	array	optional	kind:'boundary' — tuple of 4 existing Curve3D variable names (bottom, right, top, left) declared earlier in the source.
continuity	any	optional	kind:'boundary' — continuity grade applied to every edge ('C0' \| 'C1' \| 'C2'), or an array of 4 grades (one per edge, bottom/right/top/left order). Default 'C0'.
sampling	integer	optional	kind:'boundary' — OCCT NbPtsOnCur sampling parameter (default 15).
binding_name	string	optional	JS const name for the new Surface binding (kind:'nurbs' default surface_<N>; kind:'boundary' default _surface_<N>).

Raw schema

{
  "type": "object",
  "properties": {
    "kind": {
      "type": "string",
      "enum": [
        "nurbs",
        "boundary"
      ],
      "description": "Which surface-construction path to use."
    },
    "code": {
      "type": "string",
      "description": "Current .kcad.ts source."
    },
    "controls": {
      "type": "array",
      "description": "kind:'nurbs' — control-point grid for direct construction (controls[u][v] = [x, y, z], mm).",
      "items": {
        "type": "array",
        "items": {
          "type": "array",
          "items": {
            "type": "number"
          }
        }
      }
    },
    "weights": {
      "type": "array",
      "description": "kind:'nurbs' — optional rational weights, same grid shape as controls. Ignored in slice-1.",
      "items": {
        "type": "array",
        "items": {
          "type": "number"
        }
      }
    },
    "degree": {
      "type": "object",
      "description": "kind:'nurbs' — degrees in U and V; each in [1, nU-1] / [1, nV-1].",
      "properties": {
        "u": {
          "type": "integer",
          "minimum": 1
        },
        "v": {
          "type": "integer",
          "minimum": 1
        }
      },
      "required": [
        "u",
        "v"
      ]
    },
    "knots": {
      "type": "object",
      "description": "kind:'nurbs' — optional explicit knot vectors; missing => clamped uniform inferred.",
      "properties": {
        "u": {
          "type": "array",
          "items": {
            "type": "number"
          }
        },
        "v": {
          "type": "array",
          "items": {
            "type": "number"
          }
        }
      }
    },
    "periodic": {
      "type": "object",
      "description": "kind:'nurbs' — optional periodic flags per parametric direction.",
      "properties": {
        "u": {
          "type": "boolean"
        },
        "v": {
          "type": "boolean"
        }
      }
    },
    "section_sketch_ids": {
      "type": "array",
      "description": "kind:'nurbs' — existing sketch FeatureIds (2 or more) to skin a surface through, in order.",
      "items": {
        "type": "string"
      }
    },
    "curve_bindings": {
      "type": "array",
      "description": "kind:'boundary' — tuple of 4 existing Curve3D variable names (bottom, right, top, left) declared earlier in the source.",
      "items": {
        "type": "string"
      },
      "minItems": 4,
      "maxItems": 4
    },
    "continuity": {
      "description": "kind:'boundary' — continuity grade applied to every edge ('C0' | 'C1' | 'C2'), or an array of 4 grades (one per edge, bottom/right/top/left order). Default 'C0'.",
      "oneOf": [
        {
          "type": "string",
          "enum": [
            "C0",
            "C1",
            "C2"
          ]
        },
        {
          "type": "array",
          "items": {
            "type": "string",
            "enum": [
              "C0",
              "C1",
              "C2"
            ]
          },
          "minItems": 4,
          "maxItems": 4
        }
      ]
    },
    "sampling": {
      "type": "integer",
      "minimum": 1,
      "description": "kind:'boundary' — OCCT NbPtsOnCur sampling parameter (default 15)."
    },
    "binding_name": {
      "type": "string",
      "description": "JS const name for the new Surface binding (kind:'nurbs' default surface_<N>; kind:'boundary' default _surface_<N>)."
    }
  },
  "required": [
    "kind",
    "code"
  ]
}

add_curve

Use this when you need to author a 3D Curve3D into the user's .kcad.ts immediately before the last top-level return. One authoring path, selected by `kind`: - 'nurbs' — insert a `nurbsCurve(controlPoints, opts?)` declaration. Pass `controlPoints` as a Vec3[] (mm, at least 2 points). Optional NURBS knobs: `degree` (default 3), rational `weights`, explicit `knots`, `closed`. - 'hermite' — insert a `hermiteG2(a, b)` declaration: a quintic Hermite curve interpolating two endpoints with matching positions, tangents, and (optional) curvatures — bridges two curves with G2 continuity. Each endpoint is `{ point: Vec3, tangent: Vec3, curvature?: Vec3 }` in mm; tangent magnitude ~ chord length; curvature defaults to [0,0,0] (G1-only). The returned binding has type Curve3D (peer to Shape / Surface) — consume it via `add_variable_sweep` (spine input), `add_surface({ kind: 'boundary' })` (boundary curve), or downstream Curve3D-accepting features. Returns the modified code + diagnostics from re-evaluating. Side-effect-free. Each kind fails closed on its own missing required params.

Parameters10

kind	string	required	Which curve-construction path to use.
code	string	required	The .kcad.ts source code.
controlPoints	array	optional	kind:'nurbs' — control points as Vec3 triples in mm; at least 2 entries.
degree	integer	optional	kind:'nurbs' — curve degree; default 3 (cubic).
weights	array	optional	kind:'nurbs' — optional rational weights, one per control point (same length as controlPoints).
knots	array	optional	kind:'nurbs' — optional explicit knot vector; missing => clamped-uniform inferred.
closed	boolean	optional	kind:'nurbs' — optional periodic/closed-curve flag.
a	object	optional	kind:'hermite' — start endpoint.
b	object	optional	kind:'hermite' — end endpoint.
binding_name	string	optional	JS const name for the new Curve3D binding (default: _curve_<N>).

Raw schema

{
  "type": "object",
  "properties": {
    "kind": {
      "type": "string",
      "enum": [
        "nurbs",
        "hermite"
      ],
      "description": "Which curve-construction path to use."
    },
    "code": {
      "type": "string",
      "description": "The .kcad.ts source code."
    },
    "controlPoints": {
      "type": "array",
      "description": "kind:'nurbs' — control points as Vec3 triples in mm; at least 2 entries.",
      "items": {
        "type": "array",
        "items": {
          "type": "number"
        },
        "minItems": 3,
        "maxItems": 3
      }
    },
    "degree": {
      "type": "integer",
      "minimum": 1,
      "description": "kind:'nurbs' — curve degree; default 3 (cubic)."
    },
    "weights": {
      "type": "array",
      "description": "kind:'nurbs' — optional rational weights, one per control point (same length as controlPoints).",
      "items": {
        "type": "number"
      }
    },
    "knots": {
      "type": "array",
      "description": "kind:'nurbs' — optional explicit knot vector; missing => clamped-uniform inferred.",
      "items": {
        "type": "number"
      }
    },
    "closed": {
      "type": "boolean",
      "description": "kind:'nurbs' — optional periodic/closed-curve flag."
    },
    "a": {
      "type": "object",
      "description": "kind:'hermite' — start endpoint.",
      "properties": {
        "point": {
          "type": "array",
          "items": {
            "type": "number"
          },
          "minItems": 3,
          "maxItems": 3,
          "description": "Endpoint position in mm."
        },
        "tangent": {
          "type": "array",
          "items": {
            "type": "number"
          },
          "minItems": 3,
          "maxItems": 3,
          "description": "First derivative of the curve at this endpoint."
        },
        "curvature": {
          "type": "array",
          "items": {
            "type": "number"
          },
          "minItems": 3,
          "maxItems": 3,
          "description": "Optional second derivative; defaults to [0, 0, 0] (G1-only)."
        }
      },
      "required": [
        "point",
        "tangent"
      ]
    },
    "b": {
      "type": "object",
      "description": "kind:'hermite' — end endpoint.",
      "properties": {
        "point": {
          "type": "array",
          "items": {
            "type": "number"
          },
          "minItems": 3,
          "maxItems": 3,
          "description": "Endpoint position in mm."
        },
        "tangent": {
          "type": "array",
          "items": {
            "type": "number"
          },
          "minItems": 3,
          "maxItems": 3,
          "description": "First derivative of the curve at this endpoint."
        },
        "curvature": {
          "type": "array",
          "items": {
            "type": "number"
          },
          "minItems": 3,
          "maxItems": 3,
          "description": "Optional second derivative; defaults to [0, 0, 0] (G1-only)."
        }
      },
      "required": [
        "point",
        "tangent"
      ]
    },
    "binding_name": {
      "type": "string",
      "description": "JS const name for the new Curve3D binding (default: _curve_<N>)."
    }
  },
  "required": [
    "kind",
    "code"
  ],
  "allOf": [
    {
      "if": {
        "properties": {
          "kind": {
            "const": "nurbs"
          }
        }
      },
      "then": {
        "required": [
          "controlPoints"
        ]
      }
    },
    {
      "if": {
        "properties": {
          "kind": {
            "const": "hermite"
          }
        }
      },
      "then": {
        "required": [
          "a",
          "b"
        ]
      }
    }
  ]
}

add_path_segment

Use this when you need to append a curved segment to an existing PathBuilder chain on the named `chain_anchor` variable. The call is injected at the END of the chain, immediately before any `.close()`. One segment kind, selected by `kind`: - 'spline' — `.spline(points, opts?)`: interpolates through every `points` waypoint (Vec2[] mm, >= 2 entries; points[0] must match current pen position). Optional `tension`, and `startTangent`/`endTangent` 2D direction vectors that constrain the first-derivative direction at the endpoints (magnitude normalised internally). Use for organic 2D outlines (eyewear brow, ergonomic handle, sneaker midsole). - 'nurbs' — `.nurbsSegment(controlPoints, opts?)`: explicit B-spline net (Vec2[] mm, >= degree+1 entries; controlPoints[0] must match pen; pen ends at controlPoints[N-1]). Optional `degree` (default 3), rational `weights` (strictly positive), explicit `knots` (length = controlPoints.length + degree + 1). - 'hermite' — `.hermiteG2(a, b)`: each endpoint `{ point: Vec2, tangent: Vec2, curvature?: Vec2 }` in mm (a.point must match pen; pen ends at b.point). `curvature` defaults to [0,0] (G1); pass matching curvatures for G2 blends. Tangent magnitude is the first derivative (~ chord length), NOT unit length. Returns the modified code + diagnostics from re-evaluating. Side-effect-free. Each kind fails closed on its own missing required params.

Parameters14

kind	string	required	Which path-segment kind to append.
code	string	required	The .kcad.ts source code.
chain_anchor	string	required	JS identifier of an existing PathBuilder binding (e.g. `const brow = path().moveTo(0,0)`).
points	array	optional	kind:'spline' — waypoints as Vec2 pairs in mm; at least 2 entries; first must match current pen position.
tension	number	optional	kind:'spline' — optional Catmull-Rom-style stiffness; forwarded to the underlying B-spline approximation.
startTangent	array	optional	kind:'spline' — optional [x, y] direction vector at points[0]. Magnitude is normalised internally; direction matters.
endTangent	array	optional	kind:'spline' — optional [x, y] direction vector at points[N-1]. Magnitude is normalised internally; direction matters.
controlPoints	array	optional	kind:'nurbs' — control-net vertices as Vec2 pairs in mm; at least degree+1 entries.
degree	integer	optional	kind:'nurbs' — B-spline degree (default 3).
weights	array	optional	kind:'nurbs' — optional rational weights (one per control point; strictly positive).
knots	array	optional	kind:'nurbs' — optional explicit knot vector; length must equal controlPoints.length + degree + 1.
a	object	optional	kind:'hermite' — start endpoint; point must match current pen position within 1e-6 mm.
b	object	optional	kind:'hermite' — end endpoint; pen ends at b.point.
binding_name	string	optional	Reserved for future use; the segment injection mutates the chain anchor in place.

Raw schema

{
  "type": "object",
  "properties": {
    "kind": {
      "type": "string",
      "enum": [
        "spline",
        "nurbs",
        "hermite"
      ],
      "description": "Which path-segment kind to append."
    },
    "code": {
      "type": "string",
      "description": "The .kcad.ts source code."
    },
    "chain_anchor": {
      "type": "string",
      "description": "JS identifier of an existing PathBuilder binding (e.g. `const brow = path().moveTo(0,0)`)."
    },
    "points": {
      "type": "array",
      "description": "kind:'spline' — waypoints as Vec2 pairs in mm; at least 2 entries; first must match current pen position.",
      "items": {
        "type": "array",
        "items": {
          "type": "number"
        },
        "minItems": 2,
        "maxItems": 2
      },
      "minItems": 2
    },
    "tension": {
      "type": "number",
      "description": "kind:'spline' — optional Catmull-Rom-style stiffness; forwarded to the underlying B-spline approximation."
    },
    "startTangent": {
      "type": "array",
      "description": "kind:'spline' — optional [x, y] direction vector at points[0]. Magnitude is normalised internally; direction matters.",
      "items": {
        "type": "number"
      },
      "minItems": 2,
      "maxItems": 2
    },
    "endTangent": {
      "type": "array",
      "description": "kind:'spline' — optional [x, y] direction vector at points[N-1]. Magnitude is normalised internally; direction matters.",
      "items": {
        "type": "number"
      },
      "minItems": 2,
      "maxItems": 2
    },
    "controlPoints": {
      "type": "array",
      "description": "kind:'nurbs' — control-net vertices as Vec2 pairs in mm; at least degree+1 entries.",
      "items": {
        "type": "array",
        "items": {
          "type": "number"
        },
        "minItems": 2,
        "maxItems": 2
      }
    },
    "degree": {
      "type": "integer",
      "minimum": 1,
      "description": "kind:'nurbs' — B-spline degree (default 3)."
    },
    "weights": {
      "type": "array",
      "description": "kind:'nurbs' — optional rational weights (one per control point; strictly positive).",
      "items": {
        "type": "number"
      }
    },
    "knots": {
      "type": "array",
      "description": "kind:'nurbs' — optional explicit knot vector; length must equal controlPoints.length + degree + 1.",
      "items": {
        "type": "number"
      }
    },
    "a": {
      "type": "object",
      "description": "kind:'hermite' — start endpoint; point must match current pen position within 1e-6 mm.",
      "properties": {
        "point": {
          "type": "array",
          "items": {
            "type": "number"
          },
          "minItems": 2,
          "maxItems": 2,
          "description": "Endpoint position in mm."
        },
        "tangent": {
          "type": "array",
          "items": {
            "type": "number"
          },
          "minItems": 2,
          "maxItems": 2,
          "description": "First derivative (~ chord length), NOT unit length."
        },
        "curvature": {
          "type": "array",
          "items": {
            "type": "number"
          },
          "minItems": 2,
          "maxItems": 2,
          "description": "Optional second derivative; defaults to [0, 0] (G1-only)."
        }
      },
      "required": [
        "point",
        "tangent"
      ]
    },
    "b": {
      "type": "object",
      "description": "kind:'hermite' — end endpoint; pen ends at b.point.",
      "properties": {
        "point": {
          "type": "array",
          "items": {
            "type": "number"
          },
          "minItems": 2,
          "maxItems": 2,
          "description": "Endpoint position in mm."
        },
        "tangent": {
          "type": "array",
          "items": {
            "type": "number"
          },
          "minItems": 2,
          "maxItems": 2,
          "description": "First derivative (~ chord length), NOT unit length."
        },
        "curvature": {
          "type": "array",
          "items": {
            "type": "number"
          },
          "minItems": 2,
          "maxItems": 2,
          "description": "Optional second derivative; defaults to [0, 0] (G1-only)."
        }
      },
      "required": [
        "point",
        "tangent"
      ]
    },
    "binding_name": {
      "type": "string",
      "description": "Reserved for future use; the segment injection mutates the chain anchor in place."
    }
  },
  "required": [
    "kind",
    "code",
    "chain_anchor"
  ],
  "allOf": [
    {
      "if": {
        "properties": {
          "kind": {
            "const": "spline"
          }
        }
      },
      "then": {
        "required": [
          "points"
        ]
      }
    },
    {
      "if": {
        "properties": {
          "kind": {
            "const": "nurbs"
          }
        }
      },
      "then": {
        "required": [
          "controlPoints"
        ]
      }
    },
    {
      "if": {
        "properties": {
          "kind": {
            "const": "hermite"
          }
        }
      },
      "then": {
        "required": [
          "a",
          "b"
        ]
      }
    }
  ]
}

trace_from_image

Use this when you need to trace features from a reference photo into waypoints. Trace pixel-space features from a reference photo into normalized [0..1] waypoints the agent can map to mm via a known scale anchor and feed to path().spline / path().nurbsSegment. Three backends are dispatched behind the scenes: `opencv` (deterministic; uniform-bg silhouette only), `vision-llm` (Claude vision; named points/cluttered backgrounds; caller-supplied ANTHROPIC_API_KEY), and `hybrid` (opencv silhouette + LLM-labeled named points). Default backend is `auto` — the tool picks based on the image's corner-color stddev. Accuracy honesty: opencv contour is geometrically exact; vision-LLM is typically 5–10% off on dense landmarks. Per-feature `confidence` is reported. Caller pays for any vision-LLM API spend via their own ANTHROPIC_API_KEY. Pair with the `kernelcad-trace-from-image` skill for the conversion-to-mm pipeline.

Parameters5

imageUrl	string	required	URL or path to the reference image. Supports file://, http(s)://, data:image/...;base64,..., or a bare filesystem path.
hint	string	optional	Optional free-text hint forwarded to vision-LLM backends (e.g. "a pair of eyewear; trace the upper brow only").
features	array	optional	Features to trace. Defaults to a single { label: "silhouette", kind: "silhouette" } when omitted.
maxWaypointsPerFeature	integer	optional	Cap on waypoints per feature. Defaults to 12 (suitable for medium-inflection outlines).
backend	string	optional	Force a specific backend; default `auto` routes by corner-color stddev.

Raw schema

{
  "type": "object",
  "properties": {
    "imageUrl": {
      "type": "string",
      "description": "URL or path to the reference image. Supports file://, http(s)://, data:image/...;base64,..., or a bare filesystem path."
    },
    "hint": {
      "type": "string",
      "description": "Optional free-text hint forwarded to vision-LLM backends (e.g. \"a pair of eyewear; trace the upper brow only\")."
    },
    "features": {
      "type": "array",
      "description": "Features to trace. Defaults to a single { label: \"silhouette\", kind: \"silhouette\" } when omitted.",
      "items": {
        "type": "object",
        "properties": {
          "label": {
            "type": "string",
            "description": "Caller-chosen identifier (echoed in the response)."
          },
          "kind": {
            "type": "string",
            "enum": [
              "silhouette",
              "curve",
              "point",
              "bbox"
            ],
            "description": "Geometric shape of the requested feature."
          },
          "region": {
            "type": "string",
            "description": "Optional free-text region hint forwarded to vision-LLM backends; ignored by opencv."
          }
        },
        "required": [
          "label",
          "kind"
        ]
      }
    },
    "maxWaypointsPerFeature": {
      "type": "integer",
      "description": "Cap on waypoints per feature. Defaults to 12 (suitable for medium-inflection outlines).",
      "minimum": 2
    },
    "backend": {
      "type": "string",
      "enum": [
        "opencv",
        "vision-llm",
        "hybrid",
        "auto"
      ],
      "description": "Force a specific backend; default `auto` routes by corner-color stddev."
    }
  },
  "required": [
    "imageUrl"
  ]
}

add_variable_sweep

Use this when you need to author a variable-section sweep along a spine. Insert a `variableSweep(spine, sections, opts?)` declaration into the user's .kcad.ts immediately before the last top-level return. The result is a Shape — chain `.translate(...)`, `.union(...)`, etc. via `add_feature`. `spine_binding` references an existing variable (Curve3D / Sketch / Vec3[]) in the source; each `sections[i].profile_binding` references an existing Sketch. Sections must be strictly increasing in `t` and span [0, 1]; first t=0, last t=1. Orientation is not exposed by this MCP tool until runtime orientation support is wired. Validates every binding exists in the source via regex before inserting (fast structured error vs capture-time stack). Returns the modified code + diagnostics. Side-effect-free.

Parameters6

code	string	required	The .kcad.ts source code.
spine_binding	string	required	Existing variable name for a Curve3D / Sketch / Vec3[] declared earlier in the source.
sections	array	required	Varying cross-sections along the spine; at least 2 entries, strictly increasing in `t`, first t=0, last t=1.
closed	boolean	optional	Optional closed-sweep flag.
continuity	string	optional	Inter-section continuity; default 'C1'.
binding_name	string	optional	JS const name for the new Shape binding (default: _sweep_<N>).

Raw schema

{
  "type": "object",
  "properties": {
    "code": {
      "type": "string",
      "description": "The .kcad.ts source code."
    },
    "spine_binding": {
      "type": "string",
      "description": "Existing variable name for a Curve3D / Sketch / Vec3[] declared earlier in the source."
    },
    "sections": {
      "type": "array",
      "description": "Varying cross-sections along the spine; at least 2 entries, strictly increasing in `t`, first t=0, last t=1.",
      "items": {
        "type": "object",
        "properties": {
          "t": {
            "type": "number",
            "description": "Spine parameter in [0, 1]."
          },
          "profile_binding": {
            "type": "string",
            "description": "Existing Sketch variable name for this section."
          }
        },
        "required": [
          "t",
          "profile_binding"
        ]
      }
    },
    "closed": {
      "type": "boolean",
      "description": "Optional closed-sweep flag."
    },
    "continuity": {
      "type": "string",
      "enum": [
        "C0",
        "C1",
        "C2"
      ],
      "description": "Inter-section continuity; default 'C1'."
    },
    "binding_name": {
      "type": "string",
      "description": "JS const name for the new Shape binding (default: _sweep_<N>)."
    }
  },
  "required": [
    "code",
    "spine_binding",
    "sections"
  ]
}

add_text

Use this when you need to author text into a kernelCAD script before the last top-level return. One authoring path, selected by `mode`: - 'sketch' — insert a sketch.text(...) call. The emitted sketch is chainable: pair with subsequent .extrude(...) / cut(...) edits to land an engraved or raised text feature. - 'emboss' — insert a `<shape>.embossText({...})` chained call onto an existing Shape `target`. Use for engraved brand text on faces (Ray-Ban temple, CE mark, model number). `depth > 0` raises text out of the face; `depth < 0` engraves text into the face. Lowers via replicad drawText → sketchOnFace → extrude → fuse|cut. Default font is the runtime-bundled Liberation Sans. Side-effect-free; returns the modified code plus diagnostics from re-evaluating. Each mode fails closed on its own missing required params.

Parameters17

mode	string	required	Which text-authoring path to use.
code	string	required	The .kcad.ts source code.
content	string	optional	mode:'sketch' — text content (UTF-8, non-empty, non-whitespace).
size	number	optional	mode:'sketch'\|'emboss' — glyph cap height in mm (positive finite).
font	string	optional	mode:'sketch' — optional logical font name or .ttf file path; defaults to bundled Liberation Sans.
align	string	optional	mode:'sketch' — horizontal alignment relative to position (default left); mode:'emboss' — relative to the UV anchor (default center).
position	array	optional	mode:'sketch' — [x, y] anchor in mm. Default [0, 0].
rotation	number	optional	mode:'sketch' — CCW rotation in degrees around position (default 0); mode:'emboss' — CCW rotation in the face tangent plane (default 0).
bindAs	string	optional	mode:'sketch' — emits `const <bindAs> = sketch.text(...)`; mode:'emboss' — emits `const <bindAs> = <target>.embossText(...);`.
target	string	optional	mode:'emboss' — variable name of the Shape to chain onto (inserted verbatim).
textContent	string	optional	mode:'emboss' — text content (UTF-8, non-empty, non-whitespace).
depth	number	optional	mode:'emboss' — signed extrusion depth in mm: positive emboss out, negative engrave in. Must be non-zero.
face	string	optional	mode:'emboss' — target face — canonical name ('top'/'bottom'/'left'/'right'/'front'/'back') or label.
fontFamily	string	optional	mode:'emboss' — optional logical font name or .ttf file path; defaults to bundled Liberation Sans.
anchorU	number	optional	mode:'emboss' — U anchor in [0, 1] face-local (0=umin, 0.5=centre, 1=umax). Default 0.5.
anchorV	number	optional	mode:'emboss' — V anchor in [0, 1] face-local. Default 0.5.
scaleMode	string	optional	mode:'emboss' — Drawing.sketchOnFace scaling mode. Default original.

Raw schema

{
  "type": "object",
  "properties": {
    "mode": {
      "type": "string",
      "enum": [
        "sketch",
        "emboss"
      ],
      "description": "Which text-authoring path to use."
    },
    "code": {
      "type": "string",
      "description": "The .kcad.ts source code."
    },
    "content": {
      "type": "string",
      "description": "mode:'sketch' — text content (UTF-8, non-empty, non-whitespace)."
    },
    "size": {
      "type": "number",
      "description": "mode:'sketch'|'emboss' — glyph cap height in mm (positive finite)."
    },
    "font": {
      "type": "string",
      "description": "mode:'sketch' — optional logical font name or .ttf file path; defaults to bundled Liberation Sans."
    },
    "align": {
      "type": "string",
      "enum": [
        "left",
        "center",
        "right"
      ],
      "description": "mode:'sketch' — horizontal alignment relative to position (default left); mode:'emboss' — relative to the UV anchor (default center)."
    },
    "position": {
      "type": "array",
      "items": {
        "type": "number"
      },
      "minItems": 2,
      "maxItems": 2,
      "description": "mode:'sketch' — [x, y] anchor in mm. Default [0, 0]."
    },
    "rotation": {
      "type": "number",
      "description": "mode:'sketch' — CCW rotation in degrees around position (default 0); mode:'emboss' — CCW rotation in the face tangent plane (default 0)."
    },
    "bindAs": {
      "type": "string",
      "description": "mode:'sketch' — emits `const <bindAs> = sketch.text(...)`; mode:'emboss' — emits `const <bindAs> = <target>.embossText(...);`."
    },
    "target": {
      "type": "string",
      "description": "mode:'emboss' — variable name of the Shape to chain onto (inserted verbatim)."
    },
    "textContent": {
      "type": "string",
      "description": "mode:'emboss' — text content (UTF-8, non-empty, non-whitespace)."
    },
    "depth": {
      "type": "number",
      "description": "mode:'emboss' — signed extrusion depth in mm: positive emboss out, negative engrave in. Must be non-zero."
    },
    "face": {
      "type": "string",
      "description": "mode:'emboss' — target face — canonical name ('top'/'bottom'/'left'/'right'/'front'/'back') or label."
    },
    "fontFamily": {
      "type": "string",
      "description": "mode:'emboss' — optional logical font name or .ttf file path; defaults to bundled Liberation Sans."
    },
    "anchorU": {
      "type": "number",
      "description": "mode:'emboss' — U anchor in [0, 1] face-local (0=umin, 0.5=centre, 1=umax). Default 0.5."
    },
    "anchorV": {
      "type": "number",
      "description": "mode:'emboss' — V anchor in [0, 1] face-local. Default 0.5."
    },
    "scaleMode": {
      "type": "string",
      "enum": [
        "original",
        "native",
        "bounds"
      ],
      "description": "mode:'emboss' — Drawing.sketchOnFace scaling mode. Default original."
    }
  },
  "required": [
    "mode",
    "code"
  ]
}

project_curve

Use this when you need to wrap a 2D curve onto a 3D face. Insert a `<shape>.projectCurve({ curve, face, scaleMode?, asEdge? })` chained call into a kernelCAD script. Wraps a 2D closed curve onto a 3D face along the face normal; pair with `.extrude(d)` / `.cut(...)` for engraved logos or label inserts on curved bodies. `asEdge: true` is captured but currently deferred at lower time (BRepProj_Projection not bundled). Side-effect-free; returns modified code plus diagnostics.

Parameters7

code	string	required	The .kcad.ts source code.
target	string	required	Variable name of the Shape to chain onto.
curveExpression	string	required	JS expression returning a closed sketch (e.g. `path().moveTo(0,0).lineTo(2,0).lineTo(2,2).close().build()`). Inserted verbatim as the `curve:` field.
face	string	required	Target face — canonical name or label.
scaleMode	string	optional	Drawing.sketchOnFace scaling mode. Default original.
asEdge	boolean	optional	Project as an open edge instead of a closed face-bound sketch. Currently deferred.
bindAs	string	optional	Optional local variable name; emits `const <bindAs> = <target>.projectCurve(...);`.

Raw schema

{
  "type": "object",
  "properties": {
    "code": {
      "type": "string",
      "description": "The .kcad.ts source code."
    },
    "target": {
      "type": "string",
      "description": "Variable name of the Shape to chain onto."
    },
    "curveExpression": {
      "type": "string",
      "description": "JS expression returning a closed sketch (e.g. `path().moveTo(0,0).lineTo(2,0).lineTo(2,2).close().build()`). Inserted verbatim as the `curve:` field."
    },
    "face": {
      "type": "string",
      "description": "Target face — canonical name or label."
    },
    "scaleMode": {
      "type": "string",
      "enum": [
        "original",
        "native",
        "bounds"
      ],
      "description": "Drawing.sketchOnFace scaling mode. Default original."
    },
    "asEdge": {
      "type": "boolean",
      "description": "Project as an open edge instead of a closed face-bound sketch. Currently deferred."
    },
    "bindAs": {
      "type": "string",
      "description": "Optional local variable name; emits `const <bindAs> = <target>.projectCurve(...);`."
    }
  },
  "required": [
    "code",
    "target",
    "curveExpression",
    "face"
  ]
}

add_pattern_feature

Use this when you need to repeat a feature in a pattern. Insert a Shape.patternLinear / .patternCircular / .patternGrid call into a kernelCAD script before the last top-level return. Pass structured args (kind + the matching spec object). Returns the modified code plus diagnostics from re-evaluating. Side-effect-free. The pattern feature is a single editable unit; pattern-instance face refs resolve via `<sourceId>_pattern_<i>` on the pattern feature's lineage. Geometric note: pattern is implemented as cumulative boolean union of transformed source copies — additive features (boxes, ribs, fins, spokes) pattern cleanly; patterning a subtractive feature (hole, cutout) only preserves the per-instance void when adjacent bodies are disjoint.

Parameters7

code	string	required	The .kcad.ts source code.
target	string	required	Variable name of the Shape to pattern (inserted verbatim as the LHS receiver).
kind	string	required
linear	object	optional	Required when kind=linear.
circular	object	optional	Required when kind=circular.
grid	object	optional	Required when kind=grid.
assign_to	string	optional	Optional const-binding name; emits `const <assign_to> = <target>.patternX(...);`. Omit for statement form.

Raw schema

{
  "type": "object",
  "properties": {
    "code": {
      "type": "string",
      "description": "The .kcad.ts source code."
    },
    "target": {
      "type": "string",
      "description": "Variable name of the Shape to pattern (inserted verbatim as the LHS receiver)."
    },
    "kind": {
      "type": "string",
      "enum": [
        "linear",
        "circular",
        "grid"
      ]
    },
    "linear": {
      "type": "object",
      "description": "Required when kind=linear.",
      "properties": {
        "count": {
          "type": "integer",
          "minimum": 2
        },
        "direction": {
          "type": "array",
          "items": {
            "type": "number"
          },
          "minItems": 3,
          "maxItems": 3
        },
        "spacing": {
          "type": "number"
        }
      },
      "required": [
        "count",
        "direction",
        "spacing"
      ]
    },
    "circular": {
      "type": "object",
      "description": "Required when kind=circular.",
      "properties": {
        "count": {
          "type": "integer",
          "minimum": 2
        },
        "axis": {
          "type": "array",
          "items": {
            "type": "number"
          },
          "minItems": 3,
          "maxItems": 3
        },
        "angleDeg": {
          "type": "number",
          "description": "Optional; defaults to 360."
        }
      },
      "required": [
        "count",
        "axis"
      ]
    },
    "grid": {
      "type": "object",
      "description": "Required when kind=grid.",
      "properties": {
        "x": {
          "type": "object",
          "description": "First grid axis.",
          "properties": {
            "count": {
              "type": "integer",
              "minimum": 2
            },
            "direction": {
              "type": "array",
              "items": {
                "type": "number"
              },
              "minItems": 3,
              "maxItems": 3
            },
            "spacing": {
              "type": "number"
            }
          },
          "required": [
            "count",
            "direction",
            "spacing"
          ]
        },
        "y": {
          "type": "object",
          "description": "Second grid axis.",
          "properties": {
            "count": {
              "type": "integer",
              "minimum": 2
            },
            "direction": {
              "type": "array",
              "items": {
                "type": "number"
              },
              "minItems": 3,
              "maxItems": 3
            },
            "spacing": {
              "type": "number"
            }
          },
          "required": [
            "count",
            "direction",
            "spacing"
          ]
        }
      },
      "required": [
        "x",
        "y"
      ]
    },
    "assign_to": {
      "type": "string",
      "description": "Optional const-binding name; emits `const <assign_to> = <target>.patternX(...);`. Omit for statement form."
    }
  },
  "required": [
    "code",
    "target",
    "kind"
  ],
  "allOf": [
    {
      "if": {
        "properties": {
          "kind": {
            "const": "linear"
          }
        }
      },
      "then": {
        "required": [
          "linear"
        ]
      }
    },
    {
      "if": {
        "properties": {
          "kind": {
            "const": "circular"
          }
        }
      },
      "then": {
        "required": [
          "circular"
        ]
      }
    },
    {
      "if": {
        "properties": {
          "kind": {
            "const": "grid"
          }
        }
      },
      "then": {
        "required": [
          "grid"
        ]
      }
    }
  ]
}

remove_feature

Use this when you need to remove a feature line from a script. Remove a single line from a kernelCAD script identified by a substring match. Returns the modified code plus diagnostics from re-evaluating. Refuses to remove the line containing the return statement. Side-effect-free.

Parameters2

code	string	required	The .kcad.ts source code.
match	string	required	A substring that uniquely identifies the line to remove (e.g. `const hole = cylinder(5,`).

Raw schema

{
  "type": "object",
  "properties": {
    "code": {
      "type": "string",
      "description": "The .kcad.ts source code."
    },
    "match": {
      "type": "string",
      "description": "A substring that uniquely identifies the line to remove (e.g. `const hole = cylinder(5,`)."
    }
  },
  "required": [
    "code",
    "match"
  ]
}

query

Use this when you need to resolve or inspect topology against a script's lowered geometry. Selected by `mode` (default 'evaluate'): - 'evaluate' — inspect a Query (@kc[...] ref, @kcq[...] DSL, or { ast }); returns matched entities. Pass expect:'unique' to assert exactly-one. - 'resolve' — resolve a single @kc[...] / @kcq[...] ref to one entity ({ ref }). - 'lineage' — walk the HistoryMap for a named face ref ({ feature_id, ref }). All params except `mode` are forwarded verbatim.

Parameters7

mode	string	optional	Resolution mode (default 'evaluate').
file	string	optional	Path to a .kcad.ts script file.
code	string	optional	Inline kernelCAD script source.
query	any	optional	mode:'evaluate' — Query input: @kc[...] / @kcq[...] string or { ast } object.
ref	string	optional	mode:'resolve'\|'lineage' — topology ref string.
expect	string	optional	mode:'evaluate' — 'unique' asserts exactly-one.
feature_id	string	optional	Optional FeatureId; defaults to the last lowered shape (use "auto" for lineage).

Raw schema

{
  "type": "object",
  "properties": {
    "mode": {
      "type": "string",
      "enum": [
        "evaluate",
        "resolve",
        "lineage"
      ],
      "description": "Resolution mode (default 'evaluate')."
    },
    "file": {
      "type": "string",
      "description": "Path to a .kcad.ts script file."
    },
    "code": {
      "type": "string",
      "description": "Inline kernelCAD script source."
    },
    "query": {
      "description": "mode:'evaluate' — Query input: @kc[...] / @kcq[...] string or { ast } object."
    },
    "ref": {
      "type": "string",
      "description": "mode:'resolve'|'lineage' — topology ref string."
    },
    "expect": {
      "type": "string",
      "enum": [
        "any",
        "unique"
      ],
      "description": "mode:'evaluate' — 'unique' asserts exactly-one."
    },
    "feature_id": {
      "type": "string",
      "description": "Optional FeatureId; defaults to the last lowered shape (use \"auto\" for lineage)."
    }
  }
}

lookup_api

Use this when you need to list the kernelCAD script-runtime surface: global functions (box, path, selectEdges, helix, etc), Shape methods (fillet, sweep, lower, etc), Sketch methods (extrude, revolve, sweep), PathBuilder methods, EdgeQuery/FaceQuery key sets, and featureKindFaceLabels (which globals accept opts.faceLabels and valid value shapes). Use this to discover what is callable from a .kcad.ts script.

Parameters

No parameters.

Raw schema

{
  "type": "object",
  "properties": {}
}

lookup_diagnostics

Use this when you need the kernelCAD 26-code diagnostic catalogue with hint templates. Tiny one-shot call; useful for an agent that wants to pre-populate retry strategies. Hints are also inline on every emitted diagnostic — this tool just gives you the canonical list up front.

Parameters

No parameters.

Raw schema

{
  "type": "object",
  "properties": {}
}

export

Use this when you need to export geometry to a file. One exporter, selected by `target`: - target:'model' — export the script geometry to one file. Pass { file | code }, a required { output_path }, and { format }. Supported formats: stl (binary STL mesh), step (BREP CAD interchange), dxf (planar laser/waterjet profile from a Region or planar face), 3mf (slicer-friendly mesh with per-part colors), glb (web-viewer / AR with PBR materials), svg-drawing (third-angle engineering-drawing sheet: front/top/left + isometric views, hidden edges dashed, tangent edges thin, overall bounding-box dimensions, title block; assemblies are drawn with inter-part occlusion). Robot descriptions: urdf (tree-topology robot description), srdf (motion-planning semantics layered over the URDF), sdf-gazebo (SDFormat 1.10 with native ball joints, closed loops, and solved per-link poses). urdf and sdf-gazebo also write one meshes/<part>.stl per link next to output_path (reported in mesh_files) — ship the whole directory to the consumer. STL exports run a watertight verify by default; failures return ok: false with export.mesh.not-watertight (open-edge count + up to 5 crack-cluster locations) but the file is still written so the broken mesh can be inspected. Optional { feature_id } selects which feature to export (default: last). Optional { options } carries per-format options bag (see the kernelcad-mcp skill for the per-format keys: dxf layers/tolerance/unit, 3mf printUnit/embedSource, glb axis/draco). - target:'part' — export solved-assembly parts as individual binary STL files in their modeled (world-frame) positions. Pass { file | code }, plus { part, output_path } for one part or { output_dir } for all parts (files land at <output_dir>/<part>.stl). A watertight verify runs on every exported mesh by default and fails the call with export.mesh.not-watertight; unknown part names fail with export.part.not-found listing the valid names. Pass { no_verify: true } to skip the watertight gate. All params except `target` are forwarded verbatim; each target fails closed on its own missing required params.

Parameters10

target	string	required	Which exporter to run: 'model' (whole-script geometry to one file) or 'part' (per-part STLs from a solved assembly).
file	string	optional	Path to a .kcad.ts script file.
code	string	optional	Inline kernelCAD script source.
output_path	string	optional	Destination path. target:'model' — the export file (required). target:'part' — single-part .stl path.
format	string	optional	target:'model' — output file format (required for that target).
feature_id	string	optional	target:'model' — optional FeatureId to export; defaults to last.
options	object	optional	target:'model' — optional per-format options bag. Discriminator options.format must equal top-level format. dxf: { layers?, unit?: "mm"\|"cm"\|"in", tolerance? }. 3mf: { printUnit?: "mm"\|"cm"\|"in", embedSource? }. glb: { axis?: "y-up"\|"z-up", draco?: false }. svg-drawing: { sheet?: "a4"\|"a3", modelName?, date? }.
part	string	optional	target:'part' — part name for single-part export, or 'all'.
output_dir	string	optional	target:'part' — destination directory (all-parts mode); files are <dir>/<part>.stl.
no_verify	boolean	optional	Skip the STL watertight verify gate.

Raw schema

{
  "type": "object",
  "properties": {
    "target": {
      "type": "string",
      "enum": [
        "model",
        "part"
      ],
      "description": "Which exporter to run: 'model' (whole-script geometry to one file) or 'part' (per-part STLs from a solved assembly)."
    },
    "file": {
      "type": "string",
      "description": "Path to a .kcad.ts script file."
    },
    "code": {
      "type": "string",
      "description": "Inline kernelCAD script source."
    },
    "output_path": {
      "type": "string",
      "description": "Destination path. target:'model' — the export file (required). target:'part' — single-part .stl path."
    },
    "format": {
      "type": "string",
      "enum": [
        "stl",
        "step",
        "dxf",
        "3mf",
        "glb",
        "svg-drawing",
        "urdf",
        "srdf",
        "sdf-gazebo"
      ],
      "description": "target:'model' — output file format (required for that target)."
    },
    "feature_id": {
      "type": "string",
      "description": "target:'model' — optional FeatureId to export; defaults to last."
    },
    "options": {
      "type": "object",
      "description": "target:'model' — optional per-format options bag. Discriminator options.format must equal top-level format. dxf: { layers?, unit?: \"mm\"|\"cm\"|\"in\", tolerance? }. 3mf: { printUnit?: \"mm\"|\"cm\"|\"in\", embedSource? }. glb: { axis?: \"y-up\"|\"z-up\", draco?: false }. svg-drawing: { sheet?: \"a4\"|\"a3\", modelName?, date? }."
    },
    "part": {
      "type": "string",
      "description": "target:'part' — part name for single-part export, or 'all'."
    },
    "output_dir": {
      "type": "string",
      "description": "target:'part' — destination directory (all-parts mode); files are <dir>/<part>.stl."
    },
    "no_verify": {
      "type": "boolean",
      "description": "Skip the STL watertight verify gate.",
      "default": false
    }
  },
  "required": [
    "target"
  ]
}

lookup_cookbook

Use this when you need a canonical pattern snippet for a CAD task. Search the kernelCAD cookbook for canonical pattern snippets. Returns top-k snippets matching the natural-language query, ranked by BM25 over title/tags/keywords/trigger. Use when you need a canonical pattern for fillet-after-subtract, non-overlapping booleans, sketch-to-extrude flows, etc. Returns empty if no snippet scores above the relevance floor — proceed without cookbook help in that case.

Parameters2

query	string	required	Natural-language description of what you want to do (e.g. "round the rim of a hole", "build an L-bracket").
k	number	optional	Max snippets to return. Default 3, max 5.

Raw schema

{
  "type": "object",
  "properties": {
    "query": {
      "type": "string",
      "description": "Natural-language description of what you want to do (e.g. \"round the rim of a hole\", \"build an L-bracket\")."
    },
    "k": {
      "type": "number",
      "description": "Max snippets to return. Default 3, max 5.",
      "default": 3
    }
  },
  "required": [
    "query"
  ]
}

find_part

Use this when you need to find a part in the catalog. Discover bundled (and optionally remote) part-catalog records by fuzzy query and faceted filters. Tokens AND-combine; cross-facet filters AND-combine. Pass partsBaseUrl (or set KERNELCAD_PARTS_BASE_URL) to enable the remote tier; otherwise results are bundled-only.

Parameters8

query	string	optional
category	string	optional
family	string	optional
standard	string	optional
tag	string	optional
limit	number	optional
source	string	optional
partsBaseUrl	string	optional	Opt-in remote endpoint; no default value ships with kernelCAD.

Raw schema

{
  "type": "object",
  "properties": {
    "query": {
      "type": "string"
    },
    "category": {
      "type": "string"
    },
    "family": {
      "type": "string"
    },
    "standard": {
      "type": "string"
    },
    "tag": {
      "type": "string"
    },
    "limit": {
      "type": "number"
    },
    "source": {
      "type": "string",
      "enum": [
        "local",
        "remote",
        "auto"
      ]
    },
    "partsBaseUrl": {
      "type": "string",
      "description": "Opt-in remote endpoint; no default value ships with kernelCAD."
    }
  }
}

fetch_part

Use this when you need to download a catalog part as a STEP file. Resolve an id (or single-match query) to a part record and write its STEP file to the local cache. Bundled ids resolve offline; non-bundled ids require partsBaseUrl (or KERNELCAD_PARTS_BASE_URL). Returns the cache path plus a sha256 fingerprint.

Parameters6

id	string	optional
query	string	optional
category	string	optional
family	string	optional
standard	string	optional
partsBaseUrl	string	optional	Opt-in remote endpoint; no default value ships with kernelCAD.

Raw schema

{
  "type": "object",
  "properties": {
    "id": {
      "type": "string"
    },
    "query": {
      "type": "string"
    },
    "category": {
      "type": "string"
    },
    "family": {
      "type": "string"
    },
    "standard": {
      "type": "string"
    },
    "partsBaseUrl": {
      "type": "string",
      "description": "Opt-in remote endpoint; no default value ships with kernelCAD."
    }
  }
}

solve_sketch

Use this when you need to solve a 2D sketch constraint set. Solve a 2D sketch constraint set. Side-effect-free: pass { entities, constraints } and receive solved entities plus the original constraints. Entities are POINT, LINE, and CIRCLE records; constraints use the kernelCAD constraint vocabulary.

Parameters2

entities	array	required	Sketch entities to solve. Lines reference point ids; circles reference a center point id.
constraints	array	required	Constraints to apply to the entities.

Raw schema

{
  "type": "object",
  "properties": {
    "entities": {
      "type": "array",
      "description": "Sketch entities to solve. Lines reference point ids; circles reference a center point id.",
      "items": {
        "oneOf": [
          {
            "type": "object",
            "description": "POINT — a 2D point.",
            "properties": {
              "id": {
                "type": "string"
              },
              "type": {
                "type": "string",
                "enum": [
                  "POINT"
                ]
              },
              "x": {
                "type": "number"
              },
              "y": {
                "type": "number"
              },
              "fixed": {
                "type": "boolean",
                "description": "If true, the solver won't move this point."
              }
            },
            "required": [
              "id",
              "type",
              "x",
              "y"
            ]
          },
          {
            "type": "object",
            "description": "LINE — references two point ids.",
            "properties": {
              "id": {
                "type": "string"
              },
              "type": {
                "type": "string",
                "enum": [
                  "LINE"
                ]
              },
              "p1": {
                "type": "string"
              },
              "p2": {
                "type": "string"
              }
            },
            "required": [
              "id",
              "type",
              "p1",
              "p2"
            ]
          },
          {
            "type": "object",
            "description": "CIRCLE — references a center point id.",
            "properties": {
              "id": {
                "type": "string"
              },
              "type": {
                "type": "string",
                "enum": [
                  "CIRCLE"
                ]
              },
              "center": {
                "type": "string"
              },
              "radius": {
                "type": "number"
              }
            },
            "required": [
              "id",
              "type",
              "center",
              "radius"
            ]
          }
        ]
      }
    },
    "constraints": {
      "type": "array",
      "description": "Constraints to apply to the entities.",
      "items": {
        "type": "object",
        "properties": {
          "id": {
            "type": "string"
          },
          "type": {
            "type": "string",
            "enum": [
              "COINCIDENT",
              "DISTANCE",
              "HORIZONTAL",
              "VERTICAL",
              "PARALLEL",
              "PERPENDICULAR",
              "EQUAL_LENGTH",
              "TANGENT",
              "RADIUS",
              "ANGLE",
              "CONCENTRIC",
              "SYMMETRIC"
            ]
          },
          "entities": {
            "type": "array",
            "items": {
              "type": "string"
            },
            "description": "Ids of the entities the constraint relates."
          },
          "value": {
            "type": "number",
            "description": "Required for DISTANCE, RADIUS, and ANGLE."
          }
        },
        "required": [
          "id",
          "type",
          "entities"
        ]
      }
    }
  },
  "required": [
    "entities",
    "constraints"
  ]
}

add_constraint

Use this when you need to add a sketch constraint to a list. Append one validated sketch constraint to a constraint list. Side-effect-free: pass { constraints, constraint } and receive the updated list.

Parameters2

constraints	array	optional	Existing constraint list to append to (omit for an empty list).
constraint	object	required	The constraint to append.

Raw schema

{
  "type": "object",
  "properties": {
    "constraints": {
      "type": "array",
      "description": "Existing constraint list to append to (omit for an empty list).",
      "items": {
        "type": "object",
        "properties": {
          "id": {
            "type": "string"
          },
          "type": {
            "type": "string",
            "enum": [
              "COINCIDENT",
              "DISTANCE",
              "HORIZONTAL",
              "VERTICAL",
              "PARALLEL",
              "PERPENDICULAR",
              "EQUAL_LENGTH",
              "TANGENT",
              "RADIUS",
              "ANGLE",
              "CONCENTRIC",
              "SYMMETRIC"
            ]
          },
          "entities": {
            "type": "array",
            "items": {
              "type": "string"
            }
          },
          "value": {
            "type": "number"
          }
        },
        "required": [
          "id",
          "type",
          "entities"
        ]
      }
    },
    "constraint": {
      "type": "object",
      "description": "The constraint to append.",
      "properties": {
        "id": {
          "type": "string"
        },
        "type": {
          "type": "string",
          "enum": [
            "COINCIDENT",
            "DISTANCE",
            "HORIZONTAL",
            "VERTICAL",
            "PARALLEL",
            "PERPENDICULAR",
            "EQUAL_LENGTH",
            "TANGENT",
            "RADIUS",
            "ANGLE",
            "CONCENTRIC",
            "SYMMETRIC"
          ]
        },
        "entities": {
          "type": "array",
          "items": {
            "type": "string"
          },
          "description": "Ids of the entities the constraint relates."
        },
        "value": {
          "type": "number",
          "description": "Required for DISTANCE, RADIUS, and ANGLE."
        }
      },
      "required": [
        "id",
        "type",
        "entities"
      ]
    }
  },
  "required": [
    "constraint"
  ]
}

add_part

Use this when you need to add a part to an assembly. Durably insert `const <binding> = <assembly>.part(partName, shapeExpression, opts?)` before the final top-level return in a kernelCAD source string. Returns modified source plus diagnostics from re-evaluating it. Side-effect-free: caller persists the returned source.

Parameters6

code	string	required	The .kcad.ts source code.
assembly_binding	string	required	JS identifier bound to assembly(...), e.g. "arm".
part_name	string	required	Assembly-unique part name.
shape_expression	string	required	JS expression for the Shape to pass to assembly.part, inserted verbatim.
binding_name	string	optional	Optional JS const name for the returned AssemblyPartRef. Defaults to a part-name-derived identifier.
at	array	optional	Optional [x, y, z] assembly placement.

Raw schema

{
  "type": "object",
  "properties": {
    "code": {
      "type": "string",
      "description": "The .kcad.ts source code."
    },
    "assembly_binding": {
      "type": "string",
      "description": "JS identifier bound to assembly(...), e.g. \"arm\"."
    },
    "part_name": {
      "type": "string",
      "description": "Assembly-unique part name."
    },
    "shape_expression": {
      "type": "string",
      "description": "JS expression for the Shape to pass to assembly.part, inserted verbatim."
    },
    "binding_name": {
      "type": "string",
      "description": "Optional JS const name for the returned AssemblyPartRef. Defaults to a part-name-derived identifier."
    },
    "at": {
      "type": "array",
      "items": {
        "type": "number"
      },
      "description": "Optional [x, y, z] assembly placement."
    }
  },
  "required": [
    "code",
    "assembly_binding",
    "part_name",
    "shape_expression"
  ]
}

add_connector

Use this when you need to add a mate connector to a part. Durably insert `<partBinding>.connector(name, { type, origin, axis?, normal? })` before the final top-level return. Use the part binding returned by add_part. Returns modified source plus diagnostics from re-evaluation. Side-effect-free.

Parameters7

code	string	required	The .kcad.ts source code.
part_binding	string	required	JS identifier bound to an AssemblyPartRef, e.g. "basePart".
name	string	required	Connector name unique within the part.
type	string	required
origin	any	required	Origin as [x, y, z] shorthand, or a structured ConnectorOrigin.
axis	array	optional	Optional [x, y, z] axis.
normal	array	optional	Optional [x, y, z] normal.

Raw schema

{
  "type": "object",
  "properties": {
    "code": {
      "type": "string",
      "description": "The .kcad.ts source code."
    },
    "part_binding": {
      "type": "string",
      "description": "JS identifier bound to an AssemblyPartRef, e.g. \"basePart\"."
    },
    "name": {
      "type": "string",
      "description": "Connector name unique within the part."
    },
    "type": {
      "type": "string",
      "enum": [
        "frame",
        "axis",
        "planar",
        "ball"
      ]
    },
    "origin": {
      "description": "Origin as [x, y, z] shorthand, or a structured ConnectorOrigin.",
      "oneOf": [
        {
          "type": "array",
          "items": {
            "type": "number"
          },
          "minItems": 3,
          "maxItems": 3,
          "description": "[x, y, z] shorthand."
        },
        {
          "type": "object",
          "description": "Explicit numeric origin.",
          "properties": {
            "kind": {
              "type": "string",
              "enum": [
                "vec3"
              ]
            },
            "value": {
              "type": "array",
              "items": {
                "type": "number"
              },
              "minItems": 3,
              "maxItems": 3
            }
          },
          "required": [
            "kind",
            "value"
          ]
        },
        {
          "type": "object",
          "description": "Topology-derived origin.",
          "properties": {
            "kind": {
              "type": "string",
              "enum": [
                "topology"
              ]
            },
            "query": {
              "type": "object",
              "properties": {
                "kind": {
                  "type": "string",
                  "enum": [
                    "face-center",
                    "face-normal",
                    "vertex",
                    "edge-axis"
                  ]
                },
                "name": {
                  "type": "string"
                }
              },
              "required": [
                "kind",
                "name"
              ]
            }
          },
          "required": [
            "kind",
            "query"
          ]
        }
      ]
    },
    "axis": {
      "type": "array",
      "items": {
        "type": "number"
      },
      "description": "Optional [x, y, z] axis."
    },
    "normal": {
      "type": "array",
      "items": {
        "type": "number"
      },
      "description": "Optional [x, y, z] normal."
    }
  },
  "required": [
    "code",
    "part_binding",
    "name",
    "type",
    "origin"
  ]
}

add_mate

Use this when you need to author a mate-graph relationship into the source, selected by `relation` (default 'mate'): - 'mate' — a typed mate between two connectors ({ name, a, b, type, pose?, limitsDeg?, limitsMm? }). - 'coupling' — couple a driven mate to a source mate by ratio ({ driven, source, ratio, offset? }). - 'transmission' — a physical drive path across mates ({ name, kind, sourceMate, drivenMates, path, ... }). All durably edit source and need { code, assembly_binding }. Params other than `relation` are forwarded verbatim; each relation fails closed on its own missing required params.

Parameters22

relation	string	optional	Which relationship to author (default 'mate').
code	string	required	The .kcad.ts source code.
assembly_binding	string	required	JS identifier bound to assembly(...).
name	string	optional	relation:'mate'\|'transmission' — name unique within the assembly.
a	string	optional	relation:'mate' — connector ref "<partName>.<connectorName>".
b	string	optional	relation:'mate' — connector ref "<partName>.<connectorName>".
type	string	optional	relation:'mate' — mate type.
pose	any	optional	relation:'mate' — optional mate pose.
limitsDeg	array	optional	relation:'mate' — optional [minDeg, maxDeg].
limitsMm	array	optional	relation:'mate' — optional [minMm, maxMm].
driven	string	optional	relation:'coupling' — driven mate name.
source	string	optional	relation:'coupling' — source mate name.
ratio	number	optional	relation:'coupling' — driven pose = source pose * ratio + offset.
offset	number	optional	relation:'coupling' — optional pose offset.
kind	string	optional	relation:'transmission' — transmission kind.
sourceMate	string	optional	relation:'transmission' — source mate name.
drivenMates	array	optional	relation:'transmission' — driven mate names.
actuator	string	optional	relation:'transmission' — optional actuator.
input	string	optional	relation:'transmission' — optional input.
output	string	optional	relation:'transmission' — optional output.
path	array	optional	relation:'transmission' — drive path.
notes	string	optional	relation:'transmission' — optional notes.

Raw schema

{
  "type": "object",
  "properties": {
    "relation": {
      "type": "string",
      "enum": [
        "mate",
        "coupling",
        "transmission"
      ],
      "description": "Which relationship to author (default 'mate')."
    },
    "code": {
      "type": "string",
      "description": "The .kcad.ts source code."
    },
    "assembly_binding": {
      "type": "string",
      "description": "JS identifier bound to assembly(...)."
    },
    "name": {
      "type": "string",
      "description": "relation:'mate'|'transmission' — name unique within the assembly."
    },
    "a": {
      "type": "string",
      "description": "relation:'mate' — connector ref \"<partName>.<connectorName>\"."
    },
    "b": {
      "type": "string",
      "description": "relation:'mate' — connector ref \"<partName>.<connectorName>\"."
    },
    "type": {
      "type": "string",
      "enum": [
        "fastened",
        "revolute",
        "prismatic",
        "cylindrical",
        "planar",
        "ball",
        "pin_slot"
      ],
      "description": "relation:'mate' — mate type."
    },
    "pose": {
      "description": "relation:'mate' — optional mate pose."
    },
    "limitsDeg": {
      "type": "array",
      "items": {
        "type": "number"
      },
      "description": "relation:'mate' — optional [minDeg, maxDeg]."
    },
    "limitsMm": {
      "type": "array",
      "items": {
        "type": "number"
      },
      "description": "relation:'mate' — optional [minMm, maxMm]."
    },
    "driven": {
      "type": "string",
      "description": "relation:'coupling' — driven mate name."
    },
    "source": {
      "type": "string",
      "description": "relation:'coupling' — source mate name."
    },
    "ratio": {
      "type": "number",
      "description": "relation:'coupling' — driven pose = source pose * ratio + offset."
    },
    "offset": {
      "type": "number",
      "description": "relation:'coupling' — optional pose offset."
    },
    "kind": {
      "type": "string",
      "enum": [
        "direct-horn",
        "link-rod",
        "four-bar",
        "gear-pair",
        "belt",
        "tendon"
      ],
      "description": "relation:'transmission' — transmission kind."
    },
    "sourceMate": {
      "type": "string",
      "description": "relation:'transmission' — source mate name."
    },
    "drivenMates": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "relation:'transmission' — driven mate names."
    },
    "actuator": {
      "type": "string",
      "description": "relation:'transmission' — optional actuator."
    },
    "input": {
      "type": "string",
      "description": "relation:'transmission' — optional input."
    },
    "output": {
      "type": "string",
      "description": "relation:'transmission' — optional output."
    },
    "path": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "relation:'transmission' — drive path."
    },
    "notes": {
      "type": "string",
      "description": "relation:'transmission' — optional notes."
    }
  },
  "required": [
    "code",
    "assembly_binding"
  ],
  "allOf": [
    {
      "if": {
        "anyOf": [
          {
            "not": {
              "required": [
                "relation"
              ]
            }
          },
          {
            "properties": {
              "relation": {
                "const": "mate"
              }
            },
            "required": [
              "relation"
            ]
          }
        ]
      },
      "then": {
        "required": [
          "name",
          "a",
          "b",
          "type"
        ]
      }
    },
    {
      "if": {
        "properties": {
          "relation": {
            "const": "coupling"
          }
        },
        "required": [
          "relation"
        ]
      },
      "then": {
        "required": [
          "driven",
          "source",
          "ratio"
        ]
      }
    },
    {
      "if": {
        "properties": {
          "relation": {
            "const": "transmission"
          }
        },
        "required": [
          "relation"
        ]
      },
      "then": {
        "required": [
          "name",
          "kind",
          "sourceMate",
          "drivenMates",
          "path"
        ]
      }
    }
  ]
}

add_workspace_target

Use this when you need to declare a reachability target for a connector. Durably insert `<assembly>.workspace(connectorRef, { reachable, toleranceMm? })` before the final top-level return. Workspace targets are checked by solvedModel validation/review pose-envelope gates. Returns modified source plus diagnostics from re-evaluation.

Parameters5

code	string	required	The .kcad.ts source code.
assembly_binding	string	required	JS identifier bound to assembly(...).
connector_ref	string	required	Connector ref "<partName>.<connectorName>".
reachable	array	required	World-frame Vec3 targets the connector must be able to reach.
toleranceMm	number	optional	Optional non-negative tolerance in mm.

Raw schema

{
  "type": "object",
  "properties": {
    "code": {
      "type": "string",
      "description": "The .kcad.ts source code."
    },
    "assembly_binding": {
      "type": "string",
      "description": "JS identifier bound to assembly(...)."
    },
    "connector_ref": {
      "type": "string",
      "description": "Connector ref \"<partName>.<connectorName>\"."
    },
    "reachable": {
      "type": "array",
      "description": "World-frame Vec3 targets the connector must be able to reach.",
      "items": {
        "type": "array",
        "items": {
          "type": "number"
        },
        "minItems": 3,
        "maxItems": 3
      }
    },
    "toleranceMm": {
      "type": "number",
      "description": "Optional non-negative tolerance in mm."
    }
  },
  "required": [
    "code",
    "assembly_binding",
    "connector_ref",
    "reachable"
  ]
}

set_scene_return

Use this when you need to set how the script returns its assembly. Replace the final top-level return statement with `return <assembly>.model();` or `return <assembly>.solvedModel(poses, options?);`. Use solvedModel for mate-authored mechanisms so FK and validation run. Returns modified source plus diagnostics from re-evaluation.

Parameters5

code	string	required	The .kcad.ts source code.
assembly_binding	string	required	JS identifier bound to assembly(...).
mode	string	required
poses	object	optional	Optional solvedModel pose overrides keyed by mate name. Defaults to {}.
options	object	optional	Optional solvedModel options such as { validate: 'warn', posesGate: 'envelope' }.

Raw schema

{
  "type": "object",
  "properties": {
    "code": {
      "type": "string",
      "description": "The .kcad.ts source code."
    },
    "assembly_binding": {
      "type": "string",
      "description": "JS identifier bound to assembly(...)."
    },
    "mode": {
      "type": "string",
      "enum": [
        "model",
        "solvedModel"
      ]
    },
    "poses": {
      "type": "object",
      "description": "Optional solvedModel pose overrides keyed by mate name. Defaults to {}."
    },
    "options": {
      "type": "object",
      "description": "Optional solvedModel options such as { validate: 'warn', posesGate: 'envelope' }."
    }
  },
  "required": [
    "code",
    "assembly_binding",
    "mode"
  ]
}

solve_mates

Use this when you need to solve the mate graph and get part poses. Run the v0.6 mate-graph solver on the active assembly. Returns { status, poses, iterations? } where each pose is a serialized Transform ({ translation, rotateAxis, rotateDeg }). Optional poses overrides mate pose values by mate name.

Parameters2

assembly	string	optional
poses	object	optional	Optional numeric pose overrides keyed by mate name.

Raw schema

{
  "type": "object",
  "properties": {
    "assembly": {
      "type": "string"
    },
    "poses": {
      "type": "object",
      "description": "Optional numeric pose overrides keyed by mate name."
    }
  }
}

review_cad

Use this when you need to review a mechanism for fitness and repair mode. Run the deterministic CAD review loop: evaluate the script, validate the assembly/mate graph, check mate connectors touch modeled material, sample declared mate limits, optionally check interferences at sampled poses, report connector workspace bounds, and return a mechanism fitness verdict for agent self-review. Fitness includes repairMode: none, local-fix, parameter-tune, or topology-redesign.

Parameters12

file	string	optional	Path to a .kcad.ts script file.
code	string	optional	Inline kernelCAD script source.
assembly	string	optional	Assembly name; defaults to the first captured assembly.
designGoal	string	optional	Original user design prompt or goal. Included in suggestedRepairPrompt so topology-redesign repairs restart from the intended physical design instead of local coordinate nudges.
preserveInterfaces	array	optional	External mates, connector refs, part names, or behavioral interfaces the repair agent must preserve during redesign.
includePoseEnvelope	boolean	optional	Whether to sample declared mate limits. Default true.
includeInterference	boolean	optional	Whether sampled poses run BREP interference checks. Default true.
samplesPerMate	integer	optional	Pose-envelope samples per declared-limit mate. 1 (default) = corners only; >=3 adds uniform interior points between min and max. Total samples per non-locked mate = samplesPerMate.
combinatorial	boolean	optional	Sample all 2^N limit-corner combinations across mates with declared limits. Capped at 8 mates with limits; combine with samplesPerMate for both interior coverage and worst-pose detection. Default false.
epsilonMm3	number	optional	Interference volume threshold in mm^3. Default 0.01.
trackConnectors	array	optional	Optional connector refs such as ["gripper-plate.tool-tip"] to limit connector workspace reporting.
gripperAperture	object	optional	Optional fingertip connector refs for gripper aperture travel reporting.

Raw schema

{
  "type": "object",
  "properties": {
    "file": {
      "type": "string",
      "description": "Path to a .kcad.ts script file."
    },
    "code": {
      "type": "string",
      "description": "Inline kernelCAD script source."
    },
    "assembly": {
      "type": "string",
      "description": "Assembly name; defaults to the first captured assembly."
    },
    "designGoal": {
      "type": "string",
      "description": "Original user design prompt or goal. Included in suggestedRepairPrompt so topology-redesign repairs restart from the intended physical design instead of local coordinate nudges."
    },
    "preserveInterfaces": {
      "type": "array",
      "description": "External mates, connector refs, part names, or behavioral interfaces the repair agent must preserve during redesign.",
      "items": {
        "type": "string"
      }
    },
    "includePoseEnvelope": {
      "type": "boolean",
      "description": "Whether to sample declared mate limits. Default true."
    },
    "includeInterference": {
      "type": "boolean",
      "description": "Whether sampled poses run BREP interference checks. Default true."
    },
    "samplesPerMate": {
      "type": "integer",
      "minimum": 1,
      "description": "Pose-envelope samples per declared-limit mate. 1 (default) = corners only; >=3 adds uniform interior points between min and max. Total samples per non-locked mate = samplesPerMate."
    },
    "combinatorial": {
      "type": "boolean",
      "description": "Sample all 2^N limit-corner combinations across mates with declared limits. Capped at 8 mates with limits; combine with samplesPerMate for both interior coverage and worst-pose detection. Default false."
    },
    "epsilonMm3": {
      "type": "number",
      "description": "Interference volume threshold in mm^3. Default 0.01."
    },
    "trackConnectors": {
      "type": "array",
      "description": "Optional connector refs such as [\"gripper-plate.tool-tip\"] to limit connector workspace reporting.",
      "items": {
        "type": "string"
      }
    },
    "gripperAperture": {
      "type": "object",
      "description": "Optional fingertip connector refs for gripper aperture travel reporting.",
      "properties": {
        "left": {
          "type": "string",
          "description": "Left fingertip connector ref such as \"left-finger.tip\"."
        },
        "right": {
          "type": "string",
          "description": "Right fingertip connector ref such as \"right-finger.tip\"."
        }
      }
    }
  }
}

design_loop

Use this when you need to run a CAD design loop over multiple attempts. Run an agent CAD design loop over one or more attempt scripts: review each attempt with review_cad, continue past functional attempts that still have unresolved review warnings, return structured repair prompts, and optionally write a Studio-compatible build record JSON for visual replay.

Parameters16

goal	string	required	Original user design goal. Fed into every review_cad repair prompt.
attempts	array	required	Ordered design attempts. Each item is { id?, title?, file? OR code?, visualReview? } — provide file or code (at least one). File attempts can be replayed by Studio build records.
assembly	string	optional
preserveInterfaces	array	optional	External mates, connector refs, part names, or behavioral interfaces the agent must preserve between attempts.
includePoseEnvelope	boolean	optional	Forwarded to review_cad. Default true.
includeInterference	boolean	optional	Forwarded to review_cad. Default true.
samplesPerMate	integer	optional	Pose-envelope samples per declared-limit mate. 1 (default) = corners only; >=3 adds uniform interior points between min and max. Total samples per non-locked mate = samplesPerMate.
combinatorial	boolean	optional	Sample all 2^N limit-corner combinations across mates with declared limits. Capped at 8 mates with limits; combine with samplesPerMate for both interior coverage and worst-pose detection. Default false.
epsilonMm3	number	optional	Forwarded to review_cad.
trackConnectors	array	optional	Connector refs to track across sampled poses.
gripperAperture	object	optional	Optional gripper aperture request forwarded to review_cad.
stopOnPass	boolean	optional	Stop after the first attempt that is functional and passes the quality gate. Default true.
requireVisualReview	boolean	optional	Require screenshot-backed visualReview with structured checks before accepting an attempt. Default true; set false only for explicit non-visual batch checks.
allowReviewWarnings	array	optional	Warning diagnostic codes the original prompt explicitly allows. Other review warnings keep the loop iterating even if review_cad is functionally ok.
outputRecordPath	string	optional	Optional JSON path to write a Studio-compatible build record.
recordTitle	string	optional	Optional title for the build record.

Raw schema

{
  "type": "object",
  "properties": {
    "goal": {
      "type": "string",
      "description": "Original user design goal. Fed into every review_cad repair prompt."
    },
    "attempts": {
      "type": "array",
      "description": "Ordered design attempts. Each item is { id?, title?, file? OR code?, visualReview? } — provide file or code (at least one). File attempts can be replayed by Studio build records.",
      "items": {
        "type": "object",
        "anyOf": [
          {
            "required": [
              "file"
            ]
          },
          {
            "required": [
              "code"
            ]
          }
        ],
        "properties": {
          "id": {
            "type": "string"
          },
          "title": {
            "type": "string"
          },
          "file": {
            "type": "string",
            "description": "Path to a .kcad.ts script on disk. Provide file or code."
          },
          "code": {
            "type": "string",
            "description": "Inline kernelCAD script source. Provide file or code."
          },
          "visualReview": {
            "type": "object",
            "description": "Optional. Evidence from the reviewing agent after rendering/opening screenshots. Accepted reviews must include screenshotPath, concrete findings, and all required checks passing.",
            "properties": {
              "accepted": {
                "type": "boolean"
              },
              "screenshotPath": {
                "type": "string"
              },
              "findings": {
                "type": "array",
                "items": {
                  "type": "string"
                }
              },
              "checks": {
                "type": "array",
                "description": "Required checklist entries: main-object-count, proportions-match-reference, required-visible-features, no-stray-or-floating-geometry, attachment-plausibility, semantic-orientation-alignment, device-depth-and-construction, canonical-views-physically-coherent.",
                "items": {
                  "type": "object",
                  "properties": {
                    "code": {
                      "type": "string"
                    },
                    "passed": {
                      "type": "boolean"
                    },
                    "finding": {
                      "type": "string"
                    },
                    "screenshotPath": {
                      "type": "string"
                    }
                  },
                  "required": [
                    "code",
                    "passed",
                    "finding"
                  ]
                }
              }
            },
            "required": [
              "accepted",
              "findings"
            ]
          }
        }
      }
    },
    "assembly": {
      "type": "string"
    },
    "preserveInterfaces": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "External mates, connector refs, part names, or behavioral interfaces the agent must preserve between attempts."
    },
    "includePoseEnvelope": {
      "type": "boolean",
      "description": "Forwarded to review_cad. Default true."
    },
    "includeInterference": {
      "type": "boolean",
      "description": "Forwarded to review_cad. Default true."
    },
    "samplesPerMate": {
      "type": "integer",
      "minimum": 1,
      "description": "Pose-envelope samples per declared-limit mate. 1 (default) = corners only; >=3 adds uniform interior points between min and max. Total samples per non-locked mate = samplesPerMate."
    },
    "combinatorial": {
      "type": "boolean",
      "description": "Sample all 2^N limit-corner combinations across mates with declared limits. Capped at 8 mates with limits; combine with samplesPerMate for both interior coverage and worst-pose detection. Default false."
    },
    "epsilonMm3": {
      "type": "number",
      "description": "Forwarded to review_cad."
    },
    "trackConnectors": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Connector refs to track across sampled poses."
    },
    "gripperAperture": {
      "type": "object",
      "description": "Optional gripper aperture request forwarded to review_cad."
    },
    "stopOnPass": {
      "type": "boolean",
      "description": "Stop after the first attempt that is functional and passes the quality gate. Default true."
    },
    "requireVisualReview": {
      "type": "boolean",
      "description": "Require screenshot-backed visualReview with structured checks before accepting an attempt. Default true; set false only for explicit non-visual batch checks."
    },
    "allowReviewWarnings": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Warning diagnostic codes the original prompt explicitly allows. Other review warnings keep the loop iterating even if review_cad is functionally ok."
    },
    "outputRecordPath": {
      "type": "string",
      "description": "Optional JSON path to write a Studio-compatible build record."
    },
    "recordTitle": {
      "type": "string",
      "description": "Optional title for the build record."
    }
  },
  "required": [
    "goal",
    "attempts"
  ]
}

flatten_pattern

Use this when you need the unfolded flat pattern of a bent sheet-metal part. Return the unfolded 2D flat-pattern of a bent sheet-metal Shape as a Region (outer polyline + holes + bend lines + sketch plane). Slice 1: at most 2 bends. Pass { file } or { code }; optional { featureId } to pick a specific Shape.

Parameters3

file	string	optional
code	string	optional
featureId	string	optional

Raw schema

{
  "type": "object",
  "properties": {
    "file": {
      "type": "string"
    },
    "code": {
      "type": "string"
    },
    "featureId": {
      "type": "string"
    }
  }
}

evaluate_sdf

Use this when you need to sample a signed-distance field at a point. Sample the signed distance from an in-script sdf.* field at a 3D point. Returns { distance, inside, aabb, kind }. Distance is in mm; negative = inside the surface, 0 = exactly on the surface, positive = outside. Use this to verify SDF composition before calling sdf.materialize (which is the expensive step). The script must bind the SdfField via sdf.bind('<name>', field) and pass that name as fieldName. Hint: pass either { file } or { code }, plus { fieldName, point: [x,y,z] }.

Parameters4

file	string	optional	Path to a .kcad.ts script file.
code	string	optional	Inline kernelCAD script source.
fieldName	string	required	sdf.bind binding name holding the SdfField.
point	array	required	Sample point [x, y, z] in mm.

Raw schema

{
  "type": "object",
  "properties": {
    "file": {
      "type": "string",
      "description": "Path to a .kcad.ts script file."
    },
    "code": {
      "type": "string",
      "description": "Inline kernelCAD script source."
    },
    "fieldName": {
      "type": "string",
      "description": "sdf.bind binding name holding the SdfField."
    },
    "point": {
      "type": "array",
      "items": {
        "type": "number"
      },
      "minItems": 3,
      "maxItems": 3,
      "description": "Sample point [x, y, z] in mm."
    }
  },
  "required": [
    "fieldName",
    "point"
  ]
}

capture_animation

Use this when you need to render a script's animation timeline to a video. Capture a kernelCAD script's animationView({...}) timeline to an MP4 (ffmpeg) or a PNG frame sequence, verifying the sampled poses for part interference. FILE ONLY: pass { file } (a .kcad.ts path) — there is no { code } mode, because the capture engine renders from a file on disk (its relative lib.fromSTEP imports resolve against the script directory). MP4 by default; pass { frames_dir } to write frame-0000.png... and skip ffmpeg entirely (mutually exclusive with output_path). Animation-pose interference verification runs by default (keyframe times + segment midpoints) BEFORE any browser/ffmpeg cost; { no_verify: true } skips it and { verify_every: n } additionally samples every n-th frame time. Pass { focus } or { hide } (arrays of feature ids or assembly part names, mutually exclusive) to isolate parts in the rendered frames — same semantics as `kernelcad render --focus/--hide`; visibility is render-only and does NOT affect the pose verification. Collisions DO NOT fail the call — the artifact is still written as evidence with ok: true; read verified: false + the collisions[] array. ENVIRONMENT REQUIREMENT (identical to `kernelcad render`): capture drives a headless browser against a running studio dev server reachable at http://localhost:5173 (or the VITE_PORT override); there is no bundled-static serving mode yet, so the same dev-server precondition applies in a production MCP install. Returns { ok, output_path, frame_count, duration_ms, fps, verified, verify_skipped?, collisions: [{ t_ms, a, b, volume_mm3 }], diagnostics }.

Parameters8

file	string	required	Path to a .kcad.ts script with an animationView({...}) record. Required (no inline { code } mode).
output_path	string	optional	MP4 output path; default <scriptDir>/<basename>-animation.mp4. Mutually exclusive with frames_dir.
frames_dir	string	optional	PNG-sequence mode directory: write frame-0000.png... and skip ffmpeg. Mutually exclusive with output_path.
fps	number	optional	Override the animationView record's fps.
no_verify	boolean	optional	Skip the animation-pose interference verification (default: verify on).
verify_every	integer	optional	Additionally verify at every n-th frame time of the fps schedule (unioned with the keyframe sample set).
focus	array	optional	Show only matching feature ids / assembly part names in the rendered frames. Mutually exclusive with hide. Render-only; does not affect pose verification.
hide	array	optional	Hide matching feature ids / assembly part names in the rendered frames. Mutually exclusive with focus. Render-only; does not affect pose verification.

Raw schema

{
  "type": "object",
  "properties": {
    "file": {
      "type": "string",
      "description": "Path to a .kcad.ts script with an animationView({...}) record. Required (no inline { code } mode)."
    },
    "output_path": {
      "type": "string",
      "description": "MP4 output path; default <scriptDir>/<basename>-animation.mp4. Mutually exclusive with frames_dir."
    },
    "frames_dir": {
      "type": "string",
      "description": "PNG-sequence mode directory: write frame-0000.png... and skip ffmpeg. Mutually exclusive with output_path."
    },
    "fps": {
      "type": "number",
      "description": "Override the animationView record's fps."
    },
    "no_verify": {
      "type": "boolean",
      "description": "Skip the animation-pose interference verification (default: verify on).",
      "default": false
    },
    "verify_every": {
      "type": "integer",
      "minimum": 1,
      "description": "Additionally verify at every n-th frame time of the fps schedule (unioned with the keyframe sample set)."
    },
    "focus": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Show only matching feature ids / assembly part names in the rendered frames. Mutually exclusive with hide. Render-only; does not affect pose verification."
    },
    "hide": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Hide matching feature ids / assembly part names in the rendered frames. Mutually exclusive with focus. Render-only; does not affect pose verification."
    }
  },
  "required": [
    "file"
  ]
}

render_preview

Use this when you need to LOOK at a kernelCAD model — render its script to deterministic PNG views for visual self-check (the visual half of the evaluate → render → inspect → fix loop), with NO studio or dev server required. Pass { code } (inline source) or { file } (a .kcad.ts path), exactly one. Renders the canonical engineering views (front, right, top, iso — pass { views } for a subset, e.g. ["iso"] for fastest iteration) plus an optional { pose: "<az>,<el>" } arbitrary camera angle (degrees; az=0,el=0 is front, +az rotates CCW around +Z, +el lifts the camera). NO STUDIO / DEV-SERVER REQUIRED: a prebuilt static player (dist/headless-player) is served from an ephemeral local port automatically; a running studio dev server is used as fallback, and { base_url } forces one. The only environment dependency is playwright chromium (npx playwright install chromium). Pass { focus } or { hide } (arrays of feature ids or assembly part names, mutually exclusive) to isolate parts — same semantics as `kernelcad render --focus/--hide`. PNGs are written to { out_dir } (default: a fresh temp session directory) and returned as absolute paths with per-view camera descriptions (kernelCAD is Z-up). Mechanism truth runs first, same protocol as `kernelcad render`: a broken mechanism still renders but every tile is watermarked MECHANISM BROKEN (KERNELCAD_RENDER_STRICT=1 refuses instead); read { mechanism, mechanism_failure_codes }. The probe runs full BREP interference sweeps and can dominate latency on large assemblies — pass { no_mechanism_check: true } for fast iteration (the preview then reports mechanism: "unverified"; ignored under strict mode). Returns { ok, images: [{ name, path, description }], out_dir, bounds, mechanism, render_source, render_ms, diagnostics }. PATHS ARE LOCAL to the machine running the MCP server — local stdio clients read them directly; hosted/remote clients should use open_in_studio instead.

Parameters13

code	string	optional	Inline kernelCAD script source. Mutually exclusive with file. Relative imports resolve against a temp dir — use file for scripts with relative lib.fromSTEP(...) imports.
file	string	optional	Path to a .kcad.ts script on disk. Mutually exclusive with code.
views	array	optional	Canonical views to render as an array, e.g. ["iso"] or ["front","top"] (default: all four). Fewer views = faster.
pose	string	optional	Extra arbitrary camera pose '<az>,<el>' in degrees, e.g. '30,20'.
focus	array	optional	Show only matching feature ids / assembly part names. Mutually exclusive with hide.
hide	array	optional	Hide matching feature ids / assembly part names. Mutually exclusive with focus.
out_dir	string	optional	Directory for the PNGs (created if missing). Default: a fresh temp session dir.
width	integer	optional	Per-view tile width in px (default 768).
height	integer	optional	Per-view tile height in px (default 768).
environment	string	optional	HDRI environment override: preset ('studio', 'softbox', 'neutral', 'outdoor', 'warehouse'), a URL, or 'none' for the default three-light rig.
no_watermark	boolean	optional	Suppress the kernelCAD version watermark.
no_mechanism_check	boolean	optional	Skip the mechanism-truth probe for fast iteration on large assemblies; the preview reports mechanism: 'unverified'. Ignored under KERNELCAD_RENDER_STRICT=1.
base_url	string	optional	Advanced: force a specific render server (e.g. a running studio dev server) instead of the bundled static player.

Raw schema

{
  "type": "object",
  "properties": {
    "code": {
      "type": "string",
      "description": "Inline kernelCAD script source. Mutually exclusive with file. Relative imports resolve against a temp dir — use file for scripts with relative lib.fromSTEP(...) imports."
    },
    "file": {
      "type": "string",
      "description": "Path to a .kcad.ts script on disk. Mutually exclusive with code."
    },
    "views": {
      "type": "array",
      "items": {
        "type": "string",
        "enum": [
          "front",
          "right",
          "top",
          "iso"
        ]
      },
      "description": "Canonical views to render as an array, e.g. [\"iso\"] or [\"front\",\"top\"] (default: all four). Fewer views = faster."
    },
    "pose": {
      "type": "string",
      "description": "Extra arbitrary camera pose '<az>,<el>' in degrees, e.g. '30,20'."
    },
    "focus": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Show only matching feature ids / assembly part names. Mutually exclusive with hide."
    },
    "hide": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Hide matching feature ids / assembly part names. Mutually exclusive with focus."
    },
    "out_dir": {
      "type": "string",
      "description": "Directory for the PNGs (created if missing). Default: a fresh temp session dir."
    },
    "width": {
      "type": "integer",
      "minimum": 64,
      "maximum": 2048,
      "description": "Per-view tile width in px (default 768)."
    },
    "height": {
      "type": "integer",
      "minimum": 64,
      "maximum": 2048,
      "description": "Per-view tile height in px (default 768)."
    },
    "environment": {
      "type": "string",
      "description": "HDRI environment override: preset ('studio', 'softbox', 'neutral', 'outdoor', 'warehouse'), a URL, or 'none' for the default three-light rig."
    },
    "no_watermark": {
      "type": "boolean",
      "description": "Suppress the kernelCAD version watermark.",
      "default": false
    },
    "no_mechanism_check": {
      "type": "boolean",
      "description": "Skip the mechanism-truth probe for fast iteration on large assemblies; the preview reports mechanism: 'unverified'. Ignored under KERNELCAD_RENDER_STRICT=1.",
      "default": false
    },
    "base_url": {
      "type": "string",
      "description": "Advanced: force a specific render server (e.g. a running studio dev server) instead of the bundled static player."
    }
  }
}

README.md6 KBView on GitHub

kernelCAD - CAD runtime for agents

kernelCAD turns mechanical intent into editable .kcad.ts source, deterministic review evidence, and exportable manufacturing artifacts.

The core loop is source-first: design brief -> editable .kcad.ts -> evaluated model -> deterministic validation -> guided revision -> export package.

kernelCAD is not trying to be a browser clone of Fusion, Onshape, or SolidWorks. Replicad/OpenCASCADE are the kernel layer. kernelCAD is the agent-first workflow layer above the kernel: deterministic CAD source, feature history, diagnostics, validation, variants, and human review.

Philosophy

Agent-First: The primary interface is .kcad.ts, CLI, and MCP. The UI reviews and steers generated designs.
Editable Source: Geometry is deterministic source code with explicit feature history, params, assemblies, and diagnostics.
Validation-Centered: Useful CAD output needs deterministic review for constraints, hardware fit, clearances, and exportability.
Workflow Over Primitives: Product progress is measured by intent-level workflows, not by copying every traditional CAD button.

Agent workflow

For agents and contributors, .kcad.ts source is the design source of truth. Rendered PNG/MP4 files, STEP/STL exports, score JSON, and capture-run metadata are generated evidence or deliverables. Prompt briefs, source files, and provenance metadata remain source. Change source first, regenerate explicit targets, and avoid broad artifact refreshes unless you are intentionally rebuilding a demo or release bundle.

Use deterministic checks before visual judgment:

bash

kernelcad evaluate model.kcad.ts
# then run review_cad from an MCP client connected through `kernelcad mcp`
kernelcad export step model.kcad.ts -o model.step
kernelcad export stl model.kcad.ts -o model.stl

When a rendered artifact is produced, inspect the image/video itself and report what is visible: proportions, interfaces, floating geometry, occlusion, camera framing, and whether required features are legible. Passing tests are not a substitute for visual evidence.

When visual evidence matters, keep a deterministic inspection bundle:

bash

kernelcad render inspect model.kcad.ts model.inspect

The v1 bundle writes a manifest and canonical RGB views. It can also emit machine-readable mask, depth, and normals channels:

bash

kernelcad render inspect model.kcad.ts model.inspect --channels rgb,mask,depth,normals

Use --focus <names> or --hide <names> when a specific feature id or assembly part needs isolated review. Keep richer channels in the same manifest packet; do not replace the canonical RGB views.

For real hardware, prefer catalog/vendor geometry via lib.fromSTEP(...) instead of fake placeholder boxes or cylinders. This keeps mounts, clearances, and mechanism checks tied to physical components.

Features

Headless Core: Run CAD operations in Node.js or Web Workers without a DOM.
Agent API: kernelCAD APIs for params, assemblies, NURBS, SDF bodies, sheet metal workflows, introspection, and feedback loops.
Review Cockpit: Browser-based 3D preview for inspecting generated designs and validation results.
Standard Exports: STEP/STL generation.
Robust Kernel: Built on OpenCASCADE, with Replicad kept as a kernel implementation detail where it is still used.

Get Started

bash

npm install -g kernelcad

Drop this in bracket.kcad.ts:

typescript

const w = param('Width', 60, { unit: 'mm' });
const h = param('Height', 40, { unit: 'mm' });
const t = param('Thickness', 5, { unit: 'mm' });

const base = box(w, h, t);
const hole = cylinder(t + 2, 4).translate(w / 2, h / 2, -1);
return base.subtract(hole).fillet(1);

Run it:

bash

kernelcad evaluate bracket.kcad.ts
kernelcad export stl bracket.kcad.ts -o bracket.stl

That's it. For agents: kernelcad mcp runs an MCP server with dynamic model introspection tools. See SKILL.md (bundled with the install) for the full API surface and authoring guide.

Use with Claude Desktop

kernelCAD runs as an MCP server, so Claude Desktop can drive it locally. After npm install -g kernelcad, add an entry to your Claude Desktop config file:

macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Windows: %APPDATA%\Claude\claude_desktop_config.json
Linux: ~/.config/Claude/claude_desktop_config.json

json

{
  "mcpServers": {
    "kernelcad": {
      "command": "npx",
      "args": ["-y", "kernelcad", "mcp"]
    }
  }
}

Restart Claude Desktop. The kernelCAD MCP tools (review_cad, model introspection, export helpers, etc.) appear in the tools list.

For prompt-driven authoring against the hosted gateway, sign in at app.kernelcad.com/connect and use the generated kernelcad mcp --cloud --token <…> snippet. The hosted surface adds generate_kcad_from_prompt (turn a natural-language brief into a .kcad.ts source) on top of the introspection and review tools, and serves the kernelcad-authoring skill as an MCP resource so Claude Desktop loads it automatically on connect. Free tier: 3 LLM-generated parts per month; introspection and review tools are unlimited.

A one-shot kernelcad install --claude-desktop command that edits this config for you is on the next slice — until then the snippet above is the interim path.

Contributing

Web app + dev workflow (clone the repo, npm install, npm run dev) for contributors who want to hack on the kernel or the visual debugger:

bash

git clone https://github.com/w1ne/kernelCAD-web.git
cd kernelCAD-web
npm install
npm run dev          # web visual debugger at localhost:5173
npm run build:cli    # build the CLI bundle into dist/cli/
npm run test         # full vitest suite
npm run qc           # quick quality gate (lint + typecheck + tests)

License

MIT — see LICENSE.

Install

Tools (45)

review_paint_peek_latestopen_in_studioget_projectget_project_revisionget_latest_renderget_model_meshlookup_authoring_skillmesh_summary

Add to VS Code Add to Cursor

claude_desktop_config.json

json

{
  "mcpServers": {
    "kernelcad": {
      "command": "npx",
      "args": [
        "-y",
        "kernelcad@0.11.2"
      ]
    }
  }
}

kernelCAD MCP Server (com.kernelcad/kernelcad)

🛠️ Key Features

🚀 Use Cases

⚡ Developer Benefits

⚠️ Limitations

Topics

review_paint_peek_latest

open_in_studio

get_project

get_project_revision

get_latest_render

get_model_mesh

lookup_authoring_skill

mesh_summary

evaluate_script

diff_scripts

inspect

verify

why_did_this_fail

set_param

add_feature

add_surface

add_curve

add_path_segment

trace_from_image

add_variable_sweep

add_text

project_curve

add_pattern_feature

remove_feature

query

lookup_api

lookup_diagnostics

export

lookup_cookbook

find_part

fetch_part

solve_sketch

add_constraint

add_part

add_connector

add_mate

add_workspace_target

set_scene_return

solve_mates

review_cad

design_loop

flatten_pattern

evaluate_sdf

capture_animation

render_preview

kernelCAD - CAD runtime for agents

Philosophy

Agent workflow

Features

Get Started

Use with Claude Desktop

Contributing

License

Install

Related servers