MCP server that lets AI clients drive FreeCAD to create, edit, and inspect 3D CAD models via XML-RPC
CADPilot presents a specialized domain (FreeCAD automation) with 33 tools covering CAD operations, sessions, and assembly workflows. Strengths: most tools have descriptions and clear naming conventions (verb_noun pattern followed consistently); comprehensive parameter schemas visible for key tools; thoughtful risk classification (WRITE/READ_ONLY/REVERSIBLE). Weaknesses: descriptions are generally terse (most under 150 chars, well below the 194-char baseline for A+ tools); output schemas are NOT documented, the codebase references screenshot attachments and result structures but never formally specifies what fields responses contain; error handling strategies are not evident in descriptions; parameter descriptions lack detail about constraints, ranges, and dependencies; no evidence of parameter validation guidance; the unified 'cad' tool is powerful but its enum of 18 operations creates a single point of brittleness; tool composition could be simplified (e.g., session_pause/resume/complete are separate when a single session_control tool might suffice). Conservative assessment: tool definitions are above-average for the community but fall short of production-grade by arcade.dev standards.
Align two shapes.
Snap parts together using anchor-based assembly.
Manage an assembly design session with multi-part coordination.
Perform a CAD modeling operation (unified mutation tool). When a modeling session is active (session_start), successful operations on the session's document are recorded as steps and can be rolled back with session_rollback. Feature ops take obj_name as the BASE object (for sketch/variables/datum_plane/hull it names the NEW object) and params via obj_properties. Every mutation runs in one FreeCAD transaction and is auto-audited for connectivity.
Check for interference (collision) between two objects.
Create a new document in FreeCAD.
Output schemas are never documented. The codebase mentions screenshots and result structures but never formalizes what fields responses contain, breaking downstream tool chaining and LLM planning.
Descriptions are uniformly terse (mostly <100 chars). Baseline for A+ tools is 194 chars with clear WHAT/WHEN/WHY/PREREQUISITES structure. Most CADPilot descriptions lack actionable context, e.g. 'Get a screenshot of the active view' does not explain when to call it vs. other inspection tools, or that it optionally focuses on a specific object.
Inferred effective spec: <=2025-11-25.
| Scored | Grade | Overall | Spec posture | Rubric |
|---|---|---|---|---|
| 2026-09-23 | D | 56 | <=2025-11-25 | v2 |
Execute arbitrary Python code in FreeCAD. The code runs on FreeCAD's GUI thread with the full FreeCAD Python API available (FreeCAD, FreeCADGui already imported; import Part/Draft/etc. as needed). print() output is captured and returned.
Execute Python code in FreeCAD without waiting for completion. Background thread, NOT the GUI thread: the code must NOT touch FreeCADGui, the active view/selection, document objects, recompute, or save — for any of that use execute_code instead (the safe default). Only for long pure OCCT/CPU computations on already-fetched shapes. Use task_print(...) for output (print() is not captured); poll with get_task_result(task_id).
Get anchors (named reference points) from an object.
Get a specific object in a document.
Get all objects in a document.
Get positioning information for an object.
Get the status and captured output of a background task started by execute_code_async.
Get the topology (faces, edges, vertices) of a shape.
Get a screenshot of the active view.
Inspect FreeCAD internals and available features.
Get a list of all open documents in FreeCAD.
Measure geometric properties of a shape.
Get reference documentation for a CAD operation.
Recall saved modeling patterns.
Save a modeling pattern for later recall.
Add a note to the current session step.
Mark a session as complete.
Get the recorded steps of a session.
List all active sessions.
Pause the current modeling session.
Redo a step that was rolled back.
Resume a paused modeling session.
Rollback to a previous step in the session.
Start a modeling session to record and rollback steps.
Get the current status of a modeling session.
Set anchors (named reference points) on an object.
Verify assembly constraints and detect issues.
Parameter descriptions lack constraint details. For example, 'width' and 'height' in get_view have no range guidance; session_rollback's 'step' parameter does not clarify if it is an index or a step count; 'action' in assembly_session is described as 'Session action' rather than listing valid values or their effects.
The 'cad' tool bundles 18 operations into a single enum, creating a single point of failure and forcing complex branching logic in agents. Operations like 'sketch', 'pad', 'pocket' are distinct workflows that would benefit from separate, focused tools (e.g. create_sketch, create_pad). This violates the single-responsibility principle.
Session control is split across six tools (session_pause, session_resume, session_complete, session_redo, session_rollback, session_status). These could be consolidated into a single 'session_control' tool with an 'action' enum, reducing cognitive load and improving composability.
Error handling is not documented in tool descriptions. Tools like 'cad' and 'execute_code' perform mutations but do not describe failure modes, recovery paths, or what errors mean. Descriptions should guide LLMs on retryability and next steps (e.g. 'If the operation fails due to geometric collision, try adjusting the offset parameter').
No tool annotations (readOnlyHint, destructiveHint, idempotentHint). The 'Risk' field in the spec (WRITE, READ_ONLY, REVERSIBLE) is metadata but never translates into MCP tool annotations, preventing LLMs from inferring safety properties without parsing descriptions.
Parameter relationships and dependencies are not documented. For example, 'cad' tool's 'obj_properties' object structure depends on the 'operation' enum value, sketch requires different keys than fillet. The operation_help tool references tool_docs.py which contains external documentation, but these dependencies should be discoverable inline or via schemas.
Batch operations (e.g., 'cad' with action='batch') return per-op results but do not document the structure. What does a failed operation in a batch return? Is there a partial_success field? How do LLMs know which operations succeeded and which failed without parsing unstructured text?