Skip to main content
Glama
Keystone for Vectorworks

Keystone for Vectorworks

Keystone for Vectorworks

Claude zeichnet in deiner offenen Vectorworks-Datei – exakt und sauber organisiert. Für Architekturpläne in 2D: Flächen schließen lückenlos und ohne Überlappung aneinander, Bögen sind echte Bögen, jedes Objekt liegt in der richtigen Klasse und Ebene. Claude prüft seine Arbeit selbst und korrigiert Fehler, bevor du sie siehst.

Beta. Getestet mit Vectorworks 2026 (Update 7, deutsch) auf macOS; Vectorworks 2027 ist vorbereitet (Python 3.14, neue Funktionen im Signatur-Index), aber noch nicht live getestet. Speichere deine Datei, bevor du Claude zeichnen lässt. Fork von giorgiomoroder/vectorworks-mcp (MIT), dessen Original-README unter docs/README-upstream.md liegt.

Was Claude damit kann

Zeichnen

Polygone, Polylinien mit echten Bögen, Rechtecke, Kreise, Bögen, Linien, Text, Bemaßung und Maßketten. Maße in mm/cm/m, auch als Maßkette (relativ) – exakt gerechnet (3650 mm = 3,65 m, nicht 3,6499999). Nach jedem Zeichnen liest Claude zurück, was Vectorworks gespeichert hat, und meldet die Abweichung (soll: 0).

Prüfen

Überlappungen und übereinanderliegende Füllflächen, Spalte und Lücken zwischen Nachbarn, Punkte, die knapp danebenliegen, doppelte Flächen und Doppellinien, offene oder sich selbst schneidende Umrisse, überflüssige Punkte, Splitterflächen, Objekte ohne Klasse, Attribute nicht „nach Klasse“. Gemessen an der exakten Geometrie (auch an Bögen), Genauigkeit 0,005 mm. Dazu ein Prüfbild mit nummerierten Fehlern.

Korrigieren

Punkte exakt fangen (Spalte und kleine Überlappungen verschwinden, Bögen bleiben auf ihrem Kreis, Kanten behalten ihre Richtung – Wände bleiben rechtwinklig), Umrisse schließen, Punkte bereinigen (Knotenpunkte an T-Stößen bleiben), Doppeltes löschen, Überlappungen wegschneiden (das oben liegende Objekt gewinnt – das Bild bleibt gleich), Teile zu einer Fläche vereinigen.

Bearbeiten

Umriss exakt ersetzen, verschieben (auch Punkt auf Punkt), drehen, spiegeln, skalieren, vereinigen, abziehen, schneiden, teilen, versetzen, Attribute/Klasse/Ebene setzen, löschen.

Organisieren

Ebenen und Klassen anzeigen und prüfen, Klassen mit Attributen anlegen (optional mit einer Architektur-Vorlage), Ebenen mit Maßstab anlegen. Neue Objekte bekommen ihre Attribute nach Klasse. Schraffuren und Linienarten aus dem Vectorworks-Zubehör werden automatisch importiert.

Sortieren

Ganze Zeichnungen auf Klassen und Ebenen verteilen – nach Regeln (Klasse/Ebene als Muster wie A-WALL*, Objektart, Text, Stiftfarbe, Strichstärke, Fläche, Größe …), z. B. nach einem DWG-Import. Erst eine Probe („was würde sich ändern, was bleibt übrig?“), dann alles in einem Schritt, der sich als Ganzes zurücknehmen lässt.

Planen (Raumpilot)

Das Planungswissen der vier Raumpilot-Bände (Grundlagen, Wohnen, Arbeiten, Lernen; Wüstenrot Stiftung): Stell- und Bewegungsflächen jedes Einrichtungsgegenstands, Abstände (VDI 6000), Höhen, barrierefreie und rollstuhlgerechte Werte (DIN 18040), Raumgrößen und über 700 Regeln zu Treppen, Türen, Fluren, Aufzügen, Stellplätzen, Rettungswegen, Arbeitsplätzen, Schulen – jeweils mit Buchseite. Räume planen: Claude passt die Standardsituationen des Buchs (WC-Räume, Duschbäder, Bäder, Küchenformen, Essplätze …) an deine Raummaße und Tür an, erzeugt weitere Varianten nach denselben Regeln, prüft alles und zeichnet die gewählte Variante. Gezeichnete Räume prüfen.

Stil

Gezeichnet wird zuerst im Raumpilot-Stil (schlichte Umrisse, Bewegungsflächen hellblau). Das ist nur die erste Ebene: Du legst deinen Bürostil fest (Klassen, Farben, Bewegungsflächen an/aus) und ordnest jedem Element eure eigenen Symbole zu – auch aus einer Bibliotheksdatei.

Ansichten

Detaillierte Symbole für Ansichten und Schnitte (Sanitär, Möbel, Bäume, Personen, Fahrzeuge).

Importe bereinigen

DWG/DXF ohne Dialog importieren und aufnehmen: was angekommen ist, was Vectorworks weggelassen hat (z. B. Kreise und Ringe aus Rhino) und wie zerstückelt die Zeichnung ist. Lose Make2D-/VectorView-Stücke zu Linienzügen verbinden, organische Formen ausdünnen, ohne sie zu verändern (Vorher-Nachher-Bild), gruppieren, nach Bereich in Klassen sortieren, Schnitte mit eigener Prüfvorgabe prüfen.

Dein Profil

Wie Claude arbeitet, stellst du ein: Detailtreue, Teile vereinigen ja/nein/fragen, Flächen, Bögen, Klassen, Attribute, Prüfmodus, ab wie vielen Objekten erst nachgefragt wird, Toleranzen und eigene Regeln in deinen Worten. Was du im Chat verlangst, geht immer vor.

Rückgängig

vw_revert_last macht genau den letzten Schritt von Claude rückgängig (Geometrie, Attribute, Klasse, Name, Stapelreihenfolge – auch Import, Verbinden, Vereinfachen, Gruppieren).

So fragst du Claude zum Beispiel:

  • „Zeichne im EG einen 3,65 × 4,80 m Raum mit 24 cm Wänden in Klasse Wand-Tragend.“

  • „Zeichne die Cavea als Ringe mit echten Bögen, jeder Ring eine Fläche.“

  • „Prüf die Ebene Grundriss und behebe alle Fehler.“

  • „Räum die Klassen auf: alles, was in ‚Keine‘ liegt, in passende Klassen.“

  • „Sortier den DWG-Import: A-WALL* nach Wand-Tragend, Texte nach Beschriftung, Bemaßungen nach Bemaßung.“

  • „Plan mir ein Duschbad mit WC, 1,60 × 1,65 m, Tür unten links, zeig mir die Varianten.“

  • „Wie viel Platz braucht ein rollstuhlgerechtes WC? Mit Quelle.“

  • „Prüf das Bad auf Ebene EG – stimmen die Bewegungsflächen?“

  • „Nimm statt der Keystone-Symbole unsere Bürosymbole aus Bibliothek.vwx: WC = ‚WC Geberit‘, Waschtisch = ‚WT 60‘.“

  • „Zeichne vor die Fassade drei Bäume und zwei Personen in der Ansicht.“

  • „Importier /Users/…/schnitt.dwg und sag mir, ob alles angekommen ist.“

  • „Bereinige den Schnitt: Schnittlinien 0,5 mm, Ansicht 0,18 mm, die Vorhänge vereinfachen und gruppieren.“

  • „Merk dir: Bestand immer organisch lassen, nur vereinfachen.“ (eigene Regel im Profil)

Related MCP server: PlanPilotMCP

Installation (macOS, ca. 2 Minuten)

Du brauchst Vectorworks 2026 oder 2027 und die Claude-Desktop-App.

1. Erweiterung installieren

  1. Keystone-for-Vectorworks.mcpb herunterladen

  2. Doppelklicken – Claude Desktop öffnet sich und zeigt „Keystone for Vectorworks“ – Installieren klicken.

Das war's: Python und alle Pakete holt sich die Erweiterung selbst (mit uv, nach ~/.vwmcp), die kleine Brücke kopiert sie bei jedem Start in den Plug-in-Ordner jeder Vectorworks-Version ab 2026 auf deinem Mac (und hält sie aktuell – ein laufendes Vectorworks lädt die neue Brücke selbst nach). Terminal, git oder Xcode brauchst du nicht.

Der allererste Start lädt Python und Pakete (1–2 Minuten). Zeigt Claude danach keine Vectorworks-Werkzeuge oder einen Fehler bei der Erweiterung, Claude einmal beenden und neu öffnen – ab dann startet sie in 2 Sekunden. Log: ~/.vwmcp/extension.log.

curl -LsSf https://raw.githubusercontent.com/seraphinernst4/vectorworks-2d-mcp/main/scripts/install-macos.sh | bash

Lädt die Erweiterung, entfernt einen alten Eintrag „vectorworks“ aus der Claude-Konfiguration (mit Sicherung; Claude Desktop wird dafür kurz beendet), trägt den Server in Claude Code ein, falls vorhanden, bereitet Python und Pakete vor (dann ist auch der erste Start schnell) und öffnet die Erweiterung in Claude Desktop – dort Installieren klicken.

2. In Vectorworks: nichts einzurichten

Seit Version 0.5 startet Keystone seine Brücke in Vectorworks direkt (über AppleScript und VectorScript PythonExecute, so wie Vectorworks es dokumentiert). Ein Menübefehl ist nicht mehr nötig. Hat Vectorworks schon offen gehabt, als du die Erweiterung zum ersten Mal installiert hast, findet es die Brücke trotzdem.

In Claude ▸ Einstellungen ▸ Erweiterungen ▸ Keystone for Vectorworks ▸ Konfigurieren ▸ Auslöser menu eintragen und einmalig den Menübefehl anlegen:

  1. Extras ▸ Plug-ins ▸ Plug-in-Manager… ▸ Register Eigene Plug-ins ▸ Neu… (englisch: Tools ▸ Plug-ins ▸ Plug-in Manager… ▸ Custom Plug-ins ▸ New…)

  2. Typ Befehl, Name genau MCP Run Job, OK.

  3. Den Befehl auswählen ▸ Skript bearbeiten… ▸ Sprache Python, einfügen:

    from vwmcp import vwmcp_bridge
    vwmcp_bridge.run_pending()

    OK, dann Schließen.

  4. Extras ▸ Arbeitsumgebungen ▸ Aktuelle Arbeitsumgebung bearbeiten… ▸ Register Menüs: MCP Run Job (links unter Sonstiges) in ein Menü rechts ziehen, z. B. Extras. OK.

3. Ausprobieren

Mit einer offenen Zeichnung in Vectorworks schreibst du Claude: „Ping Vectorworks.“ Beim ersten Mal fragt macOS, ob Claude Vectorworks steuern darf – OK klicken.

Update: Ist eine neue Version da, unterbricht Claude und besteht darauf, dass du gleich aktualisierst (ab 0.6.5 bei jedem Werkzeugaufruf, vorher nur beim Ping). Sag „Ja“ oder „Aktualisiere Keystone“: Claude sucht die neueste Version heraus, legt sie in deinen Download-Ordner und öffnet den Installationsdialog – du klickst nur noch Aktualisieren. Sagst du „nicht jetzt“, arbeitet Claude weiter und erinnert dich am Ende jeder Antwort. (Von Hand: neue .mcpb herunterladen und doppelklicken.) Vectorworks 2027: nichts einstellen – Keystone spricht mit dem Vectorworks, das gerade läuft. Nur wenn 2026 und 2027 gleichzeitig offen sind, entscheidet die Einstellung Claude ▸ Einstellungen ▸ Erweiterungen ▸ Keystone for Vectorworks ▸ Konfigurieren ▸ Vectorworks-Version (z. B. 2027). Die Brücke legt die Erweiterung auch in den Plug-in-Ordner von 2027.

Optional: Skill für Claude

Die Zeichenregeln stecken schon im Server. Wer möchte, kann zusätzlich den Skill skill/vectorworks-2d/SKILL.md in Claude hinzufügen (Einstellungen ▸ Funktionen ▸ Skills). Er beschreibt den Arbeitsablauf ausführlicher und lässt sich an euren Klassenstandard anpassen.

So arbeitet Claude damit

  1. Struktur lesen (vw2d_structure): welche Ebenen, Klassen, Maßstäbe gibt es?

  2. Zeichnen (vw2d_draw) in der richtigen Ebene und Klasse – exakt.

  3. Prüfen (vw2d_check) mit Prüfbild.

  4. Korrigieren (vw2d_fix) und erneut prüfen – bei neuen Zeichnungen bis keine Fehler mehr da sind, bei Importen und Schnitten nur, was du willst (einstellbar im Profil).

  5. Zeigen (vw2d_select): Claude markiert, was es gezeichnet hat.

Alle Werkzeuge: vw2d_read, vw2d_structure, vw2d_resources, vw2d_setup, vw2d_draw, vw2d_edit, vw2d_transform, vw2d_boolean, vw2d_offset, vw2d_set_attributes, vw2d_delete, vw2d_check, vw2d_preview, vw2d_fix, vw2d_select, vw2d_organize, vw2d_assets, vw2d_place_asset, vw2d_import, vw2d_join, vw2d_simplify, vw2d_group, vw2d_profile, die Planungswerkzeuge vw2d_knowledge, vw2d_plan_room, vw2d_check_room, vw2d_place_element, vw2d_style, dazu vw_update und aus dem Original vw_ping, vw_document_info, vw_list_layers, vw_list_classes, vw_get_selection, vw_find_objects, vw_get_record, vw_set_record, vw_list_symbols, vw_insert_symbol, vw_revert_last, vw_exec_python, vw_vs_lookup. (Die Spotlight-Lichttechnik-Werkzeuge des Originals gibt es mit VWMCP_SPOTLIGHT=1.)

Gut zu wissen

  • Rückgängig: Vectorworks fasst mehrere Claude-Schritte zu einem Cmd-Z zusammen. Einen einzelnen Schritt von Claude machst du mit „mach das rückgängig“ (vw_revert_last) rückgängig.

  • Offene Dialoge: Nimmt Vectorworks einen Auftrag nicht innerhalb von 15 Sekunden an (meist, weil ein Dialog offen ist), bricht Claude ihn ab – und er läuft garantiert nicht später nach, wenn du den Dialog schließt. Dialog schließen, nochmal fragen.

  • Lange Aufträge (z. B. eine Prüfung großer Pläne): Hat Vectorworks einen Auftrag angenommen, wartet Claude bis zu 10 Minuten auf das Ergebnis. Gemessen mit 10 000 Objekten: prüfen 2,4 s, Duplikate löschen 5 s, Überlappungen wegschneiden 5 s, sortieren 1,2 s, jeweils rückgängig ~1 s.

  • Keine Skriptfehler-Fenster mehr durch falsche Aufrufe: Jeder vs.*-Aufruf wird vorher gegen die Signaturen aller ~3200 Vectorworks-Funktionen geprüft (Anzahl und Art der Argumente, Farben als Tupel, Callbacks). Statt des modalen Fensters „Skriptfehler“ bekommt Claude eine klare Meldung mit der richtigen Signatur und korrigiert sich selbst.

  • Gerade gestartet? In den ersten ~20 Sekunden nach dem Start von Vectorworks lehnt Keystone Aufträge ab („still starting“) – Skripte während des Starts bringen Vectorworks 2026 zum Absturz. Kurz warten, dann nochmal fragen.

  • Vectorworks abgestürzt oder beendet? Merkt Keystone innerhalb von ~2 Sekunden und meldet es, statt bis zu 10 Minuten auf ein Ergebnis zu warten.

  • Exakt heißt: Koordinaten werden ungerundet durchgereicht und zurückgelesen. Rechenrauschen von Vectorworks' Booleschen Operationen (z. B. 26,999999999999996 statt 27) wird automatisch auf die exakten Eingangswerte zurückgesetzt.

  • Log: Fehler der Brücke stehen in ~/.vwmcp/vwmcp.log.

Deine Zeichnungsdaten

Was Claude aus deiner Zeichnung liest (Koordinaten, Namen, Klassen, Texte), geht als Teil deiner Unterhaltung an Anthropic. Die .vwx-Datei selbst wird nicht hochgeladen. Bei Projekten mit Vertraulichkeitsvereinbarung vorher prüfen, ob das erlaubt ist. Die Brücke läuft komplett auf deinem Mac (~/.vwmcp/). Für die Update-Meldung fragt Keystone alle paar Stunden bei GitHub nach der Versionsnummer – ohne Daten von dir; abschalten mit VWMCP_UPDATE_CHECK=0.

Fehlersuche

Problem

Lösung

„did not take the request within 15s“

Zeichnung öffnen, Dialoge schließen, nochmal fragen. Der abgebrochene Auftrag läuft nicht nach. (Nur mit Auslöser menu: prüfen, ob MCP Run Job in einem Menü liegt.)

„VSArgumentError: vs.… not called“

Kein Problem: ein falscher Aufruf wurde abgefangen, bevor er Vectorworks erreicht hat. Claude korrigiert ihn.

„is not running“ / „still starting“

Vectorworks öffnen und ein paar Sekunden warten.

Fenster „Skriptfehler“ in Vectorworks

Selten geworden (falsche Argumente fängt Keystone ab). OK klicken und Claude bitten, es anders zu versuchen.

vw_ping warnt wegen der Brücken-Version

Nochmal pingen (Keystone lädt die neue Brücke selbst nach); hilft das nicht, Vectorworks neu starten.

Werkzeuge doppelt („vectorworks“ und „Keystone for Vectorworks“)

Terminal-Installer einmal ausführen – er entfernt den alten Eintrag.

Keine macOS-Nachfrage, nichts passiert

Systemeinstellungen ▸ Datenschutz & Sicherheit ▸ Automation: Claude darf Vectorworks steuern.

Für Entwickler

uv sync
uv run pytest -q          # Server-Logik; Code, der in Vectorworks läuft, wird live getestet
uv run vwmcp              # Server über stdio
scripts/build-mcpb.sh     # baut release/Keystone-for-Vectorworks.mcpb (braucht node)
python scripts/live_test.py        # Live-Test gegen das laufende Vectorworks (Protokoll,
                                   # Signaturprüfung, Fallstricke, Regression)
python scripts/trigger_bench.py    # misst die AppleScript-Auslösung
python tools/build_vs_index.py <vs.py> --vwx <vwx vs_index.json> \
    --versions "<Functions By Version.md>" --reference "<Function Reference/Functions>"
                                   # Signatur-Index neu bauen (neues SDK)

Die Erweiterung (mcpb/: Manifest, Abhängigkeiten, Startdateien) ist eine Node-Erweiterung: server/index.js läuft mit dem Node von Claude Desktop, sucht uv (oder lädt es einmal nach ~/.vwmcp/uv) und startet damit server/main.py (Python und Pakete in ~/.vwmcp/venv). Den Verbindungsaufbau (server/discover, initialize, erste tools/list) beantwortet der Starter sofort aus server/static.json, das der Build aus dem echten Server erzeugt – Claude bricht Verbindungen ab, die darauf nicht in ~3 s antworten. Der Server-Code liegt als Quelltext bei. Version: src/vwmcp/__init__.py.

Aufbau: vw-plugin/ ist die Brücke in Vectorworks (atomares Job-Protokoll, geprüfter vs-Proxy, Bibliotheks-Cache; Python 3.9 und 3.14), src/vwmcp/data/vs_index.json der Signatur-Index, src/vwmcp/vwlib2d.py läuft in Vectorworks (Python 3.9!), src/vwmcp/geom/ rechnet auf dem Server (exakte Bögen, Prüfungen, Korrekturen, Prüfbild), src/vwmcp/tools/draw2d.py sind die MCP-Werkzeuge. Details in CLAUDE.md, docs/architecture.md, docs/api-pitfalls.md und docs/vs-notes.md. Änderungen: CHANGELOG.md.

Lizenz

MIT – © giorgiomoroder (Original) und Seraphin Ernst (2D-Werkzeuge). Enthält Material aus vwx-mcp (MIT, © vicquick: Beschreibungen im Signatur-Index, Index-Builder, API-Fallstricke) und folgt dem Job-Protokoll von vwmcp (MIT, © Matt Adcock; Fallstricke-Liste). Signaturen und Parametertypen aus Vectorworks' developer-scripting. Details in NOTICE.

Available Tools

28 tools
vw2d_booleanA

Exact area operations (Vectorworks/Parasolid, arcs stay arcs): union (targets + tools become ONE area, e.g. a ring from its pieces), subtract (tools cut out of each target, tools stay unless keep_tools=False), intersect, split (each target cut by the line split_line [[x1, y1], [x2, y2]]). Results keep the first target's class and attributes; floating-point noise is snapped back to the exact input coordinates. One undo step.

Inputs: targets (required), operation (required), unit, tools, +2 more.

vw2d_checkA
Read-only

Check drawing quality on the exact geometry and return a report (and a check image with numbered issues).

Finds: overlaps and stacked fills, gaps and slivers between neighbours, points that miss each other or an edge by up to tolerance_mm, duplicates, double lines, open or self-intersecting outlines, duplicate/redundant vertices, slivers and tiny objects, objects without class, attributes not 'by class'. Overlaps/gaps are compared between objects on the same layer (compare="layer"), the same class ("class") or everything ("all"); ignore_classes (e.g. ["Ausstattung*", "Schraffur"]) leaves out classes that overlap on purpose. checks: subset of overlap, duplicate, near, gap, self_intersection, open, double_line, vertices, tiny, classes, attributes, approx. Each issue suggests a vw2d_fix action. bbox [x1, y1, x2, y2] checks only objects touching that area (fast on big drawings). Precision: 0.005 mm; distances are measured on true arcs.

Inputs: bbox, image, layer, uuids, +7 more.

vw2d_deleteB
Destructive

Delete objects (restorable with vw_revert_last).

Inputs: uuids (required).

vw2d_drawA

Draw exact 2D objects (all or nothing, one undo step).

Each item has a "type" plus geometry; optional "class", "layer", "name", "attributes", "unit" override the call-level defaults:

  • polygon / polyline: {"points": [[x, y], ...], "relative": false, "holes": [[[x, y], ...]]}. relative=true: points after the first are offsets (exact decimal sums, like a Maßkette).

  • path (lines + true arcs): {"start": [x, y], "segments": [ {"line_to": [x, y]}, {"arc_to": [x, y], "center": [cx, cy], "direction": "ccw"|"cw"} | {"arc_to": [x, y], "through": [x, y]} | {"arc_to": [x, y], "radius": r, "direction": "ccw", "large": false}], "closed": true, "holes": [path or points]}

  • rect: {"corner": [x, y], "width": w, "height": h, "angle": 0} or {"p1": [x, y], "p2": [x, y]}

  • circle {"center", "radius"}; arc {"center", "radius", "start_angle", "sweep"} or {"start", "through", "end"}; oval {"center", "width", "height", "angle"}; line {"p1", "p2"}; locus {"point"}

  • text {"text", "position", "size" (pt), "font", "align" left|center|right, "valign" top|center|baseline|bottom, "angle"}

  • dimension {"p1", "p2", "offset", "orientation" horizontal|vertical|aligned}; chain_dimension {"points": [...], ...} attributes: pen, fill ("none" or "#rrggbb"), hatch (name), line_style, line_weight (mm), opacity; without any, everything is 'by class'. Every object needs a class (class_name or per item) unless allow_no_class=True. Returns each object's uuid and its exactness (deviation between request and what Vectorworks stored), plus any check issues involving the new objects.

Inputs: items (required), unit, check, layer, +4 more.

vw2d_editA

Replace the outline of a polygon/polyline/rect exactly.

Give one of: points [[x, y], ...] (corners), path (same format as vw2d_draw paths, lines + true arcs) or raw vertices [[x, y, type, radius]] as returned by vw2d_read. holes: list of point lists or paths. Same vertex count and no holes: edited in place (uuid stays), otherwise rebuilt with the same class, attributes, name, group and stacking position (new uuid returned). One undo step.

Inputs: uuid (required), path, unit, holes, +4 more.

vw2d_fixA

Fix check issues exactly, then check again (one undo step).

snap: points that miss a vertex/edge by <= tolerance_mm move exactly onto it (gaps and small overlaps disappear); objects in fixed never move; share_vertices inserts the point into the neighbour's edge so both share the node. Arcs keep their circle. close: close open outlines (end point merged with the start if within the tolerance). clean: remove duplicate and collinear vertices (merge_short=True also merges vertices closer than the tolerance). duplicates: delete duplicate areas/lines (the top copy stays). overlaps: clip overlapping areas: priority (uuids or class names, first wins) keeps its area; without priority the object on top wins, so the drawing looks the same but has no stacked fills. merge: union all objects in scope (or uuids) into one area. by_class: set every graphic attribute of the scoped objects to 'by class'. issue_ids limits the fix to issues from the last vw2d_check with the same scope/settings.

Inputs: action (required), fixed, image, layer, +10 more.

vw2d_offsetA

Offset a polygon/polyline outline by distance (positive = outwards for counter-clockwise outlines), e.g. wall thickness or a plaster layer. replace=True swaps the original for the result.

Inputs: uuid (required), distance (required), unit, replace, +1 more.

vw2d_previewB
Read-only

Check image of a scope, rendered from the exact geometry with issues marked (red errors, orange warnings, arrows = where vw2d_fix snap would move a point). focus_issue zooms to one issue id from vw2d_check; bbox [x1, y1, x2, y2] shows (and checks) only that area (document units).

Inputs: bbox, layer, uuids, compare, +6 more.

vw2d_readA
Read-only

Read 2D objects with their exact geometry and attributes.

Scope: uuids, or selection=True, or layer ("*" = all design layers), optionally filtered by class_name. Default: the active layer. Geometry is exact, in document units: polygons/polylines give vertices [x, y, type, radius] (type 0 corner, 3 arc control vertex) plus holes, rects give corners/angle, arcs center/radius/start_angle/sweep, lines p1/p2, texts origin/size/font. Objects inside groups are listed after their group with "parent". bbox [x1, y1, x2, y2] limits the read to an area.

Inputs: bbox, layer, limit, uuids, +3 more.

vw2d_resourcesB
Read-only

List hatches or line types (document + Vectorworks default content, imported automatically when used), or classes / layers of the document. query filters by substring, e.g. "Beton", "ISO-02".

Inputs: kind (required), limit, query, include_defaults. Returns: result

vw2d_selectB
Read-only

Select objects in Vectorworks (and zoom to them) so the user sees what was drawn or changed.

Inputs: uuids (required), zoom.

vw2d_set_attributesA

Change class, layer or graphic attributes of objects.

class_name: put the objects into this class (created if missing). layer: move them to this design layer. attributes: pen, fill ("none" | "#rrggbb"), hatch, line_style, line_weight (mm), opacity, name, or {"by_class": true} to make every graphic attribute follow the class (recommended). Any single value "class" = that attribute by class. One undo step.

Inputs: uuids (required), layer, attributes, class_name.

vw2d_setupA

Create or update classes and design layers so drawings are organised.

classes: [{"name": "Wand-Tragend", "attributes": {"pen": "#000000", "fill": "#000000" | "none", "hatch": "Beton SRF", "line_weight": 0.5 (mm), "line_style": "solid" | "ISO-02 Strichlinie", "opacity": 100}}]. Class attributes are what objects use 'by class' (the default for new objects). Use "-" for class hierarchy ("Wand-Tragend"). layers: [{"name": "EG", "scale": 100}] (design layers, scale 1:100). template "architektur": a starting set of German architecture classes (walls, columns, openings, stairs, furniture, axes, dimensions, text...); only use it if the document has no class standard yet and the user agrees. Existing classes keep their name; given attributes are applied.

Inputs: layers, classes, template, active_class, +1 more.

vw2d_structureA
Read-only

Layers and classes of the document and how they are used: objects per layer and class, class attributes, and organisation problems (objects in the none class, unused classes, empty layers, objects with their own attributes instead of 'by class', dimensions/texts outside their classes, inconsistent design layer scales). Read this before drawing so new objects follow the document's structure.

Inputs: no named parameters.

vw2d_transformA

Move, rotate, mirror or scale objects (copy=True keeps the originals).

move: dx/dy, or from_point -> to_point (exact difference, e.g. a corner onto another object's corner); rotate: center + angle (degrees, ccw); mirror: axis [[x1, y1], [x2, y2]]; scale: center + sx (+ sy). One undo step.

Inputs: uuids (required), operation (required), dx, dy, +9 more.

vw_document_infoA
Read-only

Active document: name, path, units, active layer/class, counts, selection size.

Inputs: no named parameters.

vw_exec_pythonA

Run arbitrary Python inside Vectorworks with vs in scope.

Returns stdout, the value of the last expression (or of a variable named result), and the traceback if it raised. Vectorworks embeds Python 3.9. Handles are only valid during the call; return UUIDs (vs.GetObjectUuid) to refer to objects later. A wrong vs.* signature can pop a modal "Script Errors" dialog in Vectorworks instead of raising; check with vw_vs_lookup first. Set modifies_document=False for read-only code; otherwise vw_revert_last can't step past this call.

Inputs: code (required), modifies_document.

vw_find_objectsB
Read-only

Find objects by any combination of exact class, layer, type ("Symbol", "Rectangle", "Plug-in Object"...), plug-in name ("Lighting Device"), attached record (optionally with field == value) and object name.

Inputs: name, field, layer, limit, +5 more. Returns: result

vw_get_recordB
Read-only

All field values of a record (or a plug-in object's parameters, using its plug-in name as the record) on the object with this UUID.

Inputs: uuid (required), record (required). Returns: object

vw_get_selectionB
Read-only

Selected objects on the active layer: uuid, type, name, class, layer, bbox, attached records, and symbol / plug-in name where relevant.

Inputs: limit. Returns: result

vw_insert_symbolB

Place a symbol from the document's resources at x, y (document units), optionally at height z, on a layer and in a class. One undo step.

Inputs: x (required), y (required), name (required), z, +3 more.

vw_list_classesB
Read-only

All class names, optionally filtered by a case-insensitive substring.

Inputs: name_contains. Returns: result

vw_list_layersB
Read-only

All layers (design and sheet) with visibility and which one is active.

Inputs: no named parameters. Returns: result

vw_list_symbolsB
Read-only

Symbol definitions in the document's resource list, with their folder path; filter by name and/or folder substring (e.g. fixture lookup).

Inputs: limit, folder, name_contains. Returns: result

vw_pingA
Read-only

Check the Vectorworks bridge: returns Vectorworks version, active document and bridge version. Warns if the installed bridge doesn't match this server.

Inputs: no named parameters.

vw_revert_lastA

Undo exactly the last MCP write in the active document: deletes what a tool created, restores objects a tool changed or deleted (geometry, attributes, class, name, group and stacking position) and restores record fields. Call repeatedly to step further back. (Vectorworks' own Cmd-Z merges consecutive MCP edits.) Raw vw_exec_python edits can't be reverted this way. Restored objects get new UUIDs (returned in mapping).

Inputs: no named parameters.

vw_set_recordA

Set record fields (or plug-in parameters) on one object; unknown field names are rejected before anything changes. One undo step. Returns the record afterwards.

Inputs: uuid (required), record (required), values (required). Returns: object

vw_vs_lookupA
Read-only

Search the live vs.* API (names and built-in docs) of the running Vectorworks, e.g. "record field", "symbol insert", "LDevice". Returns function names with their signature/description.

Inputs: query (required), limit. Returns: result

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.6/5.0

    Scored across 28 tools

    Disambiguation4/5

    Most tools have crisp boundaries: draw/edit/transform/boolean/check/fix form a clear pipeline, and the document-query tools (get_selection, find_objects, list_symbols, get_record) are distinguishable. The one fuzzy zone is document structure inspection, where vw_list_layers, vw_list_classes, vw2d_structure and vw2d_resources all report layers/classes and could be picked interchangeably.

    Naming Consistency4/5

    Nearly everything follows verb_noun with a stable vw_/vw2d_ namespace prefix (get_selection, list_layers, set_record, draw, offset, boolean). The vw2d_ vs vw_ split is meaningful (2D geometry vs document/general) but is not explicitly documented, so an agent has to infer why vw2d_read and vw_get_selection both exist.

    Tool Count3/5

    28 tools is on the heavy side for a single CAD bridge, and a few are thin wrappers (vw_ping, vw_document_info, vw_get_selection) that overlap with richer tools. However, most earn their place because the domain (exact 2D drafting, checking and fixing) genuinely needs that many distinct operations.

    Completeness5/5

    The surface covers the full lifecycle: document inspection, layers/classes setup, resource listing, exact draw/read/edit/transform/boolean, quality check, preview, fix, selection, undo, plus a documented Python escape hatch and API lookup for anything missing. No obvious dead ends for the stated drafting purpose.

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      C
      maintenance
      Enables Claude to control AutoCAD—draw, edit, query, layers, blocks, annotations, screenshots, plot to PDF—using plain language.
      8
      12
      MIT
    • A
      license
      Not graded
      quality
      C
      maintenance
      Enables Claude to read and edit ZWCAD drawings directly, including summarizing drawings, querying layers and entities, reading dimensions and text, and creating lines, text, and blocks.
      1
      MIT
    • A
      license
      A
      quality
      B
      maintenance
      Gives Claude full read/write control of a live Graphisoft Archicad 26 project through roughly 260 tools, spanning modeling, drafting, annotation, queries, documentation and exports. Also lets the model capture views to visually verify its work, with batched edits, strict validation and access to the official JSON API.
      258
      3
      MIT