cad_mcp
Provides tools for using FreeCAD headless as a CAD engineering backend: creating and modifying 3D parts, inspecting geometry, checking mass and interference, running finite element analysis, generating drawings and bills of materials, rendering previews, and exporting files such as STEP.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@cad_mcp model a bracket, check its mass, then run FEM at 200 N"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
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://documentsandfreecad://materials, and the promptdesign_and_validate_bracket.client_raw.pytalks 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, matplotlibFind the headless FreeCAD binary for your OS; this path goes into FREECADCMD below:
Linux, distro package:
freecadcmd(often already on PATH; check withwhich freecadcmd).Linux, AppImage: run
./FreeCAD_*.AppImage --appimage-extractonce, 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 minutesUse 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.pyThen 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 # millisecondsProject-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-marketplaceExport 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.pyor 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 defaultCheck 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.pyclient_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 tofreecadcmd(default:freecadcmdon PATH).FREECAD_MCP_WORKSPACE: where documents, renders and exports are written (default./workspaceinside 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=8Gto cap memory on a shared machine.
Troubleshooting
Server shows as failed or disconnected: run
uv --directory /abs/path/to/cad_mcp run server.pyyourself. 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.freecadcmdnot found:FREECADCMDmust 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_polygoncreate_sketch(lines, arcs, circles, polylines with Sketcher constraints),pad,pocket,revolve,loft,sweephole(simple, counterbore, countersink),shell,fillet,chamferboolean(cut, fuse, common),transform,mirror,linear_pattern,polar_patterndelete_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;explodefor 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_scriptruns 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).
undohas 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 toolsadd_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
Scored across 45 tools
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.
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.
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.
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
Related MCP Connectors
Parametric 3D CAD for AI agents: build print-ready parts, check them, export STL, 3MF or STEP.
Text-to-CAD: build exact STEP or 3MF/STL on the server, each stated requirement measured.
CAD in ChatGPT and Claude: editable parts, STEP/STL/drawings, in-chat 3D, automatic checks.
A browser 3D CAD for your AI: it scripts real-size models, uCAD builds them and returns pictures.
Related MCP Servers
- AlicenseAqualityDmaintenanceEnables 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.10MIT
- AlicenseBqualityDmaintenanceEnables AI assistants to perform 3D modeling and CAD operations in FreeCAD, including geometry creation, boolean operations, and document management.79MIT
- AlicenseNot gradedqualityDmaintenanceEnables AI agents to programmatically build, analyze, and export 3D CAD geometry using FreeCAD through REST or MCP tools.MIT
- AlicenseAqualityBmaintenanceAI pilots FreeCAD. Provides full control of FreeCAD for parametric modeling, assembly, geometry sensing, and more via MCP tool calls.27139 PyPI27MIT