solidworks_mcp.tools.modeling¶

solidworks_mcp.tools.modeling ¶

Modeling tools for SolidWorks MCP Server.

Provides tools for creating and manipulating SolidWorks models, including parts, assemblies, drawings, and features like extrusions, revolves, etc.

Attributes¶

TInput `module-attribute` ¶

TInput = TypeVar('TInput', bound=BaseModel)

Classes¶

AddFilletInput ¶

Bases: CompatInput

Input schema for adding a fillet feature.

Attributes:

Name	Type	Description
`edge_names`	`list[str]`	Edge names to fillet.
`radius`	`float`	Fillet radius in millimeters.

AddMateInput ¶

Bases: CompatInput

Input schema for mating two assembly components.

Attributes:

Name	Type	Description
`component_a`	`str`	First component instance name.
`component_b`	`str`	Second component instance name.
`entity_a`	`str`	Named feature on the first component.
`entity_b`	`str`	Named feature on the second component.
`mate_type`	`str`	Mate type.
`alignment`	`str`	Mate alignment.
`distance`	`float`	Distance in millimetres for a distance mate.
`angle`	`float`	Angle in degrees for an angle mate.

CloseModelInput ¶

Bases: BaseModel

Input schema for closing a model.

Attributes:

Name	Type	Description
`save`	`bool`	The save value.

CompatInput ¶

Bases: BaseModel

Base schema allowing legacy/extra fields used by existing tests.

Attributes:

Name	Type	Description
`model_config`	`Any`	The model config value.

CreateAssemblyInput ¶

Bases: CompatInput

Input schema for creating a new assembly.

Attributes:

Name	Type	Description
`components`	`list[str]`	The components value.
`name`	`str`	The name value.
`template`	`str \| None`	The template value.

CreateCutExtrudeInput ¶

Bases: CompatInput

Input schema for creating a cut-extrude feature.

Attributes:

Name	Type	Description
`depth`	`float`	Cut depth in millimeters.
`draft_angle`	`float`	Draft angle in degrees.
`end_condition`	`str`	End condition type.
`reverse_direction`	`bool`	Reverse cut direction.

CreateDrawingInput ¶

Bases: CompatInput

Input schema for creating a new drawing.

Attributes:

Name	Type	Description
`model_path`	`str \| None`	The model path value.
`name`	`str`	The name value.
`sheet_format`	`str \| None`	The sheet format value.
`template`	`str \| None`	The template value.

CreateExtrusionInput ¶

Bases: CompatInput

Input schema for creating an extrusion feature.

Attributes:

Name	Type	Description
`both_directions`	`bool`	The both directions value.
`depth`	`float`	The depth value.
`direction`	`str`	The direction value.
`draft_angle`	`float`	The draft angle value.
`end_condition`	`str`	The end condition value.
`merge_result`	`bool`	The merge result value.
`reverse`	`bool \| None`	The reverse value.
`reverse_direction`	`bool`	The reverse direction value.
`sketch_name`	`str`	The sketch name value.
`thin_feature`	`bool`	The thin feature value.
`thin_thickness`	`float \| None`	The thin thickness value.

Methods:¶

model_post_init ¶

model_post_init(__context: Any) -> None

Provide model post init support for the create extrusion input.

Parameters:

Name	Type	Description	Default
`__context`	`Any`	The context value.	required

Returns:

Name	Type	Description
`None`	`None`	None.

Raises:

Type	Description
`ValueError`	Sketch_name is required.

Source code in src/solidworks_mcp/tools/modeling.py

def model_post_init(self, __context: Any) -> None:
    """Provide model post init support for the create extrusion input.

    Args:
        __context (Any): The context value.

    Returns:
        None: None.

    Raises:
        ValueError: Sketch_name is required.
    """
    if self.depth <= 0:
        raise ValueError("depth must be positive")
    if not self.sketch_name.strip():
        raise ValueError("sketch_name is required")
    if self.reverse is not None:
        self.reverse_direction = self.reverse

CreateLoftInput ¶

Bases: BaseModel

Input schema for creating a loft feature.

Attributes:

Name	Type	Description
`end_tangent`	`str \| None`	The end tangent value.
`guide_curves`	`list[str] \| None`	The guide curves value.
`merge_result`	`bool`	The merge result value.
`profiles`	`list[str]`	The profiles value.
`start_tangent`	`str \| None`	The start tangent value.

CreatePartInput ¶

Bases: CompatInput

Input schema for creating a new SolidWorks part.

Attributes:

Name	Type	Description
`material`	`str \| None`	The material value.
`name`	`str`	The name value.
`template`	`str \| None`	The template value.
`units`	`str \| None`	The units value.

Methods:¶

model_post_init ¶

model_post_init(__context: Any) -> None

Provide model post init support for the create part input.

Parameters:

Name	Type	Description	Default
`__context`	`Any`	The context value.	required

Returns:

Name	Type	Description
`None`	`None`	None.

Raises:

Type	Description
`ValueError`	Name is required.

Source code in src/solidworks_mcp/tools/modeling.py

def model_post_init(self, __context: Any) -> None:
    """Provide model post init support for the create part input.

    Args:
        __context (Any): The context value.

    Returns:
        None: None.

    Raises:
        ValueError: Name is required.
    """
    if not self.name.strip():
        raise ValueError("name is required")

CreateRevolveInput ¶

Bases: CompatInput

Input schema for creating a revolve feature.

Attributes:

Name	Type	Description
`angle`	`float`	The angle value.
`axis_entity`	`str`	The axis entity value.
`both_directions`	`bool`	The both directions value.
`direction`	`str`	The direction value.
`merge_result`	`bool`	The merge result value.
`reverse_direction`	`bool`	The reverse direction value.
`sketch_name`	`str`	The sketch name value.
`thin_feature`	`bool`	The thin feature value.
`thin_thickness`	`float \| None`	The thin thickness value.

Methods:¶

model_post_init ¶

model_post_init(__context: Any) -> None

Provide model post init support for the create revolve input.

Parameters:

Name	Type	Description	Default
`__context`	`Any`	The context value.	required

Returns:

Name	Type	Description
`None`	`None`	None.

Raises:

Type	Description
`ValueError`	Angle must be positive.

Source code in src/solidworks_mcp/tools/modeling.py

def model_post_init(self, __context: Any) -> None:
    """Provide model post init support for the create revolve input.

    Args:
        __context (Any): The context value.

    Returns:
        None: None.

    Raises:
        ValueError: Angle must be positive.
    """
    if self.angle <= 0:
        raise ValueError("angle must be positive")

CreateSweepInput ¶

Bases: BaseModel

Input schema for creating a sweep feature.

Attributes:

Name	Type	Description
`merge_result`	`bool`	The merge result value.
`path`	`str`	The path value.
`twist_along_path`	`bool`	The twist along path value.
`twist_angle`	`float`	The twist angle value.

ExtrusionParameters ¶

Bases: BaseModel

Parameters for extrusion operations.

Attributes:

Name	Type	Description
`auto_select`	`bool`	The auto select value.
`both_directions`	`bool`	The both directions value.
`depth`	`float`	The depth value.
`draft_angle`	`float`	The draft angle value.
`end_condition`	`str`	The end condition value.
`feature_scope`	`bool`	The feature scope value.
`merge_result`	`bool`	The merge result value.
`reverse_direction`	`bool`	The reverse direction value.
`thin_feature`	`bool`	The thin feature value.
`thin_thickness`	`float \| None`	The thin thickness value.
`up_to_surface`	`str \| None`	The up to surface value.

GetDimensionInput ¶

Bases: CompatInput

Input schema for getting a dimension value.

Attributes:

Name	Type	Description
`dimension_name`	`str \| None`	The dimension name value.
`name`	`str \| None`	The name value.

Methods:¶

model_post_init ¶

model_post_init(__context: Any) -> None

Provide model post init support for the get dimension input.

Parameters:

Name	Type	Description	Default
`__context`	`Any`	The context value.	required

Returns:

Name	Type	Description
`None`	`None`	None.

Raises:

Type	Description
`ValueError`	Name is required.

Source code in src/solidworks_mcp/tools/modeling.py

def model_post_init(self, __context: Any) -> None:
    """Provide model post init support for the get dimension input.

    Args:
        __context (Any): The context value.

    Returns:
        None: None.

    Raises:
        ValueError: Name is required.
    """
    if self.name is None:
        self.name = self.dimension_name
    if not self.name:
        raise ValueError("name is required")

InsertComponentInput ¶

Bases: CompatInput

Input schema for inserting a component into an assembly.

Attributes:

Name	Type	Description
`file_path`	`str`	Path to the part or sub-assembly.
`x`	`float`	X position in millimetres.
`y`	`float`	Y position in millimetres.
`z`	`float`	Z position in millimetres.

LoftParameters ¶

Bases: BaseModel

Parameters for loft operations.

Attributes:

Name	Type	Description
`end_tangent`	`str \| None`	The end tangent value.
`guide_curves`	`list[str] \| None`	The guide curves value.
`merge_result`	`bool`	The merge result value.
`profiles`	`list[str]`	The profiles value.
`start_tangent`	`str \| None`	The start tangent value.

OpenModelInput ¶

Bases: BaseModel

Input schema for opening a SolidWorks model.

Attributes:

Name	Type	Description
`file_path`	`str`	The file path value.

RevolveParameters ¶

Bases: BaseModel

Parameters for revolve operations.

Attributes:

Name	Type	Description
`angle`	`float`	The angle value.
`both_directions`	`bool`	The both directions value.
`merge_result`	`bool`	The merge result value.
`reverse_direction`	`bool`	The reverse direction value.
`thin_feature`	`bool`	The thin feature value.
`thin_thickness`	`float \| None`	The thin thickness value.

SetDimensionInput ¶

Bases: CompatInput

Input schema for setting a dimension value.

Attributes:

Name	Type	Description
`dimension_name`	`str \| None`	The dimension name value.
`name`	`str \| None`	The name value.
`units`	`str \| None`	The units value.
`value`	`float`	The value value.

Methods:¶

model_post_init ¶

model_post_init(__context: Any) -> None

Provide model post init support for the set dimension input.

Parameters:

Name	Type	Description	Default
`__context`	`Any`	The context value.	required

Returns:

Name	Type	Description
`None`	`None`	None.

Raises:

Type	Description
`ValueError`	Name is required.

Source code in src/solidworks_mcp/tools/modeling.py

def model_post_init(self, __context: Any) -> None:
    """Provide model post init support for the set dimension input.

    Args:
        __context (Any): The context value.

    Returns:
        None: None.

    Raises:
        ValueError: Name is required.
    """
    if self.name is None:
        self.name = self.dimension_name
    if not self.name:
        raise ValueError("name is required")

SolidWorksAdapter ¶

SolidWorksAdapter(config: object | None = None)

Bases: ABC

Base adapter interface for SolidWorks integration.

Parameters:

Name	Type	Description	Default
`config`	`object \| None`	Configuration values for the operation. Defaults to None.	`None`

Attributes:

Name	Type	Description
`_metrics`	`Any`	The metrics value.
`config`	`Any`	The config value.
`config_dict`	`Any`	The config dict value.

Initialize adapter with configuration.

Parameters:

Name	Type	Description	Default
`config`	`object \| None`	Configuration values for the operation. Defaults to None.	`None`

Source code in src/solidworks_mcp/adapters/base.py

def __init__(self, config: object | None = None):
    """Initialize adapter with configuration.

    Args:
        config (object | None): Configuration values for the operation. Defaults to None.
    """
    if config is None:
        normalized_config: dict[str, Any] = {}
    elif isinstance(config, Mapping):
        normalized_config = dict(config)
    elif hasattr(config, "model_dump"):
        normalized_config = dict(config.model_dump())
    else:
        normalized_config = {}

    # Preserve original config object for compatibility with tests and
    # call sites that compare object identity/equality.
    self.config = config
    # Keep a normalized mapping for adapter internals.
    self.config_dict = normalized_config
    self._metrics = {
        "operations_count": 0,
        "errors_count": 0,
        "average_response_time": 0.0,
    }
    # SolidWorks-as-Code session logging. Set soc_session_id to enable
    # automatic ToolCallRecord writes for every adapter operation.
    self.soc_session_id: str | None = None
    self.soc_db_path: Path | None = None

Methods:¶

add_arc `async` ¶

add_arc(center_x: float, center_y: float, start_x: float, start_y: float, end_x: float, end_y: float) -> AdapterResult[str]

Add an arc to the current sketch.

Parameters:

Name	Type	Description	Default
`center_x`	`float`	The center x value.	required
`center_y`	`float`	The center y value.	required
`start_x`	`float`	The start x value.	required
`start_y`	`float`	The start y value.	required
`end_x`	`float`	The end x value.	required
`end_y`	`float`	The end y value.	required

Returns:

Type	Description
`AdapterResult[str]`	AdapterResult[str]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

async def add_arc(
    self,
    center_x: float,
    center_y: float,
    start_x: float,
    start_y: float,
    end_x: float,
    end_y: float,
) -> AdapterResult[str]:
    """Add an arc to the current sketch.

    Args:
        center_x (float): The center x value.
        center_y (float): The center y value.
        start_x (float): The start x value.
        start_y (float): The start y value.
        end_x (float): The end x value.
        end_y (float): The end y value.

    Returns:
        AdapterResult[str]: The result produced by the operation.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="add_arc is not implemented by this adapter",
    )

add_centerline `async` ¶

add_centerline(x1: float, y1: float, x2: float, y2: float) -> AdapterResult[str]

Add a centerline to the current sketch.

Parameters:

Name	Type	Description	Default
`x1`	`float`	The x1 value.	required
`y1`	`float`	The y1 value.	required
`x2`	`float`	The x2 value.	required
`y2`	`float`	The y2 value.	required

Returns:

Type	Description
`AdapterResult[str]`	AdapterResult[str]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

async def add_centerline(
    self, x1: float, y1: float, x2: float, y2: float
) -> AdapterResult[str]:
    """Add a centerline to the current sketch.

    Args:
        x1 (float): The x1 value.
        y1 (float): The y1 value.
        x2 (float): The x2 value.
        y2 (float): The y2 value.

    Returns:
        AdapterResult[str]: The result produced by the operation.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="add_centerline is not implemented by this adapter",
    )

add_circle `abstractmethod` `async` ¶

add_circle(center_x: float, center_y: float, radius: float) -> AdapterResult[str]

Add a circle to the current sketch.

Parameters:

Name	Type	Description	Default
`center_x`	`float`	The center x value.	required
`center_y`	`float`	The center y value.	required
`radius`	`float`	The radius value.	required

Returns:

Type	Description
`AdapterResult[str]`	AdapterResult[str]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

@abstractmethod
async def add_circle(
    self, center_x: float, center_y: float, radius: float
) -> AdapterResult[str]:
    """Add a circle to the current sketch.

    Args:
        center_x (float): The center x value.
        center_y (float): The center y value.
        radius (float): The radius value.

    Returns:
        AdapterResult[str]: The result produced by the operation.
    """
    pass

add_ellipse `async` ¶

add_ellipse(center_x: float, center_y: float, major_axis: float, minor_axis: float) -> AdapterResult[str]

Add an ellipse to the current sketch.

Parameters:

Name	Type	Description	Default
`center_x`	`float`	The center x value.	required
`center_y`	`float`	The center y value.	required
`major_axis`	`float`	The major axis value.	required
`minor_axis`	`float`	The minor axis value.	required

Returns:

Type	Description
`AdapterResult[str]`	AdapterResult[str]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

async def add_ellipse(
    self,
    center_x: float,
    center_y: float,
    major_axis: float,
    minor_axis: float,
) -> AdapterResult[str]:
    """Add an ellipse to the current sketch.

    Args:
        center_x (float): The center x value.
        center_y (float): The center y value.
        major_axis (float): The major axis value.
        minor_axis (float): The minor axis value.

    Returns:
        AdapterResult[str]: The result produced by the operation.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="add_ellipse is not implemented by this adapter",
    )

add_fillet `async` ¶

add_fillet(radius: float, edge_names: list[str]) -> AdapterResult[Any]

Add a fillet feature to selected edges.

Rounds the selected edges of the current solid body with the given radius.

Parameters:

Name	Type	Description	Default
`radius`	`float`	Fillet radius in millimeters.	required
`edge_names`	`list[str]`	List of edge names to fillet.	required

Returns:

Name	Type	Description
`AdapterResult`	`AdapterResult[Any]`	Feature result or error.

Source code in src/solidworks_mcp/adapters/base.py

async def add_fillet(
    self, radius: float, edge_names: list[str]
) -> AdapterResult[Any]:
    """Add a fillet feature to selected edges.

    Rounds the selected edges of the current solid body with the given radius.

    Args:
        radius (float): Fillet radius in millimeters.
        edge_names (list[str]): List of edge names to fillet.

    Returns:
        AdapterResult: Feature result or error.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="add_fillet is not implemented by this adapter",
    )

add_line `abstractmethod` `async` ¶

add_line(x1: float, y1: float, x2: float, y2: float) -> AdapterResult[str]

Add a line to the current sketch.

Parameters:

Name	Type	Description	Default
`x1`	`float`	The x1 value.	required
`y1`	`float`	The y1 value.	required
`x2`	`float`	The x2 value.	required
`y2`	`float`	The y2 value.	required

Returns:

Type	Description
`AdapterResult[str]`	AdapterResult[str]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

@abstractmethod
async def add_line(
    self, x1: float, y1: float, x2: float, y2: float
) -> AdapterResult[str]:
    """Add a line to the current sketch.

    Args:
        x1 (float): The x1 value.
        y1 (float): The y1 value.
        x2 (float): The x2 value.
        y2 (float): The y2 value.

    Returns:
        AdapterResult[str]: The result produced by the operation.
    """
    pass

add_mate `async` ¶

add_mate(component_a: str, component_b: str, entity_a: str = 'Front Plane', entity_b: str = 'Front Plane', mate_type: str = 'coincident', alignment: str = 'aligned', distance: float = 0.0, angle: float = 0.0) -> AdapterResult[dict[str, Any]]

Mate two components together in the active assembly.

Parameters:

Name	Type	Description	Default
`component_a`	`str`	First component instance name.	required
`component_b`	`str`	Second component instance name.	required
`entity_a`	`str`	Named feature on the first component. Defaults to "Front Plane".	`'Front Plane'`
`entity_b`	`str`	Named feature on the second component. Defaults to "Front Plane".	`'Front Plane'`
`mate_type`	`str`	Mate type, e.g. `coincident`. Defaults to "coincident".	`'coincident'`
`alignment`	`str`	`aligned`, `anti_aligned` or `closest`. Defaults to "aligned".	`'aligned'`
`distance`	`float`	Distance in millimetres, for a distance mate. Defaults to 0.0.	`0.0`
`angle`	`float`	Angle in degrees, for an angle mate. Defaults to 0.0.	`0.0`

Returns:

Type	Description
`AdapterResult[dict[str, Any]]`	AdapterResult[dict[str, Any]]: Mate details, or error.

Source code in src/solidworks_mcp/adapters/base.py

async def add_mate(
    self,
    component_a: str,
    component_b: str,
    entity_a: str = "Front Plane",
    entity_b: str = "Front Plane",
    mate_type: str = "coincident",
    alignment: str = "aligned",
    distance: float = 0.0,
    angle: float = 0.0,
) -> AdapterResult[dict[str, Any]]:
    """Mate two components together in the active assembly.

    Args:
        component_a (str): First component instance name.
        component_b (str): Second component instance name.
        entity_a (str): Named feature on the first component. Defaults to
            "Front Plane".
        entity_b (str): Named feature on the second component. Defaults to
            "Front Plane".
        mate_type (str): Mate type, e.g. ``coincident``. Defaults to
            "coincident".
        alignment (str): ``aligned``, ``anti_aligned`` or ``closest``.
            Defaults to "aligned".
        distance (float): Distance in millimetres, for a distance mate.
            Defaults to 0.0.
        angle (float): Angle in degrees, for an angle mate. Defaults to 0.0.

    Returns:
        AdapterResult[dict[str, Any]]: Mate details, or error.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="add_mate is not implemented by this adapter",
    )

add_polygon `async` ¶

add_polygon(center_x: float, center_y: float, radius: float, sides: int) -> AdapterResult[str]

Add a regular polygon to the current sketch.

Parameters:

Name	Type	Description	Default
`center_x`	`float`	The center x value.	required
`center_y`	`float`	The center y value.	required
`radius`	`float`	The radius value.	required
`sides`	`int`	The sides value.	required

Returns:

Type	Description
`AdapterResult[str]`	AdapterResult[str]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

async def add_polygon(
    self, center_x: float, center_y: float, radius: float, sides: int
) -> AdapterResult[str]:
    """Add a regular polygon to the current sketch.

    Args:
        center_x (float): The center x value.
        center_y (float): The center y value.
        radius (float): The radius value.
        sides (int): The sides value.

    Returns:
        AdapterResult[str]: The result produced by the operation.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="add_polygon is not implemented by this adapter",
    )

add_rectangle `abstractmethod` `async` ¶

add_rectangle(x1: float, y1: float, x2: float, y2: float) -> AdapterResult[str]

Add a rectangle to the current sketch.

Parameters:

Name	Type	Description	Default
`x1`	`float`	The x1 value.	required
`y1`	`float`	The y1 value.	required
`x2`	`float`	The x2 value.	required
`y2`	`float`	The y2 value.	required

Returns:

Type	Description
`AdapterResult[str]`	AdapterResult[str]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

@abstractmethod
async def add_rectangle(
    self, x1: float, y1: float, x2: float, y2: float
) -> AdapterResult[str]:
    """Add a rectangle to the current sketch.

    Args:
        x1 (float): The x1 value.
        y1 (float): The y1 value.
        x2 (float): The x2 value.
        y2 (float): The y2 value.

    Returns:
        AdapterResult[str]: The result produced by the operation.
    """
    pass

add_sketch_circle `async` ¶

add_sketch_circle(center_x: float, center_y: float, radius: float, construction: bool = False) -> AdapterResult[str]

Alias for add_circle used by some tool flows.

Parameters:

Name	Type	Description	Default
`center_x`	`float`	The center x value.	required
`center_y`	`float`	The center y value.	required
`radius`	`float`	The radius value.	required
`construction`	`bool`	The construction value. Defaults to False.	`False`

Returns:

Type	Description
`AdapterResult[str]`	AdapterResult[str]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

async def add_sketch_circle(
    self,
    center_x: float,
    center_y: float,
    radius: float,
    construction: bool = False,
) -> AdapterResult[str]:
    """Alias for add_circle used by some tool flows.

    Args:
        center_x (float): The center x value.
        center_y (float): The center y value.
        radius (float): The radius value.
        construction (bool): The construction value. Defaults to False.

    Returns:
        AdapterResult[str]: The result produced by the operation.
    """
    return await self.add_circle(center_x, center_y, radius)

add_sketch_constraint `async` ¶

add_sketch_constraint(entity1: str, entity2: str | None, relation_type: str, entity3: str | None = None) -> AdapterResult[str]

Apply a geometric constraint between sketch entities.

Parameters:

Name	Type	Description	Default
`entity1`	`str`	The entity1 value.	required
`entity2`	`str \| None`	The entity2 value.	required
`relation_type`	`str`	The relation type value.	required
`entity3`	`str \| None`	Third entity ID — only used by the `symmetric` relation (the centerline of symmetry). All other relation types reject a non-null `entity3`.	`None`

Returns:

Type	Description
`AdapterResult[str]`	AdapterResult[str]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

async def add_sketch_constraint(
    self,
    entity1: str,
    entity2: str | None,
    relation_type: str,
    entity3: str | None = None,
) -> AdapterResult[str]:
    """Apply a geometric constraint between sketch entities.

    Args:
        entity1 (str): The entity1 value.
        entity2 (str | None): The entity2 value.
        relation_type (str): The relation type value.
        entity3 (str | None): Third entity ID — only used by the
            ``symmetric`` relation (the centerline of symmetry). All
            other relation types reject a non-null ``entity3``.

    Returns:
        AdapterResult[str]: The result produced by the operation.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="add_sketch_constraint is not implemented by this adapter",
    )

add_sketch_dimension `async` ¶

add_sketch_dimension(entity1: str, entity2: str | None, dimension_type: str, value: float) -> AdapterResult[str]

Add a sketch dimension.

Parameters:

Name	Type	Description	Default
`entity1`	`str`	The entity1 value.	required
`entity2`	`str \| None`	The entity2 value.	required
`dimension_type`	`str`	The dimension type value.	required
`value`	`float`	The value value.	required

Returns:

Type	Description
`AdapterResult[str]`	AdapterResult[str]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

async def add_sketch_dimension(
    self,
    entity1: str,
    entity2: str | None,
    dimension_type: str,
    value: float,
) -> AdapterResult[str]:
    """Add a sketch dimension.

    Args:
        entity1 (str): The entity1 value.
        entity2 (str | None): The entity2 value.
        dimension_type (str): The dimension type value.
        value (float): The value value.

    Returns:
        AdapterResult[str]: The result produced by the operation.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="add_sketch_dimension is not implemented by this adapter",
    )

add_spline `async` ¶

add_spline(points: list[dict[str, float]]) -> AdapterResult[str]

Add a spline through the provided points.

Parameters:

Name	Type	Description	Default
`points`	`list[dict[str, float]]`	The points value.	required

Returns:

Type	Description
`AdapterResult[str]`	AdapterResult[str]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

async def add_spline(self, points: list[dict[str, float]]) -> AdapterResult[str]:
    """Add a spline through the provided points.

    Args:
        points (list[dict[str, float]]): The points value.

    Returns:
        AdapterResult[str]: The result produced by the operation.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="add_spline is not implemented by this adapter",
    )

check_sketch_fully_defined `async` ¶

check_sketch_fully_defined(sketch_name: str | None = None) -> AdapterResult[dict[str, Any]]

Check whether a sketch is fully defined.

Parameters:

Name	Type	Description	Default
`sketch_name`	`str \| None`	Optional sketch name to inspect. Defaults to None.	`None`

Returns:

Type	Description
`AdapterResult[dict[str, Any]]`	AdapterResult[dict[str, Any]]: Definition status payload.

Source code in src/solidworks_mcp/adapters/base.py

async def check_sketch_fully_defined(
    self, sketch_name: str | None = None
) -> AdapterResult[dict[str, Any]]:
    """Check whether a sketch is fully defined.

    Args:
        sketch_name (str | None): Optional sketch name to inspect. Defaults to None.

    Returns:
        AdapterResult[dict[str, Any]]: Definition status payload.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="check_sketch_fully_defined is not implemented by this adapter",
    )

close_model `abstractmethod` `async` ¶

close_model(save: bool = False) -> AdapterResult[None]

Close the current model.

Parameters:

Name	Type	Description	Default
`save`	`bool`	The save value. Defaults to False.	`False`

Returns:

Type	Description
`AdapterResult[None]`	AdapterResult[None]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

@abstractmethod
async def close_model(self, save: bool = False) -> AdapterResult[None]:
    """Close the current model.

    Args:
        save (bool): The save value. Defaults to False.

    Returns:
        AdapterResult[None]: The result produced by the operation.
    """
    pass

connect `abstractmethod` `async` ¶

connect() -> None

Connect to SolidWorks application.

Returns:

Name	Type	Description
`None`	`None`	None.

Source code in src/solidworks_mcp/adapters/base.py

@abstractmethod
async def connect(self) -> None:
    """Connect to SolidWorks application.

    Returns:
        None: None.
    """
    pass

create_assembly `abstractmethod` `async` ¶

create_assembly(name: str | None = None) -> AdapterResult[SolidWorksModel]

Create a new assembly document.

Parameters:

Name	Type	Description	Default
`name`	`str \| None`	The name value. Defaults to None.	`None`

Returns:

Type	Description
`AdapterResult[SolidWorksModel]`	AdapterResult[SolidWorksModel]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

@abstractmethod
async def create_assembly(
    self, name: str | None = None
) -> AdapterResult[SolidWorksModel]:
    """Create a new assembly document.

    Args:
        name (str | None): The name value. Defaults to None.

    Returns:
        AdapterResult[SolidWorksModel]: The result produced by the operation.
    """
    pass

create_cut `async` ¶

create_cut(sketch_name: str, depth: float) -> AdapterResult[str]

Create a cut feature from an existing sketch.

Parameters:

Name	Type	Description	Default
`sketch_name`	`str`	The sketch name value.	required
`depth`	`float`	The depth value.	required

Returns:

Type	Description
`AdapterResult[str]`	AdapterResult[str]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

async def create_cut(self, sketch_name: str, depth: float) -> AdapterResult[str]:
    """Create a cut feature from an existing sketch.

    Args:
        sketch_name (str): The sketch name value.
        depth (float): The depth value.

    Returns:
        AdapterResult[str]: The result produced by the operation.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="create_cut is not implemented by this adapter",
    )

create_cut_extrude `async` ¶

create_cut_extrude(params: ExtrusionParameters) -> AdapterResult[Any]

Create a cut-extrude feature from the active sketch.

Cuts material from the current solid body using the active sketch profile. Equivalent to SolidWorks Insert > Cut > Extrude.

Parameters:

Name	Type	Description	Default
`params`	`ExtrusionParameters`	Depth and direction parameters.	required

Returns:

Name	Type	Description
`AdapterResult`	`AdapterResult[Any]`	Feature result or error.

Source code in src/solidworks_mcp/adapters/base.py

async def create_cut_extrude(
    self, params: ExtrusionParameters
) -> AdapterResult[Any]:
    """Create a cut-extrude feature from the active sketch.

    Cuts material from the current solid body using the active sketch profile.
    Equivalent to SolidWorks Insert > Cut > Extrude.

    Args:
        params (ExtrusionParameters): Depth and direction parameters.

    Returns:
        AdapterResult: Feature result or error.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="create_cut_extrude is not implemented by this adapter",
    )

create_drawing `abstractmethod` `async` ¶

create_drawing(name: str | None = None) -> AdapterResult[SolidWorksModel]

Create a new drawing document.

Parameters:

Name	Type	Description	Default
`name`	`str \| None`	The name value. Defaults to None.	`None`

Returns:

Type	Description
`AdapterResult[SolidWorksModel]`	AdapterResult[SolidWorksModel]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

@abstractmethod
async def create_drawing(
    self, name: str | None = None
) -> AdapterResult[SolidWorksModel]:
    """Create a new drawing document.

    Args:
        name (str | None): The name value. Defaults to None.

    Returns:
        AdapterResult[SolidWorksModel]: The result produced by the operation.
    """
    pass

create_extrusion `abstractmethod` `async` ¶

create_extrusion(params: ExtrusionParameters) -> AdapterResult[SolidWorksFeature]

Create an extrusion feature.

Parameters:

Name	Type	Description	Default
`params`	`ExtrusionParameters`	The params value.	required

Returns:

Type	Description
`AdapterResult[SolidWorksFeature]`	AdapterResult[SolidWorksFeature]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

@abstractmethod
async def create_extrusion(
    self, params: ExtrusionParameters
) -> AdapterResult[SolidWorksFeature]:
    """Create an extrusion feature.

    Args:
        params (ExtrusionParameters): The params value.

    Returns:
        AdapterResult[SolidWorksFeature]: The result produced by the operation.
    """
    pass

create_loft `abstractmethod` `async` ¶

create_loft(params: LoftParameters) -> AdapterResult[SolidWorksFeature]

Create a loft feature.

Parameters:

Name	Type	Description	Default
`params`	`LoftParameters`	The params value.	required

Returns:

Type	Description
`AdapterResult[SolidWorksFeature]`	AdapterResult[SolidWorksFeature]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

@abstractmethod
async def create_loft(
    self, params: LoftParameters
) -> AdapterResult[SolidWorksFeature]:
    """Create a loft feature.

    Args:
        params (LoftParameters): The params value.

    Returns:
        AdapterResult[SolidWorksFeature]: The result produced by the operation.
    """
    pass

create_part `abstractmethod` `async` ¶

create_part(name: str | None = None, units: str | None = None) -> AdapterResult[SolidWorksModel]

Create a new part document.

Parameters:

Name	Type	Description	Default
`name`	`str \| None`	The name value. Defaults to None.	`None`
`units`	`str \| None`	The units value. Defaults to None.	`None`

Returns:

Type	Description
`AdapterResult[SolidWorksModel]`	AdapterResult[SolidWorksModel]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

@abstractmethod
async def create_part(
    self, name: str | None = None, units: str | None = None
) -> AdapterResult[SolidWorksModel]:
    """Create a new part document.

    Args:
        name (str | None): The name value. Defaults to None.
        units (str | None): The units value. Defaults to None.

    Returns:
        AdapterResult[SolidWorksModel]: The result produced by the operation.
    """
    pass

create_revolve `abstractmethod` `async` ¶

create_revolve(params: RevolveParameters) -> AdapterResult[SolidWorksFeature]

Create a revolve feature.

Parameters:

Name	Type	Description	Default
`params`	`RevolveParameters`	The params value.	required

Returns:

Type	Description
`AdapterResult[SolidWorksFeature]`	AdapterResult[SolidWorksFeature]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

@abstractmethod
async def create_revolve(
    self, params: RevolveParameters
) -> AdapterResult[SolidWorksFeature]:
    """Create a revolve feature.

    Args:
        params (RevolveParameters): The params value.

    Returns:
        AdapterResult[SolidWorksFeature]: The result produced by the operation.
    """
    pass

create_sketch `abstractmethod` `async` ¶

create_sketch(plane: str) -> AdapterResult[str]

Create a new sketch on the specified plane.

Parameters:

Name	Type	Description	Default
`plane`	`str`	The plane value.	required

Returns:

Type	Description
`AdapterResult[str]`	AdapterResult[str]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

@abstractmethod
async def create_sketch(self, plane: str) -> AdapterResult[str]:
    """Create a new sketch on the specified plane.

    Args:
        plane (str): The plane value.

    Returns:
        AdapterResult[str]: The result produced by the operation.
    """
    pass

create_sweep `abstractmethod` `async` ¶

create_sweep(params: SweepParameters) -> AdapterResult[SolidWorksFeature]

Create a sweep feature.

Parameters:

Name	Type	Description	Default
`params`	`SweepParameters`	The params value.	required

Returns:

Type	Description
`AdapterResult[SolidWorksFeature]`	AdapterResult[SolidWorksFeature]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

@abstractmethod
async def create_sweep(
    self, params: SweepParameters
) -> AdapterResult[SolidWorksFeature]:
    """Create a sweep feature.

    Args:
        params (SweepParameters): The params value.

    Returns:
        AdapterResult[SolidWorksFeature]: The result produced by the operation.
    """
    pass

disconnect `abstractmethod` `async` ¶

disconnect() -> None

Disconnect from SolidWorks application.

Returns:

Name	Type	Description
`None`	`None`	None.

Source code in src/solidworks_mcp/adapters/base.py

@abstractmethod
async def disconnect(self) -> None:
    """Disconnect from SolidWorks application.

    Returns:
        None: None.
    """
    pass

exit_sketch `abstractmethod` `async` ¶

exit_sketch() -> AdapterResult[None]

Exit sketch editing mode.

Returns:

Type	Description
`AdapterResult[None]`	AdapterResult[None]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

@abstractmethod
async def exit_sketch(self) -> AdapterResult[None]:
    """Exit sketch editing mode.

    Returns:
        AdapterResult[None]: The result produced by the operation.
    """
    pass

export_file `abstractmethod` `async` ¶

export_file(file_path: str, format_type: str) -> AdapterResult[None]

Export the current model to a file.

Parameters:

Name	Type	Description	Default
`file_path`	`str`	Path to the target file.	required
`format_type`	`str`	The format type value.	required

Returns:

Type	Description
`AdapterResult[None]`	AdapterResult[None]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

@abstractmethod
async def export_file(
    self, file_path: str, format_type: str
) -> AdapterResult[None]:
    """Export the current model to a file.

    Args:
        file_path (str): Path to the target file.
        format_type (str): The format type value.

    Returns:
        AdapterResult[None]: The result produced by the operation.
    """
    pass

export_image `abstractmethod` `async` ¶

export_image(payload: dict) -> AdapterResult[dict]

Export a viewport screenshot (PNG/JPG) of the current model.

Payload keys: file_path (str): Absolute output path. width (int): Image width in pixels. height (int): Image height in pixels. view_orientation (str): One of "isometric", "front", "top", "right", "back", "bottom", "current".

Parameters:

Name	Type	Description	Default
`payload`	`dict`	The payload value.	required

Returns:

Type	Description
`AdapterResult[dict]`	AdapterResult[dict]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

@abstractmethod
async def export_image(self, payload: dict) -> AdapterResult[dict]:
    """Export a viewport screenshot (PNG/JPG) of the current model.

    Payload keys: file_path (str): Absolute output path. width (int): Image width in pixels.
    height (int): Image height in pixels. view_orientation (str): One of "isometric",
    "front", "top", "right", "back", "bottom", "current".

    Args:
        payload (dict): The payload value.

    Returns:
        AdapterResult[dict]: The result produced by the operation.
    """
    pass

get_dimension `abstractmethod` `async` ¶

get_dimension(name: str) -> AdapterResult[float]

Get the value of a dimension.

Parameters:

Name	Type	Description	Default
`name`	`str`	The name value.	required

Returns:

Type	Description
`AdapterResult[float]`	AdapterResult[float]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

@abstractmethod
async def get_dimension(self, name: str) -> AdapterResult[float]:
    """Get the value of a dimension.

    Args:
        name (str): The name value.

    Returns:
        AdapterResult[float]: The result produced by the operation.
    """
    pass

get_mass_properties `abstractmethod` `async` ¶

get_mass_properties() -> AdapterResult[MassProperties]

Get mass properties of the current model.

Returns:

Type	Description
`AdapterResult[MassProperties]`	AdapterResult[MassProperties]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

@abstractmethod
async def get_mass_properties(self) -> AdapterResult[MassProperties]:
    """Get mass properties of the current model.

    Returns:
        AdapterResult[MassProperties]: The result produced by the operation.
    """
    pass

get_metrics ¶

get_metrics() -> dict[str, Any]

Get adapter metrics.

Returns:

Type	Description
`dict[str, Any]`	dict[str, Any]: A dictionary containing the resulting values.

Source code in src/solidworks_mcp/adapters/base.py

def get_metrics(self) -> dict[str, Any]:
    """Get adapter metrics.

    Returns:
        dict[str, Any]: A dictionary containing the resulting values.
    """
    return self._metrics.copy()

get_model_info `abstractmethod` `async` ¶

get_model_info() -> AdapterResult[dict[str, Any]]

Get metadata for the active model.

Returns:

Type	Description
`AdapterResult[dict[str, Any]]`	AdapterResult[dict[str, Any]]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

@abstractmethod
async def get_model_info(self) -> AdapterResult[dict[str, Any]]:
    """Get metadata for the active model.

    Returns:
        AdapterResult[dict[str, Any]]: The result produced by the operation.
    """
    pass

health_check `abstractmethod` `async` ¶

health_check() -> AdapterHealth

Get adapter health status.

Returns:

Name	Type	Description
`AdapterHealth`	`AdapterHealth`	The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

@abstractmethod
async def health_check(self) -> AdapterHealth:
    """Get adapter health status.

    Returns:
        AdapterHealth: The result produced by the operation.
    """
    pass

insert_component `async` ¶

insert_component(file_path: str, x: float = 0.0, y: float = 0.0, z: float = 0.0) -> AdapterResult[dict[str, Any]]

Insert a part or sub-assembly into the active assembly.

Parameters:

Name	Type	Description	Default
`file_path`	`str`	Absolute path to the `.sldprt` or `.sldasm`.	required
`x`	`float`	X position in millimetres. Defaults to 0.0.	`0.0`
`y`	`float`	Y position in millimetres. Defaults to 0.0.	`0.0`
`z`	`float`	Z position in millimetres. Defaults to 0.0.	`0.0`

Returns:

Type	Description
`AdapterResult[dict[str, Any]]`	AdapterResult[dict[str, Any]]: Component name and counts, or error.

Source code in src/solidworks_mcp/adapters/base.py

async def insert_component(
    self, file_path: str, x: float = 0.0, y: float = 0.0, z: float = 0.0
) -> AdapterResult[dict[str, Any]]:
    """Insert a part or sub-assembly into the active assembly.

    Args:
        file_path (str): Absolute path to the ``.sldprt`` or ``.sldasm``.
        x (float): X position in millimetres. Defaults to 0.0.
        y (float): Y position in millimetres. Defaults to 0.0.
        z (float): Z position in millimetres. Defaults to 0.0.

    Returns:
        AdapterResult[dict[str, Any]]: Component name and counts, or error.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="insert_component is not implemented by this adapter",
    )

is_connected `abstractmethod` ¶

is_connected() -> bool

Check if connected to SolidWorks.

Returns:

Name	Type	Description
`bool`	`bool`	True if connected, otherwise False.

Source code in src/solidworks_mcp/adapters/base.py

@abstractmethod
def is_connected(self) -> bool:
    """Check if connected to SolidWorks.

    Returns:
        bool: True if connected, otherwise False.
    """
    pass

list_components `async` ¶

list_components() -> AdapterResult[list[str]]

List the top-level components of the active assembly.

Returns:

Type	Description
`AdapterResult[list[str]]`	AdapterResult[list[str]]: Component instance names, or error.

Source code in src/solidworks_mcp/adapters/base.py

async def list_components(self) -> AdapterResult[list[str]]:
    """List the top-level components of the active assembly.

    Returns:
        AdapterResult[list[str]]: Component instance names, or error.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="list_components is not implemented by this adapter",
    )

list_configurations `abstractmethod` `async` ¶

list_configurations() -> AdapterResult[list[str]]

List configuration names for the active model.

Returns:

Type	Description
`AdapterResult[list[str]]`	AdapterResult[list[str]]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

@abstractmethod
async def list_configurations(self) -> AdapterResult[list[str]]:
    """List configuration names for the active model.

    Returns:
        AdapterResult[list[str]]: The result produced by the operation.
    """
    pass

list_features `abstractmethod` `async` ¶

list_features(include_suppressed: bool = False, max_assembly_depth: int = 2) -> AdapterResult[list[dict[str, Any]]]

List model features from the feature tree.

For a Part document, returns that document's own feature list, unchanged from prior behavior. For an Assembly document, returns a single flat list containing the assembly's own top-level features plus every resolved component's features, recursing into sub-assemblies up to max_assembly_depth. Every descriptor gains component, component_path, and component_parent keys: None for a document's own features (Part features, or an Assembly's top-level features), or the owning component's name/path for a component-derived feature. component_parent is the immediate parent component name when the component is nested inside a sub-assembly, otherwise None. A component that cannot be resolved (suppressed, lightweight-and-unloaded, missing file) is represented by one descriptor with type: "UnresolvedComponent" instead of being silently dropped.

Parameters:

Name	Type	Description	Default
`include_suppressed`	`bool`	The include suppressed value. Defaults to False. Applied independently to the assembly's own features and to each component's features.	`False`
`max_assembly_depth`	`int`	How many levels of sub-assembly to recurse into. Defaults to 2. Ignored for Part documents. A component beyond the configured depth still appears in the result as a single descriptor (name + path), not expanded.	`2`

Returns:

Type	Description
`AdapterResult[list[dict[str, Any]]]`	AdapterResult[list[dict[str, Any]]]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

@abstractmethod
async def list_features(
    self, include_suppressed: bool = False, max_assembly_depth: int = 2
) -> AdapterResult[list[dict[str, Any]]]:
    """List model features from the feature tree.

    For a Part document, returns that document's own feature list,
    unchanged from prior behavior. For an Assembly document, returns a
    single flat list containing the assembly's own top-level features
    plus every resolved component's features, recursing into
    sub-assemblies up to ``max_assembly_depth``. Every descriptor gains
    ``component``, ``component_path``, and ``component_parent`` keys:
    ``None`` for a document's own features (Part features, or an Assembly's
    top-level features), or the owning component's name/path for a
    component-derived feature. ``component_parent`` is the immediate parent
    component name when the component is nested inside a sub-assembly,
    otherwise ``None``. A component that cannot be resolved (suppressed,
    lightweight-and-unloaded, missing file) is represented by one descriptor
    with ``type: "UnresolvedComponent"`` instead of being silently dropped.

    Args:
        include_suppressed (bool): The include suppressed value. Defaults to False.
            Applied independently to the assembly's own features and to
            each component's features.
        max_assembly_depth (int): How many levels of sub-assembly to
            recurse into. Defaults to 2. Ignored for Part documents. A
            component beyond the configured depth still appears in the
            result as a single descriptor (name + path), not expanded.

    Returns:
        AdapterResult[list[dict[str, Any]]]: The result produced by the operation.
    """
    pass

open_model `abstractmethod` `async` ¶

open_model(file_path: str) -> AdapterResult[SolidWorksModel]

Open a SolidWorks model (part, assembly, or drawing).

Parameters:

Name	Type	Description	Default
`file_path`	`str`	Path to the target file.	required

Returns:

Type	Description
`AdapterResult[SolidWorksModel]`	AdapterResult[SolidWorksModel]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

@abstractmethod
async def open_model(self, file_path: str) -> AdapterResult[SolidWorksModel]:
    """Open a SolidWorks model (part, assembly, or drawing).

    Args:
        file_path (str): Path to the target file.

    Returns:
        AdapterResult[SolidWorksModel]: The result produced by the operation.
    """
    pass

save_file `async` ¶

save_file(file_path: str | None = None) -> AdapterResult[Any]

Save the active model to the existing path or the provided path.

Parameters:

Name	Type	Description	Default
`file_path`	`str \| None`	Path to the target file. Defaults to None.	`None`

Returns:

Type	Description
`AdapterResult[Any]`	AdapterResult[Any]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

async def save_file(self, file_path: str | None = None) -> AdapterResult[Any]:
    """Save the active model to the existing path or the provided path.

    Args:
        file_path (str | None): Path to the target file. Defaults to None.

    Returns:
        AdapterResult[Any]: The result produced by the operation.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="save_file is not implemented by this adapter",
    )

set_dimension `abstractmethod` `async` ¶

set_dimension(name: str, value: float) -> AdapterResult[None]

Set the value of a dimension.

Parameters:

Name	Type	Description	Default
`name`	`str`	The name value.	required
`value`	`float`	The value value.	required

Returns:

Type	Description
`AdapterResult[None]`	AdapterResult[None]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

@abstractmethod
async def set_dimension(self, name: str, value: float) -> AdapterResult[None]:
    """Set the value of a dimension.

    Args:
        name (str): The name value.
        value (float): The value value.

    Returns:
        AdapterResult[None]: The result produced by the operation.
    """
    pass

sketch_circular_pattern `async` ¶

sketch_circular_pattern(entities: list[str], angle: float, count: int) -> AdapterResult[str]

Create a circular pattern of sketch entities around the sketch origin.

The rotation axis is always the sketch origin — SW's CreateCircularSketchStepAndRepeat has no pattern-centre parameter and derives the axis from the seed's geometry. Place the seed entity at the desired radius from the origin.

Parameters:

Name	Type	Description	Default
`entities`	`list[str]`	The entities value.	required
`angle`	`float`	The angle value.	required
`count`	`int`	The count value.	required

Returns:

Type	Description
`AdapterResult[str]`	AdapterResult[str]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

async def sketch_circular_pattern(
    self,
    entities: list[str],
    angle: float,
    count: int,
) -> AdapterResult[str]:
    """Create a circular pattern of sketch entities around the sketch origin.

    The rotation axis is always the sketch origin — SW's
    ``CreateCircularSketchStepAndRepeat`` has no pattern-centre
    parameter and derives the axis from the seed's geometry. Place
    the seed entity at the desired radius from the origin.

    Args:
        entities (list[str]): The entities value.
        angle (float): The angle value.
        count (int): The count value.

    Returns:
        AdapterResult[str]: The result produced by the operation.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="sketch_circular_pattern is not implemented by this adapter",
    )

sketch_linear_pattern `async` ¶

sketch_linear_pattern(entities: list[str], direction_x: float, direction_y: float, spacing: float, count: int) -> AdapterResult[str]

Create a linear pattern of sketch entities.

Parameters:

Name	Type	Description	Default
`entities`	`list[str]`	The entities value.	required
`direction_x`	`float`	The direction x value.	required
`direction_y`	`float`	The direction y value.	required
`spacing`	`float`	The spacing value.	required
`count`	`int`	The count value.	required

Returns:

Type	Description
`AdapterResult[str]`	AdapterResult[str]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

async def sketch_linear_pattern(
    self,
    entities: list[str],
    direction_x: float,
    direction_y: float,
    spacing: float,
    count: int,
) -> AdapterResult[str]:
    """Create a linear pattern of sketch entities.

    Args:
        entities (list[str]): The entities value.
        direction_x (float): The direction x value.
        direction_y (float): The direction y value.
        spacing (float): The spacing value.
        count (int): The count value.

    Returns:
        AdapterResult[str]: The result produced by the operation.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="sketch_linear_pattern is not implemented by this adapter",
    )

sketch_mirror `async` ¶

sketch_mirror(entities: list[str], mirror_line: str) -> AdapterResult[str]

Mirror sketch entities about a mirror line.

Parameters:

Name	Type	Description	Default
`entities`	`list[str]`	The entities value.	required
`mirror_line`	`str`	The mirror line value.	required

Returns:

Type	Description
`AdapterResult[str]`	AdapterResult[str]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

async def sketch_mirror(
    self, entities: list[str], mirror_line: str
) -> AdapterResult[str]:
    """Mirror sketch entities about a mirror line.

    Args:
        entities (list[str]): The entities value.
        mirror_line (str): The mirror line value.

    Returns:
        AdapterResult[str]: The result produced by the operation.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="sketch_mirror is not implemented by this adapter",
    )

sketch_offset `async` ¶

sketch_offset(entities: list[str], offset_distance: float, reverse_direction: bool) -> AdapterResult[str]

Offset sketch entities.

Parameters:

Name	Type	Description	Default
`entities`	`list[str]`	The entities value.	required
`offset_distance`	`float`	The offset distance value.	required
`reverse_direction`	`bool`	The reverse direction value.	required

Returns:

Type	Description
`AdapterResult[str]`	AdapterResult[str]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

async def sketch_offset(
    self,
    entities: list[str],
    offset_distance: float,
    reverse_direction: bool,
) -> AdapterResult[str]:
    """Offset sketch entities.

    Args:
        entities (list[str]): The entities value.
        offset_distance (float): The offset distance value.
        reverse_direction (bool): The reverse direction value.

    Returns:
        AdapterResult[str]: The result produced by the operation.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="sketch_offset is not implemented by this adapter",
    )

update_metrics ¶

update_metrics(operation_time: float, success: bool) -> None

Update adapter metrics.

Parameters:

Name	Type	Description	Default
`operation_time`	`float`	The operation time value.	required
`success`	`bool`	The success value.	required

Returns:

Name	Type	Description
`None`	`None`	None.

Source code in src/solidworks_mcp/adapters/base.py

def update_metrics(self, operation_time: float, success: bool) -> None:
    """Update adapter metrics.

    Args:
        operation_time (float): The operation time value.
        success (bool): The success value.

    Returns:
        None: None.
    """
    self._metrics["operations_count"] += 1
    if not success:
        self._metrics["errors_count"] += 1

    # Update average response time
    current_avg = self._metrics["average_response_time"]
    count = self._metrics["operations_count"]
    self._metrics["average_response_time"] = (
        current_avg * (count - 1) + operation_time
    ) / count

SweepParameters ¶

Bases: BaseModel

Parameters for sweep operations.

Attributes:

Name	Type	Description
`merge_result`	`bool`	The merge result value.
`path`	`str`	The path value.
`twist_along_path`	`bool`	The twist along path value.
`twist_angle`	`float`	The twist angle value.

Functions:¶

_normalize_input ¶

_normalize_input(input_data: Any, model_type: type[TInput]) -> TInput

Build internal normalize input.

Parameters:

Name	Type	Description	Default
`input_data`	`Any`	The input data value.	required
`model_type`	`type[TInput]`	The model type value.	required

Returns:

Name	Type	Description
`TInput`	`TInput`	The result produced by the operation.

Source code in src/solidworks_mcp/tools/modeling.py

def _normalize_input(input_data: Any, model_type: type[TInput]) -> TInput:
    """Build internal normalize input.

    Args:
        input_data (Any): The input data value.
        model_type (type[TInput]): The model type value.

    Returns:
        TInput: The result produced by the operation.
    """
    if isinstance(input_data, model_type):
        return input_data
    return model_type.model_validate(input_data)

_result_value ¶

_result_value(data: Any, *keys: str, default: Any = None) -> Any

Build internal result value.

Parameters:

Name	Type	Description	Default
`data`	`Any`	The data value.	required
`*keys`	`str`	Additional positional arguments forwarded to the call.	`()`
`default`	`Any`	Fallback value returned when the operation fails. Defaults to None.	`None`

Returns:

Name	Type	Description
`Any`	`Any`	The result produced by the operation.

Source code in src/solidworks_mcp/tools/modeling.py

def _result_value(data: Any, *keys: str, default: Any = None) -> Any:
    """Build internal result value.

    Args:
        data (Any): The data value.
        *keys (str): Additional positional arguments forwarded to the call.
        default (Any): Fallback value returned when the operation fails. Defaults to None.

    Returns:
        Any: The result produced by the operation.
    """
    if isinstance(data, dict):
        for key in keys:
            if key in data and data[key] is not None:
                return data[key]
        return default

    for key in keys:
        if hasattr(data, key):
            value = getattr(data, key)
            if value is not None:
                return value
    return default

register_modeling_tools `async` ¶

register_modeling_tools(mcp: FastMCP, adapter: SolidWorksAdapter, config: dict[str, Any]) -> int

Register modeling tools with FastMCP.

Registers comprehensive modeling tools for SolidWorks automation including model creation, feature creation, and model management operations.

Parameters:

Name	Type	Description	Default
`mcp`	`FastMCP`	The mcp value.	required
`adapter`	`SolidWorksAdapter`	Adapter instance used for the operation.	required
`config`	`dict[str, Any]`	Configuration values for the operation.	required

Returns:

Name	Type	Description
`int`	`int`	The computed numeric result.

Example

from solidworks_mcp.tools.modeling import register_modeling_tools

tool_count = await register_modeling_tools(mcp, adapter, config)
print(f"Registered {tool_count} modeling tools")

Source code in src/solidworks_mcp/tools/modeling.py

async def register_modeling_tools(
    mcp: FastMCP, adapter: SolidWorksAdapter, config: dict[str, Any]
) -> int:
    """Register modeling tools with FastMCP.

    Registers comprehensive modeling tools for SolidWorks automation including model
    creation, feature creation, and model management operations.

    Args:
        mcp (FastMCP): The mcp value.
        adapter (SolidWorksAdapter): Adapter instance used for the operation.
        config (dict[str, Any]): Configuration values for the operation.

    Returns:
        int: The computed numeric result.

    Example:
                        ```python
                        from solidworks_mcp.tools.modeling import register_modeling_tools

                        tool_count = await register_modeling_tools(mcp, adapter, config)
                        print(f"Registered {tool_count} modeling tools")
                        ```
    """
    tool_count = 0

    @mcp.tool()
    async def open_model(input_data: OpenModelInput) -> dict[str, Any]:
        """Open a SolidWorks model (part, assembly, or drawing).

        Opens an existing SolidWorks file and makes it the active document for further
        operations. Supports all standard SolidWorks file formats and provides detailed model
        information upon successful opening.

        Args:
            input_data (OpenModelInput): The input data value.

        Returns:
            dict[str, Any]: A dictionary containing the resulting values.

        Example:
                            ```python
                            result = await open_model({
                                "file_path": "C:/Models/bracket.sldprt"
                            })

                            if result["status"] == "success":
                                model = result["model"]
                                print(f"Opened {model['type']}: {model['name']}")
                                print(f"Configuration: {model['configuration']}")
                            ```

                        Note:
                            File path must be absolute and accessible to SolidWorks.
                            Model becomes the active document for subsequent operations.
        """
        try:
            input_data = _normalize_input(input_data, OpenModelInput)
            result = await adapter.open_model(input_data.file_path)

            if result.is_success:
                model = result.data
                title = _result_value(
                    model, "title", "name", default=input_data.file_path
                )
                model_type = _result_value(model, "type", default="Part")
                path = _result_value(
                    model, "path", "file_path", default=input_data.file_path
                )
                configuration = _result_value(model, "configuration", default="Default")
                return {
                    "status": "success",
                    "message": f"Opened {model_type}: {title}",
                    "model": {
                        "title": title,
                        "name": title,
                        "type": model_type,
                        "path": path,
                        "configuration": configuration,
                    },
                    "execution_time": result.execution_time,
                }
            else:
                return {
                    "status": "error",
                    "message": f"Failed to open model: {result.error}",
                }

        except Exception as e:
            logger.error(f"Error in open_model tool: {e}")
            return {
                "status": "error",
                "message": f"Unexpected error: {str(e)}",
            }

    @mcp.tool()
    async def create_part(input_data: CreatePartInput) -> dict[str, Any]:
        """Create a new SolidWorks part document.

        Creates a new SolidWorks part document using the default part template. The new part
        becomes the active document and is ready for modeling operations such as sketch creation
        and feature addition.

        Args:
            input_data (CreatePartInput): The input data value.

        Returns:
            dict[str, Any]: A dictionary containing the resulting values.

        Example:
                            ```python
                            result = await create_part()

                            if result["status"] == "success":
                                part = result["model"]
                                print(f"Created new part: {part['name']}")
                                # Ready for sketching and feature creation
                            ```

                        Note:
                            - Uses default SolidWorks part template
                            - Part document is created in memory (not saved)
                            - Use save operations to persist to disk
                            - Subsequent modeling operations will apply to this part
        """
        try:
            input_data = _normalize_input(input_data, CreatePartInput)
            result = await adapter.create_part(input_data.name, input_data.units)

            if result.is_success:
                model = result.data
                part_name = _result_value(model, "name", default=input_data.name)
                units = _result_value(model, "units", default=input_data.units or "mm")
                return {
                    "status": "success",
                    "message": f"Created new part: {part_name}",
                    "part": {
                        "name": part_name,
                        "units": units,
                        "material": input_data.material,
                        "template": input_data.template,
                    },
                    "execution_time": result.execution_time,
                }
            else:
                return {
                    "status": "error",
                    "message": f"Failed to create part: {result.error}",
                }

        except Exception as e:
            logger.error(f"Error in create_part tool: {e}")
            return {
                "status": "error",
                "message": f"Unexpected error: {str(e)}",
            }

    @mcp.tool()
    async def create_assembly(input_data: CreateAssemblyInput) -> dict[str, Any]:
        """Create a new SolidWorks assembly document.

        Creates a new SolidWorks assembly document using the default assembly template. The new
        assembly becomes the active document and is ready for component insertion, mating, and
        assembly-level operations.

        Args:
            input_data (CreateAssemblyInput): The input data value.

        Returns:
            dict[str, Any]: A dictionary containing the resulting values.

        Example:
                            ```python
                            result = await create_assembly()

                            if result["status"] == "success":
                                assembly = result["model"]
                                print(f"Created new assembly: {assembly['name']}")
                                # Ready for component insertion and mating
                            ```

                        Note:
                            - Uses default SolidWorks assembly template
                            - Assembly document is created in memory (not saved)
                            - Use save operations to persist to disk
                            - Ready for component insertion and mate creation
                            - Assembly tree will initially be empty

                        This tool creates a new assembly document using the default assembly template.
                        The new assembly will become the active document.
        """
        try:
            input_data = _normalize_input(input_data, CreateAssemblyInput)
            result = await adapter.create_assembly(input_data.name)

            if result.is_success:
                model = result.data
                assembly_name = _result_value(model, "name", default=input_data.name)
                return {
                    "status": "success",
                    "message": f"Created new assembly: {assembly_name}",
                    "assembly": {
                        "name": assembly_name,
                        "components": input_data.components,
                        "template": input_data.template,
                    },
                    "execution_time": result.execution_time,
                }
            else:
                return {
                    "status": "error",
                    "message": f"Failed to create assembly: {result.error}",
                }

        except Exception as e:
            logger.error(f"Error in create_assembly tool: {e}")
            return {
                "status": "error",
                "message": f"Unexpected error: {str(e)}",
            }

    @mcp.tool()
    async def create_drawing(input_data: CreateDrawingInput) -> dict[str, Any]:
        """Create a new SolidWorks drawing document.

        This tool creates a new drawing document using the default drawing template. The new
        drawing will become the active document.

        Args:
            input_data (CreateDrawingInput): The input data value.

        Returns:
            dict[str, Any]: A dictionary containing the resulting values.
        """
        try:
            input_data = _normalize_input(input_data, CreateDrawingInput)
            result = await adapter.create_drawing(input_data.name)

            if result.is_success:
                model = result.data
                drawing_name = _result_value(model, "name", default=input_data.name)
                sheet_format = _result_value(
                    model, "sheet_format", default=input_data.sheet_format
                )
                return {
                    "status": "success",
                    "message": f"Created new drawing: {drawing_name}",
                    "drawing": {
                        "name": drawing_name,
                        "model_path": input_data.model_path,
                        "sheet_format": sheet_format,
                        "template": input_data.template,
                    },
                    "execution_time": result.execution_time,
                }
            else:
                return {
                    "status": "error",
                    "message": f"Failed to create drawing: {result.error}",
                }

        except Exception as e:
            logger.error(f"Error in create_drawing tool: {e}")
            return {
                "status": "error",
                "message": f"Unexpected error: {str(e)}",
            }

    @mcp.tool()
    async def close_model(input_data: CloseModelInput) -> dict[str, Any]:
        """Close the current SolidWorks model.

        Closes the currently active SolidWorks document with an option to save changes before
        closing. This is essential for proper model lifecycle management and preventing data
        loss.

        Args:
            input_data (CloseModelInput): The input data value.

        Returns:
            dict[str, Any]: A dictionary containing the resulting values.

        Example:
                            ```python
                            # Close without saving
                            result = await close_model({"save": False})

                            # Save and close
                            result = await close_model({"save": True})

                            if result["status"] == "success":
                                print(f"Model closed, saved: {result['saved']}")
                            ```

                        Note:
                            - Unsaved changes will be lost if save=False
                            - Always save important work before closing
                            - Model must be open to close it
        """
        try:
            input_data = _normalize_input(input_data, CloseModelInput)
            result = await adapter.close_model(input_data.save)

            if result.is_success:
                return {
                    "status": "success",
                    "message": "Model closed successfully",
                    "saved": input_data.save,
                    "execution_time": result.execution_time,
                }
            else:
                return {
                    "status": "error",
                    "message": f"Failed to close model: {result.error}",
                }

        except Exception as e:
            logger.error(f"Error in close_model tool: {e}")
            return {
                "status": "error",
                "message": f"Unexpected error: {str(e)}",
            }

    @mcp.tool()
    async def create_extrusion(input_data: CreateExtrusionInput) -> dict[str, Any]:
        """Create an extrusion feature from the active sketch.

        Creates a 3D extrusion feature (boss or cut) from the currently active 2D sketch.
        Supports advanced options like draft angles, thin features, bidirectional extrusion, and
        various end conditions for professional modeling workflows.

        Args:
            input_data (CreateExtrusionInput): The input data value.

        Returns:
            dict[str, Any]: A dictionary containing the resulting values.

        Example:
                            ```python
                            # Simple boss extrusion
                            result = await create_extrusion({
                                "depth": 25.0,
                                "merge_result": True
                            })

                            # Cut with draft angle
                            result = await create_extrusion({
                                "depth": 10.0,
                                "reverse_direction": True,
                                "draft_angle": 2.0
                            })

                            # Thin wall feature
                            result = await create_extrusion({
                                "depth": 50.0,
                                "thin_feature": True,
                                "thin_thickness": 2.0
                            })
                            ```
        """
        try:
            input_data = _normalize_input(input_data, CreateExtrusionInput)
            # Convert input to ExtrusionParameters
            params = ExtrusionParameters(
                depth=input_data.depth,
                draft_angle=input_data.draft_angle,
                reverse_direction=input_data.reverse_direction,
                both_directions=input_data.both_directions,
                thin_feature=input_data.thin_feature,
                thin_thickness=input_data.thin_thickness,
                end_condition=input_data.end_condition,
                merge_result=input_data.merge_result,
                feature_scope=False,
                auto_select=True,
            )

            result = await adapter.create_extrusion(params)

            if result.is_success:
                feature = result.data
                return {
                    "status": "success",
                    "message": f"Created extrusion: {_result_value(feature, 'feature_name', 'name', default='Extrusion')}",
                    "extrusion": {
                        "name": _result_value(
                            feature, "feature_name", "name", default="Extrusion"
                        ),
                        "sketch": input_data.sketch_name,
                        "depth": input_data.depth,
                        "direction": input_data.direction,
                    },
                    "execution_time": result.execution_time,
                }
            else:
                return {
                    "status": "error",
                    "message": f"Failed to create extrusion: {result.error}",
                }

        except Exception as e:
            logger.error(f"Error in create_extrusion tool: {e}")
            return {
                "status": "error",
                "message": f"Unexpected error: {str(e)}",
            }

    @mcp.tool()
    async def create_revolve(input_data: CreateRevolveInput) -> dict[str, Any]:
        """Create a revolve feature from the active sketch.

        Creates a 3D revolve feature by rotating the active 2D sketch profile around a specified
        axis of revolution. Supports full and partial revolves, thin features, and bidirectional
        revolution for comprehensive rotational modeling.

        Args:
            input_data (CreateRevolveInput): The input data value.

        Returns:
            dict[str, Any]: A dictionary containing the resulting values.

        Example:
                            ```python
                            # Full revolution (cylinder)
                            result = await create_revolve({
                                "angle": 360.0,
                                "merge_result": True
                            })

                            # Partial revolution (arc section)
                            result = await create_revolve({
                                "angle": 120.0,
                                "both_directions": True
                            })

                            # Thin wall revolution (pipe)
                            result = await create_revolve({
                                "angle": 360.0,
                                "thin_feature": True,
                                "thin_thickness": 3.0
                            })
                            ```
        """
        try:
            input_data = _normalize_input(input_data, CreateRevolveInput)
            # Convert input to RevolveParameters
            params = RevolveParameters(
                angle=input_data.angle,
                reverse_direction=input_data.reverse_direction,
                both_directions=input_data.both_directions,
                thin_feature=input_data.thin_feature,
                thin_thickness=input_data.thin_thickness,
                merge_result=input_data.merge_result,
            )

            result = await adapter.create_revolve(params)

            if result.is_success:
                feature = result.data
                return {
                    "status": "success",
                    "message": f"Created revolve: {_result_value(feature, 'feature_name', 'name', default='Revolve')}",
                    "revolve": {
                        "name": _result_value(
                            feature, "feature_name", "name", default="Revolve"
                        ),
                        "sketch": input_data.sketch_name,
                        "axis_entity": input_data.axis_entity,
                        "angle": input_data.angle,
                        "direction": input_data.direction,
                    },
                    "execution_time": result.execution_time,
                }
            else:
                return {
                    "status": "error",
                    "message": f"Failed to create revolve: {result.error}",
                }

        except Exception as e:
            logger.error(f"Error in create_revolve tool: {e}")
            return {
                "status": "error",
                "message": f"Unexpected error: {str(e)}",
            }

    @mcp.tool()
    async def get_dimension(input_data: GetDimensionInput) -> dict[str, Any]:
        """Get the value of a dimension from the current model.

        Retrieves the current value of a named dimension from the active SolidWorks model.
        Dimensions can be from sketches, features, or global dimensions. Useful for parametric
        modeling and design validation.

        Args:
            input_data (GetDimensionInput): The input data value.

        Returns:
            dict[str, Any]: A dictionary containing the resulting values.

        Example:
                            ```python
                            # Get sketch dimension
                            result = await get_dimension({
                                "name": "D1@Sketch1"
                            })

                            if result["status"] == "success":
                                dim = result["dimension"]
                                print(f"Dimension {dim['name']}: {dim['value']} {dim['units']}")

                            # Get feature dimension
                            result = await get_dimension({
                                "name": "D1@Boss-Extrude1"
                            })
                            ```
        """
        try:
            input_data = _normalize_input(input_data, GetDimensionInput)
            if not input_data.name:
                return {"status": "error", "message": "Dimension name is required"}
            result = await adapter.get_dimension(input_data.name)

            if result.is_success:
                value = result.data
                dimension_value = _result_value(value, "value", default=value)
                dimension_units = _result_value(value, "units", default="mm")
                return {
                    "status": "success",
                    "message": f"Dimension {input_data.name} = {dimension_value} {dimension_units}",
                    "dimension": {
                        "name": input_data.name,
                        "value": dimension_value,
                        "units": dimension_units,
                    },
                    "execution_time": result.execution_time,
                }
            else:
                return {
                    "status": "error",
                    "message": f"Failed to get dimension: {result.error}",
                }

        except Exception as e:
            logger.error(f"Error in get_dimension tool: {e}")
            return {
                "status": "error",
                "message": f"Unexpected error: {str(e)}",
            }

    @mcp.tool()
    async def set_dimension(input_data: SetDimensionInput) -> dict[str, Any]:
        """Set the value of a dimension in the current model.

        This tool modifies the value of a named dimension and rebuilds the model. Use this to
        parametrically modify your model dimensions.

        Args:
            input_data (SetDimensionInput): The input data value.

        Returns:
            dict[str, Any]: A dictionary containing the resulting values.
        """
        try:
            input_data = _normalize_input(input_data, SetDimensionInput)
            if not input_data.name:
                return {"status": "error", "message": "Dimension name is required"}
            result = await adapter.set_dimension(input_data.name, input_data.value)

            if result.is_success:
                payload = result.data
                return {
                    "status": "success",
                    "message": f"Set dimension {input_data.name} = {input_data.value} mm",
                    "dimension_update": {
                        "name": input_data.name,
                        "old_value": _result_value(payload, "old_value"),
                        "new_value": _result_value(
                            payload, "new_value", default=input_data.value
                        ),
                        "units": input_data.units or "mm",
                    },
                    "execution_time": result.execution_time,
                }
            else:
                return {
                    "status": "error",
                    "message": f"Failed to set dimension: {result.error}",
                }

        except Exception as e:
            logger.error(f"Error in set_dimension tool: {e}")
            return {
                "status": "error",
                "message": f"Unexpected error: {str(e)}",
            }

    @mcp.tool()
    async def create_cut_extrude(input_data: CreateCutExtrudeInput) -> dict[str, Any]:
        """Cut material from the active model using the current sketch profile.

        Creates a Cut-Extrude feature (Insert > Cut > Extrude) from the active sketch.
        Use this after exit_sketch when you want to remove material — e.g. to create
        windows, holes, slots, or any through/blind cut in an existing solid body.

        Args:
            input_data (CreateCutExtrudeInput): Depth, direction and draft parameters.

        Returns:
            dict[str, Any]: Status and feature details.

        Example:
            ```python
            # Cut a blind pocket 10 mm deep
            result = await create_cut_extrude({"depth": 10.0})

            # Through-all cut (use a depth larger than the solid)
            result = await create_cut_extrude({"depth": 200.0})
            ```
        """
        try:
            input_data = _normalize_input(input_data, CreateCutExtrudeInput)
            params = ExtrusionParameters(
                depth=input_data.depth,
                draft_angle=input_data.draft_angle,
                reverse_direction=input_data.reverse_direction,
                both_directions=False,
                thin_feature=False,
                thin_thickness=None,
                end_condition=input_data.end_condition,
                merge_result=False,
                feature_scope=False,
                auto_select=True,
            )
            result = await adapter.create_cut_extrude(params)
            if result.is_success:
                feature = result.data
                return {
                    "status": "success",
                    "message": f"Created cut-extrude: {_result_value(feature, 'feature_name', 'name', default='Cut-Extrude')}",
                    "cut_extrude": {
                        "name": _result_value(
                            feature, "feature_name", "name", default="Cut-Extrude"
                        ),
                        "depth": input_data.depth,
                    },
                    "execution_time": result.execution_time,
                }
            else:
                return {
                    "status": "error",
                    "message": f"Failed to create cut-extrude: {result.error}",
                }
        except Exception as e:
            logger.error(f"Error in create_cut_extrude tool: {e}")
            return {"status": "error", "message": f"Unexpected error: {str(e)}"}

    @mcp.tool()
    async def add_fillet(input_data: AddFilletInput) -> dict[str, Any]:
        """Add a fillet (rounded edge) to selected edges of the current model.

        Rounds the specified named edges with the given radius. Edge names use the
        SolidWorks convention, e.g. 'Edge<1>', or you can leave edge_names empty to
        fillet all edges if the adapter supports it.

        Args:
            input_data (AddFilletInput): Radius and edge names.

        Returns:
            dict[str, Any]: Status and feature details.

        Example:
            ```python
            # Fillet two specific edges with 2 mm radius
            result = await add_fillet({"radius": 2.0, "edge_names": ["Edge<1>", "Edge<2>"]})
            ```
        """
        try:
            input_data = _normalize_input(input_data, AddFilletInput)
            result = await adapter.add_fillet(input_data.radius, input_data.edge_names)
            if result.is_success:
                feature = result.data
                return {
                    "status": "success",
                    "message": f"Created fillet: {_result_value(feature, 'feature_name', 'name', default='Fillet')}",
                    "fillet": {
                        "name": _result_value(
                            feature, "feature_name", "name", default="Fillet"
                        ),
                        "radius": input_data.radius,
                        "edges": input_data.edge_names,
                    },
                    "execution_time": result.execution_time,
                }
            else:
                return {
                    "status": "error",
                    "message": f"Failed to add fillet: {result.error}",
                }
        except Exception as e:
            logger.error(f"Error in add_fillet tool: {e}")
            return {"status": "error", "message": f"Unexpected error: {str(e)}"}

    @mcp.tool()
    async def create_sweep(input_data: CreateSweepInput) -> dict[str, Any]:
        """Sweep the active profile sketch along a named path sketch.

        Creates a swept boss/protrusion (Insert > Boss/Base > Sweep). Requires
        two sketches in the active part: a closed profile sketch and an open
        path sketch named by ``path``. The profile is inferred as the sketch
        that is not the path (in the usual "draw profile, draw path, sweep"
        flow this is unambiguous). Optionally applies a constant twist along
        the path.

        Args:
            input_data (CreateSweepInput): Path name and twist/merge options.

        Returns:
            dict[str, Any]: Status and feature details.

        Example:
            ```python
            # Sweep a circular profile along "Sketch2"
            result = await create_sweep({"path": "Sketch2"})

            # Sweep with a 90-degree twist along the path
            result = await create_sweep({
                "path": "Sketch2",
                "twist_along_path": True,
                "twist_angle": 90.0,
            })
            ```
        """
        try:
            input_data = _normalize_input(input_data, CreateSweepInput)
            params = SweepParameters(
                path=input_data.path,
                twist_along_path=input_data.twist_along_path,
                twist_angle=input_data.twist_angle,
                merge_result=input_data.merge_result,
            )
            result = await adapter.create_sweep(params)
            if result.is_success:
                feature = result.data
                return {
                    "status": "success",
                    "message": f"Created sweep: {_result_value(feature, 'feature_name', 'name', default='Sweep')}",
                    "sweep": {
                        "name": _result_value(
                            feature, "feature_name", "name", default="Sweep"
                        ),
                        "path": input_data.path,
                        "twist_along_path": input_data.twist_along_path,
                        "twist_angle": input_data.twist_angle,
                    },
                    "execution_time": result.execution_time,
                }
            else:
                return {
                    "status": "error",
                    "message": f"Failed to create sweep: {result.error}",
                }
        except Exception as e:
            logger.error(f"Error in create_sweep tool: {e}")
            return {"status": "error", "message": f"Unexpected error: {str(e)}"}

    @mcp.tool()
    async def create_loft(input_data: CreateLoftInput) -> dict[str, Any]:
        """Loft a solid between two or more profile sketches.

        Creates a lofted boss/protrusion (Insert > Boss/Base > Loft) blending
        the listed profile sketches in order. Each profile must be a closed
        contour. Optional guide curves shape the transition between profiles.

        Args:
            input_data (CreateLoftInput): Profile names, optional guide curves,
                and tangency/merge options.

        Returns:
            dict[str, Any]: Status and feature details.

        Example:
            ```python
            # Loft between two profiles (e.g. a tapered bevel)
            result = await create_loft({"profiles": ["Sketch1", "Sketch2"]})

            # Loft with guide curves
            result = await create_loft({
                "profiles": ["Sketch1", "Sketch2"],
                "guide_curves": ["Sketch3"],
            })
            ```
        """
        try:
            input_data = _normalize_input(input_data, CreateLoftInput)
            params = LoftParameters(
                profiles=input_data.profiles,
                guide_curves=input_data.guide_curves,
                start_tangent=input_data.start_tangent,
                end_tangent=input_data.end_tangent,
                merge_result=input_data.merge_result,
            )
            result = await adapter.create_loft(params)
            if result.is_success:
                feature = result.data
                return {
                    "status": "success",
                    "message": f"Created loft: {_result_value(feature, 'feature_name', 'name', default='Loft')}",
                    "loft": {
                        "name": _result_value(
                            feature, "feature_name", "name", default="Loft"
                        ),
                        "profiles": input_data.profiles,
                        "guide_curves": input_data.guide_curves,
                    },
                    "execution_time": result.execution_time,
                }
            else:
                return {
                    "status": "error",
                    "message": f"Failed to create loft: {result.error}",
                }
        except Exception as e:
            logger.error(f"Error in create_loft tool: {e}")
            return {"status": "error", "message": f"Unexpected error: {str(e)}"}

    @mcp.tool()
    async def insert_component(input_data: InsertComponentInput) -> dict[str, Any]:
        """Insert a part or sub-assembly into the active assembly.

        Call ``create_assembly`` first. Position is in millimetres from the
        assembly origin.

        **The component file must contain solid geometry** — SolidWorks
        silently refuses to insert an empty part, so a missing or empty
        component surfaces as an error rather than a fabricated success.

        Args:
            input_data (InsertComponentInput): File path and position.

        Returns:
            dict[str, Any]: Status, the component's instance name and counts.

        Example:
            ```python
            await create_assembly({"name": "bracket_asm"})
            await insert_component({"file_path": "C:/parts/plate.sldprt"})
            await insert_component({"file_path": "C:/parts/plate.sldprt", "x": 100.0})
            ```
        """
        try:
            input_data = _normalize_input(input_data, InsertComponentInput)
            result = await adapter.insert_component(
                input_data.file_path, input_data.x, input_data.y, input_data.z
            )
            if result.is_success:
                data = result.data if isinstance(result.data, dict) else {}
                return {
                    "status": "success",
                    "message": f"Inserted {data.get('component', 'component')}",
                    "component": data,
                    "execution_time": result.execution_time,
                }
            return {
                "status": "error",
                "message": f"Failed to insert component: {result.error}",
            }
        except Exception as e:
            logger.error(f"Error in insert_component tool: {e}")
            return {"status": "error", "message": f"Unexpected error: {str(e)}"}

    @mcp.tool()
    async def add_mate(input_data: AddMateInput) -> dict[str, Any]:
        """Mate two components in the active assembly.

        Positions components relative to one another — coincident planes to
        stack or align them, concentric to line up axes, distance to hold a
        gap.

        Entities are selected by feature name, so only each component's
        reference planes and axes can be mated. Mating to a specific face or
        edge needs entity names this adapter cannot enumerate.

        Args:
            input_data (AddMateInput): Components, entities and mate type.

        Returns:
            dict[str, Any]: Status and mate details.

        Example:
            ```python
            components = await list_components()
            await add_mate({
                "component_a": components["components"][0],
                "component_b": components["components"][1],
                "mate_type": "coincident",
            })
            ```
        """
        try:
            input_data = _normalize_input(input_data, AddMateInput)
            result = await adapter.add_mate(
                input_data.component_a,
                input_data.component_b,
                input_data.entity_a,
                input_data.entity_b,
                input_data.mate_type,
                input_data.alignment,
                input_data.distance,
                input_data.angle,
            )
            if result.is_success:
                data = result.data if isinstance(result.data, dict) else {}
                message = (
                    f"Added {input_data.mate_type} mate between "
                    f"{input_data.component_a} and {input_data.component_b}"
                )
                # SolidWorks accepts a mate whose constraint is already
                # satisfied and moves nothing. That is a real success, but
                # saying so plainly beats leaving the caller to infer it.
                if data.get("geometry_moved") is False:
                    message += (
                        " (no component moved - the constraint was already "
                        "satisfied)"
                    )
                return {
                    "status": "success",
                    "message": message,
                    "mate": data,
                    "execution_time": result.execution_time,
                }
            return {
                "status": "error",
                "message": f"Failed to add mate: {result.error}",
            }
        except Exception as e:
            logger.error(f"Error in add_mate tool: {e}")
            return {"status": "error", "message": f"Unexpected error: {str(e)}"}

    @mcp.tool()
    async def list_components() -> dict[str, Any]:
        """List the top-level components of the active assembly.

        Returns:
            dict[str, Any]: Status and the component instance names.
        """
        try:
            result = await adapter.list_components()
            if result.is_success:
                components = result.data if isinstance(result.data, list) else []
                return {
                    "status": "success",
                    "message": f"{len(components)} component(s) in the assembly",
                    "components": components,
                    "execution_time": result.execution_time,
                }
            return {
                "status": "error",
                "message": f"Failed to list components: {result.error}",
            }
        except Exception as e:
            logger.error(f"Error in list_components tool: {e}")
            return {"status": "error", "message": f"Unexpected error: {str(e)}"}

    tool_count = 15  # Number of tools registered
    return tool_count

solidworks_mcp.tools.modeling¶