Follow a call that outlived the wait (a long job, or one stuck behind an Inventor dialog): elapsed time, any open dialog's text, execute_python's progress() line and latest output — and the call's result once it has finished. Safe to call at any time.

Args: wait_seconds: Wait up to this long (at most 45 s) for the running call to finish and return its result at once — instead of calling call_status again and again. Without a name, waits until the first of the running calls finishes.

Stop the running call — a long execute_python loop, a Content Center scan, a job that turned out wrong. cancelled() in execute_python code turns True at once (poll it in long loops to stop cleanly); code that hasn't stopped by itself after CANCEL_GRACE seconds gets a KeyboardInterrupt in the Inventor thread. That takes effect at the next Python line: a call stuck INSIDE one COM call (a long Inventor operation, or a modal dialog) stops only once that call returns.

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 call_status shows while a long job runs cancelled() — True once cancel_call asked to stop: poll it in long loops Variables you assign persist between calls until the server restarts or reload_api runs — 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. A call longer than the wait limit keeps running; follow it with call_status(wait_seconds=30), which shows the prints so far; cancel_call 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 cancel_call does (0 = none).

Run a Python file into this Inventor's execute_python namespace and keep it there: after reload_api or a new namespace it is loaded again by itself. For helper functions and cached objects (Content Center families…) you would otherwise redefine every time. A file at ~/.inventor-mcp/startup.py (or INVENTOR_MCP_STARTUP) is loaded the same way for every Inventor.

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.

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". focus: Assembly component name — zoom to it, keeping each view's direction. 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.

Compact snapshot of the active part: volume, bbox, faces/edges count, feature tree with names, sketches, sheet metal thickness. One call instead of several diagnostic queries.

Compact edge table of body 1: '[i] L=200.0 mid=(0.0,-225.0,0.8)' per line. Use to locate edges for flange/fillet/chamfer. min_length filters small edges (mm).

Compact face table of body 1: '[i] Plane A=90000 c=(0.0,225.0,12.5)' per line. Use to locate faces for sketching/cuts. min_area filters small faces (mm²).

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.

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.

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.

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.

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

Args: name: Display name for the part (optional). template: Template type — "metric" (mm, default), "english" (inches), or full path to .ipt file. material: Material from the library (list_materials), e.g. "Steel, Mild". part_number, description: iProperties for the BOM.

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.

Close documents that were never saved (Part12, Assembly3… left by failed attempts) without saving. Ones another open document references are kept.

Args: include_active: Close the active document too if it was never saved.

List open documents (name, path, type, unsaved changes) and which one is active. Tools act on the ACTIVE document — check here when juggling several parts.

Make an open document the active one (by display name or full path).

Export active document to another format.

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

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.

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

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.

Draw a line in a sketch. Coordinates in mm.

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

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

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

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

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

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

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

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

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 (list_faces). edge_indices: Or these edges, "3,7,8" (list_edges). body_index: Body in a multi-body part (1 = first). sketch_index: Sketch number (0 = latest sketch).

Extrude a sketch profile to create 3D geometry. Distance in mm.

Args: distance: Extrusion distance in mm. Ignored when extent_type="all". direction: Direction — positive, negative, or symmetric. operation: Boolean operation — join, cut, intersect, surface, or new. sketch_index: Sketch number to extrude (0 = latest sketch). extent_type: Extent type — "distance" (fixed distance, default) or "all" (through entire body).

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.

Add fillet (rounded edge) to edges of the solid body. Radius in mm.

Args: radius: Fillet radius in mm. edge_indices: Comma-separated edge indices (e.g. "1,2,3"). Use status() to see edge count.

Add chamfer (angled edge) to edges of the solid body. Distance in mm.

Args: distance: Chamfer distance in mm. edge_indices: Comma-separated edge indices (e.g. "1,2,3").

Create a native Inventor HoleFeature. Dimensions in mm. Creates a proper Hole feature (not extrude cut) — works with circular_pattern. Supports both plain drilled holes and tapped (threaded) metric holes.

Args: x: Hole center X in mm. y: Hole center Y in mm. diameter: Hole diameter in mm. For tapped holes this is the nominal thread diameter (e.g. 16 for M16). depth: Hole depth in mm. 0 = through-all (default). tapped: True = create tapped (threaded) hole with ISO Metric profile (6H). False = plain drilled hole. pitch: Thread pitch in mm (e.g. 2.0 for M16x2). 0 = auto-select standard coarse pitch.

Hole placed parametrically from two edges of a face (Linear placement). Survives part resizing — hole keeps its distance from the edges. Drill direction resolved automatically (volume check).

Args: face_axis/face_value: planar face to drill into, e.g. ("z", 25) = top face at Z=25mm. ref1_axis/ref1_value/dist1: first edge of that face + distance from it, e.g. ("x", -34.5, 8). ref2_axis/ref2_value/dist2: second edge + distance. diameter: hole diameter mm (or thread nominal if tapped, e.g. 5 for M5). depth: 0 = through-all, otherwise depth in mm. tapped: True = ISO metric thread 6H (standard coarse pitch unless pitch given). pitch: thread pitch mm (0 = auto standard coarse). cbore_diameter/cbore_depth: >0 adds counterbore seat (M5 ISO 4762: 10 and 5.5).

Create a circular (rotational) pattern of a feature around a work axis. Ideal for bolt holes around a flange — one hole + 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).

Get all parameters of the active document. Returns JSON list.

Set a parameter value by name.

Args: name: Parameter name (e.g. "d0", "width"). expression: New value or expression (e.g. "50 mm", "d0 * 2").

Add a new user parameter.

Args: name: Parameter name (e.g. "flange_diameter"). expression: Value or expression (e.g. "100", "width * 2"). units: Units — mm, cm, m, deg, etc.

Override the active sheet metal style's thickness. Use after create_part(template="sheet_metal"). If the shop has named rules (see list_sheet_metal_rules), use set_sheet_metal_rule instead — changing only the thickness leaves the rule's bend radius and unfold method unmatched.

List the sheet metal rules available in the active sheet metal part (name, thickness, bend radius, which one is active). Shops often encode their tooling in rule names, e.g. 'T15-V10' = 1.5 mm sheet, V10 die.

Activate a sheet metal rule by name (case-insensitive). Sets thickness, bend radius and unfold method together — prefer this over set_sheet_metal_thickness whenever a matching rule exists. Unknown names return the list of available rules.

Create a base Sheet Metal Face from a closed sketch profile. The first flat panel in a sheet metal part. Uses style's Thickness automatically.

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

Cut holes through the sheet, placed in WORLD coordinates (mm) on a face. Avoids the face-sketch axis confusion — no need to know the sketch's origin. Verifies material was removed (a cut on a work plane silently removes nothing).

Args: face_index: Face of the sheet to sketch on (use find_face / list_faces). circles: JSON list of [x, y, z, diameter], e.g. "[[180, 267, 0, 4.9]]". rectangles: JSON list of 4-corner lists, e.g. "[[[-150,-300,40],[150,-300,40],[150,-300,160],[-150,-300,160]]]".

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.

Cut through the panel — depth = Thickness automatically (parametric!). Sketch must be on the panel face (not a work plane): a cut that removes no material is deleted and reported as an error. For holes at known world coordinates, cut_on_face is easier. One sketch with multiple closed shapes = one Cut feature with multiple holes.

Find an edge by its midpoint coordinates (mm). Returns edge index (string). Useful for flange — locate the edge to bend without printing all edges.

Args: x/y/z: Target midpoint coordinates (mm). use_x/y/z: Set True for each coord that should be matched (False = ignored). tolerance: How close midpoint must be (mm). Default 0.1.

Find a planar face by its centroid coordinates (mm). Returns face index (string). Useful for sheet metal Cut — locate the outer panel face to sketch on.

Args: x/y/z: Target centroid coordinates (mm). use_x/y/z: Set True for each coord that should be matched. min_area: Minimum area in mm² (filters tiny edge faces). Default 100. tolerance: Centroid match tolerance (mm). Default 0.5.

List all features in the active part. Returns JSON list.

Delete one or more features by index. Use list_features() to find indices.

Args: indices: Comma-separated feature indices to delete (e.g. "3,4,5"). Deletes in reverse order automatically.

Suppress or unsuppress features (hide without deleting). Use list_features() to find indices.

Args: indices: Comma-separated feature indices (e.g. "3,4,5"). suppressed: True to suppress (hide), False to unsuppress (show).

Create a new empty assembly document (.iam).

Args: name: Display name for the assembly (optional). template: "metric" (mm, default), "english" (inches), or full path to an .iam file.

Place a part or sub-assembly into the active assembly. The file must exist on disk — save_document() the part first.

Args: path: Full path to the .ipt / .iam file. x: X position in mm (where the component's origin goes). y: Y position in mm. z: Z position in mm. grounded: Fix the component in space. Ground the FIRST component of every assembly, otherwise constraints move it instead of the others. x_axis: Optional orientation — where the component's X axis points, e.g. "0,0,1". y_axis: Where its Y axis points, e.g. "0,1,0" (must be perpendicular; Z = X × Y).

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

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.

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"; list_materials). mass_kg: Override the mass — for vendor models made of surfaces, which have no volume (a 1.23 kg motor showed 0.23 kg). material_report lists them.

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.

Material names in Inventor's libraries, e.g. search="steel" or "alum" — the exact names set_material / properties / create_part take.

Material and mass of every part of the active assembly (or part; below path for a sub-assembly): 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.

Args: path: Sub-assembly path to limit it to (list_occurrences(depth=2)). only_problems: Just the summary and the problems, no per-part rows.

Give many parts a material at once — every part of the active assembly whose name matches. Content Center and library parts are left alone. Save afterwards.

Args: material: From the library (list_materials), e.g. "Steel, Mild". parts: Name patterns, ","-separated, e.g. "PLATE,BRACKET" ("*" = all parts). only_generic: Only parts still on Generic / Default. path: Limit to a sub-assembly (list_occurrences(depth=2)).

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

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

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

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

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

Place many parts / sub-assemblies into the active assembly in one call — for frames of dozens or hundreds of members, where place_component one by one is slow.

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 (axes: where the part's own X/Y point; give both). Files must exist — all are checked before anything is placed.

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

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

Check overlap between occurrences of the active assembly. Touching faces are not reported. Intended overlaps (gasket compression) show up too — read the volume and bbox.

Args: set_a: Comma-separated occurrence names, e.g. "PANO_KAPAK:1". Use "Asm:1/2" for one part inside a sub-assembly (e.g. a vendor hinge's body). set_b: Names to test against; empty = everything else.

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

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.

Compact table of the assembly's components: '[1] block:1 pos=(0.0,0.0,0.0) grounded'. Indices feed the constrain tools.

Args: depth: 2+ also lists the components inside sub-assemblies, with their paths ("Frame:1/Post:2") for assembly_faces / constrain_faces / check_interference.

Find faces of a component anywhere in the assembly — also inside sub-assemblies — in TOP assembly coordinates (mm). Each result has a ref ("Sub:1/Part:1#F12") that constrain_faces takes. For a sub-assembly path, every part below it is searched.

Args: path: Component path from list_occurrences(depth=2), e.g. "Z AXIS:1/FIXED PLATE:1". 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.

Constrain two components by faces (refs from assembly_faces) or origin geometry ("Sub:1/Part:1#XY", "#X", "#ORIGIN") — anywhere in the assembly, sub-assemblies too. The constraint goes into the active (top) assembly.

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

Args: a, b: Refs. a is the one meant to move. kind: "mate" (faces against each other / axes in line), "flush" (faces the same way, side by side) or "angle". offset: mm for mate / flush. 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.

Snapshot of the active assembly: components with positions, constraint count, mass and volume. One call instead of several queries.

Constrain two components by their ORIGIN geometry — the parametric way to assemble. Origin constraints survive part edits; face picks break when topology renumbers.

Args: occurrence1: Index of the first component (see list_occurrences). geometry1: "XY", "XZ", "YZ", "X", "Y", "Z" or "ORIGIN". occurrence2: Index of the second component. geometry2: Same options as geometry1. kind: "mate" (planes face each other / axes collinear), "flush" (planes point the same way) or "angle". offset: Offset in mm for mate/flush. angle: Angle in degrees for kind="angle".

Insert constraint between two circular edges — a bolt into a hole in one call (aligns the axes AND seats the faces).

Args: occurrence1: Index of the first component. edge1: Circular edge index on that component (see list_component_edges). occurrence2: Index of the second component. edge2: Circular edge index on that component. offset: Distance between the two circle planes in mm. axes_opposed: True = the components face each other (normal bolt/hole case).

Edge table of one placed component in its own part coordinates: '[1] circle D=10.0 c=(0.0,0.0,10.0)'. Use to pick edges for constrain_insert.

Args: occurrence: Component index (see list_occurrences). circular_only: Only list circular edges (the ones Insert can use). max_count: Maximum rows to return.

List the assembly constraints with their indices.

Delete an assembly constraint by index (see list_constraints).

Ground (fix in space) or unground a component.

Args: index: Component index (see list_occurrences). grounded: True to ground, False to release.

Remove a component from the assembly (see list_occurrences for the index).