# Construction AutoCAD MCP (mcpb · construction-autocad-mcp-1.2.1.mcpb)

Let AI draw in AutoCAD: plans from images, KT/KC/NT sets, TCVN calc, quantities, sheets, PDF.

- Trust score: 33/100 (low)
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-11-05

## Components

- mcpb · `construction-autocad-mcp-1.2.1.mcpb`: 33/100 (this document), [markdown](https://verifymcp.io/servers/2ez4gcx-construction-autocad-mcp/construction-autocad-mcp.md), [page](https://verifymcp.io/servers/2ez4gcx-construction-autocad-mcp/construction-autocad-mcp)

## Channel facts

- Registry: `mcpb`
- Package: `https://github.com/2ez4gcx/construction-autocad-mcp/releases/download/v1.2.1/construction-autocad-mcp-1.2.1.mcpb`
- Version: `1.2.1`
- Transport: `stdio`
- SHA-256: `3e24333b95bb069ae58120c6a5fdc2feee39cf5e254614922b91f6c375309e92`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-11-05.

- **Supply Chain Security**: 0/100
  - No malware scan is available for this kind of package: the supply-chain vendors we use do not cover it. This is a permanent gap in our coverage, not a finding about the package.
  - Known CVEs could not be checked: we found no dependency list to check in this bundle: either it runs a compiled binary, whose bundled manifests we do not read, or none of the package.json, requirements.txt, pyproject.toml or uv.lock files it ships for its runtime declares a dependency we can read (a requirements.txt that only points at a setup.py project, a local path, or a nested requirements file we cannot follow counts as none).
  - Install-script risk not yet assessed.
  - Dependency health could not be checked: we found no dependency list to check in this bundle: either it runs a compiled binary, whose bundled manifests we do not read, or none of the package.json, requirements.txt, pyproject.toml or uv.lock files it ships for its runtime declares a dependency we can read (a requirements.txt that only points at a setup.py project, a local path, or a nested requirements file we cannot follow counts as none).
- **Provenance & Transparency**: 45/100
  - Source repository is publicly reachable at the declared URL.
  - Provenance check failed: no build-provenance attestation is published.
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 1 days ago).
  - Disclosure check failed: no security disclosure policy was found in the source repository.
- **Schema Quality & AI Usability**: 48/100
  - AI-judged instruction clarity (good).
  - Context-footprint check failed: tool/resource definitions use about 15270 tokens (~288/item across 53 items; 53 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 0/100
  - Stability not yet verified: not enough scan history yet (needs a 30-day window).
- **Tool Coverage**: 73/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 20% of tool parameters carry a description.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - All 2 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation.
  - An AI judge read all 54 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

**Unverified: 2 categories.** Categories scored 0 because we could not verify them: a data source with nothing on this package, evidence we could not reach, or a check we could not run. We only credit what we can confirm.

## Install

### How do I install the Construction AutoCAD MCP server?

Construction AutoCAD MCP ships as an MCPB bundle, a single file you download and open in an MCP host that supports MCPB bundles, such as Claude Desktop. The host reads the launch command from the bundle's own manifest, so there is no command to copy. Before opening it, check the file's SHA-256 matches the one the MCP registry declares for it, 3e24333b95bb069ae58120c6a5fdc2feee39cf5e254614922b91f6c375309e92; the commands to do that are on this page. If it does not match, do not open it.

- Download bundle: `https://github.com/2ez4gcx/construction-autocad-mcp/releases/download/v1.2.1/construction-autocad-mcp-1.2.1.mcpb`
- SHA-256: `3e24333b95bb069ae58120c6a5fdc2feee39cf5e254614922b91f6c375309e92`

### Verify on macOS / Linux

```bash
echo "3e24333b95bb069ae58120c6a5fdc2feee39cf5e254614922b91f6c375309e92  construction-autocad-mcp-1.2.1.mcpb" | shasum -a 256 -c
```

### Verify on Windows (PowerShell)

```powershell
(Get-FileHash -Algorithm SHA256 .\construction-autocad-mcp-1.2.1.mcpb).Hash -eq "3e24333b95bb069ae58120c6a5fdc2feee39cf5e254614922b91f6c375309e92"
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-11-03 (score 33)

First indexed and scored.

## MCP tools (53)

### `ping` (~26 tokens)

Check the connection to AutoCAD: AutoCAD version, open drawing, bridge and server versions.

### `drawing_info` (~58 tokens)

Overview of the open drawing: file, units (INSUNITS), extents, current layer/text style/dimension style/DIMSCALE, model-space entity counts by type, number of layers/blocks/xrefs, layouts, text and dimension styles.

### `list_layers` (~39 tokens)

List layers: name, color, linetype, lineweight, on/frozen/locked/plot, description and number of entities (all spaces).

### `list_blocks` (~39 tokens)

List block definitions with their reference counts (dynamic blocks included), attribute tags, xref paths. Sorted by count.

Input parameters:

- `include_unused` (boolean)

### `query_entities` (~263 tokens)

Find entities and read their geometry: handle, type, layer, and per type: line from/to/length, polyline points/closed/length/area, circle/arc center/radius, text/mtext content/position/height, block name/position/rotation/scale/attributes, hatch pattern/area, dimension measurement. Filters combine (AND). detail=true adds polyline points, styles and bounds. Paged by limit/offset.

Input parameters:

- `block_names`: Block names (wildcards) for INSERTs
- `detail` (boolean)
- `handles`
- `layers`: Layer names, * and ? wildcards (e.g. ["A-WALL*"])
- `limit` (integer)
- `offset` (integer)
- `space` (string|null): model (default), paper, all, current, or a layout name
- `text_contains` (string|null)
- `types`: DXF types: LINE, LWPOLYLINE (or polyline), CIRCLE, ARC, TEXT, MTEXT, INSERT (or block), HATCH, DIMENSION, MULTILEADER, IMAGE...
- `window`: [[x1,y1],[x2,y2]]
- `window_mode` (string)

### `selection_info` (~51 tokens)

The objects the user has selected in AutoCAD (PICKFIRST): counts by type and layer, bounds and each entity (as query_entities).

Input parameters:

- `detail` (boolean)
- `limit` (integer)

### `quantity_takeoff` (~327 tokens)

Quantity takeoff of the drawing (QS): per layer (or per block / type): count, length in m (lines, arcs, polylines, circles, splines), area in m² of closed polylines/circles/regions, hatch area in m² (separate, never add both), block counts, and for group_by=block the tally of attribute values. Filters as query_entities; selection_only uses the user's selection. csv_path saves the table for Excel (UTF-8).

Input parameters:

- `block_names`: Block names (wildcards) for INSERTs
- `csv_format` (string): semicolon = ";" separators and decimal commas, for Excel with Vietnamese/European regional settings
- `csv_path` (string|null): Optional CSV file, e.g. 'D:/QS/plan_takeoff.csv'
- `group_by` (string)
- `handles`
- `language`
- `layers`: Layer names, * and ? wildcards (e.g. ["A-WALL*"])
- `selection_only` (boolean)
- `space` (string|null): model (default), paper, all, current, or a layout name
- `text_contains` (string|null)
- `types`: DXF types: LINE, LWPOLYLINE (or polyline), CIRCLE, ARC, TEXT, MTEXT, INSERT (or block), HATCH, DIMENSION, MULTILEADER, IMAGE...
- `window`: [[x1,y1],[x2,y2]]
- `window_mode` (string)

### `check_drawing` (~160 tokens)

Drawing QA: stacked duplicates (they double quantities), polylines that look closed but are not, open polylines on area layers, Vietnamese/non-ASCII text in SHX styles (shows "?"), missing fonts, unresolved xrefs and images, objects on Defpoints (never plot), dimensions whose value was typed over, objects far from the rest (blow up zoom extents), tiny/empty objects, objects on layer 0, color/linetype/lineweight not ByLayer, objects on hidden layers, unitless drawing; plus layers outside the standard. Each issue has handles (first 20) to fix with set_properties/delete_entities.

Input parameters:

- `space` (string|null): all (default), model, paper or a layout name

### `setup_layers` (~393 tokens)

Create layers. standard="arch" creates the architectural set (AIA/NCS style, lineweights for monochrome plotting, descriptions in the user's language): S-GRID trục (CENTER), S-GRID-IDEN, S-COLS cột, S-COLS-PATT, S-BEAM dầm (HIDDEN), A-WALL tường cắt 0.5, A-WALL-PATT hatch, A-DOOR cửa đi, A-GLAZ cửa sổ/kính, A-OPEN lỗ mở (HIDDEN), A-FLOR-STRS cầu thang, A-FLOR-LEVL, A-FLOR-PATT, A-FLOR-FIXT TBVS, A-FURN nội thất, A-EQPM, A-ROOF, A-ELEV, A-ELEV-OTLN, A-SECT, A-SECT-PATT, A-HIDD, A-AREA ranh diện tích (no plot), A-ANNO-ROOM, A-ANNO-TEXT, A-ANNO-DIMS, A-ANNO-SYMB, A-ANNO-TTLB khung tên, A-ANNO-VPRT (no plot), X-IMAGE ảnh tham chiếu (no plot), X-REF. layers adds/changes custom layers: {name, color (1-255, [r,g,b], "#rrggbb"), linetype, lineweight (mm), plot, description, transparency %, on, frozen, locked}. Existing layers are kept as they are unless update_existing=true (use that to turn layers on/off, freeze or lock). current sets the current layer.

Input parameters:

- `current` (string|null)
- `language`: Language of the layer descriptions (default vi)
- `layers`
- `standard` (string)
- `update_existing` (boolean)

### `setup_styles` (~210 tokens)

Set up the drawing for a plot scale 1:scale: units (mm), the text style MCP-ARIAL (TrueType Arial: Vietnamese shows correctly, no "?"), the dimension style MCP-1-<scale> (DIMSCALE=scale, text 2.5 mm on paper above the line, architectural ticks, no decimals, ByLayer colors), a multileader style of the same name, table text in MCP-ARIAL, and LTSCALE=0.4 x scale (PSLTSCALE off). All become current. Call once per drawing scale; draw_plan does it for its own scale.

Input parameters:

- `arrow` (string)
- `font` (string): TrueType font family, or an .shx file
- `scale` (number): Plot scale denominator: 50 for 1:50, 100 for 1:100
- `text_height` (number): Dimension text height on paper (mm)
- `units` (string)

### `draw_entities` (~650 tokens)

Draw a batch of entities in one Undo step (if one spec is invalid nothing is drawn and the error names it). Missing layers are created (standard layers with their standard properties). Returns each entity's handle and the bounds.
Each entity: {type, layer, color?, linetype?, lineweight?, ...}. Types and fields (points [x,y], angles in degrees):
\- line {from, to} or {points:[...]} (one line per segment)
\- polyline {points, closed?, bulges? (per vertex, arc segments), width? (symbols only, never for walls)}
\- rectangle {from, to} or {corner, width, height, rotation?}
\- circle {center, radius|diameter}; arc {center, radius, start_angle, end_angle} or {start, mid, end}
\- ellipse {center, major_axis:[dx,dy], ratio, start_angle?, end_angle?}; spline {points, closed?}; point {at}
\- text {at, text, height, rotation?, align (left|center|right|middle|top_left|...|bottom_right), style?}
\- mtext {at, text (\n = new line), height, width?, align (default top_left), style?}
\- hatch {boundary:[pts] | boundaries:[[pts],[island]...] | boundary_handles, pattern (SOLID, ANSI31, ANSI37, AR-CONC, AR-SAND, AR-BRSTD, AR-PARQ1, AR-B816, NET, DOTS, GRAVEL, EARTH...), scale, angle}
\- dimension {kind: linear|aligned|angular|radius|diameter, from, to, at (point on the dimension line) or offset, direction (horizontal|vertical|aligned|angle, linear), text? ("<>" = measured), style?}; angular {center, from, to, at}; radius/diameter {center, radius, angle}
\- dim_chain {points (measured points), direction, at or offset, total? (adds the overall dimension), style?}
\- leader {points (arrow first, text last), text, height?}
\- block {name, at or points:[...] (several copies), scale?, rotation?, attributes?:{TAG: value}, file? (.dwg to load the block from), redefine?}
\- table {at (top-left), rows:[[...],...], title?, col_widths?, row_height?, height?}
Text heights are in drawing units: paper height x scale (2.5 mm at 1:100 = 250). Use style "MCP-ARIAL" for Vietnamese text.
image_handle: points (and radi…

Input parameters:

- `entities` (array, required)
- `image_handle` (string|number|null)
- `language`
- `space` (string): model (default) or the current space (a layout when one is active)

### `draw_plan` (~1206 tokens)

Draw a complete floor plan in one Undo step from a plan description in mm (read from an image, a sketch or a 3D model):
\- walls: [{id?, points:[[x,y],...] (wall AXIS), thickness (200), justify: center|left|right (side of the axis, looking along it), closed?, material: brick|concrete|block|light|stone|solid|none}] -> clean L/T/X junctions (wall pieces are unioned), cut outline on A-WALL 0.5, material hatch on A-WALL-PATT
\- openings: [{wall (id or index), segment (0 = first axis segment), offset (from the segment start to the opening edge) or at (centre point), width, type: door|double_door|sliding|window|opening, toward:[x,y] (point the door swings to, e.g. inside the room) or side: left|right, hinge: start|end, tag? ("D1"), tag_at? (tag position when the automatic one collides)}] -> wall cut, leaf + swing arc, window lines; door tags go opposite the swing, window tags outside
\- columns: [{at, size:[w,h] or diameter, rotation?, pattern?}] and/or grid_columns {size} (a column at every grid intersection): cut out of the walls, solid hatch
\- grids: {x:[0, 6000, ...] or [{at, label}], y:[...], bubbles: both|start|end} -> axes 1,2,3 (x) and A,B,C (y)
\- rooms: [{name, at (point inside), number?, hatch?:{pattern, scale}}] -> area MEASURED from the walls, label "name / xx,xx m²" on A-ANNO-ROOM, closed boundary on A-AREA (not plotted). A room not closed by walls gets a warning; unlabelled_spaces lists closed spaces without a room.
\- stairs: [{start (middle of the first tread edge), direction (deg, 90 = up the page), width, treads, going, label?}] or U stairs [{type: "u", region: [[x0,y0],[x1,y1]] (stairwell), direction: up|down|left|right (flight 1 going up), turn: left|right (side of flight 2), gap: 100, risers?}] -> two flights, half landing, treads, LÊN/XUỐNG walking lines, cut line
\- balconies: [{region (slab outside the walls), railing: 1100}] -> slab edge and railing
\- floors (a building of several storeys): [{name, height (3600 ground floor, 3300 above), level?, walls…

Input parameters:

- `balconies`
- `columns`
- `dimensions`
- `dry_run` (boolean): Check the description and list the defaults it would assume, without drawing
- `entities`
- `floors`: Several storeys: see floors above
- `grid_columns`
- `grids`
- `hatch_walls` (boolean)
- `heights`: For draw_elevation/draw_section, see there
- `interior_dimensions` (boolean): Interior chains through every room (not the stairwells): wall face to wall face across the building, one each way, clear of the room name and moved aside from openings
- `language`
- `layers`
- `levels`
- `north`
- `openings`
- `roofs`: For draw_elevation/draw_section, see there
- `room_options`: {decimals: 2, decimal_separator: "," (vi) or ".", boundary: true, text_height: 2.5 (paper mm)}
- `rooms`
- `scale` (number)
- `sections`
- `stairs`
- `wall_material` (string|null)
- `wall_thickness`
- `walls`

### `define_block` (~138 tokens)

Define (or with replace=true redefine) a block from entity specs (same format as draw_entities, relative to base). Contents go on layer 0 unless a layer is given, so each insert takes its own layer. attributes: [{tag, prompt?, default?, at, height, align?: center|middle_center, invisible?}]. Use blocks for repeated items (doors, furniture, fixtures, title marks); insert with draw_entities type=block.

Input parameters:

- `attributes`
- `base`
- `description` (string|null)
- `entities` (array, required)
- `name` (string, required)
- `replace` (boolean)

### `transform_entities` (~282 tokens)

Edit entities by handle (one Undo step): op=move {vector or from/to}, copy {vector or from/to, count?}, rotate {center, angle}, scale {base, factor}, mirror {from, to (mirror line), keep_original=true}, array_rect {rows, cols, row_spacing, col_spacing}, array_polar {center, count, angle (total, 360), rotate_items}, offset {distance, toward:[x,y] (side) or both_sides}, explode (blocks/polylines/dimensions; block attribute values are kept as text). Returns created handles.

Input parameters:

- `angle` (number|null)
- `base`
- `both_sides` (boolean|null)
- `center`
- `col_spacing` (number|null)
- `cols`
- `count`
- `distance` (number|null)
- `factor` (number|null)
- `from`
- `handles` (array, required): Entity handles (hex strings like "2A7") from tool results; valid while the drawing is open.
- `keep_original` (boolean|null)
- `op` (string, required)
- `rotate_items` (boolean|null)
- `row_spacing` (number|null)
- `rows`
- `to`
- `toward`
- `vector`

### `set_properties` (~199 tokens)

Change entity properties by handle (one Undo step): layer (created if missing), color ("bylayer", 1-255, [r,g,b]), linetype, lineweight (mm or "bylayer"), ltscale, transparency %, text (text/mtext/dimension override/leader), height, rotation, closed (polylines), attributes {TAG: value} (blocks).

Input parameters:

- `attributes`
- `closed` (boolean|null)
- `color`
- `handles` (array, required): Entity handles (hex strings like "2A7") from tool results; valid while the drawing is open.
- `height`
- `layer` (string|null)
- `linetype` (string|null)
- `lineweight` (string|number|null)
- `ltscale`
- `rotation` (number|null)
- `text` (string|null)
- `transparency` (number|null)

### `delete_entities` (~50 tokens)

Delete entities by explicit handle (never by selection). One Undo step.

Input parameters:

- `handles` (array, required): Entity handles (hex strings like "2A7") from tool results; valid while the drawing is open.

### `select_entities` (~35 tokens)

Select entities in AutoCAD (grips) so the user can see them; empty handles clears the selection.

Input parameters:

- `handles`

### `undo` (~49 tokens)

Undo the last AutoCAD step(s) (each tool edit is one step). Undoes whatever is last in AutoCAD, so only use it right after your own edit.

Input parameters:

- `steps` (integer)

### `purge_drawing` (~79 tokens)

Purge unused layers, blocks, linetypes, text and dimension styles, registered apps (repeats for nested items). Standard layers are kept even when empty (keep_standard_layers). dry_run=true only lists what would go.

Input parameters:

- `dry_run` (boolean)
- `keep_layers`
- `keep_standard_layers` (boolean)

### `run_lisp` (~139 tokens)

Run AutoLISP in AutoCAD and return the value of the last expression (lists come back as JSON arrays, entities as "<entity handle>"). The code runs as one Undo group; errors come back as "LISP error: ...". (command ...) works. Use it only when no tool fits (e.g. AutoCAD commands such as OVERKILL, BOUNDARY, FLATSHOT, specific system variables). Never wait for user input (getpoint etc.).

Input parameters:

- `code` (string, required): AutoLISP code, one or more expressions, e.g. (getvar "INSUNITS")
- `undo_group` (boolean)

### `set_view` (~80 tokens)

Zoom/frame the user's view: view=extents (default) or a direction (top, front, iso...); window [[x1,y1],[x2,y2]] or handles frame that area. Changes what the user sees.

Input parameters:

- `handles`
- `margin` (number)
- `view` (string)
- `window`

### `screenshot` (~193 tokens)

Render the drawing to an image Claude sees (off-screen: the user's view is not changed), white background like a plot. view=extents (default) frames all of model space, window/handles frame that area, current = exactly what the user sees, or a direction (top, front, iso...) for 3D. space=current renders the active layout instead of model space. Use after every larger edit and compare with the source image. save_path also writes the PNG to a file (an image export, up to 4096 px with max_size).

Input parameters:

- `handles`
- `margin` (number)
- `max_size` (integer)
- `save_path` (string|null): Optional PNG file, e.g. 'D:/Export/plan.png'
- `space` (string)
- `view`: Default: extents (or the window/handles area)
- `window`

### `view_image` (~120 tokens)

Look at an image file (plan scan, photo, sketch, render; png/jpg/bmp/tif/gif) and return it to Claude, optionally a crop [x0,y0,x1,y1] in original pixels (zoom into details to read dimensions) and a pixel grid with coordinate labels (grid=true or a step in pixels) to read positions for calibration and tracing. Needs AutoCAD with the bridge running.

Input parameters:

- `crop`
- `grid`
- `max_size` (integer)
- `path` (string, required)

### `attach_image` (~231 tokens)

Attach an image (scan/photo of a plan, a render, a SketchUp export) as a faded underlay to draw over, on layer X-IMAGE (not plotted), sent to the back. Scale: calibrate {p1:[px,py], p2:[px,py], distance} = two pixels of a known dimension and its real length in drawing units (best), or width (drawing units of the whole image width), or units_per_pixel. Position: anchor {pixel:[px,py], at:[x,y]} puts a pixel (e.g. grid A-1) on a drawing point, else the bottom-left corner at "at". Returns pixel_to_drawing (x = x0 + x1*px + x2*py, y likewise), used by draw_entities image_handle.

Input parameters:

- `anchor`
- `at`
- `calibrate`
- `fade` (integer)
- `layer` (string)
- `path` (string, required)
- `rotation` (number)
- `units_per_pixel`
- `width`

### `import_drawing` (~154 tokens)

Insert a DWG/DXF file into the drawing as a block (or exploded): e.g. a 2D export of a SketchUp/Revit plan, section or elevation to clean up and annotate, a standard detail, a site plan. layer_prefix renames the file's layers (e.g. "X-SU-") so they do not mix with yours. Check the size afterwards (units of the source).

Input parameters:

- `at`
- `block_name` (string|null)
- `explode` (boolean)
- `layer` (string|null)
- `layer_prefix` (string|null)
- `path` (string, required)
- `rotation` (number)
- `scale` (number)

### `create_layout` (~396 tokens)

Create a sheet: a layout on ISO paper (A0-A4) for "DWG To PDF.pc3" with monochrome.ctb, a frame and title block (TCVN/ISO margins, 180 mm title block: company, project, client, drawing title, scale, date, drawn/checked by, drawing no., revision, sheet) and a locked viewport showing a model window at a standard scale (auto-fitted if scale is omitted). replace=true rebuilds a layout of the same name. Export with export_pdf.

Input parameters:

- `activate` (boolean): Leave the new layout open in AutoCAD (default: back to Model)
- `language`
- `name` (string, required)
- `orientation` (string)
- `paper` (string)
- `replace` (boolean)
- `scale`: 100 = 1:100; default: largest standard scale that fits
- `title_block`: {style: strip (vertical strip on the right, default on landscape A3-A0) | bottom, company, company_address, project, location, item, client, client_address, title, number (default: a field of the lay…
- `views`: Several viewports on the sheet instead of window/scale, each a model window at its own scale (a plan at 1:50 and its details at 1:20): packed in rows left to right, bottoms aligned, the block centred…
- `window`: Model area to show; default: drawing extents

### `export_pdf` (~164 tokens)

Plot to PDF with DWG To PDF.pc3: layouts (names, ["all"], or default the current one) become pages of one PDF; layouts on different paper sizes give one PDF per size (<name>_A1.pdf, <name>_A3-portrait.pdf: see pdfs). For "Model": paper, orientation, window (default extents) and scale (default fit). monochrome.ctb unless plot_style is given. Plotting can take ~30 s on machines whose default Windows printer is an unreachable network printer.

Input parameters:

- `layouts`
- `orientation` (string)
- `paper` (string)
- `path` (string, required)
- `plot_style` (string|null)
- `scale`
- `window`

### `save_drawing` (~147 tokens)

Save the drawing (DWG, or DXF by extension/format). Empty path = save in place; a new path = Save As (the open drawing takes that name), overwrite=true to replace an existing file. version: 2018 (default), 2013, 2010, 2007, 2004, 2000. copy=true writes a copy and leaves the open drawing as it is (the default for DXF and older versions: an export for someone else).

Input parameters:

- `copy` (boolean|null)
- `format`
- `overwrite` (boolean|null)
- `path` (string|null)
- `version` (string|null)

### `open_drawing` (~54 tokens)

Open a .dwg/.dxf file in AutoCAD (or switch to it if already open). Handles from another drawing are not valid there.

Input parameters:

- `path` (string, required)
- `read_only` (boolean)

### `new_drawing` (~38 tokens)

Create a new drawing from a template (default acadiso.dwt, metric) and make it current.

Input parameters:

- `template` (string|null)

### `draw_elevation` (~480 tokens)

Draw elevations derived from the plan of draw_plan (same walls, openings, columns, grids), so they always agree: the nearest walls and columns win, roofs and columns hide what is behind them, doors and windows with frames, plinth line, ground line with earth hatch, roofs (gable end or eaves side), level marks, height dimensions, grid bubbles with spacing, title "MẶT ĐỨNG TRỤC 1-3". sides: plan sides the viewer stands on (bottom = front at the bottom of the plan). Several sides are placed side by side to the right of the drawing unless at is given (left end of the facade at ±0.000). Decorative details seen in a photo (mouldings, gable ornaments) can be added with draw_entities.
heights {ground: -450 (outside ground, mm from the finished floor ±0.000), top: 3600 (top of walls / eaves), door_head: 2400, window_sill: 900, window_head: 2400, slab: 100, foundation: {depth: 1500, width: 900, height: 350, lean: 100}, walls_to_roof: end|all (walls across the ridge rise to the roof: gable ends only, or every one = tường thu hồi)}; per opening: sill, head; per wall: height. roofs [{type: gable|flat, ridge: x|y (direction of the ridge in plan), pitch (deg), overhang, thickness, base (eaves level, default heights.top), parapet (flat), region [[x0,y0],[x1,y1]] (default: the whole building)}] - several parts for e.g. a porch gable in front of the main roof.

Input parameters:

- `at`
- `dry_run` (boolean): List the heights/roof defaults it would assume, without drawing
- `heights`
- `language`
- `plan`: Plan description (as draw_plan); default: the last one drawn
- `roofs`
- `scale`
- `sides` (array)
- `titles`: {bottom: "MẶT ĐỨNG CHÍNH", ...} to replace the automatic titles

### `draw_section` (~508 tokens)

Draw a section derived from the plan of draw_plan along a cut line (from/to, looking to its left or right like the plan's section mark, or mark: the label of a section drawn by draw_plan): walls cut (heavy outline + brick hatch) with the openings they cross and concrete lintels, footings with lean concrete, floor slab and fill, the roof cut (gable profile, eaves band or flat slab with parapets), walls/doors/windows seen beyond in thin lines, room names, level marks, height dimensions, grid bubbles, title "MẶT CẮT A-A". Footings are drawn as a typical section (sizes from heights.foundation), not a design.
heights {ground: -450 (outside ground, mm from the finished floor ±0.000), top: 3600 (top of walls / eaves), door_head: 2400, window_sill: 900, window_head: 2400, slab: 100, foundation: {depth: 1500, width: 900, height: 350, lean: 100}, walls_to_roof: end|all (walls across the ridge rise to the roof: gable ends only, or every one = tường thu hồi)}; per opening: sill, head; per wall: height. roofs [{type: gable|flat, ridge: x|y (direction of the ridge in plan), pitch (deg), overhang, thickness, base (eaves level, default heights.top), parapet (flat), region [[x0,y0],[x1,y1]] (default: the whole building)}] - several parts for e.g. a porch gable in front of the main roof.

Input parameters:

- `at`
- `beam_depth`: Depth of the beams drawn under the slabs on the cut walls (default heights.beam or 300; 0 = none)
- `dry_run` (boolean): List the heights/roof/foundation defaults it would assume, without drawing
- `from`
- `heights`
- `label` (string|null)
- `language`
- `look` (string)
- `mark` (string|null): Label of a section mark of the plan (e.g. "A"): its from/to/look are used
- `plan`
- `roofs`
- `scale`
- `title` (string|null)
- `to`

### `draw_structure_detail` (~643 tokens)

Draw a reinforced-concrete detail at a detail scale (default 1:20 sections, 1:25 beams/footings) on the structural layers (S-CONC, S-REBR, S-REBR-STIR, S-ANNO-*): concrete outline, bars and stirrups with 135° hooks, bar marks with leaders, dimensions, levels, title. Sizes and reinforcement must come from the user or the structural design (this tool computes no strength: draw what the engineer specifies, or label values as typical/to be checked). Returns the bar schedule rows (length, count) for rebar_schedule; schedule=true also draws the table next to the detail. Warns when bars in one row do not fit the clear spacing.
kind=section: rectangular RC cross-section {b, h, cover: 25, groups: [{face: bottom|top|bottom2|top2|corners|sides|left|right, d, n, mark}], stirrup: {d, spacing, mark} (null = none), label: "1-1"}; kind=beam: beam along its spans {spans: [axis-to-axis], support: column width, b, h, cover, bottom {d, n, mark}, top {d, n, mark}, extra_top {d, n, mark, ratio: 0.25} (support bars over ratio x span), stirrup {d, end: 100, mid: 200, zone: 0.25, mark}, axes: labels, name, count: identical members} with sections 1-1 / 2-2; kind=footing: pad footing section {B, L, H, edge (sloped when < H), cover: 50, lean: 100, depth (bottom below ±0.000), ground, mesh {d, spacing, mark}, column {b, top, bars {d, n, mark}, ties {d, spacing, mark}}, name, count}.

Input parameters:

- `B` (number|null)
- `H` (number|null)
- `L` (number|null)
- `at`
- `axes`
- `b` (number|null)
- `bottom`
- `column`
- `count`
- `cover` (number|null)
- `depth` (number|null)
- `dry_run` (boolean): List the sizes/bars it would assume and the schedule rows, without drawing
- `edge` (number|null)
- `extra_top`
- `ground` (number|null)
- `groups`
- `h` (number|null)
- `kind` (string, required)
- `label` (string|null)
- `language`
- `lean` (number|null)
- `mesh`
- `name` (string|null)
- `scale`
- `schedule` (boolean)
- `spans`
- `stirrup`
- `support` (number|null)
- `title` (string|null)
- `top`

### `rebar_schedule` (~168 tokens)

Bar schedule (bảng thống kê cốt thép): rows [{mark, shape, d (mm), length (mm per bar), n (bars per member), members}] (e.g. the schedule_rows of draw_structure_detail, several details combined) -> total bars, total length (m) and weight (d²/162 kg/m) per row, per diameter and overall. Draws it as a table at "at" (top-left, default right of the drawing) unless draw=false; csv_path also saves it for Excel.

Input parameters:

- `at`
- `csv_format` (string)
- `csv_path` (string|null)
- `draw` (boolean)
- `language`
- `rows` (array, required)
- `scale` (number)

### `draw_structure_plan` (~410 tokens)

Structural framing plan of one slab (mặt bằng kết cấu dầm sàn) from the plan of draw_plan, for the structural set (its own drawing: new_drawing first): beams along the load-bearing walls of the floor below (walls of 150 mm and more; thinner partitions stand on the slab), named per slab (D2.1, D2.2 ... for the slab of floor 2, DM.1 ... for the roof) with b x h and their count, columns at the wall nodes, the slab thickness, lowered slabs (wet rooms, balconies -50) hatched, stair openings crossed, grids with bubbles and dimensions, title "MẶT BẰNG KẾT CẤU SÀN <floor> (+level)". Sizes are preliminary (h = span/12 rounded up to 50, 300-700; b = wall thickness) and reported as assumed: the structural engineer designs them; give beam {b, h} and column {size} to use theirs. The beams are remembered for draw_beam_schedule.

Input parameters:

- `at`
- `beam`: {b, h, min_wall: 150}
- `column`: {size: [b, h]}
- `dry_run` (boolean): List the beams, columns and sizes it would assume, without drawing
- `floor`: The slab: floor number from 2 or name (its floor slab), "roof" (over the top floor; default for a one-floor plan), or "foundation" (pad footings under the columns, ground beams GM under the ground fl…
- `footing`: Foundation plan: {B, L, depth} of the pad footings M1 (default 1200 x 1200, depth heights.foundation.depth or 1500)
- `language`
- `plan`
- `prefix` (string|null)
- `scale` (number)
- `slab`

### `draw_beam_schedule` (~199 tokens)

Beam schedule (bảng mặt cắt dầm) of the structural set: for every beam type its section at the support (GỐI) and at midspan (NHỊP) with the slab flange, the slab level (FL), bars, stirrups and b/h dimensions, titled "DẦM D2.1 (220x400) - SL: 03". beams default to those of the draw_structure_plan calls of this session; or give beams [{name, b, h, count, level, slab, bars: {support: [{face, d, n}], span: [...]}, stirrup: {d, support, span}}]. Bars not given are preliminary (by depth) and reported as assumed.

Input parameters:

- `at`
- `beams`
- `dry_run` (boolean)
- `language`
- `per_row` (integer)
- `scale` (number)

### `structural_calc` (~506 tokens)

Preliminary structural calculation (bảng tính kết cấu sơ bộ) of the frame of the plan of draw_plan, for the structural set: the beams of every slab (as draw_structure_plan lays them out) and the ground beams; loads by TCVN 2737:2023 (slab build-ups, live loads by room: rooms 1.5, halls and stairs 3, balconies 2 kPa..., partitions, walls on the beams less their openings, self-weight); slab panels shared out to their beams (two-way trapezoid / triangle, one-way); continuous beams with the live load on all / odd / even spans; bending and shear by TCVN 5574:2018 (αm, ξ ≤ ξR, As, bars; stirrups at the supports and midspan); column loads down to the footings, the column capacity and the footing area for the soil pressure. Drawn as a sheet of tables (materials, slab loads, floor build-up, beams, columns and footings, assumptions) with the sign-off (người tính, kiểm tra, chủ trì kết cấu: name, licence No., signature, date) and the note that a licensed structural engineer checks it, calculates it again and signs it. csv_path writes the tables for Excel. The designed bars and stirrups replace the preliminary ones of draw_beam_schedule (call it afterwards). Defaults (materials, loads, soil pressure, footing, column) are reported as assumed; sizes that fail are listed in warnings.

Input parameters:

- `at`
- `column`: {size: [b, h], bars: {n, d}}
- `concrete` (string)
- `cover` (number)
- `csv_format` (string)
- `csv_path` (string|null)
- `draw` (boolean)
- `dry_run` (boolean)
- `footing`: {B, L} of the pad footings drawn, mm
- `language`
- `plan`
- `scale` (number)
- `soil_pressure` (number): Bearing pressure R at the footing bottom, kPa (from the site investigation)
- `steel` (string)
- `stirrup_steel` (string)
- `xlsx_path` (string|null): Excel workbook with live formulas: the inputs (materials, loads, soil, sections, bars, q) in yellow cells, the design calculated from them

### `draw_quantity_schedule` (~328 tokens)

Bar schedule of the whole structural set (bảng thống kê cốt thép: footings, columns, ground beams and the beams of every slab with the bars and stirrups of structural_calc, slabs and stairs by the detailing rules; bars, lengths with laps and anchorage, weights by d²/162 as table formulas, totals per diameter) and the bill of quantities (bảng tổng hợp khối lượng vật tư: lean concrete, concrete and formwork of the footings, column stubs, ground beams, columns storey by storey, beams, slabs and stairs; steel by grade; brick walls by thickness in m² (and m³) less the openings; plaster inside, outside and of the soffits), each with how it is made up (diễn giải). Uses the last structural_calc of this session, else runs it with its defaults. The bar schedule flows in columns over pages (page_height mm, per_page columns), each page and the bill drawn apart for their own sheets (returned bounds); csv_path writes both for Excel. For estimating: the quantity surveyor checks them against the final drawings.

Input parameters:

- `csv_format` (string)
- `csv_path` (string|null)
- `language`
- `page_height` (number)
- `per_page` (integer)
- `plan`
- `scale` (number)
- `xlsx_path` (string|null): Excel workbook with live formulas: the calculation (parameters, loads, beams, columns and footings), the bar schedule and the bill of quantities

### `draw_structure_notes` (~216 tokens)

Structural general notes (ghi chú chung kết cấu) as tables: materials (concrete B20/B15/B7.5, steel CB240-T / CB300-V), concrete cover by member, anchorage and lap lengths by diameter, typical lintels by span, and numbered notes (codes, laps, formwork, preliminary sizes). TCVN 5574:2018 defaults, every value can be given: concrete {main, minor, lean, steel_small, steel_large}, cover {footing, ground_beam, column, beam, slab, lintel}, laps {anchor_tension, anchor_compression, lap_tension, lap_compression} (multiples of d), lintels (rows), notes (lines). Defaults are listed as assumed.

Input parameters:

- `at`
- `concrete`
- `cover`
- `dry_run` (boolean)
- `language`
- `laps`
- `lintels`
- `notes`
- `scale` (number)

### `draw_door_schedule` (~156 tokens)

Door and window schedule of the architectural set (bảng thống kê cửa đi, cửa sổ) from the plan of draw_plan: every type (by tag, kind and size, on every floor) drawn in elevation with its frame, leaves and opening direction (dashed lines meet on the hinge side), glazing, width / height / sill dimensions, its tag and count, then the table: tag, kind, W x H, sill, count by floor, description. materials {tag: description} replaces the default descriptions (listed as assumed).

Input parameters:

- `at`
- `dry_run` (boolean)
- `language`
- `materials`
- `plan`
- `scale` (number)

### `draw_stair_detail` (~305 tokens)

Stair detail sheet of the architectural set (chi tiết cầu thang) for a U stair of the plan of draw_plan: the stair plan on each kind of floor (start, typical floors grouped, arrival) with the walls around it, the treads numbered, run / landing / width dimensions (n x going), floor and landing levels, grids and the section mark 1-1; section 1-1 along the flights (cut flight with its RC waist slab and landing, the flight beyond, floor slabs and walls cut, handrails with balusters, riser dimensions n x riser per flight, floor heights, levels); the build-up notes of treads and landing with 2h + b; and the tread and handrail detail (granite, mortar, brick steps, waist slab, plaster, handrail, balusters) at detail_scale, drawn apart: put the two parts on one sheet with create_layout views [{window: main, scale}, {window: detail, scale: detail_scale}].

Input parameters:

- `at`
- `detail_scale` (number)
- `dry_run` (boolean)
- `finish` (number)
- `landing` (number)
- `language`
- `plan`
- `rail` (number)
- `scale` (number)
- `stair` (integer): which U stair of the floor where stairs start (0 = the first)
- `waist` (number)

### `draw_roof_plan` (~191 tokens)

Roof plan of the architectural set (mặt bằng mái) from the plan of draw_plan, for flat roofs: a copy of the top floor plan with its walls (the parapets and the stair tower) at the plan scale with its grids and dimensions, the roof of the stair tower hatched, the roof terrace, floor drains with falls (i=2%) and rainwater pipes, the levels of the terrace, the parapet top and the tower roof, names and notes (waterproofing, screed to falls, pipes).

Input parameters:

- `fall` (number)
- `language`
- `notes`: General notes of the sheet (GHI CHÚ): true = the standard ones for this kind of plan, a list = these, false = none
- `offset`
- `plan`
- `scale` (number)
- `title` (string|null)

### `draw_cover_sheet` (~180 tokens)

Cover sheet of a set (tờ bìa): "HỒ SƠ BẢN VẼ <set>" large, the phase, then project, item, client, design consultant, contractor, location and date, framed. set: KIẾN TRÚC, KẾT CẤU, NỘI THẤT... Put it on its own sheet before the drawing list.

Input parameters:

- `at`
- `client` (string|null)
- `company` (string|null)
- `contractor` (string|null)
- `date` (string|null)
- `item` (string|null)
- `language`
- `location` (string|null)
- `phase` (string|null)
- `project` (string|null)
- `scale` (number)
- `set` (string, required)

### `draw_drawing_list` (~144 tokens)

Drawing list (danh mục bản vẽ) of the set in this drawing: a table of its sheets (number, title, scale, paper). sheets default to the layouts create_layout made in this drawing in this session; or give sheets [{number, title, scale, paper, note}]. item names the set (KIẾN TRÚC, KẾT CẤU, NỘI THẤT). Put it on the first sheet of the set (e.g. KT-00).

Input parameters:

- `at`
- `item` (string|null)
- `language`
- `scale` (number)
- `sheets`

### `draw_furniture_plan` (~645 tokens)

Furniture layout plan (mặt bằng bố trí nội thất): a copy of the plan of draw_plan at 1:50 (walls, doors, windows, grids, dimensions, room names) to the right of the drawing (or at offset), with the furniture and joinery from the library and their code tags, and elevation keys (A top, B right, C bottom, D left) for the interior elevations. copy=false draws the items on the plan itself. Place an item with room + wall (A/B/C/D or top/right/bottom/left: its back against that wall) + offset from the left end of the wall seen from inside (default centred) + gap, or at (middle of its back edge) + facing (degrees the front faces), or center + facing (freestanding, e.g. a dining table). width/depth/height override the type size; code (default per type, e.g. FN-01 bed), description; kitchen_base takes sink and hob (x from its left end) and modules [{w, type: door|doors|drawers|sink|open|appliance}]; kitchen_wall/hood take z0 (underside). The items are remembered for draw_interior_elevation, draw_ceiling_plan (pendants over tables), draw_joinery_detail and material_schedule. Types (w x d x h): bed (1600x2000x450), nightstand (450x400x500), wardrobe (1600x600x2400), sofa (2100x850x800), armchair (850x850x800), coffee_table (1100x600x420), tv_cabinet (1800x400x450), dining_table (1600x900x750), chair (450x450x850), desk (1200x600x750), kitchen_base (2400x600x850), kitchen_wall (2400x350x700), hood (700x480x650), fridge (700x700x1800), washer (600x600x850), toilet (400x700x400), vanity (800x500x850), shower (900x900x2000), bathtub (1600x750x550), shoe_cabinet (1000x350x1000), altar (1530x610x1270), bookshelf (800x300x2000).

Input parameters:

- `copy` (boolean)
- `dry_run` (boolean): Resolve the items and list the sizes/codes/positions it would assume, without drawing
- `elevation_keys`: Rooms that get an elevation key: names, or {room, at}
- `floor`: Floor of a building (name or number from 1)
- `items` (array, required)
- `language`
- `notes`: General notes of the sheet (GHI CHÚ): true = the standard ones for this kind of plan, a list = these, false = none
- `offset`
- `plan`
- `scale` (number)
- `tags` (boolean)
- `title` (string|null)

### `draw_floor_finish_plan` (~519 tokens)

Floor finish plan (mặt bằng lát sàn): a copy of the plan at 1:50 with the real tile or plank joints of each room (tiles centred in the room by default, or from a start point; planks staggered by a third), kept clear of the room names, a code tag under each name and the legend (finish, swatch at the real size, area m² and rooms). Defaults by room name (reported in assumed): dry rooms FL-01 porcelain 600x600 centred, SK-01 skirting 100, WL-01 white paint, CL-01 suspended gypsum +3.000 (floors of 3.3 m: +2.800) with a 600 wide, 150 deep drop band and LED cove (flat in rooms narrower than 2.4 m); stairs FL-04 granite treads, no ceiling (stairwell); kitchens the same plus WL-03 backsplash tiles between the base and wall cabinets; WC/bathrooms FL-02 anti-slip 300x300, WL-02 wall tiles 300x600 to the ceiling, CL-02 moisture-resistant gypsum +3.000 flat; yards/balconies FL-03 outdoor tiles, no ceiling.

Input parameters:

- `dry_run` (boolean): List the finishes it would assume per room, without drawing
- `floor`: Floor of a building (name or number from 1)
- `language`
- `legend` (boolean)
- `notes`: General notes of the sheet (GHI CHÚ): true = the standard ones for this kind of plan, a list = these, false = none
- `offset`
- `plan`
- `rooms`: [{room: "PHÒNG NGỦ 1", floor: {code, description, pattern: tile|plank|none|<hatch>, size: [600, 600], start: center|corner|[x,y], angle}, skirting: {code, description, height} | null, wall: {code, de…
- `scale` (number)
- `title` (string|null)

### `draw_wall_finish_plan` (~541 tokens)

Wall finish plan (mặt bằng hoàn thiện tường): a copy of the plan at 1:50; along the inside face of every wall of a room a band of its finish (one line for paint, two lines with the tile joints for tiles), broken at the doors and windows, the kitchen splashback behind the base cabinets of draw_furniture_plan, a code tag per room with the tiling height, the legend with the area of each wall finish (openings and splashback deducted) and the general notes. Defaults by room name (reported in assumed): dry rooms FL-01 porcelain 600x600 centred, SK-01 skirting 100, WL-01 white paint, CL-01 suspended gypsum +3.000 (floors of 3.3 m: +2.800) with a 600 wide, 150 deep drop band and LED cove (flat in rooms narrower than 2.4 m); stairs FL-04 granite treads, no ceiling (stairwell); kitchens the same plus WL-03 backsplash tiles between the base and wall cabinets; WC/bathrooms FL-02 anti-slip 300x300, WL-02 wall tiles 300x600 to the ceiling, CL-02 moisture-resistant gypsum +3.000 flat; yards/balconies FL-03 outdoor tiles, no ceiling.

Input parameters:

- `dry_run` (boolean): List the wall finishes it would assume per room, without drawing
- `floor`: Floor of a building (name or number from 1)
- `language`
- `legend` (boolean)
- `notes`: General notes of the sheet (GHI CHÚ): true = the standard ones for this kind of plan, a list = these, false = none
- `offset`
- `plan`
- `rooms`: [{room: "PHÒNG NGỦ 1", floor: {code, description, pattern: tile|plank|none|<hatch>, size: [600, 600], start: center|corner|[x,y], angle}, skirting: {code, description, height} | null, wall: {code, de…
- `scale` (number)
- `title` (string|null)

### `draw_ceiling_plan` (~591 tokens)

Reflected ceiling plan (mặt bằng trần đèn): a copy of the plan at 1:50 without door leaves; per room the drop band along the walls (step line, LED cove dashed), downlights in the band about every spacing (a grid on flat ceilings), a ceiling lamp in the middle or a pendant over each dining table of draw_furniture_plan, level tags (code over level) for the band and the field, the room name; then the light legend with counts (remembered for material_schedule). Defaults by room name (reported in assumed): dry rooms FL-01 porcelain 600x600 centred, SK-01 skirting 100, WL-01 white paint, CL-01 suspended gypsum +3.000 (floors of 3.3 m: +2.800) with a 600 wide, 150 deep drop band and LED cove (flat in rooms narrower than 2.4 m); stairs FL-04 granite treads, no ceiling (stairwell); kitchens the same plus WL-03 backsplash tiles between the base and wall cabinets; WC/bathrooms FL-02 anti-slip 300x300, WL-02 wall tiles 300x600 to the ceiling, CL-02 moisture-resistant gypsum +3.000 flat; yards/balconies FL-03 outdoor tiles, no ceiling.

Input parameters:

- `dry_run` (boolean): List the ceilings it would assume per room, without drawing
- `floor`: Floor of a building (name or number from 1)
- `language`
- `legend` (boolean)
- `mode` (string): finish = ceiling finish plan (materials, levels, step widths; no lights), lighting = lighting layout (lights and legend; no level tags), both = one reflected ceiling plan
- `notes`: General notes of the sheet (GHI CHÚ): true = the standard ones for this kind of plan, a list = these, false = none
- `offset`
- `plan`
- `rooms`: [{room: "PHÒNG NGỦ 1", floor: {code, description, pattern: tile|plank|none|<hatch>, size: [600, 600], start: center|corner|[x,y], angle}, skirting: {code, description, height} | null, wall: {code, de…
- `scale` (number)
- `spacing` (number)
- `title` (string|null)

### `draw_interior_elevation` (~570 tokens)

Interior elevations (triển khai mặt đứng nội thất) of the walls of one room, seen from inside, side by side: cut end walls, floor slab and ceiling (the drop band cut at the ends), the doors and windows of the wall (from the plan), the furniture and joinery of draw_furniture_plan backed on it (front view) and along the side walls (side view), wall finish joints (tiles, panels), kitchen backsplash between base and wall cabinets, skirting, width and height dimension chains, material notes with leaders (codes + descriptions), title "MẶT ĐỨNG A - <room>". walls: A top, B right, C bottom, D left (as in plan). Defaults by room name (reported in assumed): dry rooms FL-01 porcelain 600x600 centred, SK-01 skirting 100, WL-01 white paint, CL-01 suspended gypsum +3.000 (floors of 3.3 m: +2.800) with a 600 wide, 150 deep drop band and LED cove (flat in rooms narrower than 2.4 m); stairs FL-04 granite treads, no ceiling (stairwell); kitchens the same plus WL-03 backsplash tiles between the base and wall cabinets; WC/bathrooms FL-02 anti-slip 300x300, WL-02 wall tiles 300x600 to the ceiling, CL-02 moisture-resistant gypsum +3.000 flat; yards/balconies FL-03 outdoor tiles, no ceiling.

Input parameters:

- `at`
- `dry_run` (boolean): List the finishes and items it would show per wall, without drawing
- `floor`: Floor of a building (name or number from 1)
- `items`: Furniture as in draw_furniture_plan; default: the items of the last draw_furniture_plan
- `language`
- `plan`
- `room` (string, required)
- `rooms`: [{room: "PHÒNG NGỦ 1", floor: {code, description, pattern: tile|plank|none|<hatch>, size: [600, 600], start: center|corner|[x,y], angle}, skirting: {code, description, height} | null, wall: {code, de…
- `scale` (number)
- `walls` (array)

### `draw_joinery_detail` (~367 tokens)

Joinery shop drawing (chi tiết đồ gỗ) at 1:10: kind kitchen (base cabinets with plinth, carcass, doors/drawers, stone top; backsplash; wall cabinets) or wardrobe (plinth, doors, top boxes): front elevation with the modules, hinge side dashed, handles, module and height dimension chains and section mark 1-1; section 1-1 through the carcass (panels 17 mm, back 8 mm, shelves, door, plinth, countertop, wall cabinet) with dimensions and material notes. item: the code of a kitchen_base or wardrobe of draw_furniture_plan takes its width, modules, sink and hob (and the kitchen_wall of the same room). materials {carcass, door, back, top, plinth, backsplash, rod, handle} replace the default specifications (reported in assumed).

Input parameters:

- `at`
- `base`
- `depth`
- `dry_run` (boolean): List the sizes and materials it would assume, without drawing
- `height`
- `hob` (number|null)
- `hood`: {x, w: 700, h: 650, z0: 1600} cooker hood between the wall cabinets
- `item` (string|null)
- `kind` (string)
- `language`
- `materials`
- `modules`
- `name` (string|null)
- `panel`
- `scale` (number)
- `sink` (number|null)
- `wall`
- `wall_runs`: [{x (from the left of the base run), w, modules}] wall cabinet runs; default one over the whole run
- `width`

### `draw_finish_quantities` (~291 tokens)

Architectural finish quantities (bảng khối lượng hoàn thiện kiến trúc) of the building of draw_plan, floor by floor, for the architectural set: floor tiles by finish, wall tiles (toilets, kitchen backsplash), skirting; skim coat and paint of the inner walls, the outer walls (faces with no room on their side, the plinth, parapets) and the ceilings (gypsum, concrete soffits); gypsum ceilings; waterproofing of toilets, balconies and the roof terrace (300 up the walls), screed to falls, the tower roof; stair granite (treads, landings, risers), stair and balcony railings; doors and windows by type (sets and m²). The rooms and finishes are those of the interior tools (material_schedule, the same defaults by room name, the finishes given there in this session). Drawn as a table with the quantity of every floor (diễn giải); csv_path writes it for Excel. Masonry and plaster are in the structural bill (draw_quantity_schedule).

Input parameters:

- `at`
- `csv_format` (string)
- `csv_path` (string|null)
- `draw` (boolean)
- `language`
- `plan`
- `scale` (number)
- `xlsx_path` (string|null): Excel workbook: the quantity of every floor, the total as their sum

### `material_schedule` (~499 tokens)

Finish and material schedule (bảng thống kê vật liệu hoàn thiện): floors and ceilings in m² from the room outlines, skirting in m (door widths deducted), walls in m² (perimeter x height to the ceiling, openings deducted), kitchen backsplash, furniture/joinery/sanitary/equipment by count (draw_furniture_plan) and lights (draw_ceiling_plan); one row per code with its rooms. Draws a table (default right of the drawing) and csv_path saves it for Excel. Defaults by room name (reported in assumed): dry rooms FL-01 porcelain 600x600 centred, SK-01 skirting 100, WL-01 white paint, CL-01 suspended gypsum +3.000 (floors of 3.3 m: +2.800) with a 600 wide, 150 deep drop band and LED cove (flat in rooms narrower than 2.4 m); stairs FL-04 granite treads, no ceiling (stairwell); kitchens the same plus WL-03 backsplash tiles between the base and wall cabinets; WC/bathrooms FL-02 anti-slip 300x300, WL-02 wall tiles 300x600 to the ceiling, CL-02 moisture-resistant gypsum +3.000 flat; yards/balconies FL-03 outdoor tiles, no ceiling.

Input parameters:

- `at`
- `csv_format` (string)
- `csv_path` (string|null)
- `draw` (boolean)
- `floor`: One floor of a building; default: every floor (rooms listed as "<floor>: <room>")
- `language`
- `plan`
- `rooms`: [{room: "PHÒNG NGỦ 1", floor: {code, description, pattern: tile|plank|none|<hatch>, size: [600, 600], start: center|corner|[x,y], angle}, skirting: {code, description, height} | null, wall: {code, de…
- `scale` (number)

### `install_autocad_bridge` (~99 tokens)

Install (or update) the "ACAD MCP Bridge" add-in so the other tools can connect: copies AcadMcpBridge.bundle into %APPDATA%/Autodesk/ApplicationPlugins, which AutoCAD 2021-2024 loads at startup (restart AutoCAD afterwards; the first time AutoCAD may ask to load an unsigned file: choose "Always load"). dry_run=true only reports.

Input parameters:

- `dry_run` (boolean)

## Diagnostics

Captured diagnostic sections: Provenance. The full working is on the page: https://verifymcp.io/servers/2ez4gcx-construction-autocad-mcp/construction-autocad-mcp#diagnostics

## Score history

- 2026-11-05: 33
- 2026-11-04: 33
- 2026-11-03: 33

## Common questions

### What is the Construction AutoCAD MCP server?

Construction AutoCAD MCP is listed in the public MCP registry as io.github.2ez4gcx/construction-autocad-mcp. Let AI draw in AutoCAD: plans from images, KT/KC/NT sets, TCVN calc, quantities, sheets, PDF. This page covers its MCPB bundle (https://github.com/2ez4gcx/construction-autocad-mcp/releases/download/v1.2.1/construction-autocad-mcp-1.2.1.mcpb).

### Is the Construction AutoCAD MCP server safe to use?

Construction AutoCAD MCP scores 33 out of 100 on VerifyMCP. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the Construction AutoCAD MCP server expose?

Construction AutoCAD MCP exposes 53 tools: ping, drawing_info, list_layers, list_blocks, query_entities, and 48 more. Their descriptions and schemas cost roughly 14,526 tokens of context every time the server is loaded.

### What licence is the Construction AutoCAD MCP server under?

Construction AutoCAD MCP declares the MIT licence, which is OSI-approved. That covers the source only, and says nothing about the cost of any service it calls.

## Links

- Repository: https://github.com/2ez4gcx/construction-autocad-mcp
- Changelog RSS feed: https://verifymcp.io/servers/2ez4gcx-construction-autocad-mcp/construction-autocad-mcp.xml
- Changelog JSON feed: https://verifymcp.io/servers/2ez4gcx-construction-autocad-mcp/construction-autocad-mcp.json
- HTML version of this page: https://verifymcp.io/servers/2ez4gcx-construction-autocad-mcp/construction-autocad-mcp