Skip to main content
Glama

cad_mcp - a FreeCAD engineering MCP server

cad_mcp is a Model Context Protocol server that lets an AI client (Claude Code, Claude Desktop, any MCP client) use FreeCAD as an engineering tool. It runs FreeCAD headless, so it works on servers and in CI. The model can build parts, look at them, check mass and interference, run a finite element analysis, and produce drawings, a bill of materials and export files, and it gets numbers back at every step so it can verify its own work.

It is written to be readable: server.py is one file with the tool declarations and comments for someone learning MCP.

What MCP is, in one minute

  • An MCP server is a program the client starts as a child process. They talk JSON-RPC 2.0 over the server's stdin and stdout.

  • The server advertises three kinds of things. Tools are functions the model can call (typed parameters, the docstring is the description the model reads). Resources are read-only data addressed by URI. Prompts are reusable prompt templates.

  • This server has 45 tools, resources freecad://documents and freecad://materials, and the prompt design_and_validate_bracket.

  • client_raw.py talks to the server with no SDK at all, so you can see every message on the wire.

Related MCP server: FreeCAD MCP Server

Architecture

 MCP client (Claude)          server.py (FastMCP, stdio)                 freecadcmd (one process per call)
 ------------------          ---------------------------                 ---------------------------------
  tools/call  ----JSON-RPC--->  validate args, snapshot doc  --job.json-->  cad_mcp/core.py: open workspace/<doc>.FCStd
                                                                            run ONE registered op (ops_*.py)
  <--text + PNG image---------  format result              <--result.json--  save .FCStd, write result JSON
                                render.py: STL -> PNG (numpy + matplotlib, in the server process)
  • Stateless on purpose: state lives in workspace/<doc>.FCStd. A crashed or hung FreeCAD never takes the session down.

  • Before every modifying call the previous file is copied to workspace/.history/<doc>/ (used for undo).

  • Renders: FreeCAD tessellates each object to STL; the server projects the triangles, draws sharp edges, shades and returns a PNG as MCP image content, so the model can actually look at its part.

Install and use

You need three things on the machine that runs the server: FreeCAD 1.x (headless freecadcmd is enough), Python 3.10+ and uv. The AI client (Claude Code, Codex, Claude Desktop, Cursor, ...) starts the server itself as a subprocess and talks to it over stdin/stdout, so you never run server.py by hand in normal use.

1. Get the server and find freecadcmd

git clone https://github.com/abhinavpathak9873/cad_mcp
cd cad_mcp
uv sync                      # creates .venv with the mcp SDK, numpy, matplotlib

Find the headless FreeCAD binary for your OS; this path goes into FREECADCMD below:

  • Linux, distro package: freecadcmd (often already on PATH; check with which freecadcmd).

  • Linux, AppImage: run ./FreeCAD_*.AppImage --appimage-extract once, then use <dir>/squashfs-root/usr/bin/freecadcmd.

  • macOS: /Applications/FreeCAD.app/Contents/Resources/bin/freecadcmd.

  • Windows: C:\Program Files\FreeCAD 1.0\bin\freecadcmd.exe (adjust the version folder).

Check FreeCAD and the server work before wiring up a client:

export FREECADCMD=/path/to/freecadcmd
"$FREECADCMD" -c "import FreeCAD; print(FreeCAD.Version())"
uv run pytest -q             # real FreeCAD runs, takes a few minutes

Use absolute paths everywhere below. Clients start the server from their own working directory, so relative paths break.

2a. Claude Code

One command (user scope = available in every project; use --scope project to write a shareable .mcp.json instead):

claude mcp add cad_mcp --scope user \
  -e FREECADCMD=/path/to/freecadcmd \
  -- uv --directory /abs/path/to/cad_mcp run server.py

Then check it: claude mcp list should show cad_mcp ... Connected, and inside a session /mcp lists its tools. FEM and drawings can take longer than the default tool timeout, so start Claude Code with a longer one:

MCP_TOOL_TIMEOUT=300000 claude      # milliseconds

Project-scoped alternative: copy .mcp.json.example to .mcp.json in your project root and fix the two paths. Claude Code asks once whether to trust project MCP servers.

Remove it again with claude mcp remove cad_mcp.

Claude Code plugin (server plus skill in one install)

The repo is also a Claude Code plugin and a one-plugin marketplace. It registers the MCP server (started with uv from the plugin directory, FREECADCMD taken from your environment) and installs the cad-mcp skill, which teaches the model the engineering loop (model, look, check, FEM to a safety factor, document, export):

/plugin marketplace add abhinavpathak9873/cad_mcp
/plugin install cad_mcp@cad-mcp-marketplace

Export FREECADCMD in the shell that starts Claude Code. Optional: CAD_MCP_WORKSPACE to choose where documents are stored.

Skill only (no plugin): copy skills/cad-mcp into ~/.claude/skills/ (or a project's .claude/skills/) and add the server with claude mcp add as above.

2b. Codex (OpenAI Codex CLI / IDE extension)

One command:

codex mcp add cad_mcp --env FREECADCMD=/path/to/freecadcmd \
  -- uv --directory /abs/path/to/cad_mcp run server.py

or add it by hand to ~/.codex/config.toml (the CLI and the IDE extension share this file):

[mcp_servers.cad_mcp]
command = "uv"
args = ["--directory", "/abs/path/to/cad_mcp", "run", "server.py"]
env = { FREECADCMD = "/path/to/freecadcmd" }
startup_timeout_sec = 30
tool_timeout_sec = 300        # FEM and drawings can exceed the 60 s default

Check with codex mcp list, and inside a Codex session with /mcp. Remove with codex mcp remove cad_mcp.

2c. Claude Desktop

Settings > Developer > Edit Config opens claude_desktop_config.json (macOS ~/Library/Application Support/Claude/, Windows %APPDATA%\Claude\). Add:

{
  "mcpServers": {
    "cad_mcp": {
      "command": "uv",
      "args": ["--directory", "/abs/path/to/cad_mcp", "run", "server.py"],
      "env": {"FREECADCMD": "/path/to/freecadcmd"}
    }
  }
}

Restart Claude Desktop; the tools appear under the tools icon in the chat box. If uv is not found, put the absolute path to uv in command (which uv), because the desktop app does not load your shell PATH.

2d. Any other MCP client (Cursor, VS Code, Windsurf, Zed, ...)

They all use the same three fields: command uv, args --directory /abs/path/to/cad_mcp run server.py, env FREECADCMD. Cursor reads the same JSON shape as above from .cursor/mcp.json; VS Code uses .vscode/mcp.json with the top-level key servers instead of mcpServers.

3. Poke it without any AI client

The MCP Inspector is a small web UI that acts as a client, so you can list tools and call them by hand:

npx @modelcontextprotocol/inspector uv --directory /abs/path/to/cad_mcp run server.py

client_raw.py does the same from plain Python with no SDK and prints every JSON-RPC message, which is the clearest way to see what the protocol actually looks like.

4. First prompt to try

Using cad_mcp: make an L-bracket, 60 x 40 mm base and 50 mm wall, 5 mm thick aluminium 6061, two M6 clearance holes in the base, 3 mm fillet on the inside corner. Render it and look at it, give me the mass, then run FEM with the wall's back face fixed and 300 N down on the base's top face. If the yield safety factor is under 3, thicken it and rerun. Finish with a drawing and a STEP export.

Settings

Environment variables read by the server:

  • FREECADCMD: path to freecadcmd (default: freecadcmd on PATH).

  • FREECAD_MCP_WORKSPACE: where documents, renders and exports are written (default ./workspace inside the repo).

  • FREECAD_MCP_TIMEOUT: seconds allowed per FreeCAD call (default 240).

  • FREECAD_MCP_LAUNCHER: command prefix for each FreeCAD subprocess, e.g. systemd-run --user --scope -p MemoryMax=8G to cap memory on a shared machine.

Troubleshooting

  • Server shows as failed or disconnected: run uv --directory /abs/path/to/cad_mcp run server.py yourself. It should sit silently waiting for input (Ctrl-C to quit). Any traceback is the real error.

  • Tools time out: raise the client's tool timeout (see above) and FREECAD_MCP_TIMEOUT, or use a coarser FEM mesh.

  • freecadcmd not found: FREECADCMD must be an absolute path to the binary, not to the AppImage file itself.

  • Never print() to stdout inside the server: stdout is the protocol channel. Logs go to stderr.

Tool reference

Conventions: millimetres, degrees, +Z up. Faces and edges are addressed by 1-based index (from list_faces / list_edges) or by a selector string such as normal:+Z z:max (top face) or parallel:Y length>25. Indices change after any geometry edit, so list again.

Documents, state and inspection

  • new_document, list_documents, document_info, list_objects (volume, bbox, centre of mass, validity, metadata)

  • list_faces, list_edges (indices with centres, normals, radii; selectors)

  • set_properties (material, part number, description, supplier, colour, quantity)

  • undo (restores the previous saved version, 20 deep), list_history, object_history

Modelling

  • add_primitive (box, cylinder, sphere, cone, torus with placement), extrude_polygon

  • create_sketch (lines, arcs, circles, polylines with Sketcher constraints), pad, pocket, revolve, loft, sweep

  • hole (simple, counterbore, countersink), shell, fillet, chamfer

  • boolean (cut, fuse, common), transform, mirror, linear_pattern, polar_pattern

  • delete_object, import_step

Assemblies, fasteners, library

  • mate_faces (face against face with offset), mate_coaxial (bolt into hole)

  • add_fastener (ISO 4762 socket head cap screw, ISO 4017 hex bolt, ISO 4032 nut, ISO 7089 washer, M3 to M12)

  • list_library, insert_library_part (STEP files from a local folder, FREECAD_MCP_LIBRARY, default ./library)

Engineering checks

  • mass_properties (mass, centre of mass, inertia tensor)

  • check_interference (pairwise common volume), check_clearance (exact minimum distances)

  • run_fem (linear static, Gmsh + CalculiX: several fixtures and loads, von Mises, displacement, yield safety factor, plot)

Seeing and documenting

  • render_view (iso, front, back, top, bottom, left, right, grid; explode for exploded assemblies), section_view (cut at a plane)

  • make_drawing (third-angle sheet, hidden lines, dimensions, hole callouts, title block; SVG, PDF, PNG)

  • bom (CSV and Markdown), export (STEP, STL, OBJ, 3MF, FCStd), export_dxf (face or section outline for laser cutting)

Escape hatch

  • run_script runs arbitrary FreeCAD Python on a document.

Resources: freecad://documents, freecad://materials. Prompt: design_and_validate_bracket.

Built-in materials: aluminium_6061, steel, stainless_304, pa12, pla, pom (handbook values, not certified).

Example output

client_raw.py runs the whole loop on an L-bracket with two M6 bolts and writes its results to examples/: bracket_grid.png, bracket_exploded.png, bracket_section.png, bracket_fem_vonmises.png, bracket_drawing.(png|pdf|svg), bracket_assembly.step, bracket_base.dxf, bracket_bom.(csv|md) and fem_result.json. In that run: bracket mass 37.8 g (aluminium 6061), a deliberately oversized bolt is reported as an interference (32.5 mm3), and FEM with 300 N on the vertical leg and the bolt holes fixed gives max von Mises 49.9 MPa away from the constraints (68.6 MPa raw peak), 0.45 mm displacement and a yield safety factor of 5.5.

Honest limits

  • Headless only: there is no GUI, and the render is a lightweight software renderer, not a ray tracer.

  • Stateless subprocess per call: roughly 1-2 s overhead per tool call.

  • FEM is linear static, small displacement, isotropic material, tetrahedral mesh of one solid. Stress at fixed or loaded face edges is a numerical singularity; the tool reports a value that excludes it and the raw peak.

  • Objects are stored as plain shapes (not a parametric feature tree), so earlier steps cannot be edited retroactively; use undo or rebuild.

  • Fasteners are nominal-size solids without threads; fixtures in FEM are rigid (a bolted hole is fully fixed, no preload or contact).

  • undo has no redo, and history is per document file.

  • Interference uses exact boolean intersection and can be slow on complex assemblies.

Credits

Tool design ideas were informed by existing community FreeCAD MCP servers: neka-nat/freecad-mcp, bonninr/freecad_mcp and tessalabs-space/freecad-mcp. No code was copied.

Licence: MIT.

Available Tools

45 tools
add_fastenerA

Generate a parametric ISO-style fastener (steel, with part number and description set for the BOM): shcs = ISO 4762 socket head cap screw, hex_bolt = ISO 4017, hex_nut = ISO 4032, washer = ISO 7089. length (mm under the head) is required for bolts. position is the bearing face (underside of the head / one face of the nut or washer); direction is the way the shank points, e.g. [0,0,-1] for a screw going down from a top face. Modelled nominal size (no threads).

Inputs: doc (required), kind (required), name (required), size (required), +3 more. Returns: result

add_primitiveA

Add a primitive solid. dimensions keys per shape: box {length(x), width(y), height(z)}; cylinder {radius, height} (axis +Z); sphere {radius}; cone {radius1, radius2, height}; torus {radius1 (ring), radius2 (tube)}. The shape is created with its origin corner/base centre at position [x,y,z] mm (default origin) after rotating rotation_deg about rotation_axis (default Z). Box origin is its min corner; cylinder/cone origin is the centre of the base circle. material: aluminium_6061, steel, stainless_304, pa12, pla, pom. color: [r,g,b] 0..1.

Inputs: doc (required), name (required), shape (required), dimensions (required), +5 more. Returns: result

bomB

Bill of materials from object metadata (set_properties: part_no, description, material, supplier, quantity). Identical part_no+material+description lines are merged and quantities summed. Returns the rows and writes CSV and Markdown under workspace/bom//. Mass is volume x material density.

Inputs: doc (required), objects. Returns: result

booleanA

Boolean combine objects. cut: base minus all tools; fuse: union of base and tools (coplanar faces merged); common: intersection. The inputs are deleted unless keep_inputs=true; the result object is result_name and keeps the base's material. Avoid exactly coplanar/tangent tool faces: extend cutting tools slightly past the surface.

Inputs: doc (required), base (required), tools (required), operation (required), +2 more. Returns: result

chamferB

Bevel edges of a solid by size mm (equal distance). Same edge selection rules as fillet.

Inputs: doc (required), name (required), size (required), edges, +1 more. Returns: result

check_clearanceA

Minimum distance between every pair of solids (exact), returning the pairs closer than report_below_mm sorted by distance with the closest point on each. Distance 0 means touching or overlapping (use check_interference for volume).

Inputs: doc (required), objects, report_below_mm. Returns: result

check_interferenceA

Pairwise interference test: for every pair of solids whose bounding boxes touch, compute the volume of their intersection. Pairs above tolerance_mm3 are returned with the common volume, overlap centre and size. Face contact (zero volume) is not interference. clean: true means no pair overlaps.

Inputs: doc (required), objects, tolerance_mm3. Returns: result

create_sketchA

Create a 2D sketch (FreeCAD Sketcher with a real constraint solver). plane XY (x,y; normal +Z), XZ (sketch x,y map to world x,z; normal -Y) or YZ (maps to world y,z; normal +X); offset shifts the plane along its normal. geometry items (sketch coordinates in mm; index = position in the list, starting 0): {"type":"line","p1":[x,y],"p2":[x,y]}, {"type":"circle","center":[x,y],"radius":r}, {"type":"arc","center":[x,y],"radius":r,"start_deg":a,"end_deg":b} (counter- clockwise), {"type":"polyline","points":[[x,y],...]} (closed polygon, expands to one line per side). Add "construction":true for reference geometry. Closed loops become faces; a loop inside another becomes a hole. constraints (optional, reference geometry by index geo/geo2, point ids pos 1=start, 2=end, 3=centre): coincident (geo,pos,geo2,pos2), horizontal, vertical, parallel, perpendicular, equal, tangent, radius/diameter (geo,value), length (geo,value), distance_x/distance_y (geo,value), lock (geo,pos,x,y). Returns closed/open wire counts and solver DOF (0 = fully constrained). Next: pad, pocket, revolve, loft or sweep.

Inputs: doc (required), name (required), plane, offset, +2 more. Returns: result

delete_objectC

Delete one object from the document.

Inputs: doc (required), name (required). Returns: result

document_infoB

Summary of a document: file size, object names, overall bounding box, undo depth and the last 5 modifying operations.

Inputs: doc (required). Returns: result

exportA

Export objects (default all solids) to workspace/exports// as STEP, STL, OBJ, 3MF or a FCStd copy. Returns the absolute path. For DXF (laser cutting) use export_dxf.

Inputs: doc (required), fmt (required), objects, filename. Returns: result

export_dxfA

Export a 2D DXF outline for laser/waterjet cutting. Either face (one planar face, by index or selector; its boundary and holes in the face's own 2D coordinates) or plane + offset (cross-section of the object by the plane x=, y= or z=offset). Lines and full circles are written as LINE/CIRCLE entities in mm. Saved under workspace/exports//.

Inputs: doc (required), name (required), face, plane, +2 more. Returns: result

extrude_polygonA

Extrude a closed 2D polygon (list of [a,b] points, no need to repeat the first) by height mm. plane XY: points are (x,y), extrusion along +Z. XZ: points are (x,z), extrusion along +Y. YZ: points are (y,z), extrusion along +X. offset moves the profile along the extrusion axis first. holes is an optional list of polygons cut out of the profile. Example L-bracket profile in XZ: [[0,0],[60,0],[60,5],[5,5],[5,40],[0,40]].

Inputs: doc (required), name (required), height (required), points (required), +5 more. Returns: result

filletA

Round edges of a solid with radius mm. edges: list of 1-based edge indices (from list_edges) or an edge selector string (see list_edges); default all edges. Modifies the object in place unless result_name is given. Fails with a clear message if the radius is too large for the geometry.

Inputs: doc (required), name (required), radius (required), edges, +1 more. Returns: result

holeA

Drill a hole into solid name (modified in place). position is the point on the surface where the hole starts, direction points INTO the material (e.g. [0,0,-1] to drill down from a top face). depth None = through all. kind counterbore needs cbore_diameter and cbore_depth; countersink needs csink_diameter (90 degree cone). Fails if no material was removed. Find surface points with list_faces.

Inputs: doc (required), name (required), diameter (required), position (required), +6 more. Returns: result

import_stepC

Import a STEP file (absolute path) as a new object name.

Inputs: doc (required), name (required), path (required), material. Returns: result

insert_library_partB

Insert a STEP file from the parts library (see list_library) as object name, then optionally rotate/translate it.

Inputs: doc (required), name (required), library_path (required), material, +3 more. Returns: result

linear_patternA

Repeat an object count times (including the original) every spacing mm along direction. fuse=false creates objects result_name_1.. for the copies only (the original stays); fuse=true returns one solid with all instances. Typical use: pattern a cylinder 'tool', then boolean cut it from a plate.

Inputs: doc (required), name (required), count (required), spacing (required), +3 more. Returns: result

list_documentsA

List all documents in the workspace with size and modification time.

Inputs: no named parameters. Returns: result

list_edgesA

List edges with 1-based index, curve type, length, midpoint, direction (lines) or radius (circles). selector tokens (space separated, all must match): 'parallel:X|Y|Z' (straight edges), 'type:line|circle', 'length>10', 'length<5', 'radius:3.3', 'z:max' / 'x:min' / 'y:5' (midpoint coordinate), 'index:3,4'.

Inputs: doc (required), name (required), selector. Returns: result

list_facesA

List faces of an object with 1-based index, surface type, area, centre, normal (planes) or radius/axis (cylinders). Indices are what run_fem and fillet need; they change after any geometry edit, so list again. selector filters, tokens separated by spaces (all must match): 'normal:+Z' (planar faces with that normal; also -X, +Y ...), 'z:max' / 'x:min' / 'y:12.5' (face centre coordinate at the extreme or value), 'type:cylinder|plane', 'radius:3.3', 'area>50', 'area<10', 'index:1,2'. Example: 'normal:+Z z:max' = the top face.

Inputs: doc (required), name (required), selector. Returns: result

list_historyC

Journal of modifying operations applied to doc (time, operation, abbreviated arguments), newest last.

Inputs: doc (required), limit. Returns: result

list_libraryA

List STEP files (.step/.stp) in the local parts library folder (env FREECAD_MCP_LIBRARY, default ./library), optionally filtered by a case-insensitive substring. Use the returned relative path with insert_library_part.

Inputs: query. Returns: result

list_objectsA

List every solid/shape object in doc with type, validity, volume (mm3), area, bounding box, centre of mass and metadata (material, part number, ...). Use this to inspect state after each modelling step.

Inputs: doc (required). Returns: result

loftA

Loft a solid through two or more closed sketch profiles in order (e.g. sketches on parallel planes with different offset). ruled gives straight transitions instead of smooth ones.

Inputs: doc (required), sketches (required), result_name (required), ruled, +1 more. Returns: result

make_drawingA

Make a third-angle engineering drawing (front, top, right, isometric) with hidden-line removal via TechDraw's projection, overall dimensions on each orthographic view, diameter callouts for round holes seen face-on, and a title block (title, material, mass, scale, date). Writes SVG, PDF and PNG into workspace/drawings// and returns the paths plus the PNG as an image. scale is paper:model (e.g. 0.5); default picks a standard scale that fits.

Inputs: doc (required), scale, sheet, title, +3 more.

mass_propertiesA

Volume, mass (g), centre of mass (mm) per object and for the set, plus the combined inertia tensor (g*mm2, about the combined centre of mass, world axes). Density comes from each object's material (set_properties) unless material or density_kg_m3 overrides it for all objects. Objects without material report volume only.

Inputs: doc (required), objects, material, density_kg_m3. Returns: result

mate_coaxialA

Make a cylindrical face of moving (e.g. a bolt shank) coaxial with a cylindrical face of fixed (e.g. a hole) and slide it axial_offset mm along the shared axis. flip reverses the moving part's direction. Combine with mate_faces to seat a screw head on a surface, then check_interference / check_clearance.

Inputs: doc (required), fixed (required), moving (required), fixed_face (required), +3 more. Returns: result

mate_facesA

Placement-based assembly joint: move object moving so its planar face lies against a planar face of fixed (normals facing each other), centres aligned, separated by offset mm (use a negative value to sink in). Each face spec must match exactly one face (index or selector, see list_faces). Optionally spin the part about the contact normal afterwards.

Inputs: doc (required), fixed (required), moving (required), fixed_face (required), +3 more. Returns: result

mirrorA

Mirror an object across a world-aligned plane (XY mirrors Z, XZ mirrors Y, YZ mirrors X) at plane_offset mm along its normal. With fuse=true the result is the union of the original and the mirror image.

Inputs: doc (required), name (required), plane (required), result_name (required), +2 more. Returns: result

new_documentA

Create an empty FreeCAD document name (saved as workspace/.FCStd). Every other tool takes this doc name. Units are millimetres, +Z is up, angles are degrees.

Inputs: name (required). Returns: result

object_historyB

All journal entries whose arguments mention object name: how it was created, edited, combined or moved.

Inputs: doc (required), name (required). Returns: result

padA

Extrude the closed loops of a sketch by length mm along the sketch normal (XY +Z, XZ -Y, YZ +X; reverse flips it, symmetric splits the length across the sketch plane) into a new solid result_name. Inner loops become holes.

Inputs: doc (required), length (required), sketch (required), result_name (required), +4 more. Returns: result

pocketA

Cut the sketch profile out of solid target. Cuts opposite to the sketch normal by default (reverse flips); depth in mm, or through_all. Modifies target unless result_name is given. Place the sketch on or above the surface being cut.

Inputs: doc (required), sketch (required), target (required), depth, +3 more. Returns: result

polar_patternA

Rotate copies of an object about an axis through center: count instances spread over total_angle_deg (360 = full circle, evenly spaced). Same fuse behaviour as linear_pattern. Use for bolt circles.

Inputs: doc (required), name (required), count (required), result_name (required), +4 more. Returns: result

render_viewA

Render the document (or the listed objects) to a PNG you can look at. views: iso, front (looking along +Y), back, top, bottom, right, left, or grid (iso+front+top+right in one image). Objects are coloured by their color/material. explode (0..1.5) pushes every object away from the assembly centre along the line from the centre to the object's own centre, producing an exploded view. The PNG is also saved under workspace/renders//.

Inputs: doc (required), size, view, title, +2 more.

revolveA

Revolve the sketch's closed profile about a world-space axis (point + direction) by angle_deg. The profile must not cross the axis. Example: shaft profile in an XY sketch, axis_dir [1,0,0].

Inputs: doc (required), sketch (required), result_name (required), axis_dir, +3 more. Returns: result

run_femA

Linear-static FEM (Gmsh 2nd-order tetrahedra + CalculiX) on ONE solid. Returns max von Mises (MPa), max displacement (mm), yield safety factor, mesh size, and a colour plot of von Mises (returned as an image and saved as PNG). fixed_faces: fully fixed faces (several fixtures allowed): 1-based indices from list_faces, a selector string such as 'normal:-Z z:min' (see list_faces), or a list mixing selectors and index lists, which are united. loads: list of dicts, each with faces (indices or selector) and either force_n (total force in newtons, spread over those faces) + direction [x,y,z], or pressure_mpa (acts normal into the face). Example: loads=[{"faces": "normal:+X x:max", "force_n": 500, "direction": [0,0,-1]}]. material defaults to the object's material. mesh_size is the max element edge in mm: smaller is more accurate and slower (keep >= thickness/2; 3-5 mm is fine for hand-sized parts, runtime seconds to a minute). Stress at the edge of a fixed/loaded face is a numerical singularity, so max_von_mises_mpa (and the safety factor) ignore nodes within exclude_mm (default = mesh_size) of those edges; *_raw values include them. Fillet sharp corners and refine the mesh before trusting stress concentrations.

Inputs: doc (required), name (required), loads (required), fixed_faces (required), +4 more.

run_scriptA

Escape hatch: run arbitrary FreeCAD Python in the worker on doc (saved afterwards). Predefined: App (=FreeCAD), Part, V (Vector), doc, result (a dict you can fill; it is returned), add_shape(doc, name, shape, material=None). print() output is returned. Use only when no dedicated tool fits; geometry made here should go in via add_shape so other tools see it.

Inputs: doc (required), code (required). Returns: result

section_viewA

Cut the model with the plane axis=offset (e.g. z=10), discard the half on the remove side and render what is left, with the cut faces highlighted in orange so internal features (bores, walls, fastener fit) are visible. view 'auto' looks straight at the cut face; any render_view name also works. Nothing in the document is changed.

Inputs: doc (required), axis (required), offset (required), size, +3 more.

set_propertiesB

Set metadata on an object. These feed mass_properties, run_fem, bom and the renders. material is one of aluminium_6061, steel, stainless_304, pa12, pla, pom (see the freecad://materials resource). color is [r,g,b] 0..1 (defaults to the material's colour). quantity is used by the BOM.

Inputs: doc (required), name (required), color, group, +5 more. Returns: result

shellA

Hollow out a solid leaving walls of thickness mm (inward), opening the faces in remove_faces (indices or a face selector, see list_faces). Large thickness relative to features fails; the tool says so.

Inputs: doc (required), name (required), thickness (required), remove_faces (required). Returns: result

sweepA

Sweep a closed profile sketch along a path (a sketch of connected edges, or a 3D polyline path_points). The profile should sit at the path start, roughly perpendicular to it. Use for pipes, rails and cable runs.

Inputs: doc (required), result_name (required), profile_sketch (required), frenet, +3 more. Returns: result

transformA

Rotate then translate an object (mm, degrees). Rotation is about rotation_axis through rotation_center (default world Z through the origin), applied before the translation. With copy_as a new object is created and the original stays where it is (use for repeated parts).

Inputs: doc (required), name (required), copy_as, translate, +3 more. Returns: result

undoA

Undo the last steps modifying operations by restoring the previous saved version of the document (up to 20 versions are kept). The restored version replaces the current file; there is no redo, so check list_history first if unsure.

Inputs: doc (required), steps. Returns: result

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    B3.3/5.0

    Scored across 45 tools

    Disambiguation4/5

    The tools mostly target clearly distinct CAD actions and resources, with detailed descriptions clarifying boundaries. Minor overlaps exist between export/export_dxf, import_step/insert_library_part, list_history/object_history, and check_interference/check_clearance, but they are semantically separable.

    Naming Consistency4/5

    All names use snake_case consistently and many follow a verb_noun pattern such as list_objects, create_sketch, and check_clearance. A few core CAD operations are noun-only or bare verbs (fillet, pad, boolean, export), but the convention remains readable and predictable.

    Tool Count2/5

    45 tools is a large surface for a single MCP server, well above the typical 3-15 range and into the 25+ category that risks overwhelming selection. While the CAD domain is broad, many operations could be grouped or exposed more selectively.

    Completeness4/5

    The surface covers document management, modeling, assembly mating, measurement, FEM, drawings, BOM, rendering, and export, giving strong lifecycle coverage. Minor gaps include direct STL/OBJ import and sketch editing, though run_script provides an escape hatch.

    Maintenance

    ActivityMaintained
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      D
      maintenance
      Enables AI assistants to control FreeCAD 3D modeling software, allowing creation and manipulation of 3D objects, execution of Python code, and interaction with FreeCAD's parts library through natural language.
      10
      MIT
    • A
      license
      Not graded
      quality
      D
      maintenance
      Enables AI agents to programmatically build, analyze, and export 3D CAD geometry using FreeCAD through REST or MCP tools.
      MIT
    • A
      license
      A
      quality
      B
      maintenance
      AI pilots FreeCAD. Provides full control of FreeCAD for parametric modeling, assembly, geometry sensing, and more via MCP tool calls.
      27
      139 PyPI
      27
      MIT