inventor-mcp-server
Drive Autodesk Inventor from an MCP client to build and inspect parametric 3D parts, assemblies, and shop-floor outputs in natural language.
Sketching: create sketches, rectangles, circles, lines, polygons, arcs, slots, patterns, closed profiles with arcs, offsets, projected edges, and sketch diagnostics.
3D modeling: extrude, revolve, loft, sweep, shell, fillet, chamfer, specify holes (drilled/tapped/counterbore), and convert surfaces to solids.
Patterns & mirroring: circular/rectangular feature patterns and body/feature mirroring.
Sheet metal: rules, base faces, contour profiles, flanges, corner rounds, cuts, flat-pattern checks, and DXF/DWG export.
Assemblies: create assemblies, place/import components (including STEP), ground, constrain (mate/flush/angle/insert), assembly cuts, and interference/distance/rotation-sweep checks.
Inspection & validation: find faces/edges, inspect models, check sketches, fastener alignment, manufacturability, and capture rendered views as images.
Outputs: export STEP/IGES/SAT/STL, BOM (CSV), flat patterns, and PDF drawings with dimensions, sections, parts lists, and balloons.
Documents & libraries: manage documents, save safely, edit iProperties/materials, browse Content Center, build steel frame members, manage parameters and features.
Automation & control:
execute_pythonwith persistent namespace,load_library, transactions with rollback, background call following/cancel, and support for multiple Inventor instances.
Drives Autodesk Inventor via its COM API to build parametric 3D models from natural language — sketching, extrude/revolve, native hole features (drilled, tapped, counterbore), fillets, chamfers, circular patterns, and sheet metal, plus assembly placement and constraints (mate/flush/angle/insert) and parameter management, with volume/topology deltas reported after each feature.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@inventor-mcp-server Build an 80x80x4 mm sheet-metal bracket with two M6 mounting holes"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
inventor-mcp-server
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, andsweep_rotationto check a door or lock moves freely through its whole rangeAssemblies (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_pythonpower 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 stepOne tool per job — 66 tools with verb_noun names:
find_faces/find_edgeswork in a part and at any depth of an assembly,constraintakes origin geometry, faces and edges, andmanage_*tools group what you do to documents, occurrences, features, parameters, constraints, materials and sheet metal rulesProtects your files —
save_documentsaves only the active document unless asked, never a library or Content Center file; add your own paths withINVENTOR_MCP_PROTECTEDor~/.inventor-mcp/protected.txt. Deleting a component says what depends on it first, and reports what moved; replacing one reports the constraints it lostNever hangs on a dialog — calls run with
SilentOperationon 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 andprogress()line so far — and returns the result the moment it finishes;manage_call(action="cancel")stops itDo the holes line up? —
check_fastener_alignmentcompares 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 thatChecks before the shop does —
check_manufacturabilityreads 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 coatShop-floor outputs —
export_flat_patterngives the flat size and writes the DXF/DWG for the laser (contour, holes and bend lines on their own layers);create_drawingmakes 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_bomlists the assembly's parts with quantity, part number, description, material and mass (CSV for Excel / ERP);edit_propertiesreads and sets part number, description, stock number, material and custom propertiesReal arcs in sketches —
draw_closed_profiletakes rounded corners ([x, y, r]) and arcs through a point, plusdraw_rectangle(corner_radius),draw_slot,draw_arcandproject_edges(exact edges of a body, for remodelling). Arcs go through three points, so a sketch with flipped axes can't mirror them;inspect_modelwarns when a curve was drawn as many short lines.draw_patterndraws grids and circles of holes / slots,offset_profileoffsets loops, andcheck_sketch(also built into extrude's error) points at the gap that keeps a profile openSees its own work —
capture_viewreturns pictures of the model (iso / front / top / … , several in one call, zoom to components, isolate them, or from any point withlook_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 glanceSteel frames —
add_frame_memberslays 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 sSurfaces to solids —
convert_surfaces_to_solidknits 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 closeMaterials in bulk —
manage_materialsgives 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 massNested assemblies —
find_facesfinds faces of components inside sub-assemblies (type, normal, position, diameter) in top coordinates;constrainconstrains them, corrects a wrong offset sign from where the face must land, and reports any other component the constraint dragged alongContent Center and big assemblies —
use_content_centerbrowses categories → families → sizes and makes members, custom length included (a 1500 mm DIN 1026-1 U 100 in one call);place_componentsplaces dozens of components with position, orientation, name and grounding in one callAgent-friendly Python —
execute_pythonerrors show the traceback from the agent's own lines (also in helpers defined in earlier calls), stderr is captured, andundo_on_error=Truerolls 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_documentchecks the path first instead of failing with E_INVALIDARG and never rewrites library or Content Center files;manage_documentsclears the Part12s left by failed attemptsSeveral 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 takesinstance=to pick one, and each has its own call thread andexecute_pythonnamespace, so one agent's long call doesn't hold up the other.list_instancesshows 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 clientconnect(project=…)gets them backTransactions — 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 renamedFastMCPtoMCPServer; the server detects which is installed)An MCP client — used daily with Claude Code and Claude Desktop (several agents at once, see below)
Installation
Clone this repository:
git clone https://github.com/cenitu/inventor-mcp-server.gitInstall dependencies:
pip install "mcp[cli]" pywin32Register the server with your MCP client. For Claude Code, add to
.mcp.jsonin your project root (see.mcp.json.example). Use the absolute path toinventor_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 ignorescwdand starts the server from your project root, where the package can't be found — the process exits immediately and the client only reportsConnection closed. Pointing at the script by absolute path works from any directory.Configs written for 0.2.x that point at
src/server.pystill work — that file now forwards to theinventor_mcp_serverpackage — 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.)Restart the MCP client (MCP servers load at session start), start Inventor, then ask your AI assistant to build something.
Avoid
win32com.client.gencache.EnsureDispatchandCastToin your own scripts against the same Python install — they generate agen_pycache that breaks plainGetActiveObject(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_pyif 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 → Developershould then listinventoras 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:
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.With several connected, every call carries
instance=<name>(the agent learns the name fromconnect); a call without it is refused instead of guessing.list_instancesshows them all.Each Inventor has its own call thread,
execute_pythonnamespace andmanage_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_instanceslists 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'sconnect(project=…)gets the same Inventor back, open documents and all (connect(pid=…)picks one explicitly;list_instancesshows 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 --ownstarts its own Inventor and quits it. Exit your own scripts a few seconds afterapp.Quit(): a process that ends right away can leave a windowlessInventor.exebehind — 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 workIt 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).
Skills (optional, recommended)
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 orientation19201/19202/19203, …)ChamferFeatures.AddUsingDistance(EdgeCollection, d)— the 2026 replacement for the removedCreateChamferDefinitionSheet-metal
FlangeDefinition: the Distance argument is silently ignored; the real height is set viafeature.Definition.HeightExtent.Distance.Expression(and the angle is in radians — pass90and you get 5156°)CreateLinearPlacementDefinitionrequires aBiasPointargument that dynamic dispatch won't tell you aboutEdge 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/apiContributing
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.pyand 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 toolsadd_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_viewARead-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_alignmentARead-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_interferenceARead-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_sketchARead-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_edgesARead-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_facesARead-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_statusARead-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_modelBRead-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_instancesARead-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_distanceARead-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:
create_sketch("XY")
draw_closed_profile([[0,0],[30,0],[30,8],[15,60],[0,60]]) ← profile only
revolve(axis="Y", operation="join")
For a revolve CUT (e.g. groove):
create_sketch("XY")
draw_closed_profile([[8,26],[15,26],[15,34],[8,34]]) ← groove cross-section
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
Scored across 66 tools
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.
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).
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.
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
Related MCP Connectors
Parametric 3D CAD for AI agents: build print-ready parts, check them, export STL, 3MF or STEP.
Text-to-CAD: build exact STEP or 3MF/STL on the server, each stated requirement measured.
Generate game-ready 3D models, textures, and audio from natural language, over MCP.
CAD in ChatGPT and Claude: editable parts, STEP/STL/drawings, in-chat 3D, automatic checks.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceEnables 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.1MIT
- AlicenseNot gradedqualityFmaintenanceMCP server for parametric 3D modeling in Autodesk Inventor, enabling natural language control of sketching, extrusion, hole features, and sheet metal operations.53MIT
- FlicenseNot gradedqualityBmaintenanceEnables AI assistants to control Autodesk Inventor via COM automation for part modeling, assembly constraints, drawing views, and more.8-
- AlicenseNot gradedqualityCmaintenanceEnables natural-language control of Autodesk Inventor to create parametric parts, sketches, holes, and sheet-metal features, and to inspect, save, or export models.MIT