SolidworksMCP

SolidworksMCP is a production-oriented Model Context Protocol server for controlling a live SOLIDWORKS session through the Windows COM API.

This is a fork of alisamsam/Solidworks-MCP that extends it from 82 to 143 tools, adding drawings, assembly editing, sheet metal, manufacturing package export and document reference tracing. See What this fork adds.

Current release: 6.5.31. The release was acceptance-tested with SOLIDWORKS 2026 SP2.1 and retains compatibility guards for SOLIDWORKS 2025.

Highlights

• Native sketch, feature, body, reference-geometry, view, probe, and export operations.
• Transactional CAD plans with checkpoints, invariants, idempotency, budgets, and rollback.
• Parametric sketches with named entities, constraints, dimensions, equations, persistent IDs, and degree-of-freedom analysis.
• Multibody tools with explicit merge scope, clearance, interference, bounding box, and volume verification.
• Deterministic raster-to-sketch pipelines for silhouettes and line art, including GPU-backed segmentation, topology preservation, primitive fitting, and reverse-raster quality gates.
• Native sketch/body export and calibrated geometric comparison instead of screenshot-only acceptance.
• Verified active-sketch Normal To and Fit to Screen. The server reads the resulting camera matrix and pixel occupancy instead of trusting a UI command.
• Drawing documents end to end: sheets, views, model annotations, manual dimensions, notes, balloons, centre marks, and BOM tables.
• Assembly editing: components, mates, patterns, suppression, replacement, and exploded views.
• Sheet metal from base flange to flat pattern DXF, and a one-call manufacturing package that exports STEP, DXF and PDF for a whole assembly.
• Document search and reference tracing in both directions, including where-used across a project folder.
• Structured diagnostics, modal-dialog preflight, a narrowly scoped Modify watchdog, and finite recovery policies.

What this fork adds

This repository is a fork of alisamsam/Solidworks-MCP. The upstream release exposed 82 tools covering sketches, solid features, bodies, probes, vectorization and the transactional layer. This fork brings that to 143 tools and the test suite from 155 to 382 tests, all of which pass.

The additions follow the discipline the upstream project already established: no COM return value is trusted. Every new operation reads the resulting state back - annotation counts, component lists, suppression flags, face counts, files on disk - and reports failure when the model does not actually show the change, rather than when the API says so.

Drawings (17 tools)

Upstream had no drawing document support at all. This fork covers the full detailing path: create_new_drawing, add_sheet, activate_sheet, list_sheets, insert_drawing_view, insert_standard_views, insert_section_view, insert_detail_view, list_drawing_views, set_view_scale, insert_model_annotations, insert_bom_table, add_drawing_dimension, insert_drawing_note, insert_balloons, insert_center_marks and list_drawing_annotations.

Views and annotations are verified by counting what appeared on the sheet; CreateDrawViewFromModelView3 and InsertModelAnnotations3 both report success for views and annotations that were never created.

Assemblies (14 tools)

Upstream stopped at opening an assembly. This fork adds component and mate work: insert_component, list_components, add_mate, delete_mate, list_mates, set_component_fixed, check_assembly_interference, delete_component, replace_component, set_component_suppression, pattern_components, explode_assembly, show_exploded and list_exploded_views.

Sheet metal (6 tools)

Sheet metal is the one part discipline whose deliverable is not the solid but the flat pattern - the DXF a laser or turret consumes. create_base_flange thickens a sketch into a sheet metal body; convert_to_sheet_metal turns an existing solid into one, which is the route imported geometry has to take since a STEP of a bent bracket carries no bend information; create_edge_flange bends flanges off edges without a profile sketch; set_flat_pattern flattens or folds; export_flat_pattern writes the DXF or DWG; get_sheet_metal_info reports the thickness, radius, K-factor and flat pattern extents a quote or a nesting run needs.

ExportFlatPatternView reports success for a part whose flat pattern failed to build, so the export is verified against the file on disk. The flat pattern feature is found by its API type name rather than its displayed name, because displayed names are localized.

Manufacturing package (1 tool)

export_manufacturing_package produces the folder a shop actually receives, in one call: a STEP for every part and for the assembly, a DXF for every sheet metal part, a PDF of the drawing sitting beside each model, and a manifest.json listing every file with the material and mass of each part. It walks an assembly component by component, so a twenty-part machine takes one call rather than sixty. Documents it had to open are closed again afterwards and the originally active document is restored.

Document search and references (3 tools)

search_documents finds SolidWorks files in a folder by name fragment and type. list_document_references reports what a document uses and whether each of those files is still on disk. find_where_used answers the reverse question - which assemblies and drawings use this part - which SolidWorks cannot answer directly, since a document records what it references and never what references it. The reverse map is built by reading the dependencies of every assembly and drawing in a folder tree, which is affordable only because GetDocumentDependencies2 reads a file's references without opening it.

Features (5 tools)

create_loft, create_rib, apply_draft, simple_hole and hole_wizard, each with the dead-feature guard: a feature that reports success while adding no geometry is deleted rather than left in the tree.

Configurations, properties and parameters (15 tools)

activate_configuration, list_configurations, list_custom_properties, set_custom_property, delete_custom_property, get_material, set_material, get_mass_properties, get_dimension, set_dimension, add_equation, set_equation, delete_equation, list_equations and rebuild_document.

ShowConfiguration2 is one of the verified liars: it returns success for a configuration that was never activated, so the active configuration is read back afterwards.

Beyond the tools

• Tool schemas moved out of server.py into a schemas/ package grouped by family, which cut server.py from 3819 lines to 2300.
• Packaging metadata (pyproject.toml), a separate vision extra for the multi-gigabyte PyTorch backend, and a GitHub Actions workflow running the suite.
• LICENSE records both copyright holders and what the fork changes.

Requirements

• Windows 10 or Windows 11.
• SOLIDWORKS 2025 or 2026, installed and licensed.
• Python 3.10 or newer; Python 3.11 is the acceptance-tested runtime.
• Git LFS for the packaged line-art checkpoints.
• An NVIDIA CUDA environment is strongly recommended for the deep vectorization modes. get_capabilities reports the actual backend state.

The server drives the interactive SOLIDWORKS process. It is not a headless CAD kernel, and an unknown modal dialog must be inspected by a human.

Clone and install

Install Git LFS before cloning, or pull the model objects afterwards:

git lfs install
git clone https://github.com/aryesil/SolidworksMCP.git
Set-Location SolidworksMCP
git lfs pull

Create an isolated Python environment and install the package:

py -3.11 -m venv .venv
.\.venv\Scripts\Activate.ps1
python -m pip install --upgrade pip
python -m pip install -e .

The base install covers every tool except deep silhouette vectorization, whose PyTorch backend lives in the vision extra:

python -m pip install -e ".[vision]"

The extra is separate because the CUDA wheels add several gigabytes to an install that most tools never touch. Install the PyTorch build appropriate for the machine's CUDA driver first if the default wheel does not match it; get_capabilities reports the backend that is actually active.

requirements.txt still lists the base dependencies for anyone installing without the package metadata.

MCP configuration

Point the MCP client at the repository entry point using the virtual environment's Python executable:

{
  "mcpServers": {
    "SolidworksMCP": {
      "command": "C:\\path\\to\\SolidworksMCP\\.venv\\Scripts\\python.exe",
      "args": [
        "C:\\path\\to\\SolidworksMCP\\solidworks_mcp_server.py"
      ]
    }
  }
}

Start SOLIDWORKS, restart or reconnect the MCP client, then call get_capabilities and get_environment_status before a substantial modeling operation.

Stable compatibility identifiers

SolidworksMCP is the public project and MCP handshake name. The Python package remains solidworks_mcp, the configured tool namespace remains solidworks, and existing artifact schemas retain their solidworks-mcp/... identifiers. Those internal names are compatibility contracts and are intentionally not renamed.

Operation families

The server exposes both small native operations and higher-level verified workflows. Important families include:

• documents and environment: create/open/save/close, capabilities, session metrics, modal-state inspection, recovery;
• sketches: standard planes, planar faces, exact model-coordinate contours, primitive drawing, parametric sketches, dimensions, constraints, equations;
• features: verified extrude/cut, revolve, sweep, fillet, chamfer, shell, mirrors, patterns, reference axes and planes;
• bodies: visibility, naming, appearance, volume, clearance, interference, multibody insert workflows;
• verification: ray/section probes, sketch topology, native geometry export, sketch-to-sketch and calibrated image comparisons, body silhouettes;
• vectorization: selectable silhouette/region/line-art modes, deep segmentation, controllable approximation, CAD commit, and reverse-raster verification;
• drawings: sheets, model and standard views, section and detail views, model annotations, manual dimensions, notes, balloons, centre marks, BOM tables;
• assemblies: component insertion and deletion, mates, replacement, suppression, component patterns, exploded views, interference checks;
• sheet metal: base flange, conversion of imported solids, edge flanges, flat pattern state, DXF/DWG flat pattern export, sheet metal parameters;
• manufacturing output: one-call package export of STEP, DXF and PDF with a manifest, for a part or a whole assembly;
• documents on disk: file search by name and type, outgoing references with missing-file detection, and where-used across a folder tree;
• configurations and parameters: configurations, custom properties, materials, mass properties, dimensions, equations;
• orchestration: transactions, declarative CAD plans, semantic primitives, model-graph synchronization, atomic export bundles.

Use MCP tool discovery for the authoritative live schema. Tool descriptions and get_capabilities are versioned with the server.

Safety rules

• Supply an absolute save_path before the first mutation of an unsaved document, or explicitly opt into disposable work with allow_unsaved_document=true.
• Treat success as execution evidence. Verify topology, body count, bounding boxes, volume, tolerances, and a readable independent artifact.
• Use scope_bodies and expected_merge_bodies for multibody cuts and bosses.
• Do not auto-confirm unknown dialogs. Only the recognized, operation-scoped dimension Modify dialog may be handled by the watchdog.
• Native MCP tool coordinates use the declared user unit, normally millimetres. Raw SOLIDWORKS COM coordinates use metres.
• Do not invoke a blind Ctrl+8 after sketch operations. Version 6.5.31 already applies and verifies the stable side/up orientation and working-geometry fit.

Vectorization models

The deterministic line-art checkpoints live under solidworks_mcp/models/lineart/ and are stored with Git LFS:

• dexined_biped_v2.pt
• teed_biped_5.pt

Their source and license notices are documented in solidworks_mcp/models/lineart/LICENSES.md. A clone containing small LFS pointer files instead of the binary objects is incomplete; run git lfs pull before starting the server.

SOLIDWORKS Autotrace/Picture to Sketch is an interactive PropertyManager feature and has no supported public API entry point. This server therefore uses its own deterministic segmentation and line-art pipelines.

Configuration

Default runtime settings are stored in solidworks_mcp/config.json. Keep machine-specific or sensitive overrides in config.local.json; that file is ignored by Git.

Notable defaults include:

• automatic SOLIDWORKS executable and template discovery;
• millimetres as the user unit;
• operation-scoped dimension dialog guard;
• bounded transaction/runtime limits;
• automatic checkpoint directory management;
• INFO-level file logging.

Relative log_file values are written under %LOCALAPPDATA%\SolidworksMCP\, not into the source checkout. An absolute path in config.json remains supported.

Tests

The repository contains the deterministic unit and regression suite:

python -m unittest discover -s tests -p "test_*.py"

The suite passes 382 tests. These tests do not replace live acceptance for COM behavior: qualifying another SOLIDWORKS major version should also cover standard planes, planar faces, existing-sketch activation, view recovery, features, transactions, vectorization, and export.

Project layout

SolidworksMCP/
|-- solidworks_mcp_server.py       MCP stdio entry point
|-- requirements.txt
|-- LICENSE
|-- solidworks_mcp/
|   |-- server.py                  MCP dispatch and handlers
|   |-- schemas/                   tool schemas, grouped by family
|   |-- tool_registry.py           high-level tool metadata
|   |-- vector_worker.py           isolated scientific worker
|   |-- config.py / config.json
|   |-- constants.py
|   |-- automation/                SOLIDWORKS COM implementation
|   |-- models/lineart/            Git-LFS checkpoints and licenses
|   `-- utils/
`-- tests/
    `-- test_v6.py                 unit and regression suite

Runtime logs, caches, local client settings, checkpoints, generated reports, acceptance artifacts, and manual probes are intentionally excluded from the repository.

License

The server is distributed under the MIT License; see LICENSE. Packaged model notices are retained separately in solidworks_mcp/models/lineart/LICENSES.md.

This repository is a fork of alisamsam/Solidworks-MCP by Samsaam Ali Baig. The original copyright notice is retained, and the modifications made here are released under the same MIT License. LICENSE records both copyright holders and summarises what this fork adds.