Skip to main content
Glama
inventor-mcp-server

inventor-mcp-server

inventor-mcp-server

PyPI CI License: MIT Contributions welcome

Maintained continuation of NeonGlay/inventor-mcp. The original repository has had no activity since its initial release (June 2026), and fresh installs there fail on MCP SDK 2.x. This repo carries the full original history plus the fixes and features that were submitted upstream as PRs and never reviewed. If the original author returns, everything here is available to be merged back. See CHANGELOG.md.

MCP server for parametric 3D modeling in Autodesk Inventor — drive Inventor with Claude (or any MCP client) in natural language.

Build real parametric parts — flanges, shafts, nuts, brackets, sheet-metal enclosures — by talking to an AI assistant. The server wraps Inventor's COM API with high-level, millimeter-based tools and ships with battle-tested knowledge of Inventor 2026 API quirks that aren't documented anywhere else.

You:    "Build a DIN 934 M16 hex nut with proper conical chamfers"
Claude: creates sketch → hexagon → extrude → tapped M16×2 hole →
        revolve-cut chamfers → done. Fully parametric, dimensioned sketches.

Features

  • 66 MCP tools: sketching, extrude/revolve, shell, loft, sweep, native hole features (drilled / tapped / counterbore), fillets, chamfers, circular and rectangular patterns, mirror, sheet metal (named rules / Face / auto-mitered Flanges / Cut at world coordinates / Corner Round, with Flat Pattern support), parameters

  • Assemblies with vendor parts: import_step (keeps the files in your project folder), placement with full orientation, check_interference / measure_distance, and sweep_rotation to check a door or lock moves freely through its whole range

  • Assemblies (IAM): place components, ground them, constrain by origin geometry (mate / flush / angle) or drop a bolt into a hole with a single Insert constraint

  • execute_python power tool — run arbitrary Python against the live COM connection with a persistent namespace (escape hatch for anything not covered by dedicated tools)

  • Auto-reporting — every feature operation returns a volume/topology delta (Hole1 | V 23497 (-503 mm³) | F7 E14), so the AI can self-verify each step

  • One tool per job — 66 tools with verb_noun names: find_faces / find_edges work in a part and at any depth of an assembly, constrain takes origin geometry, faces and edges, and manage_* tools group what you do to documents, occurrences, features, parameters, constraints, materials and sheet metal rules

  • Protects your files — save_document saves only the active document unless asked, never a library or Content Center file; add your own paths with INVENTOR_MCP_PROTECTED or ~/.inventor-mcp/protected.txt. Deleting a component says what depends on it first, and reports what moved; replacing one reports the constraints it lost

  • Never hangs on a dialog — calls run with SilentOperation on a dedicated Inventor thread. A call stuck behind a modal dialog, or a long job, returns within 50 s with the dialog's title and text (read from the window list, no COM call); manage_call(wait_seconds=30) follows it — with the prints and progress() line so far — and returns the result the moment it finishes; manage_call(action="cancel") stops it

  • Do the holes line up? — check_fastener_alignment compares every hole and slot of parts that lie on each other: aligned, off by how much (and the bolt that still passes), a pin of the other part in it, solid material behind, or nothing behind. The geometry is read inside Inventor and kept per file, so a 400-part assembly takes about four seconds the first time and one after that

  • Checks before the shop does — check_manufacturability reads a sheet metal part's flat pattern: flanges too short for the V die, holes too close to a bend line, a flat that does not fit the sheet, a rule that does not match the thickness; on an assembly it finds parts with no room for the powder coat

  • Shop-floor outputs — export_flat_pattern gives the flat size and writes the DXF/DWG for the laser (contour, holes and bend lines on their own layers); create_drawing makes a PDF drawing (base + projected + iso views, overall dimensions, section and detail views, parts list and balloons for an assembly, or the flat pattern dimensioned with a note on every bend and a bend table); export_bom lists the assembly's parts with quantity, part number, description, material and mass (CSV for Excel / ERP); edit_properties reads and sets part number, description, stock number, material and custom properties

  • Real arcs in sketches — draw_closed_profile takes rounded corners ([x, y, r]) and arcs through a point, plus draw_rectangle(corner_radius), draw_slot, draw_arc and project_edges (exact edges of a body, for remodelling). Arcs go through three points, so a sketch with flipped axes can't mirror them; inspect_model warns when a curve was drawn as many short lines. draw_pattern draws grids and circles of holes / slots, offset_profile offsets loops, and check_sketch (also built into extrude's error) points at the gap that keeps a profile open

  • Sees its own work — capture_view returns pictures of the model (iso / front / top / … , several in one call, zoom to components, isolate them, or from any point with look_from) as images the agent can look at, with sketches hidden and the user's camera put back. A flange on the wrong side or a part floating off the frame shows at a glance

  • Steel frames — add_frame_members lays Content Center profiles along skeleton lines (start → end, roll, centered or at the profile origin, shortened or extended at either end) and returns a saw cut list — what Frame Generator does, which has no API. A 13-member frame takes ~35 s

  • Surfaces to solids — convert_surfaces_to_solid knits an imported surface model, patches the holes in the shell and closes it into a solid (or turns a closed shell into one directly), with the volume and any edges it couldn't close

  • Materials in bulk — manage_materials gives every matching part of an assembly a material (Content Center parts left alone), reports material and mass per part and flags Generic parts, surface-only vendor models and parts with no mass; edit_properties(mass_kg) overrides a mass

  • Nested assemblies — find_faces finds faces of components inside sub-assemblies (type, normal, position, diameter) in top coordinates; constrain constrains them, corrects a wrong offset sign from where the face must land, and reports any other component the constraint dragged along

  • Content Center and big assemblies — use_content_center browses categories → families → sizes and makes members, custom length included (a 1500 mm DIN 1026-1 U 100 in one call); place_components places dozens of components with position, orientation, name and grounding in one call

  • Agent-friendly Python — execute_python errors show the traceback from the agent's own lines (also in helpers defined in earlier calls), stderr is captured, and undo_on_error=True rolls back everything the call did. load_library (or ~/.inventor-mcp/startup.py) keeps helper code loaded across namespace resets. COM errors come with their name and a hint (E_INVALIDARG, RPC_E_DISCONNECTED …) instead of a localized "Exception occurred". save_document checks the path first instead of failing with E_INVALIDARG and never rewrites library or Content Center files; manage_documents clears the Part12s left by failed attempts

  • Several Inventors at once, across restarts — e.g. two agents on two projects (Claude Desktop runs one server for all its chats). connect(project="…ipj") reuses the Inventor that has the project, or the running one if it is free, or starts a separate one; every tool takes instance= to pick one, and each has its own call thread and execute_python namespace, so one agent's long call doesn't hold up the other. list_instances shows them. An Inventor opened by hand can't be targeted — Windows always hands out the first one — so let the server start the second. A keeper process holds the Inventors the server started, so after a restart of the client connect(project=…) gets them back

  • Transactions — wrap multi-step builds, roll back everything with one call

  • Hot reload — edit the API wrapper and reload without restarting the MCP client

  • Topology helpers — find edges/faces by coordinates instead of guessing indices

  • Parametric discipline — projected origin points, symmetry constraints, dimensioned sketches that survive parameter changes

Related MCP server: inventor-mcp

Requirements

  • Windows with Autodesk Inventor (developed on Inventor 2026, also verified on Inventor 2027; older versions may need enum adjustments — see the API field notes)

  • Python 3.12+

  • pip install "mcp[cli]" pywin32 — MCP Python SDK 1.x and 2.x are both supported (2.x renamed FastMCP to MCPServer; the server detects which is installed)

  • An MCP client — used daily with Claude Code and Claude Desktop (several agents at once, see below)

Installation

  1. Clone this repository:

    git clone https://github.com/cenitu/inventor-mcp-server.git
  2. Install dependencies:

    pip install "mcp[cli]" pywin32
  3. Register the server with your MCP client. For Claude Code, add to .mcp.json in your project root (see .mcp.json.example). Use the absolute path to inventor_mcp_server/server.py:

    {
      "mcpServers": {
        "inventor": {
          "command": "python",
          "args": ["C:/path/to/inventor-mcp-server/inventor_mcp_server/server.py"]
        }
      }
    }

    Don't use "cwd" with -m inventor_mcp_server. Claude Code ignores cwd and starts the server from your project root, where the package can't be found — the process exits immediately and the client only reports Connection closed. Pointing at the script by absolute path works from any directory.

    Configs written for 0.2.x that point at src/server.py still work — that file now forwards to the inventor_mcp_server package — but please update them; the shim will be removed in a later release.

    Alternatively, install it from PyPI — no clone needed, and the config gets a plain command:

    pip install inventor-mcp-server
    { "mcpServers": { "inventor": { "command": "inventor-mcp-server" } } }

    (If your MCP client can't find the command, use the full path printed by where inventor-mcp-server.)

  4. Restart the MCP client (MCP servers load at session start), start Inventor, then ask your AI assistant to build something.

Avoid win32com.client.gencache.EnsureDispatch and CastTo in your own scripts against the same Python install — they generate a gen_py cache that breaks plain GetActiveObject (KeyError: '_dispobj_'). The server itself is immune since 0.5.0 (it never uses gen_py classes), but your scripts aren't: delete %LOCALAPPDATA%\Temp\gen_py if it happens. See the API notes for the full story.

Claude Desktop

Claude Desktop reads the same mcpServers block from claude_desktop_config.json — use the full path of the Python that has mcp and pywin32 installed (a bare python may be a different one):

{
  "mcpServers": {
    "inventor": {
      "command": "C:/Users/<you>/AppData/Local/Programs/Python/Python312/python.exe",
      "args": ["C:/path/to/inventor-mcp-server/inventor_mcp_server/server.py"]
    }
  }
}

Two things that cost us an afternoon:

  • Where the file is. The Microsoft Store build of Claude Desktop does not use %APPDATA%\Claude\claude_desktop_config.json. It keeps its data in %LOCALAPPDATA%\Claude-Data\claude_<id>\claude_desktop_config.json (the <id> is the package id, e.g. claude_pzs8sxrjxfjjc). If an edit seems ignored, look in %LOCALAPPDATA%\Claude\Logs\main.log — its paths show which folder the app really uses.

  • Edit it only while Claude Desktop is fully closed. The app writes its in-memory copy of the file back when it quits, so an edit made while it runs is silently thrown away. Quit from the tray icon (closing the window is not enough), edit, start it again. Settings → Developer should then list inventor as running; its log is %LOCALAPPDATA%\Claude\Logs\mcp-server-inventor.log.

Several agents, several projects

Claude Desktop starts one server for all its chats, so several agents share it. Each agent gets its own Inventor:

  1. Tell each agent only its project: "Work in C:\…\Kiosk.ipj." It calls connect(project=…) — the server reuses the Inventor that already has that project, takes the running one if it is free, or starts a separate Inventor named after the project.

  2. With several connected, every call carries instance=<name> (the agent learns the name from connect); a call without it is refused instead of guessing. list_instances shows them all.

  3. Each Inventor has its own call thread, execute_python namespace and manage_call, so one agent's long job doesn't hold up the others.

Things to know:

  • Let the server start the Inventors. Open at most one by hand. Windows hands every client the first Inventor that started, so a second one opened by hand can't be reached (list_instances lists it as unreachable).

  • Restarting Claude Desktop (or the server) keeps the Inventors. Every Inventor the server starts is handed to a small keeper process (keeper.py) that outlives the server; after the restart each agent's connect(project=…) gets the same Inventor back, open documents and all (connect(pid=…) picks one explicitly; list_instances shows them). The keeper lets go of an Inventor when its window closes and exits on its own when it holds none. Inventors opened by hand — and ones started by a server older than 0.7 — are not kept: save and close those before restarting.

  • Don't run tests in an agent's Inventor. python tests/smoke_test.py --own starts its own Inventor and quits it. Exit your own scripts a few seconds after app.Quit(): a process that ends right away can leave a windowless Inventor.exe behind — which Windows may later hand to the next client that asks for a new Inventor. Tell an agent's Inventor from such a leftover by its open documents, not by its start time.

Smoke test

tests/smoke_test.py exercises every geometry-creating code path once against a live Inventor and reports PASS/FAIL per step — the quickest way to qualify a new Inventor release or verify your install:

python tests/smoke_test.py            # starts Inventor if needed; closes only the docs it created
python tests/smoke_test.py --keep     # leave the test documents open for inspection
python tests/smoke_test.py --own      # in a separate Inventor it starts and quits — safe while agents work

It also checks every hard-coded enum constant against the live COM type library, so a renumbered enum in a future release shows up as a named failure instead of a cryptic COM error. Exit code = number of failed steps.

Current results: 137/137 pass on Inventor 2027.1 (Python 3.12, mcp 1.29 and 2.3).

tests/assembly_smoke_test.py does the same for the assembly tools — it builds a plate and a pin on disk, places them, and exercises mate / flush / angle / insert constraints (30/30 pass on Inventor 2027.1).

The skills/ directory contains two Agent Skills that teach Claude the workflow and the Inventor 2026 API quirks:

  • inventor-modeling — core patterns: units, sketch discipline, hole placement, sheet metal, diagnostic verification, common failure modes

  • inventor-din-parts — parametric recipes for DIN/ISO standard parts (hex nuts DIN 934 / 439, bolts DIN 933, socket head cap screws DIN 912, countersunk screws DIN 7991, washers DIN 125, flanges DIN 2573) with dimension tables

Install by copying into your skills directory:

cp -r skills/inventor-modeling ~/.claude/skills/
cp -r skills/inventor-din-parts ~/.claude/skills/

Why this exists

Inventor's COM API documentation is wrong or silent about many things in recent versions. This project encodes empirically verified knowledge:

  • Correct Inventor 2026 enum values (kPartDocumentObject = 12290, dimension orientation 19201/19202/19203, …)

  • ChamferFeatures.AddUsingDistance(EdgeCollection, d) — the 2026 replacement for the removed CreateChamferDefinition

  • Sheet-metal FlangeDefinition: the Distance argument is silently ignored; the real height is set via feature.Definition.HeightExtent.Distance.Expression (and the angle is in radians — pass 90 and you get 5156°)

  • CreateLinearPlacementDefinition requires a BiasPoint argument that dynamic dispatch won't tell you about

  • Edge indices renumber after every feature; fillets shift adjacent edges

  • …and more in the API field notes

Architecture

inventor_mcp_server/server.py        MCP server (FastMCP / MCPServer) — tool definitions (stdio transport)
inventor_mcp_server/inventor_api.py  InventorConnection — COM wrapper, all geometry logic (mm units),
inventor_mcp_server/api_*.py        … put together from one module per area (sketch, features, sheet metal,
                                     assembly, views, outputs, library)
skills/              Agent Skills for Claude
inventor_mcp_server/notes/          Hard-won API knowledge, served as the resource inventor://notes/api

Contributing

Contributions welcome — see CONTRIBUTING.md for setup, the fast edit → reload_api loop, and how to add a tool. Especially valuable:

  • Testing on Inventor 2024/2025 — run tests/smoke_test.py and file an Inventor version test report (no code needed)

  • More modeling tools (rib, coil)

  • More DIN/ISO part recipes

  • Bug reports with the exact COM error and Inventor version

Start with a good first issue, or ask and share what you built in Discussions.

License

MIT — see LICENSE.

Available Tools

66 tools
add_assembly_cutA

Cut through placed components at assembly level, for a hole drilled after assembly: the cut lives in this assembly and the part files stay as they are. To change the part itself for every use, cut it in the part (extrude, sheet_metal_cut). Returns the volume removed from each component; a cut that removes nothing is taken back and reported as an error.

Args: axis: World direction of the cut: "x", "y" or "z". circles: [[x, y, z, diameter], ...] in world mm. The coordinate along axis is ignored. rectangles: Lists of 4 corners, [[[x,y,z], [x,y,z], [x,y,z], [x,y,z]], ...], in world mm. at: Where the sketch plane sits along axis, in mm. Matters when distance is set. distance: Depth in mm from that plane; 0 = through everything. direction: "symmetric" (both ways), "positive" (+axis) or "negative" (-axis). participants: Comma-separated names, paths or patterns of the only components to cut, e.g. "PANEL:1,DOOR"; empty = all that the shape meets.

Inputs: at, axis, circles, distance, +4 more. Returns: result

add_circular_patternA

Create a circular (rotational) pattern of a feature around a work axis. Ideal for bolt holes around a flange — one hole + add_circular_pattern instead of 8 holes.

Args: feature_index: Index of the feature to pattern (from list_features()). count: Number of instances (total including the original). angle: Total span angle in degrees (360 = full circle). axis: Rotation axis — X, Y, or Z (default Z for flanges).

Inputs: feature_index (required), axis, angle, count, +1 more. Returns: result

add_corner_roundA

Round sharp sheet metal corners (Corner Round — carried into the flat pattern). Use on exposed corners people handle, e.g. mounting plate tabs.

Args: edge_indices: Comma-separated indices of the short edges through the thickness at the corners. radius: Corner radius in mm.

Inputs: edge_indices (required), radius, instance. Returns: result

add_flangeA

Add a Sheet Metal Flange (bent wall) to one or more edges.

Real sheet-metal feature (vs Extrude) — supports Flat Pattern unfolding, has proper bend radius, depth ties to Thickness. Put ALL edges of a loop (e.g. the 4 edges of a base panel) in ONE call so the corners are auto-mitered; separate calls leave open corners. The flange bends toward the side of the face the edge belongs to: for an inward flange on a wall, pick the wall's inner-face edge.

Args: edge_indices: Comma-separated edge indices (use find_edges to locate). distance: Flange height in mm (default 25 = Inventor default). angle: Bend angle in degrees (default 90 = perpendicular). auto_miter: Miter the corners between the edges (default True). miter_gap: Corner gap expression; "GapSize" = from the sheet metal rule (default). height_datum: "outer" (from outer intersection, default), "inner", "tangent", "outer_ortho" or "inner_ortho".

Inputs: edge_indices (required), angle, distance, instance, +3 more. Returns: result

add_frame_membersA

Build a steel frame: structural profiles laid along skeleton lines in the active assembly — what Frame Generator does (it has no API). Each member is a Content Center custom-length part (one file per profile and length, reused), turned so its length runs from start to end. Returns the placements and a saw cut list. Check with capture_view.

Args: members: [{"start": [0,0,0], "end": [0,0,2000], "name": "Post_1"}, ...] in mm. Per member, optional: "family", "size", "category" (override the call's), "roll" (degrees, turns the section about its line), "anchor" ("center" = the section's middle on the line, default; "origin" = the profile's own origin), "extend" ([at start, at end] mm, negative to shorten — e.g. to stop at a crossing member). Horizontal members keep their section level; roll 90 turns a U to face sideways. category, family, size: Default profile, as use_content_center lists them, e.g. "Structural Shapes/Channels", "DIN 1026-1", "U 100". folder: Where the member files go (default: project workspace /Content Center Custom).

Inputs: members (required), size, family, folder, +2 more. Returns: result

add_holeA

Add a native hole feature to the active part (drilled, tapped ISO metric 6H, counterbored). Fails — instead of leaving an empty feature — if no material was removed. Placed one of three ways:

  • point + direction: absolute model coordinates, e.g. point=[30,0,12], direction=[0,0,-1] (the way the drill travels). Safest: no sketch axes involved.

  • linear: dimensioned from two edges of a face, associative — preferred for fastener holes: {"face_axis": "Z", "face_value": 20, "ref1_axis": "X", "ref1_value": 0, "dist1": 10, "ref2_axis": "Y", "ref2_value": 0, "dist2": 15}.

  • x, y: on the XY plane, drilling into +Z.

Args: diameter: mm (thread nominal if tapped, e.g. 5 for M5). depth: mm; 0 = through all. tapped: Thread it. pitch: mm; 0 = standard coarse. cbore_diameter, cbore_depth: Counterbore seat (with linear), e.g. 10 and 5.5 for M5.

Inputs: x, y, depth, pitch, +8 more. Returns: result

add_mirrorA

Mirror features, or the whole body, across a plane. For a symmetric part model one half and mirror it — half the work, and it stays symmetric when a dimension changes. A mirror that changes nothing (the copy lands off the body or on the original) is taken back.

Args: features: Feature indices or names, ","-separated (manage_features list). Not with body=True. plane: Origin plane XY, XZ or YZ, or the name of a work plane. body: Mirror the whole solid; the two halves join where they meet on the plane. remove_original: With body=True: keep only the mirrored side (left-hand from right-hand part).

Inputs: body, plane, features, instance, +1 more. Returns: result

add_rectangular_patternA

Repeat features in a row or a grid — a line of slots, a field of mounting holes, louvres. One hole + add_rectangular_pattern instead of twenty holes: one number changes the pitch. Works on sheet metal cuts too. A pattern whose copies all miss the body is taken back.

Args: features: Feature indices or names, ","-separated (manage_features list), e.g. "3" or "Hole1,Cut2". x_count: Instances along x_axis, the original included. x_spacing: Pitch in mm along x_axis; negative = the other way. x_axis: X, Y or Z (model axes). y_count: Rows along y_axis (1 = a single row). y_spacing: Row pitch in mm; negative = the other way. y_axis: X, Y or Z, different from x_axis.

Inputs: features (required), x_axis, y_axis, x_count, +4 more. Returns: result

add_sheet_metal_faceA

Create the first flat panel of a sheet metal part from a closed sketch profile; add_flange bends walls from its edges, sheet_metal_cut opens holes in it. Needs a part made with create_document(kind="sheet_metal"). Set the rule first (manage_sheet_metal_rules): the panel takes its thickness from the active rule, so it has none of its own to pass here.

Args: sketch_index: Sketch number (0 = latest sketch).

Inputs: instance, sketch_index. Returns: result

add_sheet_profileA

Make a whole bent profile — angle, channel, Z or hat — as one contour flange in an empty sheet metal part, from outer sizes: section in the XY plane from 0,0, length along +Z. It unfolds like any sheet metal part. Set the rule first (manage_sheet_metal_rules): thickness comes from it. For a panel with walls use add_sheet_metal_face + add_flange.

Args: kind: "L", "U", "C" (U with lips turned in), "Z" or "hat". width: L: bottom leg. U, C: overall width. Z: top flange, measured over the web. Hat: width of the crown. All mm. height: Overall height in mm. length: Length of the profile in mm. flange: C: lip. Z: bottom flange, measured over the web. Hat: each brim. Ignored for L and U. bend_radius: Inside radius in mm; 0 = from the rule.

Inputs: kind (required), width (required), height (required), length (required), +3 more. Returns: result

capture_viewA
Read-only

Look at the model: pictures of the active document, returned as images you can see. Use it to check your work — a flange on the wrong side, a door opening the wrong way, a part floating off the frame — which the numbers alone don't show.

Args: views: Comma-separated: iso, iso_left, iso_bottom, front, back, top, bottom, left, right, current (the user's view). E.g. "iso,front,top". width, height: Pixels per picture (keep them modest — each picture costs tokens). background: "inventor" (its gradient) or "white". fit_to: Assembly component paths, ","-separated — zoom to them, keeping each view's direction. isolate: Component paths, ","-separated — show only these (and what is inside them); the others are hidden for the picture. For details buried in an assembly. sketches: Show sketches and work features too (hidden by default; restored after). up: "y" = Inventor's own view names (its default templates have Y up); "z" for a model built with Z up (frames, buildings): front looks along +Y, top down -Z. With look_from: which axis is up in the picture, "x", "y" or "z". look_from: Camera position [x, y, z] in mm, model coordinates — when a named view looks from the wrong side, or for a detail. This picture is the view "custom": it replaces the default "iso"; name it in views to mix ("custom,top"). target: With look_from: the point [x, y, z] in mm to look at and centre on — the picture is then sized to fit_to (or the model); use zoom to get closer. Empty = the middle of fit_to / the model, the whole of it in the picture. zoom: 2 = twice as close, 0.5 = twice as far; every view. perspective: With look_from: a perspective picture from that point, not parallel.

Inputs: up, zoom, views, width, +9 more.

chamferA

Add an equal-distance chamfer to edges of the active part's first body. For rounded edges use fillet; on sheet metal corners, add_corner_round.

Give ALL edges in one call: edge numbers change after every feature, so a second call with old numbers hits the wrong edges. Returns the feature name.

Args: distance: Chamfer distance in mm, e.g. 2. edge_indices: Comma-separated edge numbers from find_edges, e.g. "1,2,3".

Inputs: distance, instance, edge_indices. Returns: result

check_fastener_alignmentA
Read-only

Do the holes and slots of parts that lie on each other line up? Run it on an assembly before it goes to the shop — a hole that is 1.5 mm off costs a part.

Wherever a flat face of one part lies on a flat face of another (facing each other, at most max_gap apart), every hole, slot and cut-out in those faces is compared with what is behind it: aligned an opening of the other part, off by at most tolerance (counted, by size) misaligned an opening that is off: by how much, and the largest bolt that still passes engaged a pin, stud or boss of the other part goes into it (counted, by size); stud_does_not_fit lists the ones that are too big or too far off blocked solid material of the other part — a hole nothing can go through open the other part does not reach there Positions are in assembly mm. Fasteners (Content Center parts) and hidden components are left out. The geometry is read inside Inventor and kept per file on disk, so a 400-part assembly takes seconds, and the next call less; a part with unsaved changes is read anew. Changes nothing. Holes are compared as modelled in the part files: an assembly-level cut is not seen. Only flat faces are compared, and what sits INSIDE a hole is not looked at: an "open" hole may hold a pin or a rivet nut that is its own part. Each row has at (assembly mm) and axis (out of the part, towards the other one) — capture_view(look_from=…, target=at) shows the spot.

Args: parts: Name patterns, ","-separated, on the component path or the file name ("DOOR,ET1-0?.ipt"); empty = every part. max_gap: Faces up to this far apart (mm) count as lying on each other — a gasket or powder coat gap; 0.5 by default. tolerance: Openings off by more than this (mm) are misaligned. refresh: Read every file again instead of using what is kept on disk. include_fasteners: Also compare Content Center parts. limit: Rows listed per kind; the counts are always complete.

Inputs: limit, parts, max_gap, refresh, +3 more. Returns: result

check_interferenceA
Read-only

Check overlap between occurrences of the active assembly: full paths of both, volume and bounding box of each. Touching faces are not reported. Intended overlaps (gasket compression, thread in thread) show up too — read the volume and bbox.

Args: set_a: Comma-separated names, paths or patterns: "DOOR:1", "Sub:1/Part:2", "BRACKET". set_b: The same, to test against; empty = everything else. ignore_fasteners: Set aside overlaps with small Content Center members (bolts, nuts, washers, under 150 mm) — threads overlap by design. They are counted.

Inputs: set_a (required), set_b, instance, ignore_fasteners. Returns: result

check_manufacturabilityA

Can it be made? Run it before a part or assembly goes to the shop.

Active sheet metal part — checked on its flat pattern (made if there is none): the rule (a TXX-VYY shop rule must match the thickness), the flat size against the sheet, every flange against the V die (on both sides of a bend line the sheet must reach V/2 + thickness, to the edge or to the next bend), holes too close to a bend line (nearer than V/2 they are pulled out of shape) and holes smaller than the thickness. Active assembly — parts closer than clearance without touching: no room for the powder coat. Touching parts and fasteners are fine. "problems" is what to fix; "notes" is what was assumed or left unchecked.

Args: v_die: V die opening in mm. 0 = from the rule name (T15-V10 → 10), else 8 x thickness. min_flange: Flat sheet needed beside a bend line, mm. 0 = V/2 + thickness. min_hole_to_bend: Hole edge to bend line, mm. 0 = V/2, or radius + 2 x thickness if more. sheet: Stock sheet, e.g. "2500x1250". Empty = the smallest standard sheet that fits (2000x1000, 2500x1250, 3000x1500) is named. brake_length: Press brake length in mm; 0 = bend length is not checked. clearance: Assembly: smallest gap in mm between parts that don't touch (0.3 for powder coat). parts: Assembly: name patterns, ","-separated, of the parts to look at (default: all).

Inputs: parts, sheet, v_die, instance, +4 more. Returns: result

check_sketchA
Read-only

Why won't it extrude? Checks a sketch for what a closed profile needs: open ends, gaps (two ends a hair apart, not joined), points where 3+ curves meet (overlaps, stray lines), lines drawn twice — with sketch coordinates in mm — and whether Inventor builds a profile, with how many closed loops. extrude / revolve report the same when they fail.

Args: sketch_index: Sketch number (0 = latest sketch).

Inputs: instance, sketch_index. Returns: result

connectA

Connect to Autodesk Inventor. Starts Inventor if none is running.

Working on a project? Pass project=<full path of its .ipj>: the server uses the Inventor that already has it — also one a previous server started (after a restart of Claude Desktop) — or the running one if it is free to switch, or else starts a separate Inventor for it — so two agents on two projects each get their own. The answer names the instance; when several Inventors are connected, pass instance= to every later call.

Args: visible: Show Inventor window (default True). project: Full path of an .ipj to work in. new_instance: Always start a separate Inventor. pid: Connect to this kept Inventor (list_instances shows them) — e.g. two in one project.

Inputs: pid, project, visible, instance, +1 more. Returns: result

constrainA

Constrain two components, at any depth — by origin geometry, faces or circular edges. Prefer origin geometry: it survives part edits; face and edge numbers change with the topology.

References: "Part:1#XY" / "#XZ" / "#YZ" / "#X" / "#Y" / "#Z" / "#ORIGIN" (origin geometry), "Sub:1/Part:1#F12" (face, from find_faces), "Sub:1/Bolt:1#E4" (edge, from find_edges). A list index works as the component: "2#XY".

Says which OTHER components the constraint moved — one can drag parts you didn't mean to touch.

Args: a, b: References; a is the one meant to move. kind: "mate" (faces against each other, axes in line), "flush" (faces the same way), "angle", or "insert" (two circular edges: a bolt into a hole). offset: mm for mate / flush / insert. Its sign is easy to get wrong — give a_at too. angle: Degrees for kind="angle". a_at: Where a's face must end up, e.g. {"Z": 182.5}. If it lands elsewhere, the offset is tried with the other sign. axes_opposed: For insert: True = the components face each other (normal bolt / hole case).

Inputs: a (required), b (required), a_at, kind, +4 more. Returns: result

convert_surfaces_to_solidA

Turn surfaces into solids — imported vendor models (x_t, IGES, STEP) that came in as faces with no volume, so no mass and no booleans. Stitches the part's visible surfaces, patches the holes left in the shell, and closes it into a solid; a shell that is already closed becomes a solid directly. Reports each step, the solids' volumes, and the open edges it couldn't close (coordinates in mm). Run it in the part that holds the surfaces.

Args: work_surfaces: "all", or WorkSurface numbers "1,2,5" to convert one group at a time (e.g. one component of a multi-part import). tolerance: Largest gap to stitch over, mm. patch_holes: Fill loops of open edges with a boundary patch.

Inputs: instance, tolerance, patch_holes, work_surfaces. Returns: result

create_documentA

Create a new document — a part with its material and part number right away, so no part is left "Generic" for the BOM and the mass.

Args: kind: "part", "sheet_metal" or "assembly". name: Display name (optional). template: "metric" (mm, default), "english" (inches), or a full path to a template file. material: Parts: from the library, e.g. "Steel, Mild". part_number, description: Parts: iProperties for the BOM.

Inputs: kind, name, instance, material, +3 more. Returns: result

create_drawingA

2D drawing of the active part or assembly (saved to disk) → PDF for the shop floor. A base view, projected views around it, overall dimensions on the base view (between its outermost straight edges — check them on assemblies), the model dimensions Inventor can retrieve, and the template's title block (filled from properties()). Assemblies: a parts list and balloons. Any model: a section and a detail view. Flat patterns: direction, angle and radius on every bend line, and a table of the bends. An annotation that fails is named in the answer; the rest of the drawing is still made. Read the PDF back to check the layout.

Args: pdf_path: Output .pdf. views: First is the base view (front/top/right/left/back/bottom); the rest are projected from it: top (placed below), right (beside), iso (shaded, half scale). template: Drawing template name (ISO, DIN, ANSI (mm) …) or a full .idw path. scale: 0 = largest standard scale that fits; or e.g. 0.2 for 1:5. flat: Sheet metal part: draw the flat pattern (one view). drawing_path: Also keep the drawing as .idw / .dwg (otherwise it is closed). parts_list: Assembly: the parts list (first-level components: item, quantity, part number, description — fill those with edit_properties) on the title block. balloons: Assembly: an item balloon for each different first-level component, on the iso view if there is one, else on the base view. section: "vertical" or "horizontal": a full section A-A through the middle of the base view; "vertical:12.5" cuts 12.5 mm (model) right of the middle, "horizontal:-8" 8 mm below it. A vertical section takes the place of the "right" view and a horizontal one of "top" — leave that view out of views. detail: [x, y, z, radius] in model mm: an enlarged detail B of the base view around that point (a small hole pattern, a corner relief). bend_notes: With flat: the bend notes and the bend table (default on).

Inputs: pdf_path (required), flat, scale, views, +8 more. Returns: result

create_sketchA

Create a new sketch on a work plane, a body face, or an offset work plane.

Args: plane: Work plane — XY, XZ, or YZ. Ignored if face_index > 0. face_index: Index of body face to sketch on (1-based). 0 = use work plane. Use list_faces() to locate. offset: mm — sketch on a hidden work plane parallel to 'plane' at this distance (positive = along plane normal: XY→+Z, XZ→+Y, YZ→+X). For ribs/bosses at a height.

Inputs: plane, offset, instance, face_index. Returns: result

draw_arcA

Draw an open arc from (x1, y1) to (x2, y2) in mm — e.g. to close a profile drawn with draw_line. Either through a point on it (xm, ym), or around its center (cx, cy) running counter-clockwise in sketch coordinates. For closed shapes prefer draw_closed_profile.

Args: x1, y1, x2, y2: Start and end. xm, ym: A point on the arc between them. cx, cy: The center (start and end must be equally far from it). sketch_index: Sketch number (0 = latest sketch).

Inputs: x1 (required), x2 (required), y1 (required), y2 (required), +6 more. Returns: result

draw_circleA

Draw a circle in a sketch with an automatic diameter dimension. Dimensions in mm.

Args: x: Center X coordinate in mm. y: Center Y coordinate in mm. diameter: Diameter in mm. A diameter constraint is added automatically. sketch_index: Sketch number (0 = latest sketch). construction: If True, draws a reference (construction) circle — not part of profile. Useful for showing bolt PCD (pitch circle diameter) without cutting.

Inputs: x, y, diameter, instance, +2 more. Returns: result

draw_closed_profileA

Draw a closed profile of lines AND arcs. All coordinates in mm. Segments share their end points, so Inventor sees one closed loop for extrude/revolve. Never approximate a curve with many short lines — round corners and arcs are built in:

[x, y] a corner [x, y, r] a corner rounded with radius r (tangent arc, lines trimmed) {"through": [x, y]} the segment from the corner before to the corner after is an arc through this point (after the last corner: the closing one)

Examples: plate with R10 corners "[[0,0,10],[200,0,10],[200,100,10],[0,100,10]]"; a D shape "[[0,-50],[0,50],{"through":[50,0]}]". Arcs go through three points, so the sketch's axis directions can't flip them.

Args: points: JSON array (or list) of the entries above. sketch_index: Sketch number (0 = latest sketch).

Inputs: points (required), instance, sketch_index. Returns: result

draw_lineA

Draw one straight line in a sketch, in the sketch's coordinates — an open line, or a construction line for a revolve axis. Lines drawn one by one don't join into a profile: for a closed shape use draw_closed_profile or draw_rectangle.

Args: x1: Start X in mm. y1: Start Y in mm. x2: End X in mm. y2: End Y in mm. sketch_index: Sketch number (0 = latest sketch). construction: If True, line becomes a construction line (used as revolve axis, not part of profile).

Inputs: x1, x2, y1, y2, +3 more. Returns: result

draw_patternA

Many copies of one shape in one sketch — vent slots, hole grids, bolt circles — then one cut makes them all. mm.

Grid: the first copy at (x, y), rows x columns, pitch dx (between columns) and dy (between rows). Circle: count copies on a circle of diameter pcd around (x, y), the first at start_angle degrees; slots and rectangles turn with the circle.

Args: shape: circle (diameter), slot (length, width — overall), rectangle (length, width, corner_radius). angle: Turn every slot / rectangle by this many degrees (length along X at 0). sketch_index: Sketch number (0 = latest sketch).

Inputs: x, y, dx, dy, +13 more. Returns: result

draw_polygonA

Draw a regular polygon in a sketch. Dimensions in mm.

Args: x: Center X in mm. y: Center Y in mm. radius: Circumscribed radius in mm. sides: Number of sides (e.g. 6 for hexagon). sketch_index: Sketch number (0 = latest sketch).

Inputs: x, y, sides, radius, +2 more. Returns: result

draw_rectangleA

Draw a centered rectangle in a sketch. Dimensions in mm.

Args: x: Center X coordinate in mm. y: Center Y coordinate in mm. width: Width in mm. height: Height in mm. sketch_index: Sketch number (0 = latest sketch). corner_radius: Round all four corners with real arcs (half the short side = a slot).

Inputs: x, y, width, height, +3 more. Returns: result

draw_slotA

Draw a slot (oblong hole / rounded-end profile) centered on (x, y), mm.

Args: x, y: Center. length: Overall length, end to end. width: Width (= the end radius x 2). angle: Direction of the length in degrees, in sketch coordinates. sketch_index: Sketch number (0 = latest sketch).

Inputs: x (required), y (required), width (required), length (required), +3 more. Returns: result

edit_propertiesA

Read — and optionally set — the active document's iProperties: part number, description, stock number, vendor, revision, title, cost center, material, mass and custom properties. These feed the BOM and the drawing's title block.

Args: values: e.g. {"part_number": "BRS-101", "description": "Side panel 2 mm", "stock_number": "DKP-2.0"}. Unknown keys become custom properties. material: Material name as in Inventor's library (e.g. "Steel, Mild"; manage_materials(action='list')). mass_kg: Override the mass — for vendor models made of surfaces, which have no volume (a 1.23 kg motor showed 0.23 kg). manage_materials lists them.

Inputs: values, mass_kg, instance, material. Returns: result

execute_pythonA

Execute Python code against the live Inventor connection.

Pre-bound objects (re-resolved fresh on every call): inv — InventorConnection wrapper (all high-level methods, mm units) app — Inventor.Application COM object doc — active document comp — its ComponentDefinition body — comp.SurfaceBodies.Item(1) (or None) tg — TransientGeometry math — math module progress(msg) — status line manage_call shows while a long job runs cancelled() — True once manage_call(action='cancel') asked to stop: poll it in long loops Variables you assign persist between calls until the server restarts or reload_api runs — get_status shows the namespace's age and names. Each connected Inventor has its own namespace. Helpers you need every time: put them in a file and load_library it (or in ~/.inventor-mcp/startup.py) — they come back by themselves in a new namespace. Internal COM units are CENTIMETERS — divide mm by 10. Objects are late-bound: a Document from Documents.Open exposes ComponentDefinition directly. Don't use CastTo / gencache.EnsureDispatch (they create a gen_py cache). Runs with SilentOperation on, so Inventor answers its own prompts instead of opening a dialog. Save with the save_document tool or inv.save_document(): a plain doc.SaveAs also writes every dirty dependent, protected and Content Center files included. A call longer than the wait limit keeps running; follow it with manage_call(wait_seconds=30), which shows the prints so far; manage_call(action='cancel') stops it. Returns captured stdout + stderr (print your results!), or the traceback from your own code down on error (COM errors named: E_INVALIDARG, RPC_E_DISCONNECTED …).

Args: code: Python source. undo_on_error: Run inside one undo transaction on the active document and roll it back if the code raises — no half-built sketches or work planes left behind. timeout: Seconds; then cancelled() turns True, and the run is interrupted CANCEL_GRACE s later if it hasn't stopped — as manage_call(action='cancel') does (0 = none).

Inputs: code (required), timeout, instance, undo_on_error. Returns: result

export_bomA

Bill of materials of the active assembly: item, quantity, part number, description, material, stock number, mass, file. For purchasing / ERP — set part numbers and descriptions first with properties().

Args: view: "parts_only" (every part once with its total quantity) or "structured" (sub-assemblies with their parts indented). path: Also write a CSV (UTF-8, ';'-separated) — opens in Excel.

Inputs: path, view, instance. Returns: result

export_documentA

Write the active document to a neutral CAD file, for a customer, a vendor or a printer. An existing file at path is replaced; the file is checked afterwards and its size returned. The Inventor document itself is unchanged — save_document saves that. For the laser use export_flat_pattern, for a parts list export_bom, for a PDF create_drawing.

Args: path: Output file, e.g. "D:/export/part.step". format: STEP, IGES, SAT or STL.

Inputs: path (required), format, instance. Returns: result

export_flat_patternA

Flat pattern of the active sheet metal part: flat size, thickness, bend count — and with a path, a DXF/DWG for the laser / punch (layers OUTER = contour, INNER = holes and cut-outs, IV_BEND* = bend lines; tangent lines, sketches etc. left out). Creates the flat pattern if the part has none.

Args: path: Output file (.dxf or .dwg). Empty: just report the flat size. format: DXF or DWG. bend_lines: Include the bend lines (on their own layers).

Inputs: path, format, instance, bend_lines. Returns: result

extrudeA

Turn a sketch's closed profile into 3D: add material, cut it, or start a new body. For a turned shape use revolve; for sheet metal, add_sheet_metal_face and sheet_metal_cut.

Returns the feature name and the change, e.g. "V 23497 (-503 mm³) | F7 E14": read it — a cut showing no volume change went the wrong way or missed the body; try the other direction. Without a closed profile it fails and says where the gap is (as check_sketch does).

Args: distance: mm. Ignored when extent_type="all". direction: "positive" (along the sketch normal: +Z on the XY plane), "negative" or "symmetric". operation: "join" (add), "cut", "intersect", "surface" or "new" (a separate body). sketch_index: Sketch number (0 = latest sketch). extent_type: "distance", or "all" to go through the entire body.

Inputs: distance, instance, direction, operation, +2 more. Returns: result

filletA

Round edges of the active part's first body. For an angled edge use chamfer; to round a profile's corners before extruding, use draw_closed_profile radii.

Edge numbers change after every feature: run find_edges again before the next fillet, and give all edges of one radius in one call. Tangent edges are followed automatically. Fails if the radius doesn't fit the geometry — fillet the big radii first. Returns the feature name.

Args: radius: Fillet radius in mm, e.g. 2. edge_indices: Comma-separated edge numbers from find_edges, e.g. "1,2,3".

Inputs: radius, instance, edge_indices. Returns: result

find_edgesA
Read-only

Find edges, filtered by position or type. Without path: the active part (the index feeds add_flange, fillet, chamfer). With path: a component at any depth, with a ref ("Sub:1/Bolt:1#E4") — circular ones feed constrain(kind="insert").

Args: path: Component path (manage_occurrences list, depth=2). Empty = the active part. at: Edge midpoint coordinates to match (circle: its center), e.g. {"X": 50, "Z": 1.5}. circular: Only circular edges. diameter: Circle diameter in mm. min_length: Skip edges shorter than this (mm). max_count: Most results to return.

Inputs: at, path, circular, diameter, +3 more. Returns: result

find_facesA
Read-only

Find faces, filtered by type, direction, position or size. Without path: the active part (the index feeds create_sketch, sheet_metal_cut). With path: a component of the active assembly at any depth, in TOP assembly coordinates, with a ref ("Sub:1/Part:1#F12") for constrain; a sub-assembly path searches every part in it.

Args: path: Component path (manage_occurrences list, depth=2). Empty = the active part. surface: "plane", "cylinder", "cone", … (empty = any). normal: Outward normal of a plane, e.g. [0, 0, 1] for faces looking up. at: Face center coordinates to match, e.g. {"Z": 182.5}. diameter: Cylinder diameter in mm. min_area: Skip faces smaller than this (mm²). max_count: Most results to return.

Inputs: at, path, normal, surface, +4 more. Returns: result

get_statusA
Read-only

Check connection status, active document info, and the execute_python namespace (age, names you defined — gone after a server restart or reload_api). If Inventor is busy or showing a dialog, says so instead.

Inputs: instance. Returns: result

import_stepA

Import a vendor STEP file (hinge, lock, gland...) as Inventor files in dest_folder. The STEP is copied into dest_folder first, because Inventor writes the parts of an imported assembly next to the .step file (e.g. into Downloads or a synced folder). Returns path, type, overall bbox and per-component bbox/volume — use them to find mounting faces and axes before placing it with place_components.

Args: step_path: The downloaded .step / .stp file. dest_folder: Project folder to hold the Inventor files. name: Base name for the .iam/.ipt (default: the STEP file name).

Inputs: step_path (required), dest_folder (required), name, instance. Returns: result

inspect_modelB
Read-only

Snapshot of the active document in one call. Part: volume, bounding box, face and edge counts, feature tree, sketches, sheet metal thickness, warnings (faceted curves, surface bodies). Assembly: components with positions, constraint count, mass, volume.

Inputs: instance. Returns: result

list_instancesA
Read-only

The Inventors this server is connected to — name, project, open documents — and any other running Inventor it can't reach (opened by hand). Answers even while they are busy.

Inputs: no named parameters. Returns: result

load_libraryA

Run a Python file into this Inventor's execute_python namespace and keep it there: after reload_api, a new namespace or a new server it is loaded again by itself (remembered per project). For helper functions you would otherwise redefine every time. Says how long it took and which lines were slowest — a COM call at module level is the usual culprit. A file at ~/.inventor-mcp/startup.py (or INVENTOR_MCP_STARTUP) is loaded for every Inventor.

Inputs: path (required), instance. Returns: result

loftA

Blend between the closed profiles of two or more sketches on different planes — a rectangle-to-circle transition, a duct, a tapered boss. For a constant profile along a curve use sweep; for a straight push, extrude.

Put each section in its own sketch (create_sketch with offset gives parallel planes). Returns the feature name and the volume / topology change.

Args: sketch_indices: Comma-separated sketch numbers in the order to blend, e.g. "1,2,3". operation: "join" (add), "cut", "intersect" or "new" (a separate body). closed: Also blend the last section back into the first (a ring).

Inputs: sketch_indices (required), closed, instance, operation. Returns: result

manage_callA

Follow or stop a call that outlived the wait — a long execute_python, a Content Center scan, one stuck behind an Inventor dialog.

"status": elapsed time, any open dialog's text, output so far, progress() line (with the time left after progress(done, total)) — and the result once it has finished. wait_seconds waits (at most 45 s) and returns as soon as it ends. The result of a call that outlived the wait is also written as JSON under ~/.inventor-mcp/calls (INVENTOR_MCP_CALLS) — the message that says it keeps running names the file — so it can be read there if this tool can't be called. "cancel": cancelled() in execute_python code turns True at once; code still running after 2 s gets a KeyboardInterrupt, repeated until it stops. That lands at the next Python line: a call stuck INSIDE one COM operation or behind a dialog stops only once that returns.

Args: action: "status" or "cancel". wait_seconds: For "status".

Inputs: action, instance, wait_seconds. Returns: result

manage_constraintsA

List the active assembly's constraints with their numbers and offsets, flagging any in an error state; change one's offset or angle; or delete one. To add one use constrain. Editing reports every other component it dragged along. Deleting frees the components it held, and the numbers after it shift — list again before deleting another.

Args: action: "list", "edit" or "delete". index: For "edit" and "delete": the constraint's number from list. value: For "edit": the new offset in mm, or angle in degrees. A formula it held is replaced. undo_if_moved: For "edit": put the old value back if any other component would move.

Inputs: index, value, action, instance, +1 more. Returns: result

manage_documentsA

Open documents of this Inventor.

"list": name, type, dirty, active; protected (library / Content Center) ones marked. "open": a file by path. "activate": switch by name or path. "close": one, without saving unless it is yours and dirty (discard=True closes it anyway). "close_unsaved": documents never saved (Part12… left by failed attempts). "close_all": everything; refuses while your own files have unsaved changes, listing them (discard=True closes anyway; protected files never count). quit_inventor=True quits after.

Args: action: "list", "open", "activate", "close", "close_unsaved" or "close_all". name_or_path: For open / activate / close. include_active: "close_unsaved" also closes the active document. discard: Close without saving your changes. quit_inventor: "close_all" then quits this Inventor.

Inputs: action, discard, instance, name_or_path, +2 more. Returns: result

manage_featuresA

List, delete or suppress the active part's features.

Args: action: "list", "delete", "suppress" or "unsuppress". indices: Feature indices from list, comma-separated, e.g. "3,4,5".

Inputs: action, indices, instance. Returns: result

manage_materialsA

Materials of many parts at once.

"report": material and mass of every part of the active assembly (or part): counts per material, total mass, and what needs a look — parts left on Generic, vendor models made of surfaces (no volume, mass too low), parts with no mass. "list": material names in Inventor's libraries (search narrows them). "set": give material to every part whose name matches parts. Content Center and library parts are left alone. Save afterwards.

Args: action: "report", "list" or "set". material: From the library, e.g. "Steel, Mild". search: For "list", e.g. "steel". parts: Name patterns, ","-separated, e.g. "PLATE,BRACKET". only_generic: "set" only parts still on Generic / Default. path: Limit "report" / "set" to a sub-assembly. only_problems: "report" without the per-part rows.

Inputs: path, parts, action, search, +4 more. Returns: result

manage_occurrencesA

Components of the active assembly.

"list": a table with positions; depth=2 also lists what is inside sub-assemblies, with paths. "find": components by what they are and where — definition name pattern, the direction of their Z axis, distance from a point. E.g. definition="ISO 4017M8*", axis=[0,0,1]. "ground": fix a component in space (grounded=False releases it). Ground the first one. "delete": says first what depends on it (patterns, constraints) and stops; force=True deletes, cascade=True also deletes pattern members. Reports components that moved. "replace": put with_file in the component's place — a rebuilt part saved under a new name, a new revision. Constraints stay where Inventor can match the geometry; reports the ones it lost and what moved. "to_top" / "to_local": a point in the component's own coordinates → assembly coordinates, and back — for a sub-assembly that was moved, or a part placed turned.

Args: action: "list", "find", "ground", "delete", "replace", "to_top" or "to_local". path: Component name, path ("Sub:1/Part:1") or list index. depth: For "list". definition: For "find": name pattern on the part / file name. axis: For "find": direction of the component's Z axis, either way along it. near: For "find": a point [x, y, z] in mm. within: For "find": largest distance from near, mm. grounded: For "ground". cascade: For "delete". force: For "delete". with_file: For "replace": full path of the .ipt / .iam that takes its place. all_same: For "replace": every occurrence of the same file at that level (default), or only this one. archive_old: For "replace": then move the old file into an "_old" folder beside it — only if no open document still uses it; never a library file. point: For "to_top" / "to_local": [x, y, z] in mm.

Inputs: axis, near, path, depth, +11 more. Returns: result

manage_parametersA

Read, change or add parameters of the active document.

Args: action: "get" (all), "set" or "add". name: Parameter name, e.g. "width". expression: Value or expression, e.g. "50 mm", "width * 2". units: For "add": mm, cm, m, deg, …

Inputs: name, units, action, instance, +1 more. Returns: result

manage_sheet_metal_rulesA

Sheet metal rules of the active part. Shops encode their tooling in rule names (e.g. 'T15-V10' = 1.5 mm sheet, V10 die): prefer "set" — it sets thickness, bend radius and unfold method together; "thickness" changes only the thickness.

Args: action: "list", "set" or "thickness". name: Rule name for "set" (case-insensitive). thickness: mm, for "thickness".

Inputs: name, action, instance, thickness. Returns: result

measure_distanceA
Read-only

Minimum distance in mm between two occurrences (0 = touching/overlapping). Names as in manage_occurrences; "Asm:1/2" reaches a part inside a sub-assembly.

Inputs: a (required), b (required), instance. Returns: result

offset_profileA

Offset every closed loop of a sketch by distance mm — a gasket groove, a wall, a lip, an inner cut-out with a margin. Lines, arcs and circles stay lines, arcs and circles.

Args: distance: Offset in mm. side: "inside" or "outside" of each loop. sketch_index: Sketch number (0 = latest sketch).

Inputs: distance (required), side, instance, sketch_index. Returns: result

place_componentsA

Place parts / sub-assemblies into the active assembly — one or hundreds in one call. Files must exist on disk (save_document first); all are checked before anything is placed.

Args: components: [{"path": "C:/.../beam.ipt", "x": 0, "y": 0, "z": 0, "x_axis": [1,0,0], "y_axis": [0,1,0], "grounded": false, "name": "Beam_A1"}, ...]. mm. "origin": [x,y,z] works too. Axes and name are optional (where the part's own X/Y point; give both). Ground the first component of every assembly. atomic: One undo step: if any placement fails, none stay. skip_if_exists: Don't place one where the same file already sits at the same place — safe to run a list again after an error.

Inputs: components (required), atomic, instance, skip_if_exists. Returns: result

project_edgesA

Project a body's edges onto the sketch — exact lines, arcs, circles and splines, linked to the model. Use it to build on existing or reference geometry (e.g. remodelling an imported part) instead of re-tracing curves point by point.

Args: face_index: Project every edge of this face of the body (find_faces). edge_indices: Or these edges, "3,7,8" (find_edges). body_index: Body in a multi-body part (1 = first). sketch_index: Sketch number (0 = latest sketch).

Inputs: instance, body_index, face_index, edge_indices, +1 more. Returns: result

reload_apiA

Hot-reload the wrapper (inventor_api.py and its api_*.py parts) from disk. Use after editing it — no Claude Code restart needed. Keeps the COM connections; clears this Inventor's execute_python namespace.

Inputs: instance. Returns: result

revolveA

Revolve a sketch profile around a work axis to create or cut 3D geometry.

PREFERRED workflow — no construction line needed in sketch:

  1. create_sketch("XY")

  2. draw_closed_profile([[0,0],[30,0],[30,8],[15,60],[0,60]]) ← profile only

  3. revolve(axis="Y", operation="join")

For a revolve CUT (e.g. groove):

  1. create_sketch("XY")

  2. draw_closed_profile([[8,26],[15,26],[15,34],[8,34]]) ← groove cross-section

  3. revolve(axis="Y", operation="cut")

Profile must be on one side of the axis (all X ≥ 0 when axis="Y").

Args: angle: Revolution angle in degrees (360 = full revolution, default). axis: Rotation axis — "X", "Y", or "Z". Default "Y" for lathe parts on XY plane. sketch_index: Sketch number (0 = latest sketch). operation: Boolean operation — join (add material), cut (remove), intersect, or new.

Inputs: axis, angle, instance, operation, +1 more. Returns: result

save_documentA

Save the active document — never opens a dialog, and never writes a library or Content Center file. Dependents that changed (e.g. sub-assemblies, edited parts) are saved one by one first, except files in the project's library paths or Content Center folders and Content Center members: Inventor marks standard parts dirty after opening an old assembly, and re-saving them would rewrite shared library files. Returns the files saved and the ones skipped. The path is checked first (characters, extension, an existing file) so a bad one gets a clear message instead of Inventor's E_INVALIDARG.

Args: path: Full file path to save as (e.g. "D:/parts/flange.ipt"). If empty, saves in place. overwrite: Replace a file that already exists at path (not one open in Inventor). save_dependents: False = save only this document (Save2(False)); changed dependents stay unsaved and are listed.

Inputs: path, instance, overwrite, save_dependents. Returns: result

sheet_metal_cutA

Cut through a sheet metal panel — depth follows the thickness, so it stays parametric. Checks that material was removed (a cut sketched on a work plane silently removes nothing).

From a sketch on the panel face: one sketch with several closed shapes = several holes. Or at WORLD coordinates, with no sketch axes to think about: face_index + circles / rectangles.

Args: sketch_index: Sketch number (0 = latest). face_index: Face of the sheet (find_faces), for circles / rectangles. circles: [[x, y, z, diameter], ...], e.g. [[180, 267, 0, 4.9]]. rectangles: Lists of 4 corners, [[[x,y,z], [x,y,z], [x,y,z], [x,y,z]], ...].

Inputs: circles, instance, face_index, rectangles, +1 more. Returns: result

shellA

Hollow the active part's first body into a wall of even thickness — a housing, cup or box — leaving the chosen faces open. For sheet metal use add_sheet_metal_face and add_flange.

Pick the open faces with find_faces (e.g. normal=[0,0,1] for the top) right before this call. Returns the feature name and the change: a shell removes volume; a wall too thick for the body fails.

Args: thickness: Wall thickness in mm. remove_faces: Comma-separated face numbers from find_faces to leave open, e.g. "5". Empty = a closed hollow body. direction: "inside" (the outer size stays), "outside" or "both".

Inputs: instance, direction, thickness, remove_faces. Returns: result

sweepA

Sweep a sketch's closed profile along a path — a tube, handle, rail or wire form. Not sweep_rotation, which swings assembly components to check collisions.

The path is a second sketch whose lines and arcs join end to end (draw_line, draw_arc), on a plane across the profile's — e.g. the path on XZ, the profile on XY where the path starts. Arcs must join the lines tangentially, or the profile kinks and the sweep fails. Returns the feature name and the volume / topology change.

Args: path_sketch: Sketch number holding the path. sketch_index: Sketch number of the profile (0 = latest sketch). operation: "join" (add), "cut", "intersect" or "new" (a separate body). orientation: "normal" (the profile stays square to the path) or "parallel" (it keeps its original direction). taper: Draft angle in degrees; positive grows the profile along the path. twist: Rotation of the profile over the whole path, in degrees.

Inputs: path_sketch (required), taper, twist, instance, +3 more. Returns: result

sweep_rotationA

Rotate occurrences about an axis in steps and report collisions at each angle — e.g. check a door opens 0–110° on its hinge axis without hitting the body, or a lock tongue turns freely. Positions are restored afterwards.

Args: moving: Comma-separated occurrences that rotate together (door + lock + door studs). axis_point: A point on the axis, "x,y,z" in mm (e.g. the hinge pin). axis_dir: Axis direction, e.g. "0,1,0". start / stop / step: Angles in degrees. against: Occurrences to test; empty = everything else. measure_to: Optional occurrence to report the minimum distance to at each angle.

Inputs: moving (required), axis_dir (required), axis_point (required), step, +5 more. Returns: result

transactionA

Wrap multiple operations in one undo unit with rollback.

Args: action: "begin" before a risky multi-step build, then "commit" on success or "abort" to roll back EVERYTHING since begin in one step. name: label shown in Inventor's undo list.

Inputs: name, action, instance. Returns: result

use_content_centerA

Browse the Content Center and make member parts to place (place_components / place_components).

Step by step — each call is quick (the whole tree takes minutes to walk, so give a path): content_center() → top categories content_center("Structural Shapes") → sub-categories content_center("Structural Shapes/Channels") → families content_center("Structural Shapes/Channels", "DIN 1026-1") → sizes content_center("Structural Shapes/Channels", "DIN 1026-1", "U 100", length=1500) → part file path

Args: category: Category path, "/"-separated, as listed. family: Family name, as listed. size: Size designation as listed (spaces and case ignored). length: mm — a custom-length member (structural shapes). 0 = standard member. file_name: Where a custom member is saved (default: project workspace / Content Center Custom/ L.ipt).

Inputs: size, family, length, category, +2 more. Returns: result

Tool Schema Changelog

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

Loading tool schema changelog…

    TDQS

    A3.9/5.0

    Scored across 66 tools

    Disambiguation4/5

    Tools generally target distinct resources and operations, and descriptions explicitly resolve most overlaps (e.g. sweep vs sweep_rotation, feature pattern vs sketch pattern). Some cutting tools—extrude cut, add_hole, sheet_metal_cut, add_assembly_cut—and the multi-action manage_* tools require reading descriptions to choose correctly.

    Naming Consistency4/5

    Almost all names are snake_case with clear verb_noun or verb conventions, and they group predictably by manage_*, add_*, draw_*, check_*, and export_*. Minor deviations are conventional CAD operation names (fillet, extrude, loft, sweep) and mixed verbs for read operations (inspect_model, get_status, list_instances).

    Tool Count3/5

    66 tools is heavy for any MCP surface, and several sketch primitives and finders could be consolidated. However the count reflects the genuinely broad Inventor domain—part modeling, sheet metal, assembly, drawings, export, and validation—rather than gratuitous duplication.

    Completeness4/5

    Coverage is unusually complete across sketching, modeling, sheet metal, assembly, drawings, BOM, content center, import/export, and manufacturability checks. Remaining gaps are narrower operations such as editing existing sketch geometry, assembly-level component patterns/mirrors, and deleting files.

    Maintenance

    ActivityMaintained
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      D
      maintenance
      Enables natural language 3D modeling in Fusion 360 through an MCP server that translates user commands into Fusion 360 API calls. Supports creating, editing, and managing 3D objects, executing Python code, and capturing model views through conversational interactions.
      1
      MIT
    • A
      license
      Not graded
      quality
      F
      maintenance
      MCP server for parametric 3D modeling in Autodesk Inventor, enabling natural language control of sketching, extrusion, hole features, and sheet metal operations.
      53
      MIT
    • F
      license
      Not graded
      quality
      B
      maintenance
      Enables AI assistants to control Autodesk Inventor via COM automation for part modeling, assembly constraints, drawing views, and more.
      8
      -
    • A
      license
      Not graded
      quality
      C
      maintenance
      Enables natural-language control of Autodesk Inventor to create parametric parts, sketches, holes, and sheet-metal features, and to inspect, save, or export models.
      MIT