# Autodesk Inventor (pypi · inventor-mcp-server)

Parametric 3D modeling in Autodesk Inventor: sketches, features, sheet metal, assemblies

- Trust score: 74/100 (medium)
- Change this week: −1
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-11-04

## Components

- pypi · `inventor-mcp-server`: 74/100 (this document), [markdown](https://verifymcp.io/servers/cenitu-inventor-mcp-server/inventor-mcp-server.md), [page](https://verifymcp.io/servers/cenitu-inventor-mcp-server/inventor-mcp-server)

## Channel facts

- Registry: `pypi`
- Package: `inventor-mcp-server`
- Version: `1.0.1`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-11-04.

- **Supply Chain Security**: 100/100
  - No malware found by supply-chain analysis.
  - No known CVEs affecting this package version or its production dependencies.
  - Runs setuptools.build_meta at install time, a recognised build step with no custom scripting around it.
  - 1 of 28 dependencies flagged as unhealthy.
- **Provenance & Transparency**: 97/100
  - Source repository is publicly reachable at the declared URL.
  - Cryptographically verified build provenance (signed, bound to cenitu/inventor-mcp-server).
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 3 days ago).
  - Disclosure check failed: no security disclosure policy was found in the source repository.
- **Schema Quality & AI Usability**: 56/100
  - AI-judged instruction clarity (good).
  - Context-footprint check failed: tool/resource definitions use about 12186 tokens (~213/item across 57 items; 57 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 0/100
  - Stability check failed: the tool surface changed between 0.9.0 and 1.0.1: 53 tool removals, 1 breaking changes, 28 additions.
- **Tool Coverage**: 77/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 19% of tool parameters carry a description.
  - Structured output schemas are declared (98% of tools); any adoption earns full credit.
- **Tool Safety**: 75/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - 0 of 1 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation; "execute_python" implies "execute" and declares no destructiveHint at all, which the MCP spec reads as destructive by default.
  - An AI judge read all 58 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a current MCP spec version (2026-07-28).

## Install

### How do I install the Autodesk Inventor MCP server?

Autodesk Inventor runs locally as a PyPI package, launched with uvx inventor-mcp-server. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add cenitu-inventor-mcp-server -- uvx inventor-mcp-server
```

### Cursor

```json
{
  "mcpServers": {
    "cenitu-inventor-mcp-server": {
      "command": "uvx",
      "args": [
        "inventor-mcp-server"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "cenitu-inventor-mcp-server": {
      "command": "uvx",
      "args": [
        "inventor-mcp-server"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add cenitu-inventor-mcp-server -- uvx inventor-mcp-server
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "cenitu-inventor-mcp-server": {
      "type": "local",
      "command": [
        "uvx",
        "inventor-mcp-server"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add cenitu-inventor-mcp-server --command uvx --arg inventor-mcp-server
```

### Hermes

```yaml
mcp_servers:
  cenitu-inventor-mcp-server:
    command: "uvx"
    args: ["inventor-mcp-server"]
```

### Netclaw

```json
{
  "McpServers": {
    "cenitu-inventor-mcp-server": {
      "Transport": "stdio",
      "Command": "uvx",
      "Arguments": [
        "inventor-mcp-server"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add cenitu-inventor-mcp-server -t stdio -c uvx -a inventor-mcp-server
```

### Other

```json
{
  "mcpServers": {
    "cenitu-inventor-mcp-server": {
      "command": "uvx",
      "args": [
        "inventor-mcp-server"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-11-04 (score 74, +15)

- [security improvement] Malware scan: unverified → pass

### 2026-11-03 (score 59, −15)

- [security regression] Malware scan: pass → unverified
- [functional regression] Security disclosure: unverified → fail

### 2026-11-02 (score 74, 0)

- [functional regression] Security disclosure: fail → unverified

### 2026-11-01 (score 74, +15)

- [security improvement] Malware scan: unverified → pass
- [functional] Package version: 0.4.0 → 1.0.1

### 2026-10-31 (score 59, −16)

- [security regression] Stability: unverified → fail
- [security regression] Malware scan: pass → unverified
- [functional regression] Schema quality: 162 → 213
- [functional regression] Schema quality: 162 → 205
- [functional] Package version: 0.9.0 → 1.0.1
- [functional] Package version: 0.9.0 → 1.0.0

### 2026-10-30 (score 75, +15)

- [security improvement] Malware scan: unverified → pass

### 2026-10-29 (score 60, −15)

- [security regression] Malware scan: pass → unverified

### 2026-10-28 (score 75, +15)

- [security improvement] Malware scan: unverified → pass

## MCP tools (57)

### `execute_python` (~515 tokens)

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 i…

Input parameters:

- `code` (string, required)
- `instance` (string): Which connected Inventor to use (list_instances). Leave empty when only one is connected.
- `timeout` (number)
- `undo_on_error` (boolean)

Output parameters:

- `result` (string)

### `load_library` (~141 tokens)

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.

Input parameters:

- `instance` (string): Which connected Inventor to use (list_instances). Leave empty when only one is connected.
- `path` (string, required)

Output parameters:

- `result` (string)

### `reload_api` (~68 tokens)

Hot-reload inventor_api.py from disk. Use after editing the wrapper —
no Claude Code restart needed. Keeps the COM connections; clears this Inventor's
execute_python namespace.

Input parameters:

- `instance` (string): Which connected Inventor to use (list_instances). Leave empty when only one is connected.

Output parameters:

- `result` (string)

### `capture_view` (~347 tokens)

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.

Input parameters:

- `background` (string)
- `fit_to` (string)
- `height` (integer)
- `instance` (string): Which connected Inventor to use (list_instances). Leave empty when only one is connected.
- `isolate` (string)
- `sketches` (boolean)
- `up` (string)
- `views` (string)
- `width` (integer)

### `transaction` (~104 tokens)

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.

Input parameters:

- `action` (string)
- `instance` (string): Which connected Inventor to use (list_instances). Leave empty when only one is connected.
- `name` (string)

Output parameters:

- `result` (string)

### `connect` (~251 tokens)

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=<that name> 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.

Input parameters:

- `instance` (string): Name for this Inventor — pass the same name to later calls. Default: 'default', or the project's name when the server starts one for it.
- `new_instance` (boolean)
- `pid` (integer)
- `project` (string)
- `visible` (boolean)

Output parameters:

- `result` (string)

### `list_instances` (~46 tokens)

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.

Output parameters:

- `result` (string)

### `get_status` (~76 tokens)

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.

Input parameters:

- `instance` (string): Which connected Inventor to use (list_instances). Leave empty when only one is connected.

Output parameters:

- `result` (string)

### `find_faces` (~285 tokens)

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.

Input parameters:

- `at`
- `diameter` (number)
- `instance` (string): Which connected Inventor to use (list_instances). Leave empty when only one is connected.
- `max_count` (integer)
- `min_area` (number)
- `normal`
- `path` (string)
- `surface` (string)

Output parameters:

- `result` (string)

### `find_edges` (~232 tokens)

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.

Input parameters:

- `at`
- `circular` (boolean)
- `diameter` (number)
- `instance` (string): Which connected Inventor to use (list_instances). Leave empty when only one is connected.
- `max_count` (integer)
- `min_length` (number)
- `path` (string)

Output parameters:

- `result` (string)

### `inspect_model` (~87 tokens)

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.

Input parameters:

- `instance` (string): Which connected Inventor to use (list_instances). Leave empty when only one is connected.

Output parameters:

- `result` (string)

### `manage_features` (~98 tokens)

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".

Input parameters:

- `action` (string)
- `indices` (string)
- `instance` (string): Which connected Inventor to use (list_instances). Leave empty when only one is connected.

Output parameters:

- `result` (string)

### `manage_parameters` (~137 tokens)

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, …

Input parameters:

- `action` (string)
- `expression` (string)
- `instance` (string): Which connected Inventor to use (list_instances). Leave empty when only one is connected.
- `name` (string)
- `units` (string)

Output parameters:

- `result` (string)

### `manage_sheet_metal_rules` (~158 tokens)

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".

Input parameters:

- `action` (string)
- `instance` (string): Which connected Inventor to use (list_instances). Leave empty when only one is connected.
- `name` (string)
- `thickness` (number)

Output parameters:

- `result` (string)

### `manage_materials` (~306 tokens)

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.

Input parameters:

- `action` (string)
- `instance` (string): Which connected Inventor to use (list_instances). Leave empty when only one is connected.
- `material` (string)
- `only_generic` (boolean)
- `only_problems` (boolean)
- `parts` (string)
- `path` (string)
- `search` (string)

Output parameters:

- `result` (string)

### `manage_constraints` (~123 tokens)

List the active assembly's constraints with their numbers, flagging any in an error
state; or delete one. To add one use constrain. Deleting frees the components it held, and
the numbers after it shift — list again before deleting another.

Args:
    action: "list" or "delete".
    index: For "delete": the constraint's number from list.

Input parameters:

- `action` (string)
- `index` (integer)
- `instance` (string): Which connected Inventor to use (list_instances). Leave empty when only one is connected.

Output parameters:

- `result` (string)

### `manage_occurrences` (~369 tokens)

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 4017*M8*", 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.

Args:
    action: "list", "find", "ground" or "delete".
    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".

Input parameters:

- `action` (string)
- `axis`
- `cascade` (boolean)
- `definition` (string)
- `depth` (integer)
- `force` (boolean)
- `grounded` (boolean)
- `instance` (string): Which connected Inventor to use (list_instances). Leave empty when only one is connected.
- `near`
- `path` (string)
- `within` (number)

Output parameters:

- `result` (string)

### `manage_documents` (~273 tokens)

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.

Input parameters:

- `action` (string)
- `discard` (boolean)
- `include_active` (boolean)
- `instance` (string): Which connected Inventor to use (list_instances). Leave empty when only one is connected.
- `name_or_path` (string)
- `quit_inventor` (boolean)

Output parameters:

- `result` (string)

### `create_document` (~190 tokens)

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.

Input parameters:

- `description` (string)
- `instance` (string): Which connected Inventor to use (list_instances). Leave empty when only one is connected.
- `kind` (string)
- `material` (string)
- `name` (string)
- `part_number` (string)
- `template` (string)

Output parameters:

- `result` (string)

### `add_hole` (~383 tokens)

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.

Input parameters:

- `cbore_depth` (number)
- `cbore_diameter` (number)
- `depth` (number)
- `diameter` (number)
- `direction`
- `instance` (string): Which connected Inventor to use (list_instances). Leave empty when only one is connected.
- `linear`
- `pitch` (number)
- `point`
- `tapped` (boolean)
- `x` (number)
- `y` (number)

Output parameters:

- `result` (string)

### `sheet_metal_cut` (~227 tokens)

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]], ...].

Input parameters:

- `circles`
- `face_index` (integer)
- `instance` (string): Which connected Inventor to use (list_instances). Leave empty when only one is connected.
- `rectangles`
- `sketch_index` (integer)

Output parameters:

- `result` (string)

### `place_components` (~255 tokens)

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.

Input parameters:

- `atomic` (boolean)
- `components` (array, required)
- `instance` (string): Which connected Inventor to use (list_instances). Leave empty when only one is connected.
- `skip_if_exists` (boolean)

Output parameters:

- `result` (string)

### `constrain` (~381 tokens)

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).

Input parameters:

- `a` (string, required)
- `a_at`
- `angle` (number)
- `axes_opposed` (boolean)
- `b` (string, required)
- `instance` (string): Which connected Inventor to use (list_instances). Leave empty when only one is connected.
- `kind` (string)
- `offset` (number)

Output parameters:

- `result` (string)

### `manage_call` (~204 tokens)

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 — and the
result once it has finished. wait_seconds waits (at most 45 s) and returns as soon as it ends.
"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".

Input parameters:

- `action` (string)
- `instance` (string): Which connected Inventor to use (list_instances). Leave empty when only one is connected.
- `wait_seconds` (number)

Output parameters:

- `result` (string)

### `save_document` (~260 tokens)

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.

Input parameters:

- `instance` (string): Which connected Inventor to use (list_instances). Leave empty when only one is connected.
- `overwrite` (boolean)
- `path` (string)
- `save_dependents` (boolean)

Output parameters:

- `result` (string)

### `export_document` (~152 tokens)

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.

Input parameters:

- `format` (string)
- `instance` (string): Which connected Inventor to use (list_instances). Leave empty when only one is connected.
- `path` (string, required)

Output parameters:

- `result` (string)

### `create_sketch` (~183 tokens)

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.

Input parameters:

- `face_index` (integer)
- `instance` (string): Which connected Inventor to use (list_instances). Leave empty when only one is connected.
- `offset` (number)
- `plane` (string)

Output parameters:

- `result` (string)

### `draw_rectangle` (~154 tokens)

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).

Input parameters:

- `corner_radius` (number)
- `height` (number)
- `instance` (string): Which connected Inventor to use (list_instances). Leave empty when only one is connected.
- `sketch_index` (integer)
- `width` (number)
- `x` (number)
- `y` (number)

Output parameters:

- `result` (string)

### `draw_circle` (~164 tokens)

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.

Input parameters:

- `construction` (boolean)
- `diameter` (number)
- `instance` (string): Which connected Inventor to use (list_instances). Leave empty when only one is connected.
- `sketch_index` (integer)
- `x` (number)
- `y` (number)

Output parameters:

- `result` (string)

### `draw_line` (~202 tokens)

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).

Input parameters:

- `construction` (boolean)
- `instance` (string): Which connected Inventor to use (list_instances). Leave empty when only one is connected.
- `sketch_index` (integer)
- `x1` (number)
- `x2` (number)
- `y1` (number)
- `y2` (number)

Output parameters:

- `result` (string)

### `draw_polygon` (~136 tokens)

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).

Input parameters:

- `instance` (string): Which connected Inventor to use (list_instances). Leave empty when only one is connected.
- `radius` (number)
- `sides` (integer)
- `sketch_index` (integer)
- `x` (number)
- `y` (number)

Output parameters:

- `result` (string)

### `draw_closed_profile` (~272 tokens)

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).

Input parameters:

- `instance` (string): Which connected Inventor to use (list_instances). Leave empty when only one is connected.
- `points` (required)
- `sketch_index` (integer)

Output parameters:

- `result` (string)

### `draw_arc` (~227 tokens)

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).

Input parameters:

- `cx`
- `cy`
- `instance` (string): Which connected Inventor to use (list_instances). Leave empty when only one is connected.
- `sketch_index` (integer)
- `x1` (number, required)
- `x2` (number, required)
- `xm`
- `y1` (number, required)
- `y2` (number, required)
- `ym`

Output parameters:

- `result` (string)

### `draw_slot` (~153 tokens)

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).

Input parameters:

- `angle` (number)
- `instance` (string): Which connected Inventor to use (list_instances). Leave empty when only one is connected.
- `length` (number, required)
- `sketch_index` (integer)
- `width` (number, required)
- `x` (number, required)
- `y` (number, required)

Output parameters:

- `result` (string)

### `draw_pattern` (~309 tokens)

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).

Input parameters:

- `angle` (number)
- `columns` (integer)
- `corner_radius` (number)
- `count` (integer)
- `diameter` (number)
- `dx` (number)
- `dy` (number)
- `instance` (string): Which connected Inventor to use (list_instances). Leave empty when only one is connected.
- `length` (number)
- `pcd` (number)
- `rows` (integer)
- `shape` (string)
- `sketch_index` (integer)
- `start_angle` (number)
- `width` (number)
- `x` (number)
- `y` (number)

Output parameters:

- `result` (string)

### `check_sketch` (~136 tokens)

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).

Input parameters:

- `instance` (string): Which connected Inventor to use (list_instances). Leave empty when only one is connected.
- `sketch_index` (integer)

Output parameters:

- `result` (string)

### `offset_profile` (~133 tokens)

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).

Input parameters:

- `distance` (number, required)
- `instance` (string): Which connected Inventor to use (list_instances). Leave empty when only one is connected.
- `side` (string)
- `sketch_index` (integer)

Output parameters:

- `result` (string)

### `project_edges` (~183 tokens)

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).

Input parameters:

- `body_index` (integer)
- `edge_indices` (string)
- `face_index` (integer)
- `instance` (string): Which connected Inventor to use (list_instances). Leave empty when only one is connected.
- `sketch_index` (integer)

Output parameters:

- `result` (string)

### `extrude` (~285 tokens)

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.

Input parameters:

- `direction` (string)
- `distance` (number)
- `extent_type` (string)
- `instance` (string): Which connected Inventor to use (list_instances). Leave empty when only one is connected.
- `operation` (string)
- `sketch_index` (integer)

Output parameters:

- `result` (string)

### `revolve` (~305 tokens)

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.

Input parameters:

- `angle` (number)
- `axis` (string)
- `instance` (string): Which connected Inventor to use (list_instances). Leave empty when only one is connected.
- `operation` (string)
- `sketch_index` (integer)

Output parameters:

- `result` (string)

### `fillet` (~183 tokens)

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".

Input parameters:

- `edge_indices` (string)
- `instance` (string): Which connected Inventor to use (list_instances). Leave empty when only one is connected.
- `radius` (number)

Output parameters:

- `result` (string)

### `chamfer` (~152 tokens)

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".

Input parameters:

- `distance` (number)
- `edge_indices` (string)
- `instance` (string): Which connected Inventor to use (list_instances). Leave empty when only one is connected.

Output parameters:

- `result` (string)

### `add_circular_pattern` (~163 tokens)

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).

Input parameters:

- `angle` (number)
- `axis` (string)
- `count` (integer)
- `feature_index` (integer, required)
- `instance` (string): Which connected Inventor to use (list_instances). Leave empty when only one is connected.

Output parameters:

- `result` (string)

### `add_sheet_metal_face` (~140 tokens)

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).

Input parameters:

- `instance` (string): Which connected Inventor to use (list_instances). Leave empty when only one is connected.
- `sketch_index` (integer)

Output parameters:

- `result` (string)

### `add_flange` (~318 tokens)

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".

Input parameters:

- `angle` (number)
- `auto_miter` (boolean)
- `distance` (number)
- `edge_indices` (string, required)
- `height_datum` (string)
- `instance` (string): Which connected Inventor to use (list_instances). Leave empty when only one is connected.
- `miter_gap` (string)

Output parameters:

- `result` (string)

### `add_corner_round` (~106 tokens)

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.

Input parameters:

- `edge_indices` (string, required)
- `instance` (string): Which connected Inventor to use (list_instances). Leave empty when only one is connected.
- `radius` (number)

Output parameters:

- `result` (string)

### `export_flat_pattern` (~177 tokens)

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).

Input parameters:

- `bend_lines` (boolean)
- `format` (string)
- `instance` (string): Which connected Inventor to use (list_instances). Leave empty when only one is connected.
- `path` (string)

Output parameters:

- `result` (string)

### `export_bom` (~146 tokens)

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.

Input parameters:

- `instance` (string): Which connected Inventor to use (list_instances). Leave empty when only one is connected.
- `path` (string)
- `view` (string)

Output parameters:

- `result` (string)

### `edit_properties` (~221 tokens)

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.

Input parameters:

- `instance` (string): Which connected Inventor to use (list_instances). Leave empty when only one is connected.
- `mass_kg` (number)
- `material` (string)
- `values`

Output parameters:

- `result` (string)

### `convert_surfaces_to_solid` (~233 tokens)

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.

Input parameters:

- `instance` (string): Which connected Inventor to use (list_instances). Leave empty when only one is connected.
- `patch_holes` (boolean)
- `tolerance` (number)
- `work_surfaces` (string)

Output parameters:

- `result` (string)

### `create_drawing` (~301 tokens)

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()).
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).

Input parameters:

- `drawing_path` (string)
- `flat` (boolean)
- `instance` (string): Which connected Inventor to use (list_instances). Leave empty when only one is connected.
- `pdf_path` (string, required)
- `scale` (number)
- `template` (string)
- `views` (string)

Output parameters:

- `result` (string)

### `use_content_center` (~287 tokens)

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/<family> <size> L<length>.ipt).

Input parameters:

- `category` (string)
- `family` (string)
- `file_name` (string)
- `instance` (string): Which connected Inventor to use (list_instances). Leave empty when only one is connected.
- `length` (number)
- `size` (string)

Output parameters:

- `result` (string)

### `add_frame_members` (~347 tokens)

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).

Input parameters:

- `category` (string)
- `family` (string)
- `folder` (string)
- `instance` (string): Which connected Inventor to use (list_instances). Leave empty when only one is connected.
- `members` (array, required)
- `size` (string)

Output parameters:

- `result` (string)

### `import_step` (~191 tokens)

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).

Input parameters:

- `dest_folder` (string, required)
- `instance` (string): Which connected Inventor to use (list_instances). Leave empty when only one is connected.
- `name` (string)
- `step_path` (string, required)

Output parameters:

- `result` (string)

### `check_interference` (~196 tokens)

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.

Input parameters:

- `ignore_fasteners` (boolean)
- `instance` (string): Which connected Inventor to use (list_instances). Leave empty when only one is connected.
- `set_a` (string, required)
- `set_b` (string)

Output parameters:

- `result` (string)

### `measure_distance` (~84 tokens)

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.

Input parameters:

- `a` (string, required)
- `b` (string, required)
- `instance` (string): Which connected Inventor to use (list_instances). Leave empty when only one is connected.

Output parameters:

- `result` (string)

### `sweep_rotation` (~243 tokens)

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.

Input parameters:

- `against` (string)
- `axis_dir` (string, required)
- `axis_point` (string, required)
- `instance` (string): Which connected Inventor to use (list_instances). Leave empty when only one is connected.
- `measure_to` (string)
- `moving` (string, required)
- `start` (number)
- `step` (number)
- `stop` (number)

Output parameters:

- `result` (string)

## Diagnostics

Captured diagnostic sections: Provenance, Install scripts, Dependencies. The full working is on the page: https://verifymcp.io/servers/cenitu-inventor-mcp-server/inventor-mcp-server#diagnostics

## Score history

- 2026-11-04: 74
- 2026-11-03: 59
- 2026-11-02: 74
- 2026-11-01: 74
- 2026-10-31: 59
- 2026-10-30: 75
- 2026-10-29: 60
- 2026-10-28: 75
- 2026-10-27: 60
- 2026-10-26: 34
- 2026-10-25: 49
- 2026-10-24: 34

## Common questions

### What is the Autodesk Inventor MCP server?

Autodesk Inventor is an MCP server listed in the public MCP registry as io.github.cenitu/inventor-mcp-server. Parametric 3D modeling in Autodesk Inventor: sketches, features, sheet metal, assemblies. This page covers its PyPI package (inventor-mcp-server).

### Is the Autodesk Inventor MCP server safe to use?

Autodesk Inventor scores 74 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 4 November 2026. Its build provenance is signed and verified. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the Autodesk Inventor MCP server expose?

Autodesk Inventor exposes 57 tools: execute_python, load_library, reload_api, capture_view, transaction, and 52 more. Their descriptions and schemas cost roughly 11,998 tokens of context every time the server is loaded.

### Is the Autodesk Inventor MCP server still maintained?

Autodesk Inventor is still listed as active in the MCP registry. We last reached this channel on 4 November 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

### What licence is the Autodesk Inventor MCP server under?

Autodesk Inventor declares the MIT licence, which is OSI-approved. That covers the source only, and says nothing about the cost of any service it calls.

## Links

- PyPI project: https://pypi.org/project/inventor-mcp-server/
- Socket report: https://socket.dev/pypi/package/inventor-mcp-server
- Repository: https://github.com/cenitu/inventor-mcp-server
- Changelog RSS feed: https://verifymcp.io/servers/cenitu-inventor-mcp-server/inventor-mcp-server.xml
- Changelog JSON feed: https://verifymcp.io/servers/cenitu-inventor-mcp-server/inventor-mcp-server.json
- HTML version of this page: https://verifymcp.io/servers/cenitu-inventor-mcp-server/inventor-mcp-server