AutoCAD MCP Server
Provides tools for interacting with AutoCAD, enabling AI agents to create, open, and manage drawings, manipulate entities (lines, circles, polylines, etc.), manage layers and blocks, add annotations and dimensions, perform P&ID operations with CTO symbol library, capture screenshots, and execute arbitrary AutoLISP code. It also supports headless DXF generation when AutoCAD is not available.
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., "@AutoCAD MCP Server Draw a circle with center at 5,5 and radius 3"
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.
AutoCAD MCP Server (NNDK fork)
MCP server for full AutoCAD (primary: AutoCAD 2027) and headless DXF generation. Upstream also supports AutoCAD LT 2024+; this fork’s working environment is full AutoCAD 2027, not LT.
Two backends, one API:
Backend | Runtime | Requires AutoCAD? | Screenshot |
File IPC | Windows Python | Yes — AutoCAD (full) / LT 2024+ (Windows) | Win32 PrintWindow |
ezdxf | Any platform | No (headless) | matplotlib render |
The server exposes 8 consolidated tools (drawing, entity, layer, block, annotation, pid, view, system) over the MCP stdio transport. An MCP client (Claude Desktop, Claude Code, etc.) connects and drives AutoCAD through natural-language requests.
Prerequisites (File IPC backend)
Windows 10/11 (the File IPC backend uses Win32 APIs for focus-free window messaging)
AutoCAD (full) — recommended AutoCAD 2027; or AutoCAD LT 2024+ (Windows AutoLISP). AutoCAD LT for Mac does not support AutoLISP.
Python 3.10+ (Windows native — not WSL Python)
uv package manager (install guide)
The ezdxf headless backend works on any platform (Linux, macOS, WSL) for offline DXF generation without AutoCAD installed.
Russian setup notes for this fork: SETUP.ru.md.
Related MCP server: AutoCAD MCP Server - Codex Edition
Quick Start
1. Clone and install
git clone https://github.com/gpt2nndk/autocad-mcp-nndk.git
cd autocad-mcp-nndk
uv sync2. Load the LISP dispatcher in AutoCAD
Open AutoCAD and load mcp_dispatch.lsp using APPLOAD:
Type
APPLOADin the AutoCAD command lineBrowse to
<repo>/lisp-code/mcp_dispatch.lspClick Load
You should see:
=== MCP Dispatch v3.1 loaded ===andReady for commands via (c:mcp-dispatch)
Tip: Add the file to your AutoCAD Startup Suite (in the APPLOAD dialog) so it loads automatically with every drawing.
3. Configure your MCP client
Add to your MCP client configuration (e.g. Claude Desktop claude_desktop_config.json):
{
"mcpServers": {
"autocad-mcp": {
"command": "C:\\path\\to\\autocad-mcp\\.venv\\Scripts\\python.exe",
"args": ["-m", "autocad_mcp"],
"env": { "AUTOCAD_MCP_BACKEND": "auto" }
}
}
}Key points:
The
commandmust point to the Windows Python inside the project venv (not WSL python).AUTOCAD_MCP_BACKENDcan beauto(default — tries File IPC, falls back to ezdxf),file_ipc(requires AutoCAD), orezdxf(headless only).
Running from WSL
If your MCP client runs in WSL (e.g. Claude Code), launch the server through cmd.exe so it runs as a native Windows process:
{
"mcpServers": {
"autocad-mcp": {
"type": "stdio",
"command": "cmd.exe",
"args": ["/d", "/s", "/c", "cd /d C:\\path\\to\\autocad-mcp && .venv\\Scripts\\python.exe -m autocad_mcp"],
"env": { "AUTOCAD_MCP_BACKEND": "auto" }
}
}
}4. Verify
From your MCP client, call:
system(operation="status")You should see backend: "file_ipc" if AutoCAD is running, or backend: "ezdxf" for headless mode.
Tools
drawing — File/drawing management
Operation | Description | File IPC | ezdxf |
| Reset to clean drawing (erase all + purge) | Yes | Yes |
| Open an existing drawing | Yes | Yes (DXF) |
| Get entity count and layers | Yes | Yes |
| Save current drawing (to path if given) | Yes | Yes |
| Export as DXF | Yes | Yes |
| Plot to PDF | Yes | No |
| Purge unused objects | Yes | Yes |
| Get system variables by name | Yes | Yes |
| Undo last operation | Yes | No |
| Redo last undone operation | Yes | No |
entity — Entity CRUD + modification
Create: create_line, create_circle, create_polyline, create_rectangle, create_arc, create_ellipse, create_mtext, create_hatch
Read: list, count, get
Modify: copy, move, rotate, scale, mirror, offset*, array, fillet*, chamfer*, erase
*
offset,fillet,chamferare File IPC only (not supported in ezdxf headless backend).
layer — Layer management
list, create, set_current, set_properties, freeze, thaw, lock, unlock
block — Block operations
Operation | File IPC | ezdxf |
| Yes | Yes |
| Yes | Yes |
| Yes | Yes |
| Yes | Yes |
| Yes | Yes |
| No | Yes |
annotation — Text, dimensions, leaders
create_text, create_dimension_linear, create_dimension_aligned, create_dimension_angular, create_dimension_radius, create_leader
pid — P&ID operations (CTO symbol library)
setup_layers, insert_symbol, list_symbols, draw_process_line, connect_equipment, add_flow_arrow, add_equipment_tag, add_line_number, insert_valve, insert_instrument, insert_pump, insert_tank
P&ID symbol insertion requires the CAD Tools Online (CTO) P&ID Symbol Library installed at
C:\PIDv4-CTO\. The ezdxf backend has built-in CTO library support. For the File IPC backend, some P&ID operations require additional LISP helpers — see the P&ID section in the wiki for setup details.
view — Viewport and screenshot
Operation | Description |
| Zoom to show all entities |
| Zoom to a specified window |
| Capture current AutoCAD view as PNG |
Screenshots use PrintWindow (Win32) for the File IPC backend — works even when AutoCAD is minimized or in the background. The ezdxf backend renders via matplotlib.
system — Server management
status, health, get_backend, runtime, init, execute_lisp
execute_lispruns arbitrary AutoLISP code (File IPC only). Passdata: {code: "(+ 1 2)"}. This turns the server into an extensible automation platform — any valid AutoLISP expression can be executed.
Architecture
MCP Client (Claude)
│ stdio (JSON-RPC)
▼
Python MCP Server (autocad_mcp)
│
├── File IPC Backend ──► C:/temp/*.json ──► mcp_dispatch.lsp (AutoCAD)
│ PostMessageW(WM_CHAR) to MDIClient — no focus steal
│
└── ezdxf Backend ──► in-memory DXF (headless, no AutoCAD needed)The File IPC backend sends keystrokes to AutoCAD's MDIClient window via PostMessageW(WM_CHAR), triggering the (c:mcp-dispatch) AutoLISP command. This approach does not steal window focus — you can continue working in other applications while automation runs.
Environment Variables
Variable | Default | Description |
|
| Backend selection: |
|
| Directory for IPC command/result JSON files (must match on both Python and LISP sides) |
|
| IPC command timeout in seconds (1-300) |
|
| Disable screenshot capture (text feedback only) |
Note: If you change
AUTOCAD_MCP_IPC_DIR, you must also update the*mcp-ipc-dir*variable inmcp_dispatch.lspto match.
Development
uv sync
uv run pytest tests/ -vAutoCAD AutoLISP Compatibility
This fork’s primary environment is full AutoCAD 2027.
AutoLISP is available in full AutoCAD. It was also added to AutoCAD LT in the 2024 release (Windows only). AutoCAD LT for Mac does not support AutoLISP.
Supported | Not Supported |
| VLIDE (Visual LISP IDE) |
All | Express Tools (varies by install) |
File I/O ( | AutoLISP on Mac LT |
Entity access ( | |
Selection sets |
On full AutoCAD 2027, ActiveX/COM (vlax-*) and SendCommand are available and preferred when IPC keystrokes fail.
The mcp_dispatch.lsp dispatcher works with full AutoCAD and LT 2024+.
What's New in v3.1
execute_lisp— Run arbitrary AutoLISP code via temp file pattern. Turns the server from a fixed command set into an extensible automation platform.Undo / Redo — Single-step undo and redo via
drawingtool.Drawing open — Open existing
.dwgfiles programmatically (FILEDIA suppressed).Drawing create — Now resets current drawing (erase all + purge) instead of
_.NEW, preserving the LISP dispatcher namespace.Drawing save with path —
savewith apathparameter uses SAVEAS; without path uses QSAVE.get_variablesfix — Respects thenamesparameter; returns requested variables with proper type handling.Polyline/leader fix — Point arrays properly encoded via semicolon-delimited format.
ESC prefix — Sends 2x ESC before each dispatch to cancel stale pending commands from prior timeouts.
UTF-8/cp1252 fallback — Handles non-ASCII characters in LISP result files (AutoCAD writes Windows-1252).
Configurable IPC timeout —
AUTOCAD_MCP_IPC_TIMEOUTenv var (1–300 seconds, default 10).Thread-safe backend init —
asyncio.Lockprevents parallel initialization races.
License
MIT
Available Tools
8 toolsannotationA
Annotation: text, dimensions, and leaders.
Operations: create_text — data: {x, y, text, height?, rotation?, layer?} create_dimension_linear — data: {x1, y1, x2, y2, dim_x, dim_y} create_dimension_aligned — data: {x1, y1, x2, y2, offset} create_dimension_angular — data: {cx, cy, x1, y1, x2, y2} create_dimension_radius — data: {cx, cy, radius, angle} create_leader — data: {points: [[x,y],...], text}
Inputs: operation (required), data, include_screenshot. Returns: result
blockA
Block definition, insertion, and attribute management.
Operations: list — List all block definitions. insert — data: {name, x, y, scale?, rotation?, block_id?} insert_with_attributes — data: {name, x, y, scale?, rotation?, attributes: {tag: value}} get_attributes — data: {entity_id} update_attribute — data: {entity_id, tag, value} define — data: {name, entities: [{type, ...}]}
Inputs: operation (required), data, include_screenshot. Returns: result
drawingA
Drawing file management.
Operations: create — Create a new empty drawing. data: {name?} open — Open an existing drawing. data: {path} info — Get drawing extents, entity count, layers, blocks. save — Save current drawing. data: {path?} (saves to path if given, else QSAVE) save_as_dxf — Export as DXF. data: {path} plot_pdf — Plot to PDF. data: {path} purge — Purge unused objects. get_variables — Get system variables. data: {names: [...]} undo — Undo last operation. redo — Redo last undone operation.
Inputs: operation (required), data, include_screenshot. Returns: result
entityA
Entity creation, querying, and modification.
Create operations: create_line — x1, y1, x2, y2, layer? create_circle — data: {cx, cy, radius}, layer? create_polyline — points: [[x,y],...], data: {closed?}, layer? create_rectangle — x1, y1, x2, y2, layer? create_arc — data: {cx, cy, radius, start_angle, end_angle}, layer? create_ellipse — data: {cx, cy, major_x, major_y, ratio}, layer? create_mtext — data: {x, y, width, text, height?}, layer? create_hatch — entity_id, data: {pattern?}
Read operations: list — layer? → list entities count — layer? → count entities get — entity_id → entity details
Modify operations: copy — entity_id, data: {dx, dy} move — entity_id, data: {dx, dy} rotate — entity_id, data: {cx, cy, angle} scale — entity_id, data: {cx, cy, factor} mirror — entity_id, x1, y1, x2, y2 offset — entity_id, data: {distance} array — entity_id, data: {rows, cols, row_dist, col_dist} fillet — data: {id1, id2, radius} chamfer — data: {id1, id2, dist1, dist2} erase — entity_id
Inputs: operation (required), x1, x2, y1, +6 more. Returns: result
layerA
Layer creation and management.
Operations: list — List all layers with properties. create — data: {name, color?, linetype?} set_current — data: {name} set_properties — data: {name, color?, linetype?, lineweight?} freeze — data: {name} thaw — data: {name} lock — data: {name} unlock — data: {name}
Inputs: operation (required), data, include_screenshot. Returns: result
pidA
P&ID drawing with CTO symbol library.
Operations: setup_layers — Create standard P&ID layers. insert_symbol — data: {category, symbol, x, y, scale?, rotation?} list_symbols — data: {category} draw_process_line — data: {x1, y1, x2, y2} connect_equipment — data: {x1, y1, x2, y2} add_flow_arrow — data: {x, y, rotation?} add_equipment_tag — data: {x, y, tag, description?} add_line_number — data: {x, y, line_num, spec} insert_valve — data: {x, y, valve_type, rotation?, attributes?} insert_instrument — data: {x, y, instrument_type, rotation?, tag_id?, range_value?} insert_pump — data: {x, y, pump_type, rotation?, attributes?} insert_tank — data: {x, y, tank_type, scale?, attributes?}
Inputs: operation (required), data, include_screenshot. Returns: result
systemBRead-only
Server status and management.
Operations: status — Backend info, capabilities, health check. health — Quick health check (ping backend). get_backend — Return current backend name and capabilities. runtime — Return process/runtime details for spawn diagnostics. init — Re-initialize the backend. execute_lisp — Execute arbitrary AutoLISP code (File IPC only). data: {code}
Inputs: operation (required), data, include_screenshot. Returns: result
viewARead-only
Viewport control and screenshot capture.
Operations: zoom_extents — Zoom to show all entities. zoom_window — Zoom to window: x1, y1, x2, y2 get_screenshot — Capture current view as PNG image.
Inputs: operation (required), x1, x2, y1, +1 more. Returns: result
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 8 tools
The eight top-level tools partition AutoCAD work into distinct domains (drawing, view, entity, layer, block, annotation, pid, system), so selection is generally clear. Minor overlap exists between entity.create_mtext and annotation.create_text, and between block insertion and P&ID symbol insertion, but descriptions help resolve them.
The eight tool names are all consistent lowercase single-word nouns (drawing, view, entity, layer, block, annotation, pid, system). Although the internal operations use mixed verb/noun styles, the exposed tool set itself follows a predictable convention.
Eight top-level tools is well-scoped for a broad CAD domain, with each tool grouping related operations rather than exposing a sprawling flat surface. The count avoids both triviality and overwhelming fragmentation.
The surface covers core 2D drafting and P&ID needs: file management, viewport control, entity creation/query/modification, layers, blocks, annotations, and system operations. Minor gaps remain, such as explicit layer deletion/rename, entity property editing beyond geometry, and xref/layout/selection operations.
Related MCP Connectors
Headless CAD engine & MCP server for 2D/3D drafting, solids, DXF/SVG export, and automation.
MCP server for generating rough-draft project plans from natural-language prompts.
Edit AutoCAD and Revit MEP drawings from Claude or ChatGPT in plain English.
Global CAD/BIM, industrial engineering (FEM, CFD) and property tools via one MCP endpoint.
Related MCP Servers
- AlicenseNot gradedqualityCmaintenanceEnables natural-language control of AutoCAD LT for automation and headless DXF generation, supporting drawing, entity, layer, block, annotation, P&ID, and system operations via an MCP interface.MIT
- AlicenseAqualityCmaintenanceMCP server for full AutoCAD automation, AutoCAD LT automation, and headless DXF generation. It provides 8 consolidated tools for drawing, entity, layer, block, annotation, P&ID, view, and system operations via MCP stdio transport.1247MIT
- 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
- FlicenseBqualityBmaintenanceFastMCP server for automating AutoCAD via COM on Windows, enabling drawing creation, entity drawing, and drawing management through natural language commands.46-