Skip to main content
Glama
SolidWorks MCP Python

SolidWorks MCP Python

by locense

Delete Feature

delete_feature
Destructive

Deletes a feature or sketch from the active SolidWorks model along with all dependent features; use undo to restore them or suppress instead if you may need them back.

Instructions

Delete a feature or sketch from the active model, along with the features that depend on it.

Ask the user before you call it: deleting a sketch also deletes every feature built from it (a cut, a boss), and deleting a feature deletes everything that depends on it. Use suppress_feature instead when you might want it back. Find names and dependents with list_features. Needs: an open part or assembly. Changes: removes the feature and its dependents (undo can restore them). Returns: data with deleted, removed_features (every feature that went, dependents included), features_before and features_after; the message names the dependents, and a warning says so whenever more than the named feature went: tell the user.

Tool call template

Replace each placeholder with a value matching the input schema. Only required parameters are included; add optional parameters as needed.

{
  "id": 1,
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "arguments": {
      "input_data": "<input_data>"
    },
    "name": "delete_feature"
  }
}

Input Schema

NameRequiredDescriptionDefault
input_dataYesThe feature. `name` (e.g. "Fillet1") is required.

Output Schema

NameRequiredDescriptionDefault

No arguments

Schema Changelog

Changes observed during successful MCP inspections.

  1. First observedv0.1.0

TDQS

A4.4/5.0
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare destructiveHint=true and idempotentHint=false, so the description needn't re-argue that deletion is irreversible in the ordinary sense. It still adds real value by disclosing the cascade (deleting a sketch kills every feature built from it), that `undo` can restore, and that a `warning` fires whenever more than the named feature is removed. The only minor gap is not saying whether dependent removal is atomic on partial failure.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Front-loaded with the destructive scope and the ask-the-user gate before any housekeeping, and the "Needs / Changes / Returns" labels make it scannable. The `Returns:` block restates field names that the output schema already declares, so a sentence there is not fully earning its place.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a destructive, cascading mutation it covers prerequisite state, blast radius, recovery path, and the warning-on-overreach behavior an agent must relay to the user. Return fields are summarized rather than re-specified, which is appropriate given an output schema exists.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100% and the single nested `name` parameter is already documented with format examples ('Boss-Extrude1', 'Sketch1'), so the description is not required to compensate. It adds only the indirect hint that valid names come from `list_features`, which is useful but is framed as a usage route rather than parameter semantics.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and resource ("Delete a feature or sketch from the active model") and immediately bounds the scope with "along with the features that depend on it." That dependent-deletion scope is what distinguishes it from `suppress_feature`, so an agent can route correctly without reading either schema.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicit when-to-use alternates are named with their selecting condition: use `suppress_feature` when you might want the feature back, and use `list_features` to discover names and dependents. It also states a prerequisite gate ("Ask the user before you call it") and a state requirement (an open part or assembly).

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Deploy Server

Other Tools