lambdacad-mcp
This MCP server allows AI to control a professional DWG CAD system (like BricsCAD on Linux) via AutoLISP for fully automated 2D drafting, 3D solid modeling, verification, and export.
2D Drafting & Annotation
Draw primitives (lines, circles, arcs, ellipses, rectangles, polylines, points, splines, donuts, xlines) and semantic shapes (slots, bolt circles, polygons, rounded rectangles, center marks) in one call.
Add hatches with island support, text (single‑line/mtext), dimensions (linear, aligned, radius, diameter, angular), and leaders.
Edit with trim, extend, fillet, chamfer, offset, mirror, array (rectangular/polar), break, join, explode, move, copy, rotate, scale.
Batch multiple operations atomically in a single
draw_batchcall (one undo step).
3D Solid Modeling
Create primitives (box, cylinder, sphere, cone, wedge, torus), extrude/revolve 2D profiles, sweep along paths.
Boolean operations (union, subtract, intersect), slice solids, and apply fillets/chamfers on edges.
Generate 2D projections (
flatshot_view) and measure volumes/centroids.
Layers, Styles & Blocks
Create/manage layers, set current layer/color/linetype (CENTER, HIDDEN, DASHED, etc.), create/insert blocks, manage text and dimension styles.
Purge unused objects; assign properties to entities.
Selection, Inspection & Verification
Select by user pick, type, layer (wildcards), or window; read GUI selection.
Get bounding box, length, area, key points, intersections; check collisions.
Query entity counts per type/layer, raw DXF data, system variables.
View, Export & Deliverables
Zoom extents/window, switch 3D views (iso, top, front, etc.) and shading modes.
Render clean PNG screenshots for visual inspection.
Save as DWG, export to DXF, PDF, STL (for 3D printing).
Automation & Flexibility
Run arbitrary AutoLISP code (
run_lisp) or direct BricsCAD commands (run_command) for full parametric control and custom operations.Undo/redo entire batches;
handle='selection'support to act on user‑selected entities.
Provides tools for interacting with AutoCAD through an AutoLISP file bridge, enabling AI agents to create and modify 2D drawings and 3D models, including drafting entities, dimensions, hatches, blocks, and solid modeling operations.
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., "@lambdacad-mcp Draw a DN80 flange: front view, dimensions, and 3D model"
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.
λ 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.
"Draw a DN80 flange: front view, hatched section, dimensions — then model it in 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 |
|
|
|
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.outRelated 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 math3D 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 modelBatch & atomic —
draw_batchexecutes N operations in one round-trip, wrapped in one undo group (one batch = one Ctrl+Z)Talk about what the user selected —
get_selectionreads the GUI pickfirst set;select_by/select_windowhighlight 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_verifiedcuts and measures the change against the volume you expected (a cut that lands short reads SHORT, not success);overhang_reportreads the STL mesh and says whether a part prints without supports, scoring all six orientations;contact_reportover 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_reportphysically probes every hole and says which are actually open (a drawing lies about its holes until something checks);graph_build/graph_traceread 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 hardcodedThe drawing REMEMBERS (new in 1.3, beta) —
memory_enableputs 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_entitygives entities semantic roles ("muro-nord", "asta-principale") keyed to handles, which survive save and reopen;world_reportanswers 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 readsDEAD (erased since tagging), reported, never hidden). The next prompt — or the next session — starts knowing the drawing instead of re-surveying itInstructions 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://trapsresource that costs nothing until readEyes when needed —
render_view: BricsCAD's internal PNG render (clean, no UI, ~30 KB) for vision modelsSheets, 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 wroteDeliverables — save DWG, export DXF, PDF and STL (
export_stl: 3D solids straight to the slicer, parked on the origin)Several drawings open —
list_documentsshows which one the tools are pointing at (plus unsaved changes and read-only),use_documentpicks another; every reply says which drawing answered, and warns when it changes underfootEscape hatch —
run_lispevaluates 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 ( |
Exactness |
|
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 --listAn 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 logThe --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.shThe 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:
Start BricsCAD and open a drawing (the bridge loads when a document opens).
Start a new AI session — the
bricscadtools appear.Ask: "draw the plan of a 4×3 m room with a door and dimensions".
Configuration (env vars)
Variable | Default | Purpose |
| session | X display where BricsCAD runs (e.g. |
| off |
|
|
| 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 |
| Is BricsCAD running on |
| 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 |
|
The tools are drawing in the wrong file |
|
Wayland | Works via XWayland; if your compositor struggles with heavy CAD redraws, run BricsCAD under a nested X server (Xephyr) and set |
Related projects
Project | CAD | Platform | 3D |
λ lambdacad-mcp (this) | any AutoLISP CAD — BricsCAD reference | Linux | yes |
AutoCAD/BricsCAD/ZWCAD via COM | Windows | no | |
AutoCAD LT (LISP bridge) | Windows | no | |
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 commandsCompact-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 toolsadd_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
Scored across 128 tools
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.
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.
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.
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
Related MCP Connectors
Headless CAD engine & MCP server for 2D/3D drafting, solids, DXF/SVG export, and automation.
Read, query, edit and render DWG drawings with AI. No AutoCAD required.
A browser 3D CAD for your AI: it scripts real-size models, uCAD builds them and returns pictures.
Text-to-CAD: build exact STEP or 3MF/STL on the server, each stated requirement measured.
Related MCP Servers
- AlicenseAqualityDmaintenanceMCP 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.8MIT
- AlicenseAqualityDmaintenanceAn 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.8MIT
- AlicenseNot gradedqualityDmaintenanceMCP server for AI-driven CAD operations, enabling parametric modeling, build, inspection, measurement, rendering, and diff comparison with STEP, DXF, and GLB export.MIT
- AlicenseNot gradedqualityBmaintenanceAn 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


