<p align="center">
  <img src="assets/logo.png" alt="Open MCP CAD" width="210">
</p>

<p align="center">
  <b>Deutsch</b> · <a href="README.en.md">English</a> · <a href="README.fr.md">Français</a> · <a href="README.it.md">Italiano</a>
</p>

# Open MCP CAD

**Die Brücke zwischen einem KI-Assistenten und deinem laufenden CAD.**

Ein MCP-Server plus CAD-Plugin, über das ein Sprachmodell Geometrie in einem
**geöffneten Cadwork-3D-Dokument** liest und erzeugt — mit Warteschlange,
Freigabe-Karten, Schreiblizenz, Rückgängig-Unterstützung und einem Fenster,
in dem man jederzeit sieht, was gerade läuft.

> **Was hier NICHT drin ist:** Konstruktionslogik. Kein Detail-Katalog, keine
> Bauteil-Generatoren, kein Fachwissen einer Branche. Dieses Repo ist das
> Rohr, nicht das Wasser. Eigenes Fachwissen hängst du über
> `OPEN_MCP_CAD_KNOWLEDGE` ein — siehe [Eigenes Fachwissen](#eigenes-fachwissen).

---

<!-- ki-assistenten:anfang -->
## Für KI-Assistenten (For AI assistants)

Du bist eine KI und sollst Open MCP CAD einrichten? Dann gilt:

- **Der MCP-Server existiert schon.** Er heisst `open-mcp-cad` und startet
  mit `python -m open_mcp_cad.server`. **Baue keinen Adapter, keine Brücke
  und keinen eigenen Server.**
- **Sprich nie selbst mit dem Plugin.** Das Plugin in Cadwork lauscht auf
  `127.0.0.1`, Ports 53127–53199, mit einem internen Protokoll
  (JSON-Zeilen), das nur für diesen Server da ist. Kein KI-Programm
  verbindet sich dort direkt.

Deine Aufgabe ist nur:

1. **Den Installer laufen lassen, falls noch nicht geschehen.** Der Nutzer
   doppelklickt `1_INSTALLIEREN.cmd` oben im entpackten ZIP (neueste
   Fassung: https://github.com/sebastiankoukoui/open-mcp-cad/releases/latest).
   Er kopiert das Plugin nach Cadwork, richtet den Server in
   `%LOCALAPPDATA%\OpenMcpCad\python` ein und bietet am Schluss selbst an,
   Schritt 2 zu erledigen. Installiert ist der Server, wenn
   `"%LOCALAPPDATA%\OpenMcpCad\python\Scripts\python.exe" -c "import open_mcp_cad.server"`
   ohne Fehler endet.
2. **Den Server im KI-Programm eintragen**, falls der Installer es nicht
   getan hat. `<PYTHON>` ist der volle Pfad von
   `%LOCALAPPDATA%\OpenMcpCad\python\Scripts\pythonw.exe` (mit **w**: ohne
   Konsolenfenster). Vorher eine Sicherungskopie der Datei anlegen, nur den
   Eintrag `open-mcp-cad` hinzufügen, alle anderen Einträge unverändert
   lassen.
   - **Codex** (CLI und Desktop-App mit Codex): `%USERPROFILE%\.codex\config.toml`
     (bzw. `%CODEX_HOME%\config.toml`)
     ```toml
     [mcp_servers.open-mcp-cad]
     command = '<PYTHON>'
     args = ["-m", "open_mcp_cad.server"]
     ```
   - **Claude Desktop**: `%APPDATA%\Claude\claude_desktop_config.json`
     (Store-Fassung: unter
     `%LOCALAPPDATA%\Packages\Claude_*\LocalCache\Roaming\Claude\`), im
     JSON Backslashes doppelt
     ```json
     {
       "mcpServers": {
         "open-mcp-cad": { "command": "<PYTHON>", "args": ["-m", "open_mcp_cad.server"] }
       }
     }
     ```
   - **Claude Code**:
     ```
     claude mcp add --scope user open-mcp-cad -- "<PYTHON>" -m open_mcp_cad.server
     ```
3. **Dem Nutzer sagen:** das KI-Programm ganz beenden und neu starten,
   dann in Cadwork im Plugin-Menü auf **Open MCP CAD** klicken, bis die
   kleine Leiste oben rechts **Bereit** zeigt. Danach stehen die Werkzeuge von Open MCP CAD
   (etwa `get_document_info`) im KI-Programm bereit.

ChatGPT im Browser oder am Handy kann keine lokalen MCP-Server benutzen.
Am PC geht es in der ChatGPT-Desktop-App mit Codex (früher Codex-App);
laut OpenAI nutzt sie dasselbe Heim `%USERPROFILE%\.codex` wie die
Codex-CLI.
<!-- ki-assistenten:ende -->

## Warum das existiert

Ein Sprachmodell kann cwapi3d-Code schreiben. Es in ein laufendes CAD zu
bekommen, ist das eigentliche Problem:

- **cwapi3d ist nicht thread-sicher.** Jeder API-Aufruf muss im Hauptthread
  laufen, sequentiell. Wer das ignoriert, bekommt Abstürze, die nicht
  reproduzierbar aussehen.
- **Das CAD darf nicht einfrieren**, während ein Auftrag läuft.
- **Nichts darf unbemerkt am Modell passieren.** Jeder Aufruf gehört in einen
  Verlauf, jeder schreibende Zugriff hinter eine Freigabe.
- **Mehrere Dokumente gleichzeitig** brauchen getrennte Leitungen, die sich
  nicht kreuzen.

Das alles steckt hier drin, gemessen statt behauptet: **über 600 Prüfungen
ohne CAD-Installation**, dazu ein Gate, das die Oberfläche wirklich baut und
bedient.

## Architektur

```
KI-Assistent --stdio--> MCP-Server --TCP 127.0.0.1:53127..53199--> CAD-Plugin
   (Host)              (open-mcp-cad)                              (in Cadwork)
                                                                        |
                                                                     cwapi3d
```

**Beliebig viele Leitungen.** Ein Menüeintrag **Open MCP CAD**, in so vielen
Cadwork-Fenstern gestartet, wie man braucht. Ein Klick öffnet das Dock und
verbindet: jedes Fenster bekommt den nächsten freien Port (53127–53199), ein
eigenes Log und einen eigenen Briefkasten — so bedienst du mehrere Dokumente
parallel, ohne dass sich die Leitungen kreuzen.

Jede Instanz trägt sich mit ihrem **Dokumentnamen** in eine Registry ein. Gefunden wird er
danach über das Dokument, nicht über den Port:

```bat
set OPEN_MCP_CAD_DOC=Seeblick
```

Das ist die Frage, die man wirklich hat. *"Welcher Port bedient Seeblick?"*
stand vorher nirgends — man musste es sich merken. Gewählt wird nur, wenn
**genau eine** laufende Instanz passt. Passen mehrere, oder keine (etwa weil
der Server vor Cadwork gestartet ist), sendet der Client nichts, nennt, was
verbunden ist, und fragt beim nächsten Aufruf neu. Auf einen festen Port
weicht er nie aus: Code in der falschen Datei ist genau der Schaden, den der
Dokumentschutz verhindern soll. Einmal gefunden, bleibt er bei diesem
Fenster, wie unten beschrieben.

Ohne jede Angabe braucht es nicht einmal das: der Server nimmt das **eine**
verbundene Fenster. Sind mehrere verbunden, rät er nicht, sondern antwortet
mit `instanz_waehlen` und der Liste, und die KI wählt mit `wait_for_bridge`.
Einmal gewählt, bleibt er bei diesem Fenster, auch wenn später ein zweites
dazukommt. Wird es geschlossen oder zeigt es eine andere Datei, fragt er
neu — still gewechselt wird nie. (Nur der Server wählt so; Skripte, die
`bridge_client` importieren, bleiben ohne Angabe bei 53127.)

Der Kern steht **einmal** in `cad_plugin/_core/omcad_bridge_core.py`; die
Plugin-Ordner werden daraus erzeugt und byteweise gegengeprüft. Neben dem
ausgelieferten `Open MCP CAD` liegen im Repo `Open MCP CAD A` … `F` mit
festen Ports (53127–53132) — für Tests und Hosts, die einen festen Port
brauchen.

### Wie das CAD bedienbar bleibt

Der TCP-Listener läuft in einem Nebenthread, die Bearbeitung eines Auftrags
ausschliesslich im Hauptthread — über einen `QTimer`, der sich in die
**bestehende** Ereignisschleife des CAD einhängt. Statusabfragen, Pause und
Beenden beantworten die Worker-Threads selbst und warten nie auf einen
laufenden Auftrag.

Arbeitet das CAD gerade selbst im Hauptthread (ein modaler Dialog oder
Fortschrittsdialog, ein offenes Menü, eine verschachtelte
Ereignisschleife), lässt der Takt alle Aufträge in der Warteschlange und
ruft die API nicht auf; `get_connection_status` nennt den Grund
(`cadwork_beschaeftigt`). Anlass war ein Absturz, nachdem zwei Leseaufträge
mitten in einer langen CAD-Berechnung liefen. Je CAD-Prozess läuft
höchstens ein Dienst: ein weiterer Klick auf das Plugin holt den laufenden
zurück, statt einen zweiten Port zu öffnen.

> Der naheliegende Weg — Fensternachrichten aus dem Plugin heraus zu pumpen —
> war nicht die Lösung, sondern die Ursache: er hat nachweislich eine
> Zugriffsverletzung im CAD-Prozess ausgelöst. Die Herleitung steht in
> [`docs/BRIDGE.md`](docs/BRIDGE.md), Abschnitt 2.

## Werkzeuge

| Werkzeug | Was es tut | Über die Brücke? |
|---|---|---|
| `get_document_info` | Dokumentname + Elementanzahl | ja |
| `get_connection_status` | Zustand, laufender Auftrag, Warteschlange, Schreiblizenz — **antwortet auch, während gezeichnet wird** | ja, ohne Hauptthread |
| `execute_cadwork_command` | führt cwapi3d-Python-Code aus (Wartezeit auf die Antwort mit `timeout_s`) | ja |
| `execute_cadwork_batch` | führt denselben Code paketweise über eine JSON-Datenliste aus: grosse Mengen, Fortschritt im Dock | ja |
| `undo` / `redo` | nimmt die letzten Aufträge zurück bzw. stellt sie wieder her (Cadworks eigenes Rückgängig) | ja |
| `set_fast_draw` | schaltet die Bildschirm-Auffrischung während langer Zeichenläufe ab | ja |
| `redraw_view` | zeichnet die Ansicht neu, wenn nach einem Zoom im Auftrag nichts zu sehen ist (ändert das Modell nicht) | ja |
| `report_check_note` | meldet eine Annahme oder Unsicherheit ins CAD-Fenster, mit anklickbaren Element-IDs | ja, ohne Hauptthread |
| `clear_check_notes` | räumt erledigte Prüfhinweise weg | ja, ohne Hauptthread |
| `get_pending_messages` | holt Nachrichten ab, die der Nutzer im CAD hinterlegt hat | ja, ohne Hauptthread |
| `list_stored_keys` / `clear_store` | Session-Speicher der Bridge (Element-ID-Listen) ansehen / leeren | ja |
| `create_from_init` | legt eine neue `.3d` als Kopie einer Vorlage an (überschreibt nie) | nein, lokal |
| `open_document` | öffnet eine `.3d` über die Windows-Verknüpfung | nein, lokal |
| `wait_for_bridge` | wartet, bis genau diese Datei verbunden ist, prüft sie und bindet die Sitzung daran | ja |
| `get_cadwork_api_help` | Module, Funktionen und Signaturen aus den Type-Stubs | nein, lokal |
| `get_working_examples` | geprüfte Code-Beispiele | nein, lokal |
| `get_detail` | Detail-Katalog — **nur mit eingehängtem Fachwissen** | nein, lokal |
| `get_experiences` | Erfahrungen aus früheren Fehlern auf diesem Rechner | nein, lokal |
| `record_experience` | hält fest, was nach einem Fehler geholfen hat | nein, lokal |

**Neue Datei anlegen und verbinden:** `create_from_init` → `open_document` →
einmal auf **Open MCP CAD** klicken (der Nutzer oder der Agent-Host) →
`wait_for_bridge`. Erst danach schreibt ein Auftrag ins Modell.

## Erfahrungen (nur auf diesem Rechner)

Scheitert ein Auftrag am Code (Cadwork meldet eine Python-Ausnahme) und
gelingt danach einer derselben Art, hält der Server das als **Erfahrung**
fest: Fehlertyp und Meldung, die Funktion, an der es scheiterte, was danach
anders war (neue und weggefallene Aufrufe, ein Code-Auszug), Cadwork- und
Kern-Version. Der Agent ergänzt mit `record_experience` in einem Satz, was
geholfen hat. Beim nächsten Start stehen die neuesten Erfahrungen in der
Beschreibung von `execute_cadwork_command`, und ein Fehler, den es schon
gab, bringt seine Erfahrung in der Antwort mit.

Die Datei bleibt auf diesem Rechner, der Server sendet sie nirgends hin.
Was der Agent davon liest (Beschreibung, Antworten), geht wie jeder
Werkzeugtext an den Anbieter seines Modells. Gespeichert wird darum
bereinigt — ohne Pfade, Datei-, Dokument-, Benutzer- und Rechnernamen, ohne
die Beschreibung des Auftrags, ohne Zeichenketten und mehrstellige Zahlen
aus dem Code — und begrenzt (200 Einträge, 256 KB), in
`%LOCALAPPDATA%\OpenMcpCad\erfahrungen.jsonl`. Anderer Ort:
`OPEN_MCP_CAD_ERFAHRUNGEN=<Datei>`; `OPEN_MCP_CAD_ERFAHRUNGEN=aus` schaltet
es ab.

## Eigenes Fachwissen

Das eingebaute Wissen in `open_mcp_cad/knowledge/` handelt ausschliesslich von
der **cwapi3d-Schnittstelle** — Stolperfallen, die jedem begegnen: dass
`cut_element_with_plane` die Anti-Normalen-Seite behält, dass `z_local` die
Drehung bestimmt, dass reine Berechnungen nichts über der Brücke verloren
haben. Jeder Eintrag ist an einem echten Modell verifiziert.

Fachwissen deiner Branche hängst du daneben:

```bat
set OPEN_MCP_CAD_KNOWLEDGE=C:\mein-katalog\knowledge
```

Ein solcher Ordner darf enthalten:

| Datei | Wirkung |
|---|---|
| `rules.md` | Regeln, die **jedem** Auftrag mitgegeben werden. Kurz halten — sie kosten bei jedem Aufruf Tokens. Fehlt `rules.md`, gelten alle `<domäne>_rules.md` des Ordners (alphabetisch). |
| `known_issues.json` | `{"issues": [...]}` — wird angehängt |
| `working_examples.json` | `{"examples": [...]}` — wird angehängt |
| `detail_catalog.json` | `{"details": [...]}` — wird angehängt, versorgt `get_detail` |

Mehrere Ordner mit `;` trennen (Windows). Ein Ordner, den es nicht gibt, wird
**gemeldet** und übersprungen — still schlucken hiesse, man merkt monatelang
nicht, dass die eigenen Regeln nie angekommen sind.

## Installation

**Voraussetzungen:** Windows, Cadwork 3D 2025 oder 2026 (beide getestet;
Plugins laufen in 2026 mit Python 3.14 und PyQt6, in 2025 mit Python 3.12
und PyQt5; ältere Versionen nicht), Python 3.10–3.13 für den MCP-Server (fehlt es, installiert
`1_INSTALLIEREN.cmd` nach Rückfrage Python 3.13 per winget, ohne winget
signaturgeprüft direkt von python.org).

**Als Anwender:** das Paket bauen (oder das ZIP aus den Releases nehmen),
entpacken, `1_INSTALLIEREN.cmd` doppelklicken. Es öffnet ein Einrichtungsfenster
(seit 2026-10-09; mit `-Konsole` oder einem anderen Schalter das Textfenster),
fragt nach den KI-Apps und kopiert dann das Plugin in jedes gewählte
Cadwork-Profil (das Fenster zeigt alle gefundenen Profile mit Häkchen,
vorausgewählt sind alle ab Cadwork 2025, in denen Cadwork installiert ist;
im Textfenster `-Profile "pfad1;pfad2"`, `-Profil` gilt weiter; in ein
Profil einer älteren Cadwork-Version kopiert es nicht), richtet den Server in einem eigenen Python ein und trägt ihn in die gewählten
KI-Programme ein. Details: [`verteilung/ANLEITUNG.md`](verteilung/ANLEITUNG.md)
(auch auf [Englisch](verteilung/ANLEITUNG.en.md),
[Französisch](verteilung/ANLEITUNG.fr.md) und
[Italienisch](verteilung/ANLEITUNG.it.md)).

```bash
python scripts/paket_bauen.py      # -> dist/Open-MCP-CAD-<version>.zip
```

**Updates:** Einmal am Tag fragt das Plugin im Hintergrund bei GitHub
(`api.github.com`, die Seite „neuestes Release“ dieses Repos), ob es eine
neue Version gibt, nie während eines Auftrags. Dabei wird nichts über dich,
dein Modell oder deinen Rechner gesendet (GitHub sieht wie bei jedem Abruf
die IP-Adresse); LignoAI erhält keine Daten. Gibt es eine, steht im Fenster
eine kleine Zeile „Neue Version 0.x.y“ mit „Aktualisieren“. Erst dieser
Klick lädt das Paket `Open-MCP-CAD.zip` des Releases, prüft Grösse,
Prüfsumme (SHA-256) und dass das Installationsprogramm darin liegt, entpackt
es nach `%LOCALAPPDATA%\OpenMcpCad\updates\<version>\` und öffnet daraus
das Einrichtungsfenster; danach steht „Schliesse Cadwork, damit das Update
eingespielt werden kann.“ Nie still, nie ohne Klick. Von Hand: „⋯“ →
„Nach Updates suchen“. Abschalten: Einstellungen, Karte „Updates“, Schalter
„Einmal am Tag nach Updates suchen“ (chat.json `updates_suchen`, der
Zeitpunkt steht in `updates_zuletzt`). Findet das Plugin auf dem PC ein
Cadwork ab 2025, in dem es noch fehlt, fragt es einmal, etwa „Open MCP CAD
auch in Cadwork 2027 einrichten?“: „Einrichten“ öffnet das
Einrichtungsfenster, „ד fragt nicht mehr (chat.json `profil_frage_weg`).

**Als Entwickler:**

```bash
git clone https://github.com/sebastiankoukoui/open-mcp-cad
cd open-mcp-cad
pip install -e .
pip install -e .[stubs]     # optional: API-Hilfe (Type-Stubs cwapi3d)
```

Den Ordner `cad_plugin/Open MCP CAD/` ins Cadwork-Benutzerprofil kopieren:

```
C:\Users\Public\Documents\cadwork\userprofil_<JAHR>\3d\API.x64\Open MCP CAD\
```

> Nur ins Benutzerprofil, **nicht** zusätzlich nach `ProgramData` — sonst
> erscheint das Plugin in Cadwork doppelt.
>
> Nur **diesen einen** Ordner, nicht ganz `cad_plugin/`: `Open MCP CAD A`
> bis `F` sind Prüf-Ordner für die Tests (feste Ports, ohne Fenster). Im
> Cadwork-Menü sehen sie aus wie das Plugin, ein Klick öffnet aber kein
> Fenster.

Gegenprobe, ob Repo und Benutzerprofil übereinstimmen:

```bash
python scripts/deployment_pruefen.py
```

Host-Konfiguration (Beispiel Claude Desktop; unter Windows `pythonw` statt
`python`, sonst blitzt bei jedem Start ein Konsolenfenster auf):

```json
{
  "mcpServers": {
    "open-mcp-cad": { "command": "pythonw", "args": ["-m", "open_mcp_cad.server"] }
  }
}
```

Ohne `env` nimmt der Server das verbundene Cadwork-Fenster (bei mehreren
siehe oben). Ein Eintrag fest auf einen Port oder ein Dokument:
`"env": { "OPEN_MCP_CAD_PORT": "53128" }` oder `"env": { "OPEN_MCP_CAD_DOC": "Seeblick" }`.

**Verwechslungsschutz:** `OPEN_MCP_CAD_EXPECT_DOC` auf einen Teil des
Dateinamens setzen — dann prüft der Server vor **jedem** Aufruf, ob wirklich
das erwartete Dokument offen ist, statt Code in der falschen Instanz auszuführen.

## Prüfen

Alles ohne CAD-Installation — Cadwork wird dabei nie gestartet:

```bash
python tests/test_offline.py       # Zustände, Pause, Beenden, Schreiblizenz, Dokumentschutz
python tests/test_wissen.py        # Fachwissen-Lader
python tests/test_a_prototyp.py    # Dashboard und Chat ohne Qt
python tests/test_registry.py      # Registry und Ports (bindet echte Ports 53127–53199)
python tests/test_bootstrap.py     # Datei-Bootstrap
python tests/test_paket.py         # Verteilpaket
python tests/test_erfahrungen.py   # Erfahrungen: bereinigt, begrenzt, nur lokal
python scripts/plugins_generieren.py --pruefen
```

Mit PyQt6 kommt `tests/test_a_live.py` dazu — es baut die Oberfläche
wirklich und bedient sie, mit Attrappen statt Cadwork.

## Stand und Grenzen

**Was läuft:** die Brücke, beliebig viele Cadwork-Fenster über einen
Menüeintrag, das Dashboard mit Verbindungen, Verlauf, Prüfhinweisen und
Briefkasten, der Chat im selben Fenster, der Datei-Bootstrap, alle Gates.

**Ein Fenster für alles:** Claude Code (Abo), Codex (ChatGPT-Abo, braucht
die Codex-CLI `irm https://chatgpt.com/codex/install.ps1 | iex` oder `npm i -g @openai/codex`) oder jede OpenAI-kompatible
Schnittstelle — OpenAI, Anthropic, OpenRouter per API-Schlüssel (liegt im
Windows-Tresor, das Dock zeigt nur die letzten vier Zeichen), Ollama und LM
Studio lokal (das Dock erkennt und startet sie und installiert sie nach
Rückfrage per winget), oder eine eigene Adresse (auch für Ollama auf einem
anderen Rechner). Der Klick zeigt eine kleine Leiste oben rechts über der
Zeichenfläche (Zustand, Knopf „Chat“, „Trennen“, Andocken; ohne Verbindung
ein „ד, das das Fenster schliesst); „Chat“ öffnet dasselbe, nicht modale
Fenster nach unten, angedockt steht es als eigene Spalte rechts neben der
Zeichnung. Ein Schalter „Chat | Briefkasten“ trennt den Chat im Plugin von
der Arbeit mit einem KI-Programm draussen (laufender Auftrag, letzte
Aufträge, Notizen für die KI); Rückgängig, Wiederherstellen, Neu zeichnen
und die Prüfhinweise stehen in beiden, die Einstellungen unter „⋯“.
Solange die KI arbeitet, zeigt eine kleine Anzeige über Cadwork, was sie
tut („KI zeichnet“ mit Fortschritt, „KI denkt nach“, „Wartet auf deine
Freigabe“, „Cadwork rechnet“), mit „Anhalten“. Strich-Symbole (Lucide, ISC, siehe
`THIRD_PARTY_NOTICES.md`) statt Emoji. Oben links der
Arbeitsordner (zuletzt gewählte, „Ordner“ mit Plus für weitere), unter der Eingabe
eine Leiste wie in den Chat-Apps: „+“ für Dateien und Fotos (auch Einfügen
und Ablegen; Bilder an alle Anbieter), der Modus, Modell und Denkstufe in
einer kleinen Karte (Modelle darüber, darunter ein Regler) und ab halb voll
ein Balken, wie voll der Kontext ist. Im Verlauf stehen
Antworten in eigenen Blasen, Werkzeugaufrufe als eine aufklappbare Zeile mit
menschlichen Namen, Zeitangaben grob und relativ. Der Chat beginnt mit der
ersten Nachricht; Chats von Claude Code lassen sich aus einer Liste
fortsetzen. Die Modelle fragt das Dock beim Anbieter ab; die Freigabe-Karten
sind dieselben.

**Grenzen:**

- **Lokale Modelle: mit Vorbehalt.** `execute_cadwork_command` lässt das
  Modell Python **generieren**. Kleine Modelle (7B/8B) beherrschen das und
  zuverlässiges Tool-Calling in der Regel nicht. Die Anbindung wird gehen —
  brauchbare Ergebnisse brauchen ein starkes Modell.
- **Nur Cadwork 3D.** Die Architektur (Warteschlange, Hauptthread-Zwang,
  Freigaben) liesse sich auf andere CAD-Systeme mit Python-API übertragen;
  getan ist es nicht.
- Die Type-Stubs stammen aus Cadwork 2025. Neuere Funktionen kennt
  `get_cadwork_api_help` unter Umständen nicht; die echten Aufrufe laufen
  über die eingebauten Module des CAD und sind davon unberührt.

## Sicherheit

- Die Brücke horcht ausschliesslich auf `127.0.0.1` — von aussen nicht
  erreichbar.
- Ausgeführter Code wird gegen Import von `os`, `subprocess`, `shutil`,
  `socket`, `urllib`, `requests` und `__import__` gefiltert. Das ist eine
  Sperrliste nach bestem Wissen, **keine Sandbox**: wer dem Modell Zugriff auf
  sein CAD gibt, gibt ihm Zugriff auf sein CAD.
- Der Chat kennt vier Modi: „Nur lesen“ lehnt alles Ändernde ohne
  Frage ab, „Fragen“ (Vorgabe) zeigt vor jeder Änderung eine Karte (einmal
  je Art bis zur nächsten Nachricht), „Cadwork frei“ lässt Cadwork ohne
  Karte arbeiten und fragt bei allem ausserhalb wie „Fragen“, „Alles
  automatisch“ fragt
  nichts und gilt nie über einen Neustart hinaus. In jedem Modus steht jeder
  Aufruf im Verlauf: eine Automatik, die nichts hinterlässt, wäre schlimmer
  als die Fragerei.
- Fällt die Freigabe aus, wird **nicht** ausgeführt. Das Gate fällt zu, nicht auf.

## Lizenz

[AGPL-3.0](LICENSE). Wer open-mcp-cad verändert weitergibt oder als Dienst
betreibt, gibt die Änderungen unter derselben Lizenz weiter.

Beiträge brauchen ein [CLA](CLA.md).

**Name und Logo sind nicht Teil der Lizenz.** Forken ist ausdrücklich erlaubt;
den Fork "Open MCP CAD" zu nennen, nicht.

*Cadwork ist eine Marke der cadwork informatik AG. Open MCP CAD ist ein
unabhängiges Projekt und steht in keiner Verbindung zu cadwork.*