# Drawing MCP Server (npm · @dmytro-prototypes/cad-drawing-mcp-server)

Read, query, edit and render DWG drawings with AI. No AutoCAD required.

- Trust score: 62/100 (medium)
- Change this week: +4
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-11-22

## Components

- remote · `cad-drawing.dmytro-prototypes.net`: 36/100, [markdown](https://verifymcp.io/servers/net-dmytro-prototypes-drawing-mcp-server/cad-drawing.md), [page](https://verifymcp.io/servers/net-dmytro-prototypes-drawing-mcp-server/cad-drawing)
- npm · `@dmytro-prototypes/cad-drawing-mcp-server`: 62/100 (this document), [markdown](https://verifymcp.io/servers/net-dmytro-prototypes-drawing-mcp-server/dmytro-prototypes-cad-drawing-mcp-server.md), [page](https://verifymcp.io/servers/net-dmytro-prototypes-drawing-mcp-server/dmytro-prototypes-cad-drawing-mcp-server)

## Channel facts

- Registry: `npm`
- Package: `@dmytro-prototypes/cad-drawing-mcp-server`
- Version: `0.2.13`
- Transport: `stdio`

## 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-22.

- **Supply Chain Security**: 100/100
  - No malware found by supply-chain analysis.
  - No known CVEs affecting this package version or its production dependencies.
  - No install/post-install scripts declared.
  - 0 of 5 dependencies flagged as unhealthy.
- **Provenance & Transparency**: 6/100
  - Repository check failed: no source repository is declared.
  - Provenance check failed: no build-provenance attestation is published.
  - Licence could not be checked: the licence is shipped as a file inside the package, not declared as a standard (SPDX) licence identifier, so we cannot tell whether it is OSI-approved.
  - Actively maintained (last published 4 days ago).
  - Security-disclosure policy not yet verified: we couldn't inspect the source repository.
- **Schema Quality & AI Usability**: 52/100
  - 33% of prompts and resources have a non-trivial description (not blank, and not just the item's name).
  - AI-judged instruction clarity (good).
  - Context-footprint check failed: tool/resource definitions use about 5639 tokens (~156/item across 36 items; 34 tools + 2 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 27/100
  - Stability observed for 8 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 93/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 78% 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 1 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation.
  - An AI judge read all 36 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.
  - Supports UI / widget rendering.

## Install

### How do I install the Drawing MCP Server server?

Drawing MCP Server runs locally as an npm package, launched with npx -y @dmytro-prototypes/cad-drawing-mcp-server. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add net-dmytro-prototypes-drawing-mcp-server -- npx -y @dmytro-prototypes/cad-drawing-mcp-server
```

### Cursor

```json
{
  "mcpServers": {
    "net-dmytro-prototypes-drawing-mcp-server": {
      "command": "npx",
      "args": [
        "-y",
        "@dmytro-prototypes/cad-drawing-mcp-server"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "net-dmytro-prototypes-drawing-mcp-server": {
      "command": "npx",
      "args": [
        "-y",
        "@dmytro-prototypes/cad-drawing-mcp-server"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add net-dmytro-prototypes-drawing-mcp-server -- npx -y @dmytro-prototypes/cad-drawing-mcp-server
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "net-dmytro-prototypes-drawing-mcp-server": {
      "type": "local",
      "command": [
        "npx",
        "-y",
        "@dmytro-prototypes/cad-drawing-mcp-server"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add net-dmytro-prototypes-drawing-mcp-server --command npx --arg -y --arg @dmytro-prototypes/cad-drawing-mcp-server
```

### Hermes

```yaml
mcp_servers:
  net-dmytro-prototypes-drawing-mcp-server:
    command: "npx"
    args: ["-y", "@dmytro-prototypes/cad-drawing-mcp-server"]
```

### Netclaw

```json
{
  "McpServers": {
    "net-dmytro-prototypes-drawing-mcp-server": {
      "Transport": "stdio",
      "Command": "npx",
      "Arguments": [
        "-y",
        "@dmytro-prototypes/cad-drawing-mcp-server"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add net-dmytro-prototypes-drawing-mcp-server -t stdio -c npx -a -y @dmytro-prototypes/cad-drawing-mcp-server
```

### Other

```json
{
  "mcpServers": {
    "net-dmytro-prototypes-drawing-mcp-server": {
      "command": "npx",
      "args": [
        "-y",
        "@dmytro-prototypes/cad-drawing-mcp-server"
      ]
    }
  }
}
```

## 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-22 (score 62, +1)

No change was recorded against any check on this day. Stability & Change Management went from 23 to 27. That category is still filling its 30-day observation window: 7 days of observed history at the previous scan, 8 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-11-20 (score 61, +1)

No change was recorded against any check on this day. Stability & Change Management went from 17 to 20. That category is still filling its 30-day observation window: 5 days of observed history at the previous scan, 6 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-11-18 (score 60, +16)

- [security improvement] Malware scan: unverified → pass

### 2026-11-17 (score 44, −14)

- [security regression] Malware scan: pass → unverified
- [functional improvement] Stability: unverified → 0.10
- [functional] Package version: 0.2.12 → 0.2.13

### 2026-11-15 (score 58, +15)

- [security improvement] Malware scan: unverified → pass

### 2026-11-14 (score 43)

First indexed and scored.

## MCP tools (34)

### `cad.license_status` (~32 tokens)

Account and allowance

The signed-in account, plan, trial and remaining allowance from the latest authorization. Anonymous use reports no account.

### `cad.sign_in` (~75 tokens)

Sign in to your Drawing MCP Server account

Start browser sign-in for this computer and return the link at once. It does not wait: signing up for the first time means an emailed code and accepting the product agreements, which no tool call can sit through. Give the user the link, then call cad.license_status when they say they have finished to confirm the account.

### `cad.show_document` (~132 tokens)

Show an open drawing in an interactive image viewer with pan, zoom, a layer list to switch layers on and off, and model/layout/block/named-view switching. onlyLayers, hideLayers and onlyHandles open it already showing only part of the drawing. Falls back to a PNG in clients without MCP Apps.

Input parameters:

- `documentId` (string, required): documentId from cad.open_file or cad.create_document.
- `hideLayers` (array): Hide these layers.
- `onlyHandles` (array): Show only these entities (hex handles).
- `onlyLayers` (array): Show only these layers (names, any case).

### `cad.list_roots` (~35 tokens)

Folders this server may read drawings from

List the folders this server may open drawings from. Call this first: cad.open_file only accepts a rootUri from here.

### `cad.open_file` (~73 tokens)

Open a DWG read-only and return a documentId plus a summary (version, counts, and how much of it this build decodes). Every other tool needs the documentId.

Input parameters:

- `path` (string, required): Path relative to that root.
- `rootUri` (string, required): A uri from cad.list_roots.

### `cad.close_file` (~65 tokens)

Close this session's document and free its memory. A stored drawing reference can be used again to reopen the original file; in-memory edits are session-local and are discarded on close or reconnect.

Input parameters:

- `documentId` (string, required): documentId from cad.open_file or cad.create_document.

### `cad.list_documents` (~48 tokens)

Drawings open in this session

List the drawings this session currently has open. This is not a library of available drawings: it starts empty and only reports what cad.open_file, cad.open_uploaded_file or cad.create_document opened.

### `cad.document_info` (~51 tokens)

Re-read a document's summary — counts and decode coverage. Useful after an edit, when the counts may have moved.

Input parameters:

- `documentId` (string, required): documentId from cad.open_file or cad.create_document.

### `cad.move_entities` (~146 tokens)

Translate entities by a world-space offset [dx, dy, dz], atomically and in memory: all of them move or none do. Works on LINE, CIRCLE, ARC, POINT and 3DFACE (the families with a byte-exact writer); circles and arcs with a non-default extrusion are refused. Other types are refused by name. Hosted created drawings auto-save; other drawings use cad.save_as. Rotate and scale are not available yet.

Input parameters:

- `delta` (array, required): [dx, dy, dz] in drawing units.
- `documentId` (string, required): documentId from cad.open_file or cad.create_document.
- `handles` (array, required): Hex entity handles.

### `cad.update_entities` (~274 tokens)

Change the layer, ACI color, linetype, linetype scale, lineweight or visibility of existing entities, atomically and in memory: all change or none do. This is how to move entities to another layer (create it first with cad.create_symbol). Works on LINE, CIRCLE, ARC, POINT, 3DFACE, TEXT, MTEXT, INSERT, LWPOLYLINE, ELLIPSE, SOLID, SPLINE and HATCH (the families with a byte-exact writer); other types, such as dimensions, are refused by name. Omitted properties are left alone. Hosted stored drawings auto-save; other drawings use cad.save_as.

Input parameters:

- `color` (integer): ACI color: 0 BYBLOCK, 256 BYLAYER. Replaces any true color.
- `documentId` (string, required): documentId from cad.open_file or cad.create_document.
- `handles` (array, required): Hex entity handles.
- `layer` (string): Existing layer name.
- `linetype` (string): BYLAYER, BYBLOCK, CONTINUOUS or an existing linetype name.
- `linetypeScale` (number)
- `lineweight` (integer): Lineweight index; 29 is BYLAYER.
- `visible` (boolean)

### `cad.copy_entities` (~157 tokens)

Copy entities, offset by [dx, dy, dz], into the same space as the originals, atomically and in memory. Keeps layer, color and linetype. Works on LINE, CIRCLE, ARC, POINT, 3DFACE, TEXT, MTEXT, INSERT, LWPOLYLINE, ELLIPSE and SOLID; other types (SPLINE and HATCH included), and block references that carry attributes, are refused by name. Returns the new handles in input order.

Input parameters:

- `delta` (array, required): [dx, dy, dz] in drawing units.
- `documentId` (string, required): documentId from cad.open_file or cad.create_document.
- `handles` (array, required): Hex entity handles.

### `cad.delete_entities` (~131 tokens)

Permanently delete entities from the drawing, atomically and in memory. Works on LINE, CIRCLE, ARC, POINT, 3DFACE, TEXT, MTEXT, INSERT, LWPOLYLINE, ELLIPSE, SOLID, SPLINE and HATCH; an entity that other objects reference (such as an associative dimension's target) or a block reference with attributes is refused. There is no undo: re-open the source file to recover.

Input parameters:

- `documentId` (string, required): documentId from cad.open_file or cad.create_document.
- `handles` (array, required): Hex entity handles.

### `cad.make_block` (~227 tokens)

Group existing entities into a new named block definition, like BLOCK in a CAD program. The entities are moved into the block (rebased so basePoint becomes its origin). With insert true (default) one block reference is placed at basePoint where the entities were, so the drawing looks unchanged; with insert false only the definition is created. Works on LINE, CIRCLE, ARC, POINT, 3DFACE, TEXT, MTEXT, INSERT, LWPOLYLINE, ELLIPSE, SOLID, SPLINE and HATCH in one space (block references with attributes are refused); other types are refused by name. Returns the block handle and the INSERT handle.

Input parameters:

- `basePoint` (array): World point that becomes the block origin; default [0,0,0].
- `documentId` (string, required): documentId from cad.open_file or cad.create_document.
- `handles` (array, required): Hex entity handles, all in the same space.
- `insert` (boolean): Place one reference where the entities were. Default true.
- `name` (string, required)

### `cad.set_object_properties` (~191 tokens)

Atomically edit an entity or non-entity object in memory. Read cad.describe_type for writable names and value types. Non-entity edits currently require AC1032 and byte-exact verification of the object. Supports layer settings, text styles/fonts, simple linetype dashes, dimension styles, layout settings and validated dictionary entries. All hosted stored drawings, including uploads, auto-save before reporting success. Local sources use cad.save_as to create a verified new file. Complex linetypes, ownership changes and dictionary graph rewiring are refused.

Input parameters:

- `documentId` (string, required): documentId from cad.open_file or cad.create_document.
- `handle` (string, required): Hex object handle.
- `properties` (object, required): Writable field names to typed values. References are hex strings; colors are {method,index,rgb}; simple dashes accept lengths or returned dash objects; entries are [{name,handle}].

### `cad.create_document` (~133 tokens)

Create an empty native R2018 DWG without a template or source file. Hosted HTTP storage immediately saves an account-owned drawing with one-year (365-day) default retention and returns stable documentId, fileId and storedFile metadata. Entity, symbol and property edits are saved automatically and survive reconnects. Add geometry with cad.add_entities and preview with cad.show_document. Local stdio drawings stay in memory until cad.save_as.

Input parameters:

- `units` (integer): INSUNITS: 0 unitless, 1 inches, 2 feet, 4 millimeters (default), 5 centimeters, 6 meters.

### `cad.add_entities` (~256 tokens)

Atomically add native AC1032 entities into model space (default) or blockHandle (a named block or layout blockHandle): LINE, CIRCLE, ARC, LWPOLYLINE (bulges/width/elevation), ELLIPSE, SPLINE (NURBS controlPoints or cubic fitPoints), TEXT, MTEXT, DIMENSION (linear, aligned, diameter), LEADER (optional attached MTEXT), SOLID. Points are [x,y,z]; polyline vertices [x,y]. Angles/ellipse parameters and rotations are degrees. Dimensions use the WCS XY plane and include evaluated graphics blocks; they are non-associative. Symbols must exist; create them with cad.create_symbol. Set layer, ACI color, linetype, linetypeScale, lineweight, textStyle and dimensionStyle as applicable. Returns primary handles in input order; dimensions/leaders may create supporting objects. All hosted stored drawings, including uploads, auto-save; local drawings use cad.save_as.

Input parameters:

- `blockHandle` (string): Optional target block record handle; omit for model space.
- `documentId` (string, required): documentId from cad.open_file or cad.create_document.
- `entities` (array, required)

### `cad.create_symbol` (~190 tokens)

Create a named LAYER, STYLE (text/font), LTYPE (simple dash pattern), or DIMSTYLE in a native AC1032 DWG. Copies the drawing's default entry and applies validated properties atomically. Read cad.describe_type for property names/types. Use font_name for STYLE; dashes for LTYPE; dimtxt/dimasz/dimdec for DIMSTYLE; color/linetype_handle/lineweight_index for LAYER. References are hex handles returned by creation/query tools. Returns the new handle. Symbols can then be assigned by name in cad.add_entities. Existing names are refused. Font files must be available to the renderer/CAD application; setting font_name does not install a font.

Input parameters:

- `documentId` (string, required): documentId from cad.open_file or cad.create_document.
- `family` (string, required)
- `name` (string, required)
- `properties` (object)

### `cad.save_as` (~180 tokens)

Save current in-memory changes as a new DWG; never overwrites. Reopens and verifies all object bytes and section payloads first. Hosted HTTP storage: saves a new account-owned stored drawing (optional name) and returns fileId plus a downloadUrl to present as a link; rootUri and path are not used. Local stdio: requires rootUri and a new relative .dwg path inside the root, and returns that path.

Input parameters:

- `documentId` (string, required): documentId from cad.open_file or cad.create_document.
- `name` (string): Hosted only: file name for the new stored drawing, e.g. plan-v2.dwg.
- `path` (string): Local stdio only: new relative .dwg path inside the root; parent directory must exist.
- `rootUri` (string): Local stdio only.

### `cad.set_entity_properties` (~169 tokens)

Compatibility alias for cad.set_object_properties. All hosted stored drawings, including uploads, auto-save; local source files stay unchanged. Only families with a byte-exact writer accept edits — ask cad.describe_type, whose `writable` list names the fields and, for each, the read property holding the same value. A field the family does not declare is refused before anything is changed, so a typo cannot half-apply a batch.

Input parameters:

- `documentId` (string, required): documentId from cad.open_file or cad.create_document.
- `handle` (string, required): Hex handle of the entity.
- `properties` (object, required): Writable field name to typed value, e.g. {"Radius": 5.0}. Names come from cad.describe_type's `writable`, not from the readable property names.

### `cad.list_types` (~21 tokens)

List the DWG types this build decodes fields for.

### `cad.list_file_types` (~67 tokens)

List the types actually present in one drawing, with counts and full/partial/unsupported decode counts. Use this before querying: it tells you what is in the file rather than what is possible.

Input parameters:

- `documentId` (string, required): documentId from cad.open_file or cad.create_document.

### `cad.describe_type` (~78 tokens)

Readable fields/types and engine-supported writable fields/types. Instance decode or byte-exact writer verification may still fail explicitly. Non-entity editing is currently AC1032 only.

Input parameters:

- `documentId` (string, required): documentId from cad.open_file or cad.create_document.
- `type` (string, required): e.g. LINE, INSERT, LAYER.

### `cad.get_objects` (~155 tokens)

Fetch entities and non-entity objects by handle, in the order asked for. Full properties include owners, extension dictionaries, references and collections where decoded, including read-only BLOCK/ENDBLK/SEQEND markers, symbol-table controls and SORTENTSTABLE. Opaque control tails are returned with partial status. decodeStatus distinguishes full, partial and unsupported bodies. Handles that are not in the drawing come back under `missing` rather than being dropped.

Input parameters:

- `documentId` (string, required): documentId from cad.open_file or cad.create_document.
- `handles` (array, required): Hex handle strings, e.g. "1A3".
- `properties`: "summary" (default), "full", or an array of property names.

### `cad.query_objects` (~212 tokens)

Find objects by type, layer, block, layout or space, with optional exact property matches and a text search. This is the main way to explore a drawing.

Input parameters:

- `block` (string): Owning block name.
- `decodedOnly` (boolean): Skip objects whose family this build does not decode.
- `documentId` (string, required): documentId from cad.open_file or cad.create_document.
- `layer` (string): Layer name (case-insensitive).
- `layout` (string): Paper-space layout name.
- `limit` (integer): Default 50, max 1000.
- `offset` (integer)
- `properties`: "summary" (default), "full", or names.
- `space` (string)
- `textContains` (string): Case-insensitive substring over any string property — text, block names.
- `types` (array): e.g. ["INSERT","MTEXT"].
- `where` (object): Exact property matches, e.g. {"closed": true}.

### `cad.list_render_views` (~50 tokens)

What can be drawn: model space, each paper-space layout with its viewports, and every block definition.

Input parameters:

- `documentId` (string, required): documentId from cad.open_file or cad.create_document.

### `cad.show_renders` (~262 tokens)

Show several pictures of a drawing at once as a titled gallery, for example one image per layer, per sheet, or per detail. Each entry takes what cad.render_view takes (view, handle, onlyLayers, hideLayers, onlyHandles, region, width, height, dark) plus a title; settings given outside renders apply to every entry. Use this, rather than several cad.render_view calls, whenever the user asks for more than one image. The pictures appear in a widget; set imageForModel to be handed them yourself as well.

Input parameters:

- `documentId` (string, required): documentId from cad.open_file or cad.create_document.
- `format` (string): Default png.
- `height` (integer)
- `imageForModel` (boolean): Hand the picture to you as an image block as well. Off by default where the host draws the widget: the user already sees the render, and the image block is the same bytes again. Set it true when you…
- `renders` (array, required): One entry per picture, in order.
- `width` (integer): Default width for every entry; 800 keeps eight pictures small.

### `cad.render_view` (~604 tokens)

Render model space, a paper-space sheet, or one block, as SVG or PNG. The picture appears in a widget for the user; set imageForModel to be handed it yourself. The result carries diagnostics — what was drawn, culled, or missing a font — so a thin-looking drawing can be explained rather than guessed at.

Input parameters:

- `background` (string): Canvas background for PNG and SVG: any #RRGGBB color, white, black, or transparent. Defaults to opaque white (black when dark=true). Opaque backgrounds automatically select the light/dark drawing pal…
- `dark` (boolean): Legacy background choice: true=opaque black, false=opaque white. For transparent output, selects the drawing's light/dark palette.
- `documentId` (string, required): documentId from cad.open_file or cad.create_document.
- `format` (string): Default png. Ask for svg only when the caller needs vector output: model space of a real drawing can emit tens of MB of SVG, which large clients refuse to render.
- `handle` (string): Layout, block or named-view handle, from cad.list_render_views. Required unless view=model.
- `handles` (array): Zoom to these entities (hex handles) instead of giving a region. Model space or block views only.
- `height` (integer): Default 1000.
- `hideLayers` (array): Do not draw these layers. Combines with onlyLayers.
- `imageForModel` (boolean): Hand the picture to you as an image block as well. Off by default where the host draws the widget: the user already sees the render, and the image block is the same bytes again. Set it true when you…
- `layer` (string): Zoom to everything on this layer (case-insensitive).
- `onlyHandles` (array): Draw only these entities (hex handles) of the viewed space; a block reference stands for everything it places. Unlike handles/layer, which only zoom, this hides everything else.
- `onlyLayers` (array): Draw only these layers (names, any case). A view of a few layers is fitted to what remains unless region is given. Layer names come from cad.query_objects or the layers list of cad.show_document.
- `region` (array): [minX, minY, maxX, maxY] in drawing units. Omit to fit the whole view.
- `showLineweights` (boolean): Draw stored lineweights. Off by default: heavy weights hide detail.
- `text` (string): Zoom to TEXT/MTEXT containing this string (case-insensitive). Filters combine with AND; ignored if region is set.
- `title` (string): Caption shown under the picture.
- `view` (string): Default model.
- `width` (integer): Default 1600.

### `cad.viewer_render` (~544 tokens)

Refresh the authenticated viewer image or 3D geometry without consuming tool-call allowance.

Input parameters:

- `background` (string): Canvas background for PNG and SVG: any #RRGGBB color, white, black, or transparent. Defaults to opaque white (black when dark=true). Opaque backgrounds automatically select the light/dark drawing pal…
- `dark` (boolean): Legacy background choice: true=opaque black, false=opaque white. For transparent output, selects the drawing's light/dark palette.
- `documentId` (string, required): documentId from cad.open_file or cad.create_document.
- `format` (string): Default png. Ask for svg only when the caller needs vector output: model space of a real drawing can emit tens of MB of SVG, which large clients refuse to render.
- `handle` (string): Layout, block or named-view handle, from cad.list_render_views. Required unless view=model.
- `handles` (array): Zoom to these entities (hex handles) instead of giving a region. Model space or block views only.
- `height` (integer): Default 1000.
- `hideLayers` (array): Do not draw these layers. Combines with onlyLayers.
- `layer` (string): Zoom to everything on this layer (case-insensitive).
- `mode` (string): Default 2d. 3d exports model-space GPU geometry for local orbiting.
- `onlyHandles` (array): Draw only these entities (hex handles) of the viewed space; a block reference stands for everything it places. Unlike handles/layer, which only zoom, this hides everything else.
- `onlyLayers` (array): Draw only these layers (names, any case). A view of a few layers is fitted to what remains unless region is given. Layer names come from cad.query_objects or the layers list of cad.show_document.
- `region` (array): [minX, minY, maxX, maxY] in drawing units. Omit to fit the whole view.
- `showLineweights` (boolean): Draw stored lineweights. On by default in the viewer.
- `text` (string): Zoom to TEXT/MTEXT containing this string (case-insensitive). Filters combine with AND; ignored if region is set.
- `title` (string): Caption shown under the picture.
- `view` (string): Default model.
- `viewerToken` (string, required)
- `viewport` (array): [minX, minY, maxX, maxY] actually on screen, when region asks for more. Not drawn; remembered as the camera.
- `width` (integer): Default 1600.

### `cad.create_block` (~83 tokens)

Create an empty named local block definition. basePoint defaults to [0,0,0]. Populate it using cad.add_entities with its returned handle as blockHandle, then place instances using cad.insert_block.

Input parameters:

- `basePoint` (array)
- `documentId` (string, required): documentId from cad.open_file or cad.create_document.
- `name` (string, required)

### `cad.insert_block` (~159 tokens)

Place an existing local block definition. position uses target-space coordinates; scale defaults to [1,1,1], rotation is degrees. targetBlockHandle defaults to model space; use a named block or layout blockHandle to place it there. layer names an existing layer for the new reference (default: the current layer). Cyclic references are refused.

Input parameters:

- `blockHandle` (string, required): Hex object handle.
- `documentId` (string, required): documentId from cad.open_file or cad.create_document.
- `layer` (string): Existing layer name; create it first with cad.create_symbol.
- `position` (array, required)
- `rotation` (number)
- `scale` (array)
- `targetBlockHandle` (string): Hex object handle.

### `cad.create_layout` (~99 tokens)

Create a paper-space sheet with paperWidth/paperHeight in millimetres. Returns layout handle, blockHandle for paper geometry and overall viewportHandle. Add model windows using cad.create_viewport. Render using view=layout and the layout handle.

Input parameters:

- `documentId` (string, required): documentId from cad.open_file or cad.create_document.
- `name` (string, required)
- `paperHeight` (number, required)
- `paperWidth` (number, required)

### `cad.create_view` (~99 tokens)

Save a named untwisted orthographic top view: center [x,y], width and height in model units. Render using view=named and its handle, or place it on a sheet using cad.create_viewport.

Input parameters:

- `center` (array, required)
- `documentId` (string, required): documentId from cad.open_file or cad.create_document.
- `height` (number, required)
- `name` (string, required)
- `width` (number, required)

### `cad.create_viewport` (~126 tokens)

Place a saved top view on a paper layout. center [x,y], width and height use paper millimetres. Copies the camera and fits the complete view preserving aspect ratio; later named-view edits do not change the window. The layout's overall viewport is managed automatically.

Input parameters:

- `center` (array, required)
- `documentId` (string, required): documentId from cad.open_file or cad.create_document.
- `height` (number, required)
- `layoutHandle` (string, required): Hex object handle.
- `viewHandle` (string, required): Hex object handle.
- `width` (number, required)

### `cad.report_issue` (~209 tokens)

Report an issue

Email a sanitized Drawing MCP Server issue to the maintainer. Show the report for review and call only after explicit user approval. Free of CAD call quota; no drawing or credentials are attached automatically. Generate one UUID reportId and preserve the exact payload for authorized retries; never retry automatically after a timeout. Optional contact requires an explicitly supplied reporterEmail; no account lookup is performed. Optional host-supplied attachment bytes only: never invent base64 or read server paths.

Input parameters:

- `approved` (boolean, required): User approved this report and every attachment.
- `attachments` (array): User-approved txt/log/json/csv/png/jpg/jpeg/pdf bytes, 5 MiB combined. DWGs and filesystem paths are not accepted.
- `body` (string, required)
- `contactPreference` (string)
- `environment` (object)
- `reportId` (string, required)
- `reporterEmail` (string): Explicit contact address only for opted-in contact. Omit for none.
- `title` (string, required)

## Diagnostics

Captured diagnostic sections: Provenance, Dependencies. The full working is on the page: https://verifymcp.io/servers/net-dmytro-prototypes-drawing-mcp-server/dmytro-prototypes-cad-drawing-mcp-server#diagnostics

## Score history

- 2026-11-22: 62
- 2026-11-21: 61
- 2026-11-20: 61
- 2026-11-19: 60
- 2026-11-18: 60
- 2026-11-17: 44
- 2026-11-16: 58
- 2026-11-15: 58
- 2026-11-14: 43

## Common questions

### What is the Drawing MCP Server server?

Drawing MCP Server is listed in the public MCP registry as net.dmytro-prototypes/drawing-mcp-server. Read, query, edit and render DWG drawings with AI. No AutoCAD required. This page covers its npm package (@dmytro-prototypes/cad-drawing-mcp-server).

### Is the Drawing MCP Server server safe to use?

Drawing MCP Server scores 62 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 22 November 2026. It declares no install or post-install scripts. 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 Drawing MCP Server server expose?

Drawing MCP Server exposes 34 tools: cad.license_status, cad.sign_in, cad.show_document, cad.list_roots, cad.open_file, and 29 more. Their descriptions and schemas cost roughly 5,333 tokens of context every time the server is loaded.

### Is the Drawing MCP Server server still maintained?

Drawing MCP Server is still listed as active in the MCP registry. We last reached this channel on 22 November 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

### What did VerifyMCP test on the Drawing MCP Server server?

VerifyMCP ran 15 checks on Drawing MCP Server, covering Malware scan, Known CVEs, Install scripts, Dependency health and 11 more. 2 items could not be completed, a gap on our side rather than a finding about Drawing MCP Server: License and Security disclosure. Endpoint Security and Transport & Reachability do not apply to an npm package, so they were not tested. The score does not measure everything, and the scoring documentation lists what it leaves out.

## Links

- npm package: https://www.npmjs.com/package/@dmytro-prototypes/cad-drawing-mcp-server
- Socket report: https://socket.dev/npm/package/@dmytro-prototypes/cad-drawing-mcp-server
- Website: https://dmytro-prototypes.net/products/drawing-mcp-server
- Changelog RSS feed: https://verifymcp.io/servers/net-dmytro-prototypes-drawing-mcp-server/dmytro-prototypes-cad-drawing-mcp-server.xml
- Changelog JSON feed: https://verifymcp.io/servers/net-dmytro-prototypes-drawing-mcp-server/dmytro-prototypes-cad-drawing-mcp-server/changelog.json
- Trust report (JSON): https://verifymcp.io/servers/net-dmytro-prototypes-drawing-mcp-server/dmytro-prototypes-cad-drawing-mcp-server.json
- HTML version of this page: https://verifymcp.io/servers/net-dmytro-prototypes-drawing-mcp-server/dmytro-prototypes-cad-drawing-mcp-server
