Skip to main content
Glama

λ lambdacad-mcp

Let AI draw in your CAD. An MCP server for any AutoLISP-capable CAD — no COM, no SDK, no plugins. Pure AutoLISP. The reference adapter drives BricsCAD on Linux: the first MCP server for a professional DWG CAD on Linux.

License: Apache 2.0 Platform: Linux Python 3.10+ Tools: 128 MCP Registry Glama score lambdacad-mcp MCP server

"Draw a DN80 flange: front view, hatched section, dimensions — then model it in 3D."

lambdacad-mcp demo: AI draws a complete flange in BricsCAD, 2D + 3D

Real-time capture, unedited: front view with bolt circle, hatched section, radial/diameter dimensions, leader, title block — then the same flange modeled as a 3D solid with an AI-written parametric AutoLISP loop and one boolean subtraction. ~20 seconds, 12 tool calls.

Complete 2D drawing, drawn by Claude

3D solids with booleans

Clean render for AI vision

2D flange

3D solids

bracket render

Why this exists

Every other MCP server for a professional DWG CAD (multiCAD-mcp, autocad-mcp, CAD-MCP, ...) talks to the CAD through Windows COM — none of them can run on Linux, and none of them does real 3D.

BricsCAD is the professional DWG CAD that does run natively on Linux. This server drives it through a mechanism that needs no API at all: an AutoLISP file bridge. The MCP server writes LISP expressions to a file, triggers a tiny MCP command inside the CAD, and reads the result back. That's the whole trick — and it unlocks everything the CAD can do, including 3D solid modeling.

Because the bridge is plain AutoLISP + standard DXF entmake + AutoCAD-compatible commands, it is portable by construction: AutoCAD, ARES Commander (also Linux-native!), ZWCAD, GstarCAD and the IntelliCAD family all speak the same language. Porting means swapping the autoload file name and the keystroke trigger — adapters welcome.

MCP client (Claude, Cursor, ...)            BricsCAD (Linux)
        │                                        │
        ▼                                        ▼
  server.py (FastMCP, 128 tools)          c:MCP AutoLISP command
        │        writes LISP  ──►  /tmp/mcp_bricscad.in
        │        triggers via xdotool ──► reads, evals line by line
        │        reads result ◄──  /tmp/mcp_bricscad.out

Related MCP server: AutoCAD MCP Server

What it can do

  • Full 2D drafting — lines/arcs/polylines/splines, line weights per layer (0.50 walls / 0.35 edges / 0.18 dimensions — measured on the plotted page, not just set), real HATCH (with islands), dimensions incl. radius/diameter/angular, leaders, linetypes (chain/hidden), text styles, trim/extend/fillet/chamfer/offset/mirror/arrays, blocks

  • Semantic shapes — slot, bolt_circle, rounded_rect, polygon, center_mark: one call, the server does the math

  • 3D solid modeling — box/cylinder/sphere/cone/wedge/torus, extrude/revolve/sweep, union/subtract/intersect, slice, fillet/chamfer on solid edges, 3D move/rotate around any axis — and flatshot_view: auto-generate correct 2D drawing views from the 3D model

  • Batch & atomic — draw_batch executes N operations in one round-trip, wrapped in one undo group (one batch = one Ctrl+Z)

  • Talk about what the user selected — get_selection reads the GUI pickfirst set; select_by/select_window highlight what the AI found before acting; modify tools accept "selection"

  • Verification without screenshots — bounding boxes, key points, exact lengths/areas, intersection checks (collision detection), solid volume/centroid

  • Design review — tools that answer an engineering question, not just run a command (new in 1.2) — boolean_verified cuts and measures the change against the volume you expected (a cut that lands short reads SHORT, not success); overhang_report reads the STL mesh and says whether a part prints without supports, scoring all six orientations; contact_report over an assembly (assembly_place/assembly_list/assembly_clear) says who touches whom, who interferes, and who is an orphan — a part touching nothing, because its job was superseded and nobody noticed; hole_report physically probes every hole and says which are actually open (a drawing lies about its holes until something checks); graph_build/graph_trace read the 2D geometry as a connectivity graph — separate networks, exact run lengths, and the open ends that are real breaks vs T-junctions, with the joining tolerance emerging from the drawing instead of hardcoded

  • The drawing REMEMBERS (new in 1.3, beta) — memory_enable puts a journal beside the .dwg that the CAD writes by itself, catching the edits the human makes in the GUI while no tool is running; tag_entity gives entities semantic roles ("muro-nord", "asta-principale") keyed to handles, which survive save and reopen; world_report answers what is here, what did I call it, what changed since I last looked — and revalidates every claim against the live drawing before answering (an entity erased behind the AI's back reads DEAD (erased since tagging), reported, never hidden). The next prompt — or the next session — starts knowing the drawing instead of re-surveying it

  • Instructions in the protocol (new in 1.2) — the server ships the rules that cannot be learned by trying (OK is not evidence; calibrate before trusting; booleans keep the first handle; one line is one complete expression; consult the drawing's memory first), plus a lambdacad://traps resource that costs nothing until read

  • Eyes when needed — render_view: BricsCAD's internal PNG render (clean, no UI, ~30 KB) for vision models

  • Sheets, at a real scale — create_sheet (A4…A0, margins zeroed so paper mm = sheet mm), add_viewport (ask for 1:50 and it is 1:50 — measured back off the entity, and parked on a non-plotting layer), fit_viewport (measures what is drawn and picks the largest STANDARD scale that fits — 1:37 is not a scale), title_block (border + ISO 7200 cartouche, sized from the sheet), export_sheet_pdf, which checks its own work by measuring the page of the PDF it just wrote

  • Deliverables — save DWG, export DXF, PDF and STL (export_stl: 3D solids straight to the slicer, parked on the origin)

  • Several drawings open — list_documents shows which one the tools are pointing at (plus unsaved changes and read-only), use_document picks another; every reply says which drawing answered, and warns when it changes underfoot

  • Escape hatch — run_lisp evaluates arbitrary AutoLISP (multi-line, multi-expression): capable models write parametric code and love it

Full reference: docs/TOOLS.md · How it works: docs/ARCHITECTURE.md

Measured, not promised

Metric

Result

Tool calls for a complete dimensioned flange

200 → 22 (9× fewer round-trips vs primitive-per-call)

Trigger latency

0.25 s per call

Error reporting

per-line LISP errors (msg=L2: ...) → models self-correct without screenshots

Exactness

entity_length on an r=20 circle: 125.664 / 1256.637 (2πr, πr² exact)

Details and model-behavior notes (Sonnet writes parametric LISP, Haiku uses typed tools): docs/BENCHMARKS.md

Tests

BRICS_DISPLAY=:0 python tests/test_tools.py     # ~135 checks incl. review + memory groups, ~2-4 min
python tests/test_tools.py 3d edges export      # or just some groups
python tests/test_tools.py --list

An integration suite: it drives the CAD you already have running, then measures what came out — closed-form volumes, bounding boxes, the value stored inside a dimension, triangle counts read out of the STL. Never "no error".

That distinction is the whole point. The bridge answers OK whenever the CAD accepted the command, which is not the same as the CAD having done what was asked. Every bug found so far was of that shape: the classic CHAMFER silently switching to all edges; a layout that plots rotated 90°, so an A3 landscape sheet comes out portrait, the drawing falls off the paper and the export writes a perfectly valid, entirely empty page; and — the one that reached a release — running object snap dragging programmatic coordinates onto nearby geometry, so five blocks placed in a row each landed on the previous. A volume, a bounding box, a measured dimension and the page of a PDF are exact signatures: every one of those surfaced as arithmetic that did not add up.

The suite draws in a scratch region (x ≥ 50000), erases it afterwards, and fails if the entity count does not come back to where it started. It still works in the active drawing, so point it at a scratch one.

Usage telemetry (local only)

With 128 tools, the interesting question is which ones earn their place — and which fail often enough to signal a docstring or design problem. The server appends one JSON line per call to ~/.lambdacad/usage.jsonl:

{"t": 1786526823.4, "tool": "draw_batch", "ms": 198, "err": 0}

Tool name, duration, error flag. Never the arguments — no coordinates, no paths, no drawing data — and nothing ever leaves your machine. Disable with LAMBDACAD_TELEMETRY=0.

python scripts/usage_report.py              # per-tool calls, error rate, p50
python scripts/usage_report.py --core 95    # smallest set covering 95% of calls
python scripts/usage_report.py --reset      # archive the current log

The --core output is a data-driven candidate for CORE_TOOLS (compact mode): after a few weeks of real use, the choice of which tools deserve a place in a schema-limited client stops being a guess. Early signal from the integration suite itself: run_lisp alone is ~half of all calls — on clients that load schemas on demand (Claude Code's tool search), the long tail of typed tools costs nothing until used, so the rich docstrings stay.

Quick start

Requirements: Linux, BricsCAD (any recent version — tested on V26), Python 3.10+, xdotool.

git clone https://github.com/Psalmustrack/lambdacad-mcp
cd lambdacad-mcp
./install.sh

The installer creates a venv, installs the AutoLISP bridge into BricsCAD's Support/on_doc_load.lsp (idempotent, marker-delimited), and prints ready-to-paste config for Claude Code / Claude Desktop.

Then:

  1. Start BricsCAD and open a drawing (the bridge loads when a document opens).

  2. Start a new AI session — the bricscad tools appear.

  3. Ask: "draw the plan of a 4×3 m room with a door and dimensions".

Configuration (env vars)

Variable

Default

Purpose

BRICS_DISPLAY

session $DISPLAY

X display where BricsCAD runs (e.g. :77 for a nested Xephyr)

BRICS_COMPACT

off

1 = expose only 14 essential tools (~1k schema tokens instead of ~7k) for clients that inject every schema

BRICS_MCP_IN / BRICS_MCP_OUT

/tmp/mcp_bricscad.{in,out}

bridge file paths

Security note

run_lisp and run_command execute arbitrary code inside BricsCAD by design — that's what makes the server fully general. Only connect MCP clients you trust, and treat the bridge files as trusted input. The bridge itself never loads foreign files (read+eval only) and honors BricsCAD's SECURELOAD.

Troubleshooting

Symptom

Fix

ERR: BricsCAD window not found

Is BricsCAD running on BRICS_DISPLAY?

ERR: no response from BricsCAD

Is a drawing open (not the Start page)? The bridge loads on document open.

Commands typed into the drawing as text

Click once inside the drawing area so the command line has focus, then retry.

Updated the bridge, nothing changed

on_doc_load.lsp runs per document, and each open drawing keeps its own copy of the definitions. Drawings already open still hold the old bridge: close and reopen them, or (load "…/Support/on_doc_load.lsp") in each.

The tools are drawing in the wrong file

list_documents shows which drawing they are pointing at; use_document moves them. Replies carry dwg=<name> and warn when it changes on its own.

Wayland

Works via XWayland; if your compositor struggles with heavy CAD redraws, run BricsCAD under a nested X server (Xephyr) and set BRICS_DISPLAY.

Project

CAD

Platform

3D

λ lambdacad-mcp (this)

any AutoLISP CAD — BricsCAD reference

Linux

yes

multiCAD-mcp

AutoCAD/BricsCAD/ZWCAD via COM

Windows

no

puran-water/autocad-mcp

AutoCAD LT (LISP bridge)

Windows

no

hvkshetry/autocad-mcp

AutoCAD LT

Windows

no

freecad-mcp (various)

FreeCAD

cross-platform

yes (FreeCAD)

Credit where due: multiCAD-mcp inspired the project; puran-water/autocad-mcp independently validated the LISP-bridge approach on Windows.

Roadmap

  • Focus-free dispatch (targeted X synthetic events — no window activation)

  • In-process socket bridge (no keystroke trigger, ~0 latency)

  • VIEWBASE paper-space drawing views; sheet metal (SMUNFOLD) and BIM commands

  • Compact-mode behavioral benchmark

License

Apache 2.0 — with an explicit patent grant and trademark protection for the lambdacad-mcp name.

Trademarks

AutoCAD® and AutoLISP® are registered trademarks of Autodesk, Inc. BricsCAD® is a registered trademark of Bricsys NV (Hexagon). ARES Commander®, ZWCAD® and all other CAD product names mentioned are trademarks of their respective owners, used here only to identify compatibility. This project is independent open-source software: it is not affiliated with, endorsed or sponsored by Autodesk, Bricsys, or any CAD vendor.

Available Tools

128 tools
add_viewportA

Put a window onto the model on a sheet: rectangle (x1,y1)-(x2,y2) in SHEET mm, at 1:scale, centred on model point (center_x,center_y). Returns the scale MEASURED back off the viewport.

Inputs: x1 (required), x2 (required), y1 (required), y2 (required), +6 more. Returns: result

array_polarA

Polar array: copy entities count times around (cx,cy) over angle degrees. handles=['selection'] uses the GUI selection.

Inputs: cx (required), cy (required), count (required), handles (required), +1 more. Returns: result

array_rectC

Rectangular array of entities: rows x cols with spacings. handles=['selection'] uses the GUI selection.

Inputs: cols (required), rows (required), handles (required), col_spacing (required), +1 more. Returns: result

assembly_clearA

Remove instances from the assembly - their copied solids are erased from the drawing and their entries leave the manifest. names=None clears the whole assembly. Masters are never touched.

Inputs: names. Returns: result

assembly_listA

The assembly manifest: every placed instance with its pose, and whether its solid still exists in the drawing (an instance whose solid was consumed or erased is reported, not hidden - a manifest that cannot drift silently is the point of having one).

Inputs: no named parameters. Returns: result

assembly_placeA

Place a COPY of a master part into the assembly, posed and registered. The master stays where it is; the copy is moved so its bounding-box anchor ('min' = the lowest corner, natural for putting a part ON something at height z; 'center') lands at (x,y,z), then rotated rot_z degrees about that point. The instance is recorded under name in a manifest beside the drawing, which is what contact_report and assembly_list read - the assembly is the sentence 'these copies belong together' that a bare drawing cannot say.

Inputs: x (required), y (required), name (required), master_handle (required), +3 more. Returns: result

bolt_circleC

N holes on a pitch-circle diameter (pcd), positions computed server-side; one call.

Inputs: cx (required), cy (required), pcd (required), count (required), +5 more. Returns: result

boolean_verifiedA

Boolean that MEASURES what it did: volume before and after, and the change checked against expected_change (mm3, worked out from the shape you meant to remove or add). Catches the two failures a plain boolean reports as success: a cut that lands SHORT (the tool solid did not fully span the part, so volume drops and it looks fine - the leftover is a sliver you find in the slicer) and a cut that misses altogether (change exactly 0). Also encodes the trap that the result KEEPS the target's handle: SUBTRACT/UNION/INTERSECT write into the first solid instead of making a new entity, so (entlast) after a boolean belongs to somebody else.

Inputs: tool_handles (required), target_handle (required), op, tol_pct, +1 more. Returns: result

bool_intersectC

Keep only the intersection of 3D solids.

Inputs: handles (required). Returns: result

bool_subtractA

Subtract solids from solids (holes, pockets). keep = the part, subtract = the tools.

Inputs: keep_handles (required), subtract_handles (required). Returns: result

bool_unionC

Union 3D solids into one.

Inputs: handles (required). Returns: result

break_entityA

Break an entity between two points (opens a gap; same point twice = split only).

Inputs: x1 (required), x2 (required), y1 (required), y2 (required), +1 more. Returns: result

center_markC

Center-mark cross at (x,y).

Inputs: x (required), y (required), size, layer. Returns: result

chamfer_polylineA

Chamfer (bevel) ALL corners of a polyline with equal distances.

Inputs: handle (required), distance (required). Returns: result

chamfer_solidA

Chamfer edges of a 3D solid: edges = [[x,y,z], ...], ONE point lying ON each edge to cut. A 45 deg chamfer prints without support where a fillet would need it. The edge nearest the camera wins, so set the view (view_3d) when the target is hidden behind the part. Check with solid_volume - the chamfer runs out where it meets another edge, so expect slightly less removed than distance^2/2 * length.

Inputs: edges (required), distance (required). Returns: result

check_intersectionC

Do two entities intersect/overlap? Returns intersection points. The anti-collision check.

Inputs: handle1 (required), handle2 (required). Returns: result

contact_reportA

Who touches whom in the assembly - and who touches NOTHING. For every pair of instances: bounding boxes first (cheap), then a real intersection on throwaway copies for the pairs whose boxes come within clearance. Verdicts: INTERFERENCE with the overlap volume (parts occupy the same space - an assembly error), CONTACT (boxes within clearance, no overlap - how parts that work together should read), CLEAR. Instances contacting nothing are listed as ORPHANS: a part that touches nothing either floats or lost its job to a design revision and nobody noticed - the second kind is the expensive one. Box gap is a lower bound of true distance, so a diagonal near-miss can read as CONTACT; interference volumes are exact.

Inputs: clearance. Returns: result

copy_entityB

Copy entity with offset (dx,dy); handle='selection' copies the user's GUI selection.

Inputs: dx (required), dy (required), handle (required). Returns: result

create_blockA

Define a reusable block from existing entities (they become the definition; re-place with insert_block).

Inputs: name (required), base_x (required), base_y (required), handles (required). Returns: result

create_layerA

Create a layer with ACI color (1=red 2=yellow 3=green 4=cyan 5=blue 6=magenta 7=white) and optional lineweight in MM (0.13/0.25/0.35/0.50/0.70/1.00 - snapped to the nearest legal one).

Inputs: name (required), color, lineweight. Returns: result

create_sheetA

Create/reset a paper-space sheet (layout) of size A4..A0 ready to plot 1:1: margins zeroed so paper mm = sheet mm, plot rotation cleared, auto-viewport removed. Returns the MEASURED sheet size.

Inputs: name (required), size, landscape. Returns: result

dim_alignedA

Aligned (parallel) dimension between two points; (line_x,line_y)=dimension line position. Exact coordinates unless snap=True (see dim_linear).

Inputs: x1 (required), x2 (required), y1 (required), y2 (required), +3 more. Returns: result

dim_angularC

Angular dimension: vertex + a point on each side + dimension arc position.

Inputs: x1 (required), x2 (required), y1 (required), y2 (required), +4 more. Returns: result

dim_diameterB

Diameter dimension (D...) on a circle/arc by handle.

Inputs: handle (required), angle, offset. Returns: result

dim_linearA

Linear (horiz/vert) dimension between two points; (line_x,line_y)=dimension line position. Measures your EXACT coordinates: snap=True instead lets running object snap pull the ends onto nearby geometry (handy to dimension existing entities, but it can silently measure the wrong distance).

Inputs: x1 (required), x2 (required), y1 (required), y2 (required), +3 more. Returns: result

dim_radiusA

Radius dimension (R...) on a circle/arc by handle; angle=where it points (deg), offset=leader length factor.

Inputs: handle (required), angle, offset. Returns: result

draw_arcC

Arc: center, radius, start/end angles in degrees (CCW).

Inputs: cx (required), cy (required), radius (required), end_angle (required), +2 more. Returns: result

draw_batchA

Execute many drawing ops in ONE call - ALWAYS prefer this over single tools for 3+ entities. Each op is {"type":...} + params (optional "layer"). Types: line(x1,y1,x2,y2) circle(cx,cy,radius) arc(cx,cy,radius,start_angle,end_angle) rectangle(x1,y1,x2,y2) polyline(points,closed) point(x,y) text(x,y,text,height,rotation) mtext(x,y,text,width,height) ellipse(cx,cy,major_dx,major_dy,ratio) layer(name,color: set current) center_mark(x,y,size) bolt_circle(cx,cy,pcd,hole_dia,count) hatch(points,pattern,scale,angle) dim_linear/dim_aligned(x1,y1,x2,y2,line_x,line_y[,snap]) polygon(cx,cy,sides,radius) slot(x1,y1,x2,y2,width) rounded_rect(x1,y1,x2,y2,radius) symbol(symbol,x,y[,rotation,scale_denominator,layer]: a library symbol by the name a designer uses). Returns OK n= h=.

Inputs: operations (required). Returns: result

draw_circleC

Circle at (cx,cy) with radius.

Inputs: cx (required), cy (required), radius (required), layer. Returns: result

draw_donutB

Donut (filled ring; inner_dia=0 gives a filled dot).

Inputs: cx (required), cy (required), inner_dia (required), outer_dia (required), +1 more. Returns: result

draw_ellipseB

Ellipse: center (cx,cy), major-axis endpoint (major_dx,major_dy) relative to center, ratio=minor/major.

Inputs: cx (required), cy (required), major_dx (required), major_dy (required), +2 more. Returns: result

drawing_infoA

Total entity count (OK n=).

Inputs: no named parameters. Returns: result

draw_lineA

Line from (x1,y1) to (x2,y2).

Inputs: x1 (required), x2 (required), y1 (required), y2 (required), +1 more. Returns: result

draw_mtextB

Multiline text; (x,y)=top-left corner, width=wrap width.

Inputs: x (required), y (required), text (required), layer, +2 more. Returns: result

draw_pointC

Point at (x,y).

Inputs: x (required), y (required), layer. Returns: result

draw_polylineB

Polyline through [[x,y],...]; closed=true to close it.

Inputs: points (required), layer, closed. Returns: result

draw_rectangleA

Rectangle (closed polyline) between opposite corners.

Inputs: x1 (required), x2 (required), y1 (required), y2 (required), +1 more. Returns: result

draw_splineB

Smooth spline through the given points [[x,y],...].

Inputs: points (required), layer. Returns: result

draw_textC

Single-line text at (x,y); rotation in degrees.

Inputs: x (required), y (required), text (required), layer, +2 more. Returns: result

draw_xlineA

Infinite construction line through (x,y) at angle degrees.

Inputs: x (required), y (required), angle, layer. Returns: result

entity_lengthB

Length (and area if closed) of a curve: line, arc, circle, polyline, spline.

Inputs: handle (required). Returns: result

entity_pointsB

Key points of an entity (ends/mid/center/radius/vertices): connect geometry without math.

Inputs: handle (required). Returns: result

erase_entityB

Delete an entity by handle, or handle='selection' for the user's GUI selection.

Inputs: handle (required). Returns: result

erase_lastA

Delete the last created entity.

Inputs: no named parameters. Returns: result

explode_entityB

Explode a block/polyline/dimension into its components.

Inputs: handle (required). Returns: result

export_dxfA

Export the drawing as ASCII DXF to path.

Inputs: path (required). Returns: result

export_pdfA

Export the current view to PDF, fitted to the page. For a sheet at a real scale use export_sheet_pdf instead.

Inputs: path (required). Returns: result

export_sheet_pdfA

Export a sheet to PDF AT ITS SCALE (unlike export_pdf, which fits the drawing to the page). Verifies by measuring the page of the PDF it produced.

Inputs: path (required), sheet. Returns: result

export_stlA

Export 3D solids to STL - the file a slicer needs to actually 3D print the part. handles=None exports EVERY 3D solid in the drawing; pass handles to export one part per file. quality low/medium/high/default sets the tessellation: use high for anything curved, low leaves visible facets. to_origin parks the part on the origin before writing (STL keeps world coordinates, so a part modelled far from 0,0 would otherwise land metres away in the slicer) and puts it back afterwards.

Inputs: path (required), binary, handles, quality, +1 more. Returns: result

extend_entityC

Extend: lengthen the entity (picked near the end to extend) until the boundary entity.

Inputs: pick_x (required), pick_y (required), boundary_handle (required). Returns: result

extrude_profileA

Extrude a CLOSED 2D profile (polyline/circle) into a 3D solid, height along Z. The 2D->3D bridge.

Inputs: handle (required), height (required). Returns: result

fillet_polylineB

Fillet (round) ALL corners of a polyline with the given radius. CAD does the math.

Inputs: handle (required), radius (required). Returns: result

fillet_solidA

Round edges of a 3D solid: edges = [[x,y,z], ...], ONE point lying ON each edge to round. Printed parts need this - a sharp inside corner is where the part cracks. The edge nearest the camera wins, so set the view (view_3d) when the target is hidden behind the part. Check the result with solid_volume.

Inputs: edges (required), radius (required). Returns: result

fit_viewportA

Fit the model into a region of a sheet: measures what is drawn, picks the largest STANDARD scale that fits, then sizes the viewport to the drawing instead of to the region. Returns the scale it chose and why.

Inputs: x1 (required), x2 (required), y1 (required), y2 (required), +4 more. Returns: result

flatshot_viewA

Auto-generate a 2D drawing view (block) of ALL 3D solids, projected from direction (front/top/right/left/back/iso), lower-left corner placed at (x,y). Model in 3D, get the 2D view for free. Returns block handle+size.

Inputs: x, y, direction. Returns: result

get_entityC

Raw DXF data of an entity by handle.

Inputs: handle (required). Returns: result

get_entity_countsA

Instant census: entity count per type (cheap; call this FIRST to understand a drawing).

Inputs: no named parameters. Returns: result

get_extentsA

Bounding box of the whole drawing or of one layer: cheap spatial check, no screenshot.

Inputs: layer. Returns: result

get_selectionA

What the user has currently selected in the GUI (count, handles, types, layers). Enables 'do X on what I selected'.

Inputs: no named parameters. Returns: result

get_variableA

Read a system variable (e.g. CLAYER, DIMSCALE).

Inputs: name (required). Returns: result

graph_buildA

Read the 2D geometry as a CONNECTIVITY GRAPH and cache it: curves whose ends meet (within tol) become one node, so the drawing can be asked questions instead of read. Reports separate networks, junctions, total length, and the open ends - and for every open end checks whether it actually lands on another curve (a T-junction, fine) or on nothing (a real break, which on a schematic is the defect you were looking for). tol=None (the default) makes the joining tolerance EMERGE from this drawing's own endpoint distances by the max-jump rule, and the report states the value used - pass a number only to override what the drawing says. window=[x1,y1,x2,y2] limits it to one drawing area, layer to one layer. Lengths are exact (arcs and bulges included), in drawing units.

Inputs: tol, layer, window. Returns: result

graph_traceA

Follow the network from a point through the graph_build cache: how many curves hang together with it, their total length (a take-off), and the open ends inside that network. Answers 'what is downstream of here' and 'is this the same run as that' without reading the drawing. Rebuild with graph_build if the drawing changed - this reads the cached index, and says so if it cannot find one.

Inputs: x (required), y (required). Returns: result

hatch_circleB

Hatch a circular area (creates the circle boundary + HATCH).

Inputs: cx (required), cy (required), radius (required), angle, +3 more. Returns: result

hatch_islandsA

HATCH the outer closed polygon SKIPPING the island polygons (hatch around holes). outer=[[x,y],...], islands=[[[x,y],...],...].

Inputs: outer (required), islands (required), angle, layer, +2 more. Returns: result

hatch_polygonC

Fill a closed polygon with a real HATCH entity (pattern ANSI31, SOLID, ...).

Inputs: points (required), angle, layer, scale, +1 more. Returns: result

hole_reportA

Probe every hole of a part and say which are actually OPEN. holes=[{name,x,y,z,axis,r,len}]: a probe cylinder (radius r SMALLER than the hole's, length len) is grown from (x,y,z) along axis X/Y/Z and intersected with a throwaway copy of the part - material found means the hole is blocked, and the volume says by how much. Born from a part that reached a printable state with four screw holes silently filled by an earlier union: a drawing lies about its holes unless something physically probes them. All probes run in one round-trip; the part is never modified.

Inputs: holes (required), handle (required). Returns: result

insert_blockB

Insert a block (or .dwg file) at (x,y); rotation in degrees.

Inputs: x (required), y (required), name (required), scale, +1 more. Returns: result

insert_symbolA

Place a library symbol by NAME OR BY WHAT YOU CALL IT: 'bocchetta di ripresa', 'recuperatore', 'sifone' all resolve through the library's synonym dictionary. Layer and scale come from the library index, so the symbol lands coloured and sized correctly without anyone remembering the convention (symbols are drawn for the index's reference scale; pass scale_denominator=100 for a 1:100 plan). Loads the block from the library DWG if the drawing does not have it yet. Use list_symbols to see what exists.

Inputs: x (required), y (required), symbol (required), layer, +3 more. Returns: result

join_entitiesA

Join touching lines/arcs/polylines into one polyline (first handle = source).

Inputs: handles (required). Returns: result

layer_infoA

Per-layer report: object count, color, linetype, frozen/locked.

Inputs: no named parameters. Returns: result

leaderA

Leader arrow: points at (x,y) [the feature], text lands at (end_x,end_y). For callouts like '4x D10'.

Inputs: x (required), y (required), text (required), end_x (required), +1 more. Returns: result

list_blocksA

List block definitions in the drawing.

Inputs: no named parameters. Returns: result

list_documentsB

Every drawing open in the CAD, marking the one the tools are acting on, with entity count, unsaved changes and read-only state.

Inputs: no named parameters. Returns: result

list_entitiesA

List entities (type, handle, layer), paginated; optional type/layer filter (wildcards ok). Use get_entity_counts first on big drawings.

Inputs: layer, limit, offset, entity_type. Returns: result

list_layersB

List layers with colors.

Inputs: no named parameters. Returns: result

list_symbolsA

What the symbol library offers: block name, Italian and English description, category and real size. Filter by category (unita/distribuzione/canali/terminali/regolazione/accessori) or leave empty for all. Use this before insert_symbol when you do not know what exists.

Inputs: library, category. Returns: result

memory_disableA

Turn the drawing's memory journal OFF, cleanly.

Flushes whatever the reactor still holds in its queue, removes every lambdacad memory reactor application-wide (also the strays another drawing may have left behind), and stops bracketing tool evaluations. Tags and journal files stay on disk untouched.

Inputs: no named parameters. Returns: result

memory_enableA

Turn ON the drawing's autonomous memory journal.

Registers a database reactor inside the CAD that appends every entity event (add / erase / undo-resurrect / modify) to a journal file beside the drawing - including changes the USER makes by hand in the GUI while no tool is running. Survives across sessions: call it once per CAD start. Then use tag_entity to give entities semantic roles and world_report to read the drawing's state and evolution.

Inputs: no named parameters. Returns: result

mirror_entitiesA

Mirror entities across the axis (x1,y1)-(x2,y2). Draw half, mirror the rest. handles=['selection'] uses the GUI selection.

Inputs: x1 (required), x2 (required), y1 (required), y2 (required), +2 more. Returns: result

move_3dA

Move an entity in 3D by (dx,dy,dz); handle='selection' moves the user's GUI selection. move_entity only shifts in the XY plane.

Inputs: dx (required), dy (required), dz (required), handle (required). Returns: result

move_allA

Move ALL entities by (dx,dy).

Inputs: dx (required), dy (required). Returns: result

move_entityA

Move entity by (dx,dy); handle='selection' moves the user's GUI selection.

Inputs: dx (required), dy (required), handle (required). Returns: result

offset_entityB

Offset a curve by distance toward the side of point (toward_x,toward_y). CAD does the math.

Inputs: handle (required), distance (required), toward_x (required), toward_y (required). Returns: result

overhang_reportA

Will this part print without supports, and which way up is best? Reads the STL mesh (no CAD needed) and measures the area that overhangs past limit_deg from the build plate, how much of that is flat ceiling (the bridges), the worst angle and the height where the trouble starts - then scores all six axis orientations so you can see whether simply flipping the part removes the problem. Areas are mm2. build_dir is the direction layers stack in ('z+' means the part prints as it is modelled, 'z-' upside down). Note this measures FACES, not spans: a flat ceiling area of zero means nothing bridges, but a large one does not say whether it is one wide bridge or many narrow ones.

Inputs: stl_path (required), build_dir, limit_deg. Returns: result

polygonA

Regular polygon: center, number of sides, circumscribed radius, rotation degrees.

Inputs: cx (required), cy (required), sides (required), radius (required), +2 more. Returns: result

purge_drawingA

Purge unused layers, blocks, linetypes, styles from the drawing.

Inputs: no named parameters. Returns: result

redoB

Redo the last undone operation.

Inputs: no named parameters. Returns: result

regenB

Regenerate the view.

Inputs: no named parameters. Returns: result

render_viewA

Render the drawing to a clean PNG (no UI chrome) for visual inspection. Pass a window (x1,y1,x2,y2) to frame a region; omit for current view.

Inputs: path (required), x1, x2, y1, +1 more. Returns: result

revolve_profileA

Revolve a CLOSED 2D profile around axis (x1,y1)-(x2,y2) by angle degrees (turned parts).

Inputs: x1 (required), x2 (required), y1 (required), y2 (required), +2 more. Returns: result

rotate_3dA

Rotate entities around ANY axis: the line (x1,y1,z1)->(x2,y2,z2), by angle degrees (right-hand rule). This is how you swing a part about a hinge - rotate_entity can only turn around Z.

Inputs: x1 (required), x2 (required), y1 (required), y2 (required), +4 more. Returns: result

rotate_allA

Rotate ALL entities around a base point by angle degrees (CCW).

Inputs: angle (required), base_x (required), base_y (required). Returns: result

rotate_entityA

Rotate one entity (or 'selection') around a base point by angle degrees (CCW). Turns around Z only - for any other axis use rotate_3d.

Inputs: angle (required), base_x (required), base_y (required), handle (required). Returns: result

rounded_rectC

Rectangle with rounded corners (raccordato), single polyline.

Inputs: x1 (required), x2 (required), y1 (required), y2 (required), +2 more. Returns: result

run_commandA

Run any BricsCAD command; tokens list, "" = Enter. The command name is checked to exist before anything is sent. Prefer dedicated tools when they exist.

Inputs: tokens (required). Returns: result

run_lispA

Eval AutoLISP code (multi-line and multiple expressions OK); set (setq MCPRES ...) to return data.

Inputs: code (required). Returns: result

save_as_dwgA

Save the drawing as DWG (2018) to path. Says so explicitly if the drawing is open read-only - typically a stale .dwl lock file left by a crash, which otherwise fails with nothing but 'Function cancelled'.

Inputs: path (required). Returns: result

save_drawingA

Save the active drawing where it already lives. Confirmed by DBMOD returning to 0, which is the only thing that proves a write happened.

Inputs: no named parameters. Returns: result

scale_allB

Scale ALL entities from a base point by factor.

Inputs: base_x (required), base_y (required), factor (required). Returns: result

scale_entityB

Scale one entity (or 'selection') from a base point by factor.

Inputs: base_x (required), base_y (required), factor (required), handle (required). Returns: result

select_byA

Select+highlight entities by type and/or layer (wildcards ok: layer='MUR*'). Returns handles; user SEES the selection.

Inputs: layer, entity_type. Returns: result

select_windowA

Select+highlight by rectangular area: crossing=false only fully-inside, true also touching. Optional type/layer filter.

Inputs: x1 (required), x2 (required), y1 (required), y2 (required), +3 more. Returns: result

set_current_colorA

Set current entity color (ACI code; 256=ByLayer).

Inputs: color (required). Returns: result

set_current_layerA

Set current layer (created with color and optional lineweight in MM if missing). Line weight is what separates a drawing from a sketch: walls 0.50, visible edges 0.35, dimensions/hatching 0.18.

Inputs: name (required), color, lineweight. Returns: result

set_dim_styleB

Appearance of NEW dimensions: text height, arrow size, decimal places, overall scale.

Inputs: scale, decimals, arrow_size, text_height. Returns: result

set_entity_propsB

Change properties of an entity (or 'selection'): layer, color (ACI, 256=ByLayer), linetype.

Inputs: handle (required), color, layer, linetype. Returns: result

set_linetypeA

Assign a linetype to a layer: CENTER (chain, for axes), HIDDEN, DASHED, PHANTOM, CONTINUOUS. Loads it if missing; ltscale>0 sets global linetype scale.

Inputs: layer (required), ltscale, linetype. Returns: result

slice_solidB

Slice a 3D solid with a vertical plane through 2 points; keep='both' or a point-side 'x,y'.

Inputs: x1 (required), x2 (required), y1 (required), y2 (required), +2 more. Returns: result

slotA

Slot/obround (asola, oblong hole): rounded-end slot between the two arc centers, given width. Use this for slots - NOT a rectangle.

Inputs: x1 (required), x2 (required), y1 (required), y2 (required), +2 more. Returns: result

solid_boxA

3D solid box: base corner (x,y,z), sizes dx,dy,dz (dz along Z).

Inputs: x (required), y (required), dx (required), dy (required), +2 more. Returns: result

solid_coneA

3D solid cone: base center (cx,cy,z), base radius, height along Z.

Inputs: cx (required), cy (required), height (required), radius (required), +1 more. Returns: result

solid_cylinderB

3D solid cylinder: base center (cx,cy,z), radius, height along Z.

Inputs: cx (required), cy (required), height (required), radius (required), +1 more. Returns: result

solid_sphereC

3D solid sphere: center (cx,cy,z), radius.

Inputs: cx (required), cy (required), radius (required), z. Returns: result

solid_torusC

3D solid torus: center (cx,cy,z), ring radius, tube radius.

Inputs: cx (required), cy (required), radius (required), tube_radius (required), +1 more. Returns: result

solid_volumeC

Volume and centroid of a 3D solid.

Inputs: handle (required). Returns: result

solid_wedgeB

3D solid wedge (ramp): base corner (x,y,z), sizes dx,dy,dz.

Inputs: x (required), y (required), dx (required), dy (required), +2 more. Returns: result

sweep_profileB

Sweep a closed 2D profile along a path curve -> 3D solid (pipes, rails, gaskets).

Inputs: path_handle (required), profile_handle (required). Returns: result

tag_entityA

Give an entity a semantic ROLE in the drawing's memory.

The role is what the geometry cannot say: "muro-nord", "asta-principale", "staffa-v2". Refuses dead handles - a memory that tags ghosts lies from day one. Tags live beside the drawing and survive sessions; world_report revalidates them against the live drawing every time it answers.

Inputs: role (required), handle (required), note. Returns: result

text_styleA

Create/set a text style with a font (e.g. isocpeur.ttf for ISO drawings) and make it current.

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

title_blockA

Draw the border and an ISO 7200 title block (180x40, bottom right) on a sheet, in SHEET mm. Reads the sheet size itself; returns the measured border.

Inputs: sheet (required), title (required), date, layer, +6 more. Returns: result

trim_entityC

Trim: remove the portion of the entity at pick point, cut by the cutting entity.

Inputs: pick_x (required), pick_y (required), cutting_handle (required). Returns: result

undoA

Undo the last N operations (a whole draw_batch counts as ONE).

Inputs: count. Returns: result

use_documentA

Choose which open drawing the tools act on (match on file name or any part of the path). Everything after this call lands there.

Inputs: name (required). Returns: result

view_3dA

3D view: direction iso/iso2/top/front/back/left/right; shade wireframe/hidden/flat/gouraud. Zooms extents.

Inputs: shade, direction. Returns: result

view_planA

Back to flat 2D view (top, wireframe, zoom extents). Use after 3D work.

Inputs: no named parameters. Returns: result

world_reportA

What is in this drawing, what changed, and is the memory still true.

Reads the semantic tags and the autonomous journal, then REVALIDATES every tagged handle against the live drawing (entget - the only liveness test that survives entdel) in one round-trip. Reports: roles alive and dead, events since the last report (including manual GUI edits the reactor journaled), and untagged newcomers worth naming.

Inputs: no named parameters. Returns: result

zoom_extentsA

Zoom to drawing extents.

Inputs: no named parameters. Returns: result

zoom_windowB

Zoom to a rectangular window.

Inputs: x1 (required), x2 (required), y1 (required), y2 (required). 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 128 tools

    Disambiguation4/5

    Almost every tool has a clearly distinct purpose, and descriptions often explicitly contrast related tools (e.g., rotate_3d vs rotate_entity, hatch_circle vs hatch_islands). With 128 tools there are some potentially confusable pairs like get_entity_counts vs drawing_info, but the detailed explanations resolve most ambiguity.

    Naming Consistency4/5

    The naming is largely consistent, with clear families such as draw_*, solid_*, bool_*, list_*, get_*, set_*, and assembly_*. Minor deviations like 'regen', 'leader', 'polygon', and the mixed bool/boolean (bool_union vs boolean_verified) prevent a perfect score.

    Tool Count1/5

    With 128 tools, this is an extreme outlier for an MCP server. Even for a broad CAD domain, the surface is overwhelming and far exceeds the 3-15 tool guideline, making tool selection costly and impractical for agents.

    Completeness5/5

    The toolset covers virtually every CAD operation: 2D drafting, 3D solids, editing, dimensions, layers, blocks, viewports, sheets, exports, rendering, analysis (interference, holes, overhang), assembly management, graph analysis, and a memory system. There are no obvious dead ends, and run_command/run_lisp fill any hypothetical gaps.

    Maintenance

    ActivityInactive
    ResponsivenessLimited data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      D
      maintenance
      MCP server for AutoCAD LT automation and headless DXF generation, exposing tools for drawing, entities, layers, blocks, annotations, P&ID, and view operations via natural language.
      8
      MIT
    • A
      license
      A
      quality
      D
      maintenance
      An MCP server that enables natural-language control of AutoCAD via file IPC or headless DXF generation, with tools for drawing, entities, layers, blocks, annotations, P&ID, views, and system operations.
      8
      MIT
    • A
      license
      Not graded
      quality
      B
      maintenance
      An MCP server enabling AI-driven CAD automation for SolidWorks at the feature level, converting intent into CAD-neutral IR and compiling it into concrete operations. It provides engineering-semantic tools and a deterministic compiler, bridging any MCP-capable AI client to SolidWorks via COM.
      AGPL 3.0