Skip to main content
Glama
fusion-cad-mcp

fusion-cad-mcp

by Mfrostbutter

fusion-cad-mcp

An MCP server that gives Autodesk Fusion a named, typed tool surface: create_sketch, extrude, add_hole, create_joint, export, and 70 more.

Fusion ships its own MCP server, but it exposes four broad tools that take raw Python. That works, and it means every call is an opportunity to get the Fusion API wrong. This sits in front of it and turns the common operations into validated tools with structured errors, so an agent can do CAD without carrying a large prose skill in context.

Status: beta (0.2.x). 75 tools, 467 tests, and a full pass of live verification against Fusion 2704.1.23 that found and fixed 17 bugs. Used in production for parametric part design.

Requirements

  • Autodesk Fusion, running, with a design open

  • Preferences > General > API > Fusion MCP Server enabled

  • Python 3.11+

Related MCP server: Fusion MCP para Codex

Install

Not a developer? Start with AI-SETUP-PROMPT.md. Paste one prompt into Claude and it walks you through the whole thing, install to first extrude, and verifies it worked.

pip install "fusion-cad-mcp @ git+https://github.com/Mfrostbutter/fusion-cad-mcp.git"

Then point your MCP client at it. For Claude Code or Claude Desktop:

{
  "mcpServers": {
    "fusion": {
      "command": "fusion-cad-mcp"
    }
  }
}

See CONNECT.md for per-client details and troubleshooting.

How it works

MCP client (Claude, Cursor, Cline, ...)
  -> fusion-cad-mcp            this package, stdio MCP server
    -> httpx
      -> 127.0.0.1:27182/mcp   Fusion's own MCP
        -> adsk.fusion / adsk.core

Each tool generates a Python script and runs it through Fusion's execute. It is a peer of Autodesk's bridge, not a replacement, so anything you can do in the Fusion API you can still do here via the execute escape hatch.

The tools

75 registered, 74 usable. Full reference with signatures, enums, return keys, and error codes is in tools.md, or search it in place with the find_tool tool.

Group

Tools

Document and state

doc_state, list_open_docs, list_projects, search_docs, open_doc, save, save_as, close, undo, redo

Parameters

add_parameters, update_parameter, list_parameters

Sketch

create_sketch, add_line, add_rectangle, add_circle, add_arc, add_ellipse, add_spline, add_polygon, add_geometric_constraint, add_dimension, assert_profiles, probe_sketch_dimensions, edit_sketch_dimension

Construction

create_construction_plane, create_construction_axis, create_construction_point, delete_construction

Features

extrude, revolve, combine, shell, add_hole, fillet_edges_by_geometry, chamfer_edges_by_geometry, mirror_feature, pattern_rectangular, pattern_circular, move_body, rebuild_feature

Assembly and joints

bodies_to_components, move_component, ground_component, unground_component, create_rigid_group, create_contact_set, interference_check, create_joint, set_joint_limits, drive_joint

Handles and measurement

list_body_entities, measure, fillet_edges, chamfer_edges, project_to_sketch, find_mesh_using_ray, ray_collision_with_mesh

Verify and visualize

bounding_box, volume, mass, center_of_mass, audit_feature_health, screenshot, set_view, screenshot_compare_with_marker

Import, export, knowledge

export, import_geometry, find_tool, find_gotcha, find_pattern, find_api

Escape hatch

execute

rib is registered but always returns rib_not_scriptable: Fusion exposes RibFeatures as a read-only collection, so ribs cannot be created through the API at all. Model one as a thin join-extrude instead.

Every tool returns the same envelope

{
  "ok": bool,
  "message": str,          # stdout from the generated script
  "result": dict | None,   # the payload
  "image": dict | None,    # base64 PNG, for screenshots
  "error": str | None,     # error code when ok is False
  "traceback": str | None
}

ok: true does not always mean the thing happened. Fusion has several operations that decline silently, and the tools surface that rather than hiding it:

  • drive_joint returns applied: false when a drive past a joint limit was ignored

  • move_component returns moved: false when a joint solver overrode the move

  • export returns bytes_written: 0 when nothing was written

  • doc_state returns active_design: false when no design is open

  • doc_state on a direct (non-parametric) design reports design_type: "direct", leaves parameters_count / timeline_count as null, and lists them in unavailable; every other field, features_count included, is reported normally

Read result, not just ok.

The knowledge tools

Four tools answer questions without touching Fusion, so they work with it closed:

Tool

Searches

find_tool

this server's tool reference

find_gotcha

a catalog of Fusion API failure modes

find_pattern

reusable Python recipes for execute

find_api

Autodesk's Fusion API help

The first three ship with the package. find_api needs a local copy of Autodesk's help, which is their content and is not redistributed, so you build your own once:

pip install "fusion-cad-mcp[corpus] @ git+https://github.com/Mfrostbutter/fusion-cad-mcp.git"
fusion-cad-mcp corpus build --i-accept-autodesk-terms

That crawls at 1 request/second into ~/.fusion-cad/corpus/, which is where the server looks first. Set FUSION_CAD_CORPUS_DIR to keep it elsewhere. Everything else works without it.

The Claude skill

SKILL.md in this repo is the agent-facing companion to the server: which tool to reach for, the six rules that prevent most failures, and how to fall back to raw scripts. It reads alongside the same tools.md, patterns.md and gotchas.md the knowledge tools search, so there is one copy of each.

Install it into a Claude skills directory:

python install_skill.py

That writes ~/.claude/skills/fusion-cad/. Use --skills-dir for another location, --name for another folder name, and --overlay DIR to copy your own markdown over the base, which is how a private variant adds house conventions without forking the skill.

Development

pip install -e ".[dev]"
pytest              # 474 tests, no Fusion required

The tests cover script generation, envelope parsing, argument validation, and packaging integrity. They deliberately do not need Fusion running, which is also their limit: passing tests prove the generated Python is valid, not that Fusion accepts it. Several of the bugs found in this project passed every unit test and only surfaced against a live document, so verify behavioral changes in Fusion and check entity counts rather than trusting a success envelope.

One test guards a bug class worth knowing about: json.dumps(None) emits null, which is not valid Python, and ast.parse cannot catch it because null is a legal identifier. Generated code must embed Python values with repr().

License

MIT. See LICENSE.

Available Tools

75 tools
add_arcB

Add an arc. kind in {3pt, center_start_end, center_start_sweep}. 3pt: p1, p2, p3. center_start_end: center, start, end. center_start_sweep: center, start, sweep_radians (positive = CCW).

Inputs: kind (required), sketch (required), p1, p2, +5 more.

add_circleA

Add a circle. kind=center_radius needs center+radius_mm. kind=3pt needs p1+p2+p3. Returns circle_index for later reference.

Inputs: kind (required), sketch (required), p1, p2, +3 more.

add_dimensionA

Add a dimension with an expression. kind in {distance_h, distance_v, distance, angle, radial, diameter}. Parameter-name expressions ('body_width', 'length / 2') work AND propagate when the param changes (gotchas.md G9, verified 2026-05-31). Use literal mm only when you want a baked value.

entities depends on kind: distance_h / distance_v / distance: 2 point refs (e.g. ['line:0:start', 'line:0:end']) angle: 2 line refs radial / diameter: 1 circle or arc ref

Inputs: kind (required), sketch (required), entities (required), expression (required), +1 more.

add_ellipseA

Add an ellipse defined by center + major-axis endpoint + minor-axis endpoint. All in mm.

Inputs: center (required), sketch (required), major_axis_end (required), minor_axis_end (required).

add_geometric_constraintB

Apply a geometric constraint. kind in {horizontal, vertical, parallel, perpendicular, coincident, tangent, equal, concentric, fix, midpoint, symmetric}. entities is a list of entity refs like 'line:0', 'line:0:start', 'circle:1:center', or 'origin'.

Inputs: kind (required), sketch (required), entities (required).

add_holeA

Add a hole on the body's top face (max-Z, +Z normal). kind: simple | counterbore (needs cbore_diameter + cbore_depth) | countersink (needs csink_diameter + csink_angle). position_mm: [x, y, z] — x/y locate on the top face; z is informational. extent_kind: all | distance (needs depth_expression).

Inputs: body (required), diameter (required), position_mm (required), kind, +7 more.

add_lineA

Add a single line to a sketch. p1, p2 are [x, y] in mm.

Inputs: p1 (required), p2 (required), sketch (required).

add_parametersA

Add user parameters idempotently. Existing names are skipped, not overwritten.

Each def: {name, expression, units?, comment?}. Reserved math names (sin/cos/pi/e/sqrt/etc) are rejected at validation time because Fusion will silently bind expressions to the math function.

Inputs: defs (required).

add_polygonB

Add a regular polygon. sides >= 3. Inscribed (default) means vertices lie on the radius.

Inputs: sides (required), center (required), sketch (required), vertex (required), +1 more.

add_rectangleA

Add a rectangle to a sketch. kind in {center, corner, 3pt}. Returns line_indices for the 4 edges. center: p1=center point, p2=corner. corner: p1, p2 are opposite corners. 3pt: p1, p2 define one edge, p3 sets the other edge direction.

Inputs: p1 (required), p2 (required), kind (required), sketch (required), +1 more.

add_splineB

Add a fitted spline through a list of [x, y] points (mm). Optionally closed.

Inputs: points (required), sketch (required), closed.

assert_profilesA

Check that the sketch has the expected number of closed profiles. Returns ok=False if not. Use after building a sketch to catch self-intersecting polygons (which return profiles=2 silently).

Inputs: sketch (required), expected (required).

audit_feature_healthA

Sweep the feature tree (root + every sub-component) and report features whose healthState != 0.

Call this after ANY tool that edits sketch geometry, user parameters, or features. If summary.failed > 0 (state 2 or 3) or summary.warning > 0 (state 1), the BREP may look healthy via the API while Fusion's UI shows a stale cached display. See gotchas G10/G11.

Args: component_name: Restrict the audit to features in this component (still recurses into its sub-components). Default: root + all. include_healthy: Include healthy features (state 0) in the features list. Default False — only broken features are returned.

Returns envelope.result = { ok, summary: {total, healthy, warning, failed}, features: [{path, component, name, classType, healthState, healthLabel, isSuppressed, errorOrWarningMessage}, ...] }

Inputs: component_name, include_healthy.

bodies_to_componentsA

Convert root-level bodies into named components, preserving world position. mapping is {body_name: new_component_name}. Multi-body designs need this before joint/motion work — Fusion's joints operate on components, not bodies.

Inputs: mapping (required).

bounding_boxA

Return mm bbox + extents for a body (by name) or all bodies if name omitted. Walks root + every occurrence.

Inputs: body_name.

center_of_massA

Return center of mass in mm world coordinates for a body or all bodies.

Inputs: body_name.

chamfer_edgesC

Chamfer specific edges by handle. kind: equal | two_dist (needs distance2) | dist_angle (needs angle).

Inputs: distance (required), edge_handles (required), kind, name, +2 more.

chamfer_edges_by_geometryC

Chamfer edges of a body by geometric filter. kind: equal (one distance) | two_dist (needs distance2) | dist_angle (needs angle).

Inputs: body (required), distance (required), kind, name, +4 more.

closeA

Close the active document. confirm must be 'save', 'discard', or 'prompt'. Never auto-pick save vs discard for dirty docs; surface the choice to the user.

Inputs: confirm.

combineC

Boolean combine. operation: join | cut | intersect. keep_tools: preserve tool bodies after op.

Inputs: target_body (required), tool_bodies (required), name, operation, +1 more.

create_construction_axisA

Create a construction axis. kind in {2_points, normal_to_face_by_geometry}. 2_points: p1, p2 each as [x, y, z] in mm normal_to_face_by_geometry: body name + face_normal [nx, ny, nz] (finds the face whose normal matches)

Inputs: kind (required), p1, p2, body, +2 more.

create_construction_planeA

Create a construction plane. kind in {offset, midplane, at_angle, 3_points}. offset: base_plane + offset expr (e.g. 'thickness') midplane: plane_a + plane_b (between two existing planes) at_angle: axis + base_plane + angle expr (e.g. '30 deg') 3_points: p1, p2, p3 each as [x, y, z] in mm Plane / axis names default to principals: 'xy', 'xz', 'yz' / 'x', 'y', 'z'.

Inputs: kind (required), p1, p2, p3, +7 more.

create_construction_pointA

Create a construction point at explicit [x, y, z] coordinates (mm).

Inputs: coords (required), name.

create_contact_setC

Create a contact set for physics / motion analysis between 2+ bodies.

Inputs: body_names (required).

create_jointA

Create a Joint between two entity-handle origins.

Joint origins are specified as entity handles (kind:path:token). Supported kinds: face (planar OR cylindrical/conical), edge (uses MiddleKeyPoint), vertex (uses Point), point (sketch point). Get handles from list_body_entities for face/edge/vertex, or use the sketch tools' returned handles for sketch points.

motion_type: one of rigid, revolute, slider, cylindrical, ball.

  • rigid: locks the two origins; no DOF

  • revolute: 1 DOF rotation about axis (use for hinges)

  • slider: 1 DOF translation along axis

  • cylindrical: rotation + translation along axis

  • ball: 3 DOF rotation (axis arg ignored; Fusion only accepts pitch=Z, yaw=X, which is what gets used)

axis: x | y | z, relative to the first joint geometry's local frame. For typical face-normal rotation (hinge pin coming out of the face) use z.

offset_mm: optional ValueInput expression for lateral offset between the two geometries. A snap hinge typically needs a few mm here to hold the gap between mating flanges. Preserved across user-param changes (unlike Move-based positioning).

angle_deg: optional initial angle (revolute / cylindrical).

name: optional joint name in the timeline.

Returns {ok, joint_name, joint_token, motion_type, axis, offset_mm, angle_deg}. Use joint_name for downstream drive_joint / set_joint_limits calls.

Errors:

  • handle_invalid: one of the geometry handles could not be resolved.

  • joint_geometry_failed: face/edge/vertex/point handle resolved but Fusion could not build a JointGeometry from it (e.g. degenerate face).

  • joints_add_failed: joint inputs were valid but Fusion refused the joint (usually means the two geometries are mateable only with a different motion type, or one geometry is in a frozen component).

Inputs: geometry_one (required), geometry_two (required), axis, name, +3 more.

create_rigid_groupA

Lock 2+ components together as a rigid group (they move as one).

Inputs: component_names (required), name.

create_sketchB

Create a new sketch on a principal plane. plane in {xy, xz, yz}. name must be unique.

Inputs: name (required), plane (required).

delete_constructionA

Delete a construction plane / axis / point by name.

Inputs: name (required).

doc_stateA

Summary of the active Fusion document: design_type (parametric/direct), bodies/sketches/features count, units, dirty flag, components, parameters, timeline. A direct design returns parameters_count and timeline_count as None, listed in result.unavailable.

Inputs: no named parameters.

drive_jointA

Drive an existing joint to a target value. value is an expression: angle for revolute, distance for slider, etc. Tries jointMotion attributes in order: rotation, slide, roll, pitch, yaw. Fusion silently ignores drives beyond the joint's limits; check applied in the response (false = the joint stayed where it was).

Inputs: value (required), joint_name (required).

edit_sketch_dimensionA

Change a sketch dimension's expression by parameter name (e.g. d278).

Triggers design.computeAll() before returning. After calling this, run audit_feature_health to check whether the edit broke any downstream features (very common for fillets when their target edges move; see G11).

On dim_not_found, the response includes the available dimensions in the sketch so the agent can correct course without another tool call.

Args: sketch: Sketch name (will search root + every sub-component). dim_name: Parameter name of the dimension (use probe_sketch_dimensions to find these). new_expression: New expression as a string. Can be a numeric literal ("20 mm"), a user param reference ("oval_x"), or an expression ("oval_x / 2 + 1 mm"). Units required if not a bare expression. component_name: Optional disambiguation when the sketch name exists in multiple components.

Inputs: sketch (required), dim_name (required), new_expression (required), component_name.

executeA

Raw Python passthrough. The script must define def run(_ctx): as entry point. Use print() for any data to return; stdout becomes the response message.

Inputs: script (required).

exportA

Export geometry to a file. format in {stl, 3mf, step, iges, obj, f3d, sat, smt}. path: absolute path (relative + '..' + Windows reserved names rejected). body: optional body name. If omitted, exports the whole root component. STEP/IGES/SAT/SMT/F3D always export the whole design (ignore body). refinement: low | medium | high — applies to STL and OBJ mesh quality. units: mm | cm | m | inch — STL/OBJ only.

Inputs: path (required), format (required), body, units, +1 more.

extrudeA

Extrude a sketch profile into a feature. operation: new_body | join | cut | intersect | new_component extent_kind: distance (needs expression) | symmetric (needs expression) | all_positive | all_negative direction: positive | negative (for distance kind) participants: body names to operate on (for cut/join/intersect) Returns feature_name + bodies_added.

Inputs: sketch (required), name, direction, operation, +5 more.

fillet_edgesB

Fillet specific edges by handle (UI-selection style). edge_handles: list from list_body_entities (kinds=['edge']). radius: expression like 'corner_r' or '8 mm'.

Inputs: radius (required), edge_handles (required), name, is_tangent_chain.

fillet_edges_by_geometryA

Fillet edges of a body by geometric filter (no UI selection needed). parallel_to: x | y | z | any — only edges parallel to that axis (or all). radius: expression like 'corner_r' or '8 mm'. min_length_mm: optional minimum edge length filter (skips tiny rounding edges).

Inputs: body (required), radius (required), name, parallel_to, +2 more.

find_apiA

Search the local Fusion API help corpus.

Returns top-N matches as {slug, title, namespace, kind, url, is_preview, introduced, snippet}. Use this BEFORE writing a script that touches an unfamiliar method or class.

Filters: kind: 'object' | 'member' | 'manual' | etc — restrict to one page type namespace: substring match on namespace (e.g. 'Fusion', 'CAM', 'core')

Inputs: query (required), kind, limit, namespace.

find_gotchaA

Search gotchas.md (known failure modes) by symptom or keyword.

Use when something behaves unexpectedly: check here for the documented cause

  • fix before debugging from scratch.

Inputs: query (required), limit.

find_mesh_using_rayA

NEW May 2026: cast a ray and return MeshBody objects intersected. origin_mm: ray origin [x, y, z] in mm. direction: ray direction [dx, dy, dz] (any magnitude; will be normalized by Fusion). component_name: optional component to scope the search; omit for whole root.

Inputs: direction (required), origin_mm (required), component_name.

find_patternA

Search patterns.md (verified Fusion MCP patterns and helpers) by intent.

Use when looking for the canonical idiom for a common operation (constrained rectangle, fillet by geometry, screenshot fit-view, etc).

Inputs: query (required), limit.

find_toolA

Search this server's own tool reference (tools.md) by intent or symptom.

Returns the matching sections: signatures, exact enum values, return keys, and error codes. Use this to look up how to call a tool instead of guessing at arguments, and to check what an error code means.

Works with Fusion closed.

Inputs: query (required), limit.

ground_componentA

Set the ground flag on an occurrence (lock its world position).

Inputs: name (required).

import_geometryA

Import geometry from a file into the active design. format in {step, iges, sat, smt, f3d}. path: absolute path to an existing file. Returns counts of bodies and occurrences added to the root component.

Inputs: path (required), format (required).

interference_checkA

Run an interference analysis on 2+ bodies or occurrences. Returns per-pair interference volume in mm^3. Empty pair list = no interference.

Inputs: entity_names (required).

list_body_entitiesA

Enumerate faces / edges / vertices of a body and return their handles. This is the bridge between name-addressing (bodies) and handle-addressing (sub-entities).

kinds: subset of [face, edge, vertex]. Defaults to all three. face_normal_filter: [nx, ny, nz] — only faces matching that normal (e.g. [0, 0, 1] for top). edge_parallel_to: x | y | z — only axis-parallel edges. min_edge_length_mm: filter out short edges (typical use: skip fillet runouts).

Returns face/edge/vertex lists, each with handle, index, and geometric info. Use the returned handles in measure, fillet_edges, chamfer_edges, project_to_sketch, etc.

Inputs: body (required), kinds, edge_parallel_to, face_normal_filter, +1 more.

list_open_docsA

List recently-open documents in Fusion.

Inputs: no named parameters.

list_parametersA

List all user parameters with resolved values, expressions, units, comments.

Inputs: no named parameters.

list_projectsA

List all projects (hubs / folders) the user can see.

Inputs: no named parameters.

massB

Return mass (kg), material name, density, and volume for a body or all bodies. Material is whatever the body has been assigned; uses Fusion's physical-properties calc.

Inputs: body_name.

measureA

Measure between two entities using their handles (from list_body_entities or tool returns). kind: distance (min distance + nearest points) | min_distance (value only) | angle.

Inputs: entity_a (required), entity_b (required), kind.

mirror_featureB

Mirror a feature or body across a plane. plane: xy | xz | yz | <construction_plane_name>.

Inputs: plane (required), feature_or_body (required), name.

move_bodyA

Move a body via a Move feature (parametric in the timeline). Provide translation_mm (mm) and/or rotation (axis + angle_deg).

Inputs: body (required), name, rotation_axis, translation_mm, +2 more.

move_componentA

Move an occurrence by translation (mm) and/or rotation (axis + angle deg). rotation_origin_mm defaults to [0, 0, 0] (world origin) if omitted. Breaks the occurrence's ground-to-parent flag if set (otherwise the move silently reverts). Check moved and after_translation_mm in the response; a joint solver can override the requested move.

Inputs: name (required), rotation_axis, translation_mm, rotation_angle_deg, +1 more.

open_docA

Open a document by name (fuzzy). Optional project scope.

Inputs: name (required), project.

pattern_circularB

Circular pattern around an axis. axis: x | y | z | <construction_axis_name>.

Inputs: feature_or_body (required), axis, name, count, +1 more.

pattern_rectangularB

Rectangular pattern. x_axis / y_axis: x | y | z | <construction_axis_name>. x_distance / y_distance: total-extent expressions like '40 mm' or '4 * pitch'.

Inputs: feature_or_body (required), name, x_axis, y_axis, +4 more.

probe_sketch_dimensionsA

Dump every dimension in a sketch with parameter name, expression, value, and entity-attachment coordinates.

Use this to identify which literal-named dim (e.g. d278) controls which geometric feature when sketches use baked-in numbers. Walks root + every sub-component to find the sketch; pass component_name for disambiguation when the same sketch name exists in multiple components.

Per-dim payload: dim_class, param_name, expression, value_mm, unit, entity_one, entity_two. Entity descriptors include point/start/end/center coords in mm so you can match dims to specific lines/circles/ellipses.

Inputs: sketch (required), component_name.

project_to_sketchA

Project entities (by handle) onto a named sketch. Useful for cut-extrudes that reference body geometry.

Inputs: sketch (required), entity_handles (required).

ray_collision_with_meshA

NEW May 2026: cast a ray against ONE MeshBody, return all intersection points. mesh_handle: handle of a mesh body (e.g. from find_mesh_using_ray or list_body_entities).

Inputs: direction (required), origin_mm (required), mesh_handle (required).

rebuild_featureA

Rebuild a feature whose downstream references are stale (G10) by capturing its inputs, deleting it, and re-creating from the current sketch.

Supported feature classes: ExtrudeFeature (DistanceExtent, ProfilePlaneStart or OffsetStart, 1 or N profiles in the same sketch). This is the most common G10 case — a feature that got healthState=1 (warning, using cached geometry) after a sketch geometry rewrite.

Returns structured not_supported_for_rebuild error for other feature classes (fillet, chamfer, hole, revolve, etc.) with a recommendation:

  • FilletFeature/ChamferFeature broken by upstream edits: SUPPRESS instead (gotcha G11; edge re-binding is design-specific geometric matching).

  • Others: delete + re-create via the appropriate add_* tool.

Profile matching: when the original sketch has more than one profile, picks the new profile whose area is closest to the captured original area. Falls back to profile[0] if no area was captured.

Failure mode warning: if delete succeeds but recreate fails (e.g., sketch name changed, multiple profiles spread across sketches), the response sets ok=false and includes a WARNING field instructing the agent to undo via Fusion's undo and try again manually.

Args: feature_name: Name of the feature to rebuild. Walks root + every sub-component. component_name: Optional hint for disambiguation.

Chain pattern: edit_sketch_dimension -> audit_feature_health -> for each broken extrude in features list, rebuild_feature -> audit_feature_health.

Inputs: feature_name (required), component_name.

redoB

Redo the last count undone actions.

Inputs: count.

revolveB

Revolve a sketch profile around an axis. axis: x | y | z | <construction_axis_name> extent_kind: full (360deg) | angle (needs angle expr) operation: new_body | join | cut | intersect | new_component

Inputs: sketch (required), axis, name, angle, +5 more.

ribA

NOT SCRIPTABLE in the current Fusion API: RibFeatures is a read-only collection (no createInput/add), so this always returns the structured error rib_not_scriptable. Model ribs as thin join-extrudes instead.

Inputs: sketch (required), thickness (required), name, side, +1 more.

saveA

Save the active document. Untitled docs are refused by Fusion; use save_as instead.

Inputs: no named parameters.

save_asA

Save the active document to a new path. Fusion's MCP may still require initial save via UI.

Inputs: path (required).

screenshotB

Capture a PNG screenshot of the active viewport. Returns base64 image in envelope.image. direction: one of current, front, back, bottom, top, left, right, iso-* (4 variants). Fusion handles fit-view internally for named directions.

Inputs: width, height, direction, transparent, +1 more.

screenshot_compare_with_markerA

Capture before/after screenshots from the same camera by rolling the timeline marker to before_marker_position, screenshotting, restoring the original marker position, and screenshotting again.

Use this to give yourself or the user a clean visual diff of a change you just made — much more convincing than describing the change in words when the geometric delta is subtle. Same camera both shots so the comparison is honest.

Restore semantics: if anything fails after the marker is moved, this tool attempts to roll back to the original position before returning. The restore_marker_failed error indicates the rollback itself failed — in that case the design may be left at an intermediate marker position and the user should manually drag the marker back.

Args: before_marker_position: Timeline marker position to capture as the "before" state. Must be in [0, timeline.count]. Use 0 for the initial empty state, or the index just before a specific feature. direction: One of: current, front, back, bottom, top, left, right, iso-bottom-left/right, iso-top-left/right. Defaults to iso-top-right. width, height: Optional image dimensions in pixels. transparent: PNG transparency. Default True. anti_aliasing: Smooth edges. Default True.

Returns envelope.result = { before_image: {data: , mime_type: "image/png"}, after_image: {data: , mime_type: "image/png"}, before_marker, after_marker, direction }

Inputs: before_marker_position (required), width, height, direction, +2 more.

search_docsB

Fuzzy-search documents by name. Optional project scope.

Inputs: query (required), project.

set_joint_limitsA

Set min/max/rest values on an existing joint by name. Values are expressions: angles for revolute (e.g. '45 deg'), distances for slider. rest_value is the NEW May 2026 snap-back position. Pass None to leave any field unset. Limits bind to rotationLimits when the motion has one, else slideLimits (cylindrical joints get rotation limits). The response echoes back what Fusion actually stored under applied (internal units: radians / cm).

Inputs: joint_name (required), max_value, min_value, rest_value.

set_viewA

Orient the viewport to a named direction. Optionally fit to view. Use when you want to change camera without capturing a screenshot.

Inputs: fit, direction.

shellA

Hollow out a body. face_normals_to_remove is a list of [nx, ny, nz] for faces to remove (e.g. [[0, 0, 1]] removes the top face). Empty / omitted = closed shell. direction: inside | outside | both.

Inputs: body (required), thickness (required), name, direction, +1 more.

undoA

Undo the last count actions. WARNING: undo is atomic on the prior execute call. Mixed-content scripts get fully wiped. Prefer delete-loop cleanup when possible.

Inputs: count.

unground_componentB

Clear the ground flag on an occurrence.

Inputs: name (required).

update_parameterA

Update one user parameter's expression. Returns before/after values.

Inputs: name (required), expression (required).

volumeA

Return volume in cm^3 and mm^3 for a body (by name) or all bodies if name omitted.

Inputs: body_name.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    B3.1/5.0

    Scored across 75 tools

    Disambiguation4/5

    The tool set is mostly distinct: sketch primitives, feature operations, joint tools, and inspection tools each have clear targets. The main ambiguity risk is the four find_* lookup tools and the handle-based vs geometry-based fillet/chamfer variants, but their descriptions disambiguate them. No two tools appear to do the same job.

    Naming Consistency3/5

    Naming is readable and consistently snake_case, but conventions are mixed: add_* for sketch primitives and parameters, create_* for sketches/joints/construction, bare verbs (extrude, shell, save, measure), and noun phrases (bounding_box, doc_state, center_of_mass). This inconsistency, especially add vs create, prevents a higher score.

    Tool Count1/5

    75 tools is far beyond the well-scoped 3-15 range and exceeds the 50+ extreme threshold. While Fusion CAD is a broad domain, the surface is too large for an agent to navigate efficiently and includes several auxiliary meta-tools (find_api, find_pattern, find_tool, find_gotcha, screenshot_compare_with_marker) that bloat the count.

    Completeness3/5

    Core modeling workflows are covered: sketching, constraints, dimensions, extrude/revolve/shell/hole, fillet/chamfer, patterns, joints, measurement, export/import, and parameters. However, there are notable gaps: no list_bodies/list_joints/list_sketches, no delete_body/delete_feature/delete_sketch (only delete_construction), no create_document, and no general feature editing. The raw execute passthrough mitigates these, but the dedicated surface is incomplete.

    Maintenance

    ActivityInactive
    ResponsivenessLimited data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      D
      maintenance
      Open-source MCP server for controlling Autodesk Fusion 360 from any AI agent, enabling 3D modeling operations via natural language.
      4
      MIT
    • F
      license
      Not graded
      quality
      D
      maintenance
      Enables AI assistants to inspect and automate Autodesk Fusion 360 through MCP, providing tools for CAD modeling, CAM manufacturing, and document management.
      -
    • F
      license
      Not graded
      quality
      C
      maintenance
      A remote MCP server exposing 36 Fusion 360 modeling tools over HTTPS, enabling secure remote control of Autodesk Fusion 360 with authentication, rate limiting, and audit logging.
      -
    • A
      license
      Not graded
      quality
      D
      maintenance
      An MCP server that gives AI agents genuine 3D spatial understanding of Autodesk Fusion 360, enabling exact measurements, collision analysis, and free-space placement search, plus Fusion-native parametric authoring for clean, human-editable models.
      MIT