kernelCAD
CAD in ChatGPT and Claude: editable parts, STEP/STL/drawings, in-chat 3D, automatic checks.
| Endpoint | https://mcp.kernelcad.com/mcp (streamable-http) |
|---|---|
| Registry version | 0.17.1 |
| Now | 71 tools · grade F (33) · pin ts_6dc5a7d33204091350128f9e1bc1e8ed · protocol 2025-06-18 |
| First / last listed | 2026-10-31 01:42 UTC / 2026-10-31 01:42 UTC |
| Grade over time | 2026-10-31: F (33), 71 tools |
Is this your server? Own a server? ToolFit hosted watch re-checks it every 24 h ($0.25 per 30 days) or 6 h ($0.60) and sends you an HMAC-signed webhook when its tools or grade change: POST https://api.youraitools.co/toolfit/v1/watch. To opt out, see About & opt-out.
Tools: review_paint_peek_latest open_in_studio get_project get_project_revision get_latest_render get_model_mesh request_upload 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 resolve_assumptions run_fea fea_summary send_to_printer repair_script sweep_tolerance diff_geometry drawing_to_cad mesh_to_features execute_cookbook get_selection set_selection import_step fab_pack dfm_review ray_pick inspect_nurbs fit_plane mesh_boolean explode_view apply_surface_blend write_bom blockout_assembly price_part order_part
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") desc params: slug, freshness_sec, paths_only |
open_in_studio | Save the model as a kernelCAD project AND show it: persists a project revision, returns the interactive Studio viewer (MCP Apps / ChatGPT outputTemplate), and includes a PNG preview in the SAME tool result (image content + previewUrl when available). ONE VIEWER PER PROJECT PER RESPONSE: every call renders a new viewer card. Do all validation with evaluate_script first, then call open_in_studio exa params: code, title, parameters, project, slug, new_project, continue_design, include_preview, likeness_profile, body_bbox, cabin_bbox, wheels, still_verdicts, require_stills, attachments, anon_token, intent |
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 ow params: slug |
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. params: slug*, version* |
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. Prefer open_in_studio for the happy path — it already includes an iso PNG preview in the same publish result when previewDelivered is true. Use this tool for a different `view`, a contact sheet (`view:"all"`), or when you only have a slug and are not publishing. Call with that `slug` to ins params: slug*, view, paths_only |
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. params: slug* |
request_upload | Use this when the user has a photo, PDF drawing, STEP, STL, DXF, SVG or 3MF file on their device and you need it in a kernelCAD tool (trace_from_image, drawing_to_cad, mesh_to_features, inspect of:"step", or lib.fromSTEP / fromSTL / fromDXF / fromSVG / referenceImage in a script). Do not ask the user to paste the file as text or base64, and do not type coordinates from an image by hand. Returns a params: purpose |
lookup_authoring_skill | Return the kernelcad-authoring skill — conventions for writing .kcad.ts scripts (API surface, parameters, evaluation contract, common pitfalls) — in sections.
Call with NO arguments first: you get the quick-start (units, axes, the return rule, the rules that prevent most failures, the intent → API routing table, the "Before you finish" checklist) and an index of every section with a one-line summ params: section, topic, query |
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 OCC params: source*, fileName, params |
evaluate_script | Use this when you need to run a script and check it compiles. Full local builds return viewerUrl: a live Studio link reused and updated on later full builds in the same MCP process. Hosted builds return viewerMode: hosted and viewerHint pointing to open_in_studio; they do not start a loopback viewer. Full evaluations return step evidence: build validity, volume and before/after local PNG paths in params: file, code, dryRun, kernel, skipMechanismCheck, baseline, requirements, intent |
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 interferenc params: baseFile, baseCode, file, code |
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: solid tree, exact bbox/volume, cylindrical holes (breached bores flagged parti params: of*, file, code, assembly, feature_id, density, gyration_axis, face_name, query, category, plane, at, axis, stack, edges, faces, spike_factor |
verify | Use this when you need to check a design against a rule set. One verifier, selected by `check`:
- 'assembly' — static assembly review ({ file | code }, or the session evaluate_script left): mate validator, default-pose interference, joint topology, mechanical plausibility. ok:false with `blocking[]` exactly when review_cad's blocking rules fire on these findings; review_cad also sweeps joint range params: check*, requirements, file, code, feature_id, tiny_face_area_mm2, tiny_face_relative, short_edge_length_mm, symmetry_tolerance_mm, mesh_deflection_mm, asserted_plane, assembly, min_radius_mm, max_radius_mm, require_edge_break, parts, edges, faces, fasteners, toleranceMm, angleToleranceDeg, urdf_path, dxf, featureId, vendor, material, thicknessIn, thicknessMm, service, refreshCatalog, directions, disassemblyOrder, sequence, threadedFasteners, stability, fixtures, contactToleranceMm, joint, range, collision_tolerance_mm3 |
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? }. params: file, code, feature_id |
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). With preview: true it builds the edit in a scratch session instead and returns the diff_geometry summary plus the requirements-ledger and S1 binding params: code*, param_name*, new_value*, preview |
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.faceLab params: code*, feature_code* |
add_surface | Use this when you need an organic, freeform, or swept shape — a body shell, panel, fairing, ergonomic curve, lens, or sculpted form — authored as a NURBS Surface into the user's .kcad.ts, OR when you need to finish surfaces into a watertight solid or taper faces for moldability. One authoring/finishing path, selected by `kind`:
- 'nurbs' — insert a nurbsSurface(...) / surfaceFromCurves(...) call. params: kind*, code*, controls, weights, degree, knots, periodic, section_sketch_ids, curve_bindings, continuity, sampling, binding_name, surface_binding, by_binding, op, surface_bindings, tolerance, require_closed, shape_binding, angle_deg, face, neutral_plane, pull_dir |
add_curve | Use this when you need a freeform/organic 3D curve — a body feature line, brow, spine rail, or G2 blend between panels — authored as a 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 knob params: kind*, code*, controlPoints, degree, weights, knots, closed, a, b, binding_name |
add_path_segment | Use this when you need a freeform/organic 2D outline — an eyewear brow, ergonomic grip, sneaker midsole, or body silhouette — by appending 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 th params: kind*, code*, chain_anchor*, points, tension, startTangent, endTangent, controlPoints, degree, weights, knots, a, b, binding_name |
trace_from_image | Use this when you need to trace a reference image into normalized 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` (vision model; named point params: imageUrl*, hint, features, maxWaypointsPerFeature, backend, scaleAnchor, priors, validate, intent |
add_variable_sweep | Use this when you need an organic swept solid whose cross-section changes along its length — a tapering body, horn, bottle, handle, ring band, fairing, or duct — authored as a variable-section sweep along a spine. Inserts `variableSweep(spine, sections, opts?)` into the .kcad.ts `code` immediately before the last top-level return (an empty `code` starts a new script that returns the sweep). Spine: params: code*, spine_points, spine_closed, spine_binding, sections*, closed, continuity, binding_name |
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 `tar params: mode*, code*, content, size, font, align, position, rotation, bindAs, target, textContent, depth, face, fontFamily, anchorU, anchorV, scaleMode |
project_curve | Use this when you need to wrap a 2D closed curve onto a 3D face. Insert a `<shape>.projectCurve({ source, face, scaleMode? })` chained call into a kernelCAD script. The `source` is the structured `{ kind: "sketchCommands", commands: [...] }` wire format the runtime API accepts. Wraps the curve onto the face along the face normal; pair with `.extrude(d)` / `.cut(...)` for raised or engraved logos o params: code*, target*, commands*, face*, scaleMode, asEdge, bindAs |
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 resolv params: code*, target*, kind*, linear, circular, grid, assign_to |
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. params: code*, match* |
query | Use this when you need to resolve or inspect topology against a script's lowered geometry. Pass the script as `code` (inline; works on a hosted server) or `file`. Selected by `mode` (default 'evaluate'):
- 'evaluate' — list the faces a Query matches ({ query }). Pass expect:'unique' to assert exactly-one.
- 'resolve' — resolve one ref to one face ({ ref }).
- 'lineage' — the creating/modifying his params: mode, file, code, query, ref, expect, feature_id |
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. params: intent |
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. params: none |
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 (2D cut file for laser / waterjet / CNC: a flat part — plate, panel, extruded profile, in any orientation — exp params: target*, file, code, output_path, format, feature_id, options, part, output_dir, no_verify, intent |
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 params: query, id, k, intent |
find_part | Search the bundled parts catalog (offline). For a NEMA-17 motor write `await lib.standard.nema17()`; for a 608 bearing write `await lib.standard.bearing608()`. Do not fan out parallel lookups and do not pass partsBaseUrl unless you set source:"remote". Remote lookups fail within 45s with errorCode parts.lookup.timeout instead of hanging. params: query, category, family, standard, tag, limit, source, partsBaseUrl, intent |
fetch_part | Fetch one bundled catalog part. Prefer `await lib.standard.nema17()` and `await lib.standard.bearing608()` — they are offline and do not download remote STEP. A lookup that cannot finish fails within 45s with errorCode parts.lookup.timeout. Do not retry in parallel. params: id, query, category, family, standard, partsBaseUrl, includeModel, model |
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. params: 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. params: constraints, 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. params: code*, assembly_binding*, part_name*, shape_expression*, binding_name, at |
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. params: code*, part_binding*, name*, type*, origin*, axis, normal |
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, d params: relation, code*, assembly_binding*, name, a, b, type, pose, limitsDeg, limitsMm, driven, source, ratio, offset, kind, sourceMate, drivenMates, actuator, input, output, path, notes |
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. params: code*, assembly_binding*, connector_ref*, reachable*, toleranceMm |
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. params: code*, assembly_binding*, mode*, poses, options |
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. params: assembly, poses |
review_cad | Run a deterministic mechanism-fitness review on supplied kernelCAD code or a file. It performs a full evaluation, replaces the active MCP session model on success, and clears that session if evaluation fails. The script may load referenced assets. The review validates the assembly/mate graph and connector placement, samples declared mate limits, optionally checks interference at sampled poses, and params: file, code, assembly, designGoal, preserveInterfaces, includePoseEnvelope, includeInterference, requirePhysicalUseCase, physicalUseCaseLevel, physicalUseCaseSamplesPerMate, samplesPerMate, combinatorial, epsilonMm3, timeBudgetMs, trackConnectors |
design_loop | Use this when the goal is complex / production / enclosure / gearbox / robot-arm / multi-body, or when you need evaluate→review/verify→revise until green. PREFERRED over one-shot evaluate_script+open_in_studio for Adam-level parts. Runs a CAD design loop over attempt scripts: review_cad each attempt, continue past functional attempts with unresolved warnings, return repair prompts (nextActionPromp params: goal*, attempts*, assembly, preserveInterfaces, includePoseEnvelope, includeInterference, samplesPerMate, combinatorial, epsilonMm3, trackConnectors, stopOnPass, consensus, autoRevise, requireVisualReview, requirePhysicalAcceptance, allowReviewWarnings, requirements, outputRecordPath, recordTitle |
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). Any number of parallel bends; crossing bends need corner relief. Pass { file } or { code }; optional { featureId } to pick a specific Shape. params: file, code, featureId |
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 t params: file, code, fieldName*, point* |
capture_animation | Use this when you need to render a script's animation timeline to a video, or a 360° turntable of a model for sharing. 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 params: file*, output_path, frames_dir, fps, no_verify, verify_every, focus, hide, turntable, preset, width, height, duration_ms, elevation_deg, background, shadow, environment |
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. [ params: code, file, views, sheet, pose, focus, hide, out_dir, width, height, environment, shading, screenshot_timeout_ms, no_watermark, no_mechanism_check, base_url, section, explode, overlay, preset, background, shadow, intent |
resolve_assumptions | Use this when you need to confirm or override the open facts in an assumption ledger from trace_from_image (missing scale, inferred/assumed values) before committing geometry built from a reference photo. Reads the persisted `<model>.ledger.json` at `ledgerPath`, applies each resolution — `{ id, confirm: true }` to accept a fact as-is, or `{ id, value }` to override it — rewrites the ledger file, params: ledgerPath*, resolutions* |
run_fea | Use this when you need to know whether a part will hold a load. Runs a linear-static structural study and returns evidence — peak von Mises stress (MPa), peak displacement (mm), the minimum safety factor against the material yield (taken away from the clamp-singular edges of the fixed faces; the raw clamp-edge peak is reported separately as peakAtSupportMPa), per-region hot spots named by @kc[...] params: file, code, study, material, fixed, loads, min_safety_factor, solver, output_dir, mesh_size, heatmaps, refine, mesh_timeout_ms, solve_timeout_ms |
fea_summary | Use this when you need a structural check's context without paying for a solve. Read-only: returns the stored summary of a previous run_fea (pass the same `output_dir`), whether the CalculiX + gmsh toolchain is available on this machine (with the install command when it is not; run_fea then uses its in-process voxel solver — toolchain.default_solver says which), and the FEA material table with rea params: output_dir |
send_to_printer | Use this when you need to upload a .gcode file (e.g. written by export with target: "model", format: "gcode") to a real network printer and, by default, start the print. protocol: 'octoprint' (POST /api/files/local with an X-Api-Key), 'moonraker' (Klipper's POST /server/files/upload), or 'bambu-lan' (Bambu Lab LAN-mode: FTPS implicit-TLS upload on port 990 as user 'bblp' with the printer's LAN acc params: gcode_path*, protocol*, host*, port, api_key, access_code, serial, model_3mf_path, printer, filename, start_print, dry_run |
repair_script | Use this when evaluate_script reported an error and you want the fix applied rather than described. Takes the candidates why_did_this_fail derives for a diagnostic, applies them one at a time, re-evaluates after each, and keeps the first that clears the diagnostic without introducing new errors. Never edits outside the repair region (failing feature statement + its input statements + the param() l params: file, code, diagnostic, strategy, max_attempts, intent |
sweep_tolerance | Use this when you need to know where and why a design breaks across a tolerance/dimension range, not just whether it builds at one nominal value. Declares one or more param() names with a { values: [...] } list or a { min, max, steps } range (number params are bisected; choice/string params are evaluated as discrete points), re-evaluates the script once per cartesian-product combination (capped at params: file, code, assembly, params*, gates, boundaryTolerance, boundaryBudget |
diff_geometry | Use this when you need to know WHAT MATERIAL changed between two versions of a model, not just how much. The deeper sibling of diff_scripts: a volume delta alone is ambiguous (a boss that grew and a pocket that deepened report the same magnitude, and a part that only moved reports zero), so this tool answers it with geometry instead of pixels. Baseline is { baseFile } or { baseCode }; the revised params: baseFile, baseCode, file, code, params, render, out_dir |
drawing_to_cad | Use this when the reference for a part is a 2D engineering drawing PDF (orthographic views with dimensions), not a photo. Deterministic, no vision model: reads the vector linework (stroke width, dash) and positioned text; classifies visible / hidden / center / dimension / extension lines; reads the title block scale, units and projection symbol; identifies front / top / side views by projection al params: path, pdfBase64, page, projection, out, verify, intent |
mesh_to_features | Use this when you are handed an STL, OBJ or 3MF of a mostly prismatic mechanical part (plate, bracket, spacer, flange, housing block) and need an EDITABLE kernelCAD model of it rather than a faceted lib.fromSTL import. Deterministic, measured, self-verifying: it welds and checks the mesh, segments planes and cylinders, picks the extrusion axis, slices each band and fits exact lines / arcs / circle params: file, data, format, out, minIoU, maxDeviationMm, maxPasses, weldToleranceMm, maxTriangles |
execute_cookbook | Use this when you need evaluate_script (and optionally open_in_studio) for an industry / cookbook demo in ONE step — after lookup_cookbook for industry demos, prefer execute_cookbook when you need evaluate+Studio together; empty lookup is not a stop (freehand-author instead). Resolves a cookbook snippet by `id` or BM25 `query` (same ranking as lookup_cookbook), evaluates its body via evaluate_scri params: id, query, openInStudio, kernel, dryRun, intent, project, new_project, continue_design |
get_selection | Use this when you need to read the human/agent selection in a local Studio session. Returns one clicked face or edge (or null), with current-generation mesh-local shapeIndex/kind/id and creating featureId. During a rebuild selection is null with “selection pending rebuild” until Studio uniquely verifies the face; ambiguous or deleted faces are cleared. Inspect the current shape before authoring a params: studio_url*, session* |
set_selection | Use this when you need to replace the shared local Studio face/edge selection, or clear it with selection:null. The viewer highlights the pick on its next sync (300 ms). Does not edit geometry. Pass model_generation from get_selection; writes from an older generation are rejected. Use only current shape indices. Requires a local Studio session. params: studio_url*, session*, model_generation*, selection* |
import_step | Use this when the user wants to start from their own STEP or STL file (a part they designed elsewhere, a vendor model). Give exactly one source: url (a public https direct-download link), upload (a file the user attached in ChatGPT), or content_base64 (raw bytes, small files only). Max 50 MB. The format is detected from the bytes (or pass format: 'step' | 'stl'). Writes the file and a starter <nam params: url, upload, content_base64, file_name, format, output_dir, name, allow_open |
fab_pack | Use this when the user wants to get a part made: packages the fabrication files into one directory plus a zip, and returns links to public instant-quote pages. Pass { file | code } and output_dir; optional scope ('part', default — one script's files; 'bom' — the whole assembly's BOM: per-part single-body files, per-part drawings, bom.csv/json and vendor handoff texts), name (default 'part'), forma params: scope, file, code, output_dir*, name, formats, processes |
dfm_review | Use this when you need a manufacturability (DFM) report before printing or machining a part: returns a pass/fail checklist, no dfmSpec(...) needed. Pass { file | code } and optional processes (default ['fdm', 'cnc']). FDM 3D printing checks: fdm.overhangs (unsupported overhang steeper than max_overhang_deg, default 45° from vertical), fdm.bridging (bridges over max_bridge_mm, default 10), fdm.min- params: file, code, processes, nozzle_mm, max_overhang_deg, max_bridge_mm, printer, build_direction, tool_diameter_mm, approach_axes, max_undercut_area_mm2 |
ray_pick | Use this when you need the faces a ray hits in a local Studio model, nearest first, with points, distances, and normals. Inputs are model units (mm); direction is normalized. Requires the local Studio URL and session token for the same script, reads the current model generation, and returns a set_selection argument object with every hit. feature_id must identify a displayed terminal shape; interme params: file, code, feature_id, studio_url*, session*, origin*, direction* |
inspect_nurbs | Evaluate supplied kernelCAD code or a file to capture an authored NURBS curve (nurbsCurve/spline3d). Returns degree, distinct knots and multiplicities, poles, weights, rational and uniformWeights flags, hasNonUnitWeights, and parameter range. Defaults to the last captured curve in that script; pass feature_id to choose one. The source may load referenced assets. Reports authored curve data, not ex params: file, code, feature_id |
fit_plane | Use this when you need to fit an orthogonal least-squares plane to XYZ point-cloud data. Returns centroid, deterministic unit normal, signed point residuals, RMS residual and maximum absolute residual. Accepts points already parsed by the caller from scan data or mesh vertices. Computes parameters only; it does not create a surface body. Requires at least three non-collinear finite points. params: points* |
mesh_boolean | Use this when the user wants to union, subtract, or intersect two imported triangle mesh solids (STL, OBJ, or 3MF). Supports union, subtract (A minus B) and intersect. Pass each operand as { file } on the MCP server or { data } with base64 mesh bytes; formats are detected or may be specified. Returns volume in mm³, triangle count and a binary STL as data_base64; pass that payload to import_step to params: operation*, a*, b*, toleranceMm, maxTriangles |
explode_view | Use this when you need an ordered exploded-view plan for an assembly. Supply parts as {name,center:[x,y,z],size:[x,y,z]} in mm. Optional assembly_order sets the sequence; missing order falls back to input part order, and unlisted/unknown order refs are reported. Choose mode axis (default) or radial; axis follows the requested direction, radial moves parts away from the assembly centroid. The resul params: parts, assembly_order, mode, axis, spacing, duration_ms |
apply_surface_blend | Use this when you need to author and evaluate a fillet or chamfer on a kernelCAD Shape. Inserts Shape.fillet(radius, selector, { continuity: G1|G2 }) or Shape.chamfer(distance, selector) through the existing public API and returns the patched source plus evaluation diagnostics. Selectors accept EdgeSelector syntax, including canonical edge refs/query strings or { face: canonical name, face label, params: code*, shape_binding*, operation, radius, distance, selector, continuity |
write_bom | Use this to merge a supplied handoff BOM with optional KernelCAD catalog parts, MPNs and pricing, write a local CSV, and return Sheets-ready rows. Pass exactly one of handoff, handoff_json or handoff_path. The default output is a new file under artifacts/bom; an explicit output_path selects another allowed destination. Existing files are preserved unless overwrite:true, which replaces the destinat params: handoff, handoff_json, handoff_path, catalog_parts, output_path, overwrite |
blockout_assembly | Use this when you have a list of parts with bounding boxes and positions (from a layout, spreadsheet, another tool or a sketch) and need an evaluable placeholder assembly script. Pass parts as { name, bboxMm:[x,y,z], positionMm:[x,y,z], rotationDeg?, anchors? } in mm; positionMm locates the bbox lower corner and anchors are named points in assembly coordinates. Optional connections [{ from, to }] params: name, parts*, connections |
price_part | Start or read the real price for making the part. Cheap. Returns status "ready" with estimate_cents and summary, or "pricing" while the makers are asked (call again in a few seconds). Creates nothing and charges nothing. params: slug, source, method |
order_part | Order the part made: creates the production request and returns a pay_url for the user. Propose the manufacturing method from the user's words and the part, pass it as method with a one-line reason. The price is the real maker price; never invent or send one. Tell the user the card is only held, and a person confirms the final price before charging. If the result is status "pricing", the price is params: slug, source, method |
Entries describe changes in tool definitions. They are not statements about a server, its quality or its author. The grade measures how the tool definitions fit model providers (token cost, schema compatibility, confusable names) as scored by the ToolFit engine at the time of the listing. JSON: append .json. Opt-out: how or hello@youraitools.co.