Skip to main content
Glama
PlanPilotMCP
by Stv-devl

PlanPilotMCP

Draw architectural plans, 3D models and BIM files in FreeCAD just by asking Claude. PlanPilotMCP is an MCP server that drives a running FreeCAD (GUI) through its native Python API. Units: millimetres.

"Draw a 10 × 8 m house with a partition in the middle and an entrance door on the south side, fill the walls, dimension the outside, then put it on an A3 sheet at 1:100 and export the PDF."

2D plan

walls (merged, no doubled lines), partitions, doors and windows linked to their wall, stairs, layers, editing (move, copy, rotate, mirror, offset, trim, extend)

Annotation

automatic dimensions, texts, rooms with areas, hatching, solid fill (poché)

Layout

TechDraw sheets (A4–A1, scale, title block), PDF / SVG / DXF export

3D

walls extruded from the plan with openings cut through, slab, flat or gable roof, stairs, isometric view

BIM

levels (one plan each), marks and properties on doors, windows, rooms and wall types, quantity schedules (CSV), IFC4 export

Architecture

flowchart LR
    C["Claude Code"] -- "stdio (MCP)" --> S["server/<br/>MCP tools<br/>Python ≥ 3.11"]
    S -- "TCP 127.0.0.1:9876<br/>JSON lines" --> B["bridge/<br/>inside FreeCAD"]
    B -- "queue + 5 ms QTimer" --> G["Qt GUI thread"]
    G --> T["tools/<br/>handlers"]
    T --> D["FreeCADBackend<br/>Draft · Part · TechDraw"]
    D --> F[("FreeCAD<br/>document")]

The tools/ layers, testable without FreeCAD thanks to a fake backend:

flowchart TB
    H["Handlers<br/>geometry · architecture2d · modify · dimensions · text · hatch · fill<br/>stair_tools · model3d · levels · bim_props · schedules · ifc_export · sheets"]
    P["Ports<br/>DrawingBackend · ModelStore · SolidBuilder · SceneReader · SceneEditor · SheetBackend"]
    G["Pure geometry<br/>geometry2d · shapes · polyunion · openings · build3d · stairs · bim_model"]
    A["FreeCAD adapter<br/>freecad_backend · techdraw_backend"]
    X["Fake backend<br/>tests/fakes.py"]
    H --> P
    H --> G
    P -.implemented by.-> A
    P -.implemented by.-> X

More in docs/ARCHITECTURE.md.

Related MCP server: freecad-mcp

MCP tools (77)

Full parameter reference: docs/TOOLS.md.

Family

Tools

Primitives

ping create_rectangle create_line create_polyline create_circle create_arc

2D architecture

create_wall_2d create_partition_2d create_wall_loop merge_walls create_door_2d create_window_2d create_stair

Reading

get_document get_objects get_selected_objects get_object_geometry get_layers get_bounds

Editing

move_object rotate_object copy_object delete_object mirror offset set_geometry trim extend

Layers

create_layer set_layer set_visibility set_line_width set_line_style

Dimensions

dimension_horizontal dimension_vertical dimension_aligned dimension_linear dimension_angle dimension_chain dimension_exterior dimension_room

Texts

create_text create_note create_room_label get_texts update_text

Hatch and fill

create_hatch create_fill fill_walls

3D

create_walls_3d create_slab create_roof create_stairs_3d clear_3d set_view

Levels

create_level set_active_level get_levels copy_level

BIM

set_properties set_wall_type get_wall_types get_schedule export_schedule export_ifc

Sheets and export

create_drawing_page get_sheet set_page_size set_orientation set_scale add_plan_view position_view add_title_block update_title_block export_pdf export_svg export_dxf

Standard layers (French names, created on first use):

Layer

Content

murs · cloisons

walls · partitions

ouvertures

doors and windows (one block each)

escaliers

stairs

cotations · textes

dimensions · room names, areas, notes

hachures · poche

hatching · solid fill

mobilier

furniture

murs_3d dalles_3d toiture_3d escaliers_3d

3D volumes (kept out of the sheet and the DXF)

Annotations, hatching and fill are real geometry (lines + vector text), so they print in the PDF.

Installation

  1. uv sync

  2. In FreeCAD (Python console: View ▸ Panels ▸ Python console):

    import runpy; runpy.run_path("/path/to/planpilotmcp/bridge/start_bridge.py")

    The Report view prints PlanPilotMCP bridge listening on 127.0.0.1:9876. Once per FreeCAD session.

  3. Register the server in Claude Code:

    claude mcp add planpilot -- uv run --directory /path/to/planpilotmcp python -m server.main

Change the port with FREECAD_MCP_PORT (on both sides). Exports with an explicit path are confined to the document folder, ~/Documents and FREECAD_MCP_EXPORT_DIR (set it on the FreeCAD side to allow another folder), and never replace an existing file unless overwrite=true. Optionally set FREECAD_MCP_TOKEN on both sides: the bridge then rejects requests without the right token. After editing the code, re-run step 2 in FreeCAD (the bridge hot-reloads) and restart Claude Code.

Try it: "draw a 10000 × 8000 mm rectangle". It appears immediately, and Ctrl+Z undoes it.

The IFC export needs ifcopenshell, which FreeCAD ships with; uv sync also installs it for the tests.

Typical run

  1. Draw: create_wall_loop, create_partition_2d, create_door_2d, create_window_2d, create_stair. Walls fuse where they touch. Place doors and windows after the walls.

  2. Annotate: create_room_label, dimension_exterior, dimension_room (they take scale = the print scale denominator), then fill_walls for the solid poché of the cut walls. Do the fill and hatching after the openings are placed.

  3. 3D (optional): create_walls_3d, create_slab, create_roof, create_stairs_3d build volumes at the active level's elevation and turn the view to isometric. clear_3d removes them.

  4. Levels (optional): create_level or copy_level for more storeys. Each level has its own plan; every tool works on the active level (set_active_level).

  5. BIM (optional): set_properties (marks, heights, materials) and set_wall_type, then get_schedule / export_schedule for quantities and export_ifc for the IFC file.

  6. Sheet: create_drawing_page (size="A3", scale="1:100", title block fields), add_plan_view (read its warning), then export_pdf / export_dxf. Save your FreeCAD file first: exports land next to it.

Sheet creation and export run TechDraw in FreeCAD's event loop and can take several seconds.

Known limits

  • The 3D, the BIM model, hatching and fill are read from or drawn over the plan: after editing the plan, run them again (create_walls_3d, fill_walls, export_ifc). A door added after a hatch does not clear it.

  • A wall already cut open by a door is no longer a closed outline and is not merged: merge the walls first, then place the openings.

  • The gable roof is a prism over the bounding box of the house (no hip roof, no L-shaped roof). Stairs are straight, quarter-turn or half-turn only; their 3D steps are solid blocks and do not cut the slab above.

  • Levels cannot be deleted or renamed yet; door/window marks (P1, F1…) are numbered per level; the sheet and the DXF show the active level only.

  • The solid fill is drawn as very dense pen-thick lines, not as a true filled area (the DXF has lines, not a HATCH); on the sheet the grey tone is striped.

  • A long handler freezes the FreeCAD window while it runs (a warning is logged above 5 s).

  • The IFC file was checked by reading it back with ifcopenshell, not in an external BIM viewer.

Tests

uv run pytest            # 698 tests: handlers on a fake backend, protocol, TCP, 3D, BIM, IFC read back
uv run pytest -m freecad # integration, needs FreeCAD importable

Full check against a running FreeCAD (bridge started as in Installation): draws a house through the bridge and asserts walls, openings, stairs, fill, 3D volumes, levels, schedules, IFC, sheet and PDF.

uv run python scripts/e2e_freecad.py --pdf /tmp/plan.pdf

Project layout

bridge/   protocol, dispatcher, TCP server, Qt GUI-thread executor, launcher
server/   MCP tool declarations + bridge client
tools/    validation, pure geometry, ports, FreeCAD adapter, handlers
tests/    unit tests + fake backend
scripts/  end-to-end check against a running FreeCAD
docs/     architecture, tool reference

Adding a tool = write a handler + registry.register(...) in a register_*_tools function wired in bridge/launcher.py + a declaration in server/main.py (a test checks that both sides stay in step).

License

MIT © 2026 stv-devl

Available Tools

77 tools
add_plan_viewA

Put the drawing (all visible layers, or only layers) on the sheet at the sheet's scale (or scale), with line weights by layer: walls heavy, partitions medium, openings/dimensions/texts light. Placed automatically in the free area, clear of the title block; position = [x, y] mm from the sheet's bottom-left corner to centre it yourself. Replaces any previous plan view. Check the result's warning (does not fit / text too small) and suggested_scale.

Inputs: page, scale, layers, position. Returns: object

add_title_blockA

Add the title block (cartouche) to a sheet created without one, and fill the given fields.

Inputs: date, page, titre, client, +5 more. Returns: object

clear_3dA

Delete the 3D volumes (walls, slab, roof) of one level, or of all levels. The 2D plan is untouched.

Inputs: level. Returns: object

copy_levelA

Create a level as a copy of source: its whole plan (walls, doors, windows, texts...) is copied, ready to be edited. elevation defaults to on top of the last level.

Inputs: name (required), source (required), height, activate, +1 more. Returns: object

copy_objectA

Copy objects count times, each copy shifted by another (dx, dy) mm. Copies keep the layer.

Inputs: dx (required), dy (required), names (required), count. Returns: object

create_arcB

Draw a counter-clockwise arc from start_angle to end_angle (degrees, 0 = +x axis).

Inputs: center (required), radius (required), end_angle (required), start_angle (required), +2 more. Returns: object

create_circleC

Draw a circle (mm).

Inputs: center (required), radius (required), layer, fit_view. Returns: object

create_door_2dA

Cut a door opening in the wall and draw the classic door: jambs, open leaf, swing arc. The door is one block ("Porte"): move/copy/delete it as a single object. It is also a BIM object: it keeps a mark (P1, P2... numbered per level unless mark is given), its height (default 2100 mm) and material (default Bois), used by the 3D, the schedules and the IFC export.

position: [x, y] centre of the opening ON THE WALL AXIS (mm). width: default 900 mm. orientation: direction of the WALL, "horizontal" (along x) or "vertical" (along y). wall_thickness: thickness of the wall/partition crossed (default 200 = wall; use 100 for a partition). hinge: "start" (lower x/y end of the opening) or "end". swing: side the door opens to: north/south for a horizontal wall, east/west for a vertical one (default north / east). Warns if no wall was found at the position.

Inputs: position (required), mark, hinge, swing, +6 more. Returns: object

create_drawing_pageA

Create a sheet: size A4/A3/A2/A1, landscape or portrait, print scale ("1:50"), with a French title block (cartouche) filled from projet, adresse, client (maitre d'ouvrage), titre (plan title), dessine, date (default today), numero, indice. Then call add_plan_view. Create the plan's dimensions and texts with scale= so they are readable on paper.

Inputs: date, name, size, scale, +9 more. Returns: object

create_fillA

Solid fill (poché) of an area, as one block on layer 'poche' (mm): what a plan shows for concrete or masonry cut by the section plane. points = outline, holes = outlines left empty (walls: outer outline as points, inner as holes). tone "black" (solid) or "grey" (lighter). scale = print scale denominator (the fill is drawn with pen-thick lines so it prints solid on the sheet and in the PDF). avoid_openings (default true): doors and windows already drawn stay empty.

Inputs: points (required), tone, holes, scale, +1 more. Returns: object

create_hatchA

Hatch an area with parallel lines, as one block "Hachure" on layer 'hachures' (mm). points: the outline [[x, y], ...]. holes: outlines to leave empty, e.g. for a wall ring give the OUTER outline as points and the INNER outline as holes (both from create_wall_loop). pattern: "lines" or "cross" (second set at +90 degrees). angle in degrees (default 45). spacing: mm between lines; default 3 mm on paper = 3 x scale (scale = print denominator). Lines align on the world origin, so neighbouring hatches of the same angle/spacing match. avoid_openings (default true): no hatch inside the doors and windows already drawn. Hatch AFTER placing them; a door added or moved later does not clear the existing hatch.

Inputs: points (required), angle, holes, scale, +3 more. Returns: object

create_layerB

Create a layer. Standard names (murs, cloisons, ouvertures, mobilier, cotations, textes, hachures) have default styles. line_color is [r, g, b] in 0..1; draw_style is Solid, Dashed, Dotted or Dashdot.

Inputs: name (required), draw_style, line_color, line_width. Returns: object

create_levelA

Add a level (storey), e.g. name="R+1". elevation = floor level in mm (default: on top of the previous level); height = floor to floor. On an existing name, changes its elevation/height. activate=true switches to it (an empty plan).

Inputs: name (required), height, activate, elevation. Returns: object

create_lineA

Draw a straight line between two [x, y] points (mm), optionally on a named layer.

Inputs: end (required), start (required), layer, fit_view. Returns: object

create_noteC

Multi-line note: lines stacked downwards from position, as one 'Note' block.

Inputs: lines (required), position (required), align, layer, +2 more. Returns: object

create_partition_2dA

Draw one interior partition on layer 'cloisons' (mm).

start/end are [x, y] points on the partition AXIS. Default thickness 100 mm. merge (default true): fused with the touching partitions into one outline, like create_wall_2d.

Inputs: end (required), start (required), merge, fit_view, +1 more. Returns: object

create_polylineA

Draw a polyline through [[x, y], ...] points (mm); closed=True joins last to first.

Inputs: points (required), layer, closed, fit_view. Returns: object

create_rectangleA

Draw a 2D rectangle in the open FreeCAD (XY plane, all values in mm).

(x, y) is the lower-left corner; width x height default to 10000 x 8000 mm. layer puts it on a named layer (created on first use; without one the rectangle is on no layer and escapes layer filters). Returns name, dimensions and bounds.

Inputs: x, y, layer, width, +2 more. Returns: object

create_roofA

Roof over the walls (outline from the walls, or points), starting at base_height (the wall height). "gable" = two slopes: a solid prism over the bounding box of the outline, pitch in degrees (5-70), ridge along the longer side ("x" or "y" to choose). "flat" = a slab of thickness. overhang (mm) extends the roof past the walls. Replaces the previous roof.

Inputs: kind, view, pitch, ridge, +5 more. Returns: object

create_room_labelA

Room name with its area (e.g. "36,10 m2") centred in the room, as one block on layer 'textes'. Give points = the room's CLEAR interior corners (wall faces, e.g. from create_wall_loop's inner outline and the partition faces): the area is computed and the label centred. Or give area_m2 and position. Returns the area. The room is also a BIM object (schedules, IFC space): optional usage (e.g. "Séjour") and floor_finish (e.g. "Carrelage").

Inputs: name (required), scale, usage, points, +3 more. Returns: object

create_slabA

Floor slab under the house: points = its outline, or omit it to use the outer outline of the walls (offset outward by margin). It occupies z from top - thickness to top (top = 0, the floor level, by default). replace=false to add a second slab instead of replacing the first.

Inputs: top, view, margin, points, +2 more. Returns: object

create_stairA

Draw a stair on the active level as one block "Escalier" on layer 'escaliers' (mm): treads, riser lines, walking line with arrow, and the cut line at 1.2 m. start = [x, y] the MIDDLE of the first riser (the bottom of the stair); angle = direction of the first flight in degrees (0 = east, 90 = north). stair_type: "straight", "quarter" (L, a square landing then a second flight turning turn left or right) or "half" (U, landing then a parallel flight back). width = flight width. tread = depth of a step (giron, default 270). rise = floor-to-floor height climbed (default the level height); risers = number of risers (default so that each is about 175 mm); landing_at = the riser number where the landing sits (default the middle). The result warns about steep or narrow stairs (rule 2 x riser + tread = 600-640). It is also a BIM object: mark E1, E2..., material Béton.

Inputs: start (required), mark, rise, turn, +8 more. Returns: object

create_stairs_3dA

Build the 3D steps of every stair of the active level (solid blocks from the floor up to each tread), standing on the level's floor. Replaces the previous ones of that level.

Inputs: view. Returns: object

create_textA

Single-line text (real vector geometry, prints in PDF). position = anchor on the baseline, align = left/center/right, angle in degrees. height = capital height in mm (default 2.5 mm on paper = 125 at 1:50). Layer 'textes' by default.

Inputs: text (required), position (required), align, angle, +3 more. Returns: object

create_wall_2dA

Draw one straight wall as a closed outline on layer 'murs' (mm).

start/end are [x, y] points on the wall AXIS. Default thickness 200 mm. merge (default true): a wall that overlaps or touches other closed walls on 'murs' is fused with them into one clean outline (no doubled lines at corners and T junctions). Do it BEFORE placing doors/windows: a wall already cut open by a door is not merged. Returns the 4 corners, length, thickness and the resulting outline name(s).

Inputs: end (required), start (required), merge, fit_view, +1 more. Returns: object

create_wall_loopA

Draw a closed run of walls (e.g. a house perimeter) with clean mitered corners. thickness defaults to 200 mm.

points: polygon vertices [[x, y], ...] in mm, in order. alignment says where the points lie: "outer" (outside face - use this for "house 12 x 8 m"), "center" (wall axis) or "inner" (inside face). Draws the outer and inner outlines on layer 'murs' and returns axis_points (wall centre line: place doors/windows on it), plus the interior bounds and area (mm2).

Inputs: points (required), fit_view, alignment, thickness. Returns: object

create_walls_3dA

Extrude the 2D walls (layer 'murs', and 'cloisons' unless partitions=false) into solids of the given height (mm), from z=0. The doors and windows drawn in 2D are cut through: doors from the floor to door_height, windows from window_sill to window_sill + window_height. Replaces the previous 3D walls. Returns the volume (m3) and z range of each solid.

Inputs: view, height, partitions, door_height, +2 more. Returns: object

create_window_2dA

Cut a window opening in the wall and draw the 2D window (jambs, frame and glazing lines). A BIM object like the door: mark (F1, F2...), height (default 1200 mm), sill = height of the bottom above the floor (default 900 mm) and material (default PVC).

position: [x, y] centre of the window ON THE WALL AXIS (mm). width: default 1200 mm. orientation: direction of the WALL, "horizontal" or "vertical". wall_thickness: thickness of the wall crossed (default 200). Warns if no wall was found there.

Inputs: position (required), mark, sill, width, +5 more. Returns: object

delete_objectC

Delete objects (a block is deleted with its parts).

Inputs: names (required). Returns: object

dimension_alignedB

Dimension of the true distance p1-p2, line parallel to it (offset > 0 = left of p1->p2).

Inputs: p1 (required), p2 (required), unit, scale, +1 more. Returns: object

dimension_angleB

Angle at vertex between the rays towards p1 and p2 (smaller angle), drawn as an arc.

Inputs: p1 (required), p2 (required), vertex (required), scale, +1 more. Returns: object

dimension_chainB

A chain of consecutive dimensions plus the overall dimension on a second line. axis="horizontal": coordinates are x values measured along the face at y=edge; the line is offset from it (> 0 above, < 0 below). axis="vertical": y values along x=edge (> 0 right).

Inputs: edge (required), coordinates (required), axis, unit, +3 more. Returns: object

dimension_exteriorB

Automatic exterior dimensions on the 4 sides of the walls (layer 'murs'): a chain through corners, door/window openings on that face and partitions meeting it, plus the overall dimension. Draw walls, partitions, doors and windows first. Returns the stops per side.

Inputs: unit, scale, offset. Returns: object

dimension_horizontalB

Horizontal dimension between two [x, y] points (mm). offset: distance of the dimension line from the points, > 0 above, < 0 below (default 600 at 1:50, i.e. 12 mm on paper). One 'Cote' block on layer 'cotations'.

Inputs: p1 (required), p2 (required), unit, scale, +1 more. Returns: object

dimension_linearC

Horizontal or vertical dimension, picked from the points (or direction="horizontal"/"vertical").

Inputs: p1 (required), p2 (required), unit, scale, +2 more. Returns: object

dimension_roomB

Clear interior width and depth of a room, drawn inside it along its bottom and left sides. points: the room's clear corners (wall FACES, not axes). Uses the bounding box.

Inputs: points (required), unit, scale, offset. Returns: object

dimension_verticalC

Vertical dimension between two points. offset > 0 puts the line to the right, < 0 to the left.

Inputs: p1 (required), p2 (required), unit, scale, +1 more. Returns: object

export_dxfA

Export a DXF. mode="model" (default): the plan at 1:1 in mm with its layers (murs, cloisons, ouvertures, cotations, textes...) and real editable texts, no sheet needed: use it to work in a CAD program. mode="sheet": the TechDraw page as drawn on paper (scaled). Path rules and overwrite as export_schedule.

Inputs: mode, page, path, overwrite. Returns: object

export_ifcA

Export the building to an IFC4 file (BIM): one storey per level, walls with their openings, doors and windows (mark, height, material) filling those openings, slabs, spaces (rooms with area and usage) and optionally a roof over the top level. Default path: next to the FreeCAD document. Path rules and overwrite as export_schedule.

Inputs: path, roof, author, overhang, +5 more. Returns: object

export_pdfA

Export the sheet to a PDF (vector, at print size). Default path: next to the saved FreeCAD file, else in ~/Documents. Path rules and overwrite as export_schedule. Returns the file path.

Inputs: page, path, overwrite. Returns: object

export_scheduleA

Save a schedule as a CSV file (semicolon-separated, opens in Excel/LibreOffice). Default path: next to the FreeCAD document. An explicit path must be in the document folder, ~/Documents or $FREECAD_MCP_EXPORT_DIR; an existing file is only replaced with overwrite=true.

Inputs: kind (required), path, level, overwrite. Returns: object

export_svgB

Export the sheet to an SVG file. Default path as export_pdf.

Inputs: page, path, overwrite. Returns: object

extendC

Extend a straight line (end = "start", "end" or "nearest") until it meets boundary.

Inputs: target (required), boundary (required), end. Returns: object

fill_wallsA

Fill (or hatch) the walls of the active level in one call: the wall outlines of layers 'murs' and 'cloisons' (or layers) are rebuilt even where doors and windows cut them, and the openings stay empty. style "solid" = poché (tone black/grey), "hatch" = diagonal hatching at angle. Replaces the fill/hatch a previous fill_walls call drew for the same layers.

Inputs: tone, angle, scale, style, +1 more. Returns: object

get_boundsA

Bounding box of the whole drawing (or one layer): x/y min/max, width, height (mm). visible_only=true ignores hidden layers and objects.

Inputs: layer, visible_only. Returns: object

get_documentA

Active document: name, file, unit (mm), object count, layers and overall bounds.

Inputs: no named parameters. Returns: object

get_layersB

Layers with object count, visibility, line width, colour and style.

Inputs: no named parameters. Returns: object

get_levelsA

The levels (name, elevation, height) and which one is active.

Inputs: no named parameters. Returns: object

get_object_geometryA

Exact geometry of one object: points/length/area (polyline), center/radius/angles (arc, circle) or components (block), in global mm coordinates.

Inputs: name (required). Returns: object

get_objectsA

List drawing objects (name, label, type, layer, visible, bounds), optionally filtered by layer or type (Wire, Rectangle, Circle, Block). visible_only=true leaves out hidden objects and layers. Door/window blocks appear as one 'Block' object.

Inputs: type, layer, visible_only. Returns: object

get_scheduleA

A quantity schedule of the building, read from the plan of every level (or one level): doors and windows (mark, size, material), walls (area, volume per wall type), rooms (area, usage), stairs (type, risers, tread), levels (elevation, height, totals). wall_height (mm) is used for the wall volumes. Returns columns, rows and totals.

Inputs: kind (required), level, wall_height. Returns: object

get_selected_objectsB

Objects currently selected by the user in FreeCAD.

Inputs: no named parameters. Returns: object

get_sheetC

The sheet's format, scale, title block fields and plan placement (fits / overlaps warnings).

Inputs: page. Returns: object

get_textsA

All texts of the drawing (room names, areas, dimension values, notes) with position, height, layer and the block that holds them.

Inputs: no named parameters. Returns: object

get_wall_typesB

The wall type (name, material, fire rating...) of the 'murs' and 'cloisons' layers.

Inputs: no named parameters. Returns: object

merge_wallsA

Fuse the closed wall outlines that overlap or touch into clean outlines (no doubled lines), on layers 'murs' and 'cloisons' (or the given layers). The inside of a wall ring made by create_wall_loop stays empty. Walls already opened by a door/window are not merged.

Inputs: layers. Returns: object

mirrorB

Mirror objects across the line through axis_start and axis_end ([x, y] mm).

Inputs: names (required), axis_end (required), axis_start (required), keep_original. Returns: object

move_objectA

Move objects by (dx, dy) mm. A door/window block moves as one, but the hole it cut in the wall stays where it was.

Inputs: dx (required), dy (required), names (required). Returns: object

offsetA

Create a parallel copy at distance mm. Closed polyline: positive = outward, negative = inward. Open polyline: positive = left of its direction. Circle/arc: positive = larger radius.

Inputs: name (required), distance (required). Returns: object

pingA

Check the link to the open FreeCAD: returns its version and active document.

Inputs: no named parameters. Returns: object

position_viewA

Move the plan so its centre is at (x, y) mm from the sheet's bottom-left corner.

Inputs: x (required), y (required), page. Returns: object

rotate_objectA

Rotate objects counter-clockwise by angle degrees around center (default: centre of the objects).

Inputs: angle (required), names (required), center. Returns: object

set_active_levelA

Switch the drawing to a level: only its plan is shown, and new objects belong to it.

Inputs: name (required), fit_view. Returns: object

set_geometryA

Redefine an object's geometry. Polyline: points (+closed). Rectangle: x, y, width, height. Circle/arc: center, radius (+start_angle and end_angle for an arc). Not for blocks.

Inputs: name (required), x, y, width, +7 more. Returns: object

set_layerB

Put objects on a layer (created if needed).

Inputs: layer (required), names (required). Returns: object

set_line_styleA

Set Solid, Dashed, Dotted or Dashdot on a layer OR on objects (exactly one of layer / names).

Inputs: style (required), layer, names. Returns: object

set_line_widthA

Set the line width of a layer OR of objects (give exactly one of layer / names).

Inputs: width (required), layer, names. Returns: object

set_orientationA

Switch the sheet to "landscape" or "portrait"; the plan is re-placed automatically.

Inputs: orientation (required), page. Returns: object

set_page_sizeB

Change the sheet format (A4, A3, A2, A1); the plan is re-placed automatically.

Inputs: size (required), page. Returns: object

set_propertiesA

Change the BIM properties of a door/window block (mark, height, sill [windows], material, description) or of a room label (name, usage, floor_finish, description). Heights and sills in mm. After changing a height or sill, call create_walls_3d again to update the 3D.

Inputs: name (required), properties (required). Returns: object

set_scaleB

Change the print scale ("1:50", "1:100"...). The result warns if the plan no longer fits or if the dimensions/texts are too small to read at that scale.

Inputs: scale (required), page. Returns: object

set_viewA

Turn the FreeCAD 3D view like the navigation cube: top (plan view, the default), front, rear, left, right, bottom or isometric. rotation = extra turn in degrees in the screen plane (positive = the drawing turns counter-clockwise, i.e. to the left). fit=True also zooms to show the whole drawing. This only moves the camera; the drawing itself is unchanged.

Inputs: fit, rotation, orientation. Returns: object

set_visibilityC

Show or hide a layer.

Inputs: layer (required), visible (required). Returns: object

set_wall_typeA

Describe the walls of a layer for the schedules and the IFC export: type name, material, fire rating (e.g. "REI 60"), finish, load_bearing. Defaults: murs = Mur, Maçonnerie, load-bearing; cloisons = Cloison, Plâtre. Only the given fields change.

Inputs: name, layer, finish, material, +2 more. Returns: object

trimB

Trim a straight line: remove the part of target around the point pick, up to the nearest crossings with cutter (any line/polyline/rectangle).

Inputs: pick (required), cutter (required), target (required). Returns: object

update_textA

Change the string of an existing text (name from get_texts), keeping its anchor and alignment.

Inputs: name (required), text (required). Returns: object

update_title_blockC

Change fields of the sheet's title block (only the given ones).

Inputs: date, page, titre, client, +5 more. Returns: object

Tool Schema Changelog

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

Loading tool schema changelog…

    TDQS

    B3.2/5.0

    Scored across 77 tools

    Disambiguation4/5

    Most tools target a distinct resource and action, but there are overlapping clusters: seven dimension tools, three fill/hatch tools, and three wall creation tools. The detailed descriptions disambiguate them, though an agent could still misselect between dimension_variant or fill_walls vs create_hatch.

    Naming Consistency5/5

    All tools use a consistent verb_noun snake_case pattern, including dimensional variants (dimension_vertical, dimension_aligned) and level/export names. The few single-verb tools (mirror, offset, trim, extend) are conventional imperative commands and do not break the pattern.

    Tool Count2/5

    77 tools is far beyond the well-scoped 3-15 range and the 25+ threshold, making the surface heavy. The broad architectural/BIM domain justifies some size, but this is still an extreme count that risks overwhelming agents and consuming context.

    Completeness4/5

    The tool surface covers the full lifecycle for the domain: create/get/update/delete for objects and levels, walls, doors/windows, stairs, 3D extrusion, schedules, and many export formats. Minor gaps exist (no delete_level, no door/window width update), but these can be worked around with existing tools.

    Maintenance

    ActivitySlowing
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      D
      maintenance
      Enables control of FreeCAD CAD software from Claude Desktop through natural language commands. Supports creating, editing, and managing 3D objects, executing Python code, and generating screenshots of designs.
      10
      MIT
    • A
      license
      A
      quality
      D
      maintenance
      Enables to control FreeCAD from Claude Desktop through MCP, allowing CAD operations like creating and editing objects, taking screenshots, and executing Python code.
      11
      1
      MIT
    • A
      license
      A
      quality
      D
      maintenance
      Enables Claude Desktop to control FreeCAD for 3D CAD modeling, including creating, editing, and deleting objects, executing Python code, and running FEM analyses.
      14
      MIT