SolidPilot

KI-gesteuerte CAD-Automatisierung für SolidWorks — ein MCP-Server (Model Context Protocol).

SolidPilot ermöglicht es einem KI-Modell, auf der CAD-Feature-Ebene mit SolidWorks zu arbeiten. Das Ziel ist, dass das Modell in Begriffen von „welche CAD-Absicht setze ich um?“ denkt, statt „welche API-Methode sollte ich aufrufen?“. Die Absicht wird in eine CAD-neutrale Zwischendarstellung überführt, und ein deterministischer Compiler senkt diese Darstellung auf konkrete SolidWorks-Operationen ab.

SolidPilot ist kein reines Claude-Plugin; es ist eine allgemeine Brücke zwischen SolidWorks und KI. Da MCP ein offener Standard ist, kann jeder MCP-fähige KI-Client eine Verbindung herstellen — neben Claude sind auch OpenClaw, OpenAI-basierte Agenten und lokale LLMs als Ziel vorgesehen. Die Architektur wurde von Anfang an auf diese Erweiterbarkeit ausgelegt: Die Ausführungs- und Planungsebenen wissen nicht, welcher Client sie aufruft; ein schlanker Adapter pro Client nutzt einen gemeinsamen Brückenkern. adapters/claude/ ist die aktuelle Implementierung; die Unterstützung eines neuen KI-Clients bedeutet lediglich, einen neuen Adapter hinzuzufügen.

Repository: mcp-server-solidworks · Öffentlicher Name: SolidPilot · Zielversion: SolidWorks 2026

Verbreitung und Erweiterungen — mit freundlicher Genehmigung von Sylvain Leduc, Präsident von Constructo AI inc.

Intelligentes Ökosystem für das Bauwesen in Québec · www.constructoai.ca

Dieses Repository übernimmt eyfel/mcp-server-solidworks (AGPL-3.0, © Çağatay Bakan) und ergänzt es um die Produktionsschicht von Constructo AI: swkit.py (Skript-Pipeline — Modellkoordinaten in Metern, rückgängig machbare Transaktionen, Kantenauswahl per Koordinaten), vier vollständige Modelle unter modeles/, den Installer INSTALLER.ps1 sowie Erweiterungen an server.py und tool-schemas.json.

Kernidee

Die SolidWorks-API stellt Tausende von Methoden bereit. Jede einzelne dem KI-Modell als separates „Tool“ zu präsentieren, sprengt die Kontextgröße und die Token-Kosten — das wirtschaftliche Problem, das ähnliche Projekte ins Stocken bringt.

SolidPilot löst dies, indem es die Abstraktionsebene anhebt:

• Die KI erzeugt Absicht auf der Feature-Ebene (zum Beispiel „ein Loch in die obere Fläche setzen“).

• Diese Absicht wird als CAD-neutrale Feature-Graph-IR ausgedrückt.

• Ein deterministischer Compiler senkt die IR auf geordnete, konkrete SolidWorks-Operationen ab.

• Ein einzelnes Feature bildet sich daher auf viele Low-Level-Operationen ab, und ein Modellaufruf pro Anfrage genügt.

Da die IR das Rückgrat bildet, läuft dieselbe Maschinerie auch rückwärts: Eine 2D-technische Zeichnung ist Konstruktionsabsicht, die in zwei Dimensionen ausgedrückt ist, sodass sie in dieselbe IR eingelesen und aufgebaut werden kann.

Von einer 2D-Zeichnungsdatei zu einem Volumenkörper

Übergeben Sie SolidPilot eine .DXF- oder .DWG-Datei — die Datei, die ein Lieferant oder Kunde tatsächlich sendet, ohne dahinterliegendes Modell — und es rekonstruiert das Bauteil:

drawing.dwg → analyze_drawing → (draw dialect: views, edge classes, chained contours,
              true-valued dimensions, bend notes) → Feature Graph IR → compiler → SolidWorks

Der Reader entscheidet, welche von zwei Antworten die Zeichnung rechtfertigt. Wenn jede Entscheidung, die das Bauteil benötigt, durch die Zeichnung selbst erzwungen wird — heute: Blech-Abwicklungen —, senkt es das gesamte Bauteil eigenständig auf IR ab, und analyze_drawing(mode='build') baut es in einem einzigen Aufruf. Wenn die Zeichnung eine echte ingenieurtechnische Auswertung erfordert (der Normalfall bei einem spanend gefertigten Bauteil), sagt es dies und übergibt die strukturierte Analyse, die das Modell unter einem versionierten Regelsatz (die Ressource recipe://usage/reverse) interpretiert und über submit_feature_graph aufbaut.

In beiden Fällen wird das Ergebnis geprüft, nicht angenommen: Das erwartete Volumen wird aus den eigenen Maßen der Zeichnung vor dem Aufbau berechnet und danach zurückgelesen. Bisher wurden auf diese Weise neun reale Zeichnungen rekonstruiert — vier interne Muster (zwei davon Blech) und fünf Produktions-Fertigungszeichnungen (A4/A3/A1, 1:1 bis 1:10, drei verschiedene Schriftfeld-Vorlagen), jeweils verifiziert gegen das eigene Schriftfeld-Gewicht auf 0,02 % genau oder gegen das Originalbauteil auf exakte Topologie.

Related MCP server: solidworks-mcp

Architektur

flowchart TD
    U(["User + AI client<br/>Claude · OpenClaw · OpenAI · local LLM"])

    subgraph ADAPT["adapters/* — MCP bridge · MCP BOUNDARY = top"]
        LOW["38 low-level tools<br/>sketch · extrude · sheet-metal · drawing · assembly · analyze"]
        RIR["rebuild_from_ir · save_analysis · compare_parts/assemblies"]
        SFG["submit_feature_graph<br/>forward single tool"]
    end

    IR["Feature Graph IR<br/>feature-graph.schema.json<br/>(cad-planner · CAD-neutral)"]

    subgraph COMP["compiler/solidworks — deterministic compiler · no LLM"]
        CO["pycompiler<br/>lowering + reference resolver (geometric anchors v0)"]
    end

    subgraph EXE["execution/solidworks — C# .NET 4.8 · the ONLY COM-touching layer"]
        EX["Execution<br/>idempotency · state_version"]
    end

    SW(["SolidWorks · COM"])

    %% Working today (thick)
    U == "MCP: low-level tools (primary today)" ==> LOW
    LOW == "REST" ==> EX
    U == "MCP: rebuild_from_ir (reverse round-trip — WORKS)" ==> RIR
    IR ==> CO
    RIR == "REST" ==> CO
    CO == "REST" ==> EX
    EX == "COM" ==> SW

    %% Reverse discovery step: read an existing part → propose an IR
    EX -. "analyze_model / analyze_drawing (DXF/DWG)" .-> IR

    %% Planned forward collapse (dashed)
    IR -. "forward: submit_feature_graph" .-> SFG
    SFG -. "REST" .-> CO

Lesen Sie das Diagramm nach Linienart: Eine durchgezogene Linie funktioniert heute, eine gestrichelte Linie ist geplant. Zwei MCP-Türen sind aktiv — die Low-Level-Tools (der heutige primäre Pfad) und rebuild_from_ir, das den echten deterministischen Compiler antreibt, um ein Bauteil — oder eine Baugruppe — aus seiner Feature-Graph-IR zu reproduzieren. Der gepunktete Rückwärtspfeil ist der Erkennungsschritt: analyze_model/analyze_drawing lesen ein vorhandenes Bauteil ein, damit eine IR dafür vorgeschlagen werden kann. Das einzige gestrichelte (noch geplante) Element ist die Vorwärts-Zusammenlegung — ein einzelnes submit_feature_graph-Tool, das die Low-Level-Oberfläche für den Aufbau von Grund auf ersetzen würde; es läuft durch denselben Compiler.

Das System hat vier Ebenen:

MCP sitzt an der Spitze: Es ist die Grenze, an der der KI-Client auf das System trifft, kein interner Transport. Alles unterhalb der IR ist deterministisch und kommuniziert über einfaches REST.

Die adapters/-Ebene ist anbieterabhängig und austauschbar. Da die Ausführungs- und Planungsebenen nicht wissen, welcher Client aufruft, bedeutet das Hinzufügen eines neuen KI-Clients (OpenClaw, OpenAI, ein lokales LLM usw.) lediglich, einen neuen Adapter zu schreiben — die IR-, Compiler- und Ausführungsebenen bleiben unverändert.

Ist-Zustand vs. Ziel: Die Feature-Graph-IR und der deterministische Compiler existieren und funktionieren — der Compiler (compiler/solidworks/pycompiler, Absenkung + ein v0-Referenzauflöser) hat reale Produktionsbauteile Ende-zu-Ende aus ihrer IR bis zu einem verified-Abgleich reproduziert (siehe Projektstatus). Er wird heute über das rebuild_from_ir-Tool erreicht (die Rückwärts-/Reproduktionsrichtung). Was noch bevorsteht, ist die Vorwärts-Zusammenlegung: das Ersetzen der Low-Level-Oberfläche durch ein einziges submit_feature_graph-Tool für den Aufbau von Grund auf sowie ein dauerhafter Referenzauflöser, der Bearbeitungen übersteht (das Modul, über das alles steht und fällt). Bis dahin bleiben die Low-Level-MCP-Tools der primäre Pfad für den Aufbau.

Tool-Liste

Das System stellt derzeit 46 Tools zum Handeln und 13 MCP-Ressourcen zum Lesen bereit. Ein Vertragstest hält beide Oberflächen ehrlich — den Adapter gegen den Ausführungsvertrag und jede im Adapter erwähnte Ressourcen-URI gegen das, was tatsächlich registriert ist (siehe CONTRIBUTING.md). Die meisten Tools sind Low-Level-CAD-Operationen; einige wenige (save_analysis, rebuild_from_ir, submit_feature_graph, compare_parts, compare_assemblies) treiben den unten beschriebenen Analyse-/IR-Roundtrip. Alle Längen sind in Metern angegeben (SolidWorks-interne Einheiten).

Die Ressourcen tragen den Regelsatz und die Verträge, nicht das Verhalten: recipe://usage/index plus eine statische recipe://usage/<section> pro Regelabschnitt sowie schema://feature-graph + schema://analysis-artifact. Die Trennung ist bewusst gewählt — die Beschreibung eines Tools wird in jeder einzelnen Runde bezahlt, ob es nun verwendet wird oder nicht, während ein Ressourceninhalt nur beim Lesen kostet. Daher gehört nahezu statisches Referenzmaterial auf die Ressourcenseite.

Dokument und Lebenszyklus

• ensure_ready — startet SolidWorks über COM und hängt sich an, wenn es geschlossen ist (öffnet kein Dokument).

• open_new_part — öffnet ein neues Bauteildokument.

• open_document — öffnet eine vorhandene Datei von der Festplatte (nativ .sldprt/.sldasm/.slddrw; importiert .ipt/.CATPart/STEP/IGES über 3D Interconnect, wenn der Übersetzer verfügbar ist, andernfalls wird ein klares OPEN_FAILED zurückgegeben).

• activate_document — wechselt zwischen geöffneten Dokumenten.

• save_document — speichert das Bauteil oder die Zeichnung auf der Festplatte.

• close_document — schließt das Dokument.

Skizze

• create_sketch — startet eine Skizze auf einer Ebene oder einer ausgewählten Fläche.

• edit_sketch — öffnet eine vorhandene Skizze erneut zum Bearbeiten.

• add_sketch_entity — fügt eine Skizzeneinheit hinzu: Linie, Kreis, Bogen, Mittelpunktsbogen, Ellipse, Spline, Rechteck, Verrundung, Fase.

• add_sketch_constraint — fügt eine Skizzenbeziehung hinzu (horizontal, deckungsgleich usw.).

• add_dimension — fügt der Skizze eine Bemaßung hinzu.

Feature- und Volumenmodellierung

• extrude_feature — Boss, Schnitt, Drehung, Sweep, Loft.

• add_edge_feature — Verrundung oder Fase an einer Volumenkante (Fase: Abstand-Winkel bei beliebigem Winkel oder Abstand-Abstand).

• create_rib — Rippen-Feature aus einem offenen Skizzenprofil.

• add_reference_geometry — Bezugsebene, -achse oder -punkt.

• create_pattern — lineares oder kreisförmiges Muster.

• sheet_metal_feature — Blech: base_flange, edge_flange (einschließlich Flanschen mit benutzerdefiniertem Profil), sketched_bend, flat_pattern.

Bearbeiten

• modify_dimension — ändert den Wert einer benannten Bemaßung (die Grundlage für Varianten).

• edit_feature — unterdrückt, hebt die Unterdrückung auf, löscht oder benennt ein Feature um.

Material

• set_part_material — weist dem Bauteil ein Material zu.

Analyse und Abfrage

• analyze_model — Modi geometry, mass_properties, bodies (Fingerabdrücke pro Körper für Mehrkörper-Bauteile), features (ein kompaktes Rezept auf Feature-Ebene), edges, faces, sketch (die exakten Segmente einer Skizze auf Abruf) und feature_map (pro Feature verbrauchte/erzeugte Topologie — die Quelle der Ankerpunkte des Referenzauflösers).

• get_selection — liest die Geometrie, die der Benutzer in der SolidWorks-GUI ausgewählt hat, und bildet sie auf den Analyse-Index ab.

• verify_state — gibt den aktuellen Zustand und den Feature-Baum zurück.

Baugruppe

• open_new_assembly — öffnet ein neues leeres Baugruppendokument.

• insert_component — fügt eine Bauteildatei als Komponente ein: Einfügepunkt oder eine vollständige 13-Zahlen-Transformation, fixiert oder frei.

• add_mate — fügt eine Verknüpfung hinzu (deckungsgleich, konzentrisch, parallel, senkrecht, tangential, Abstand, Winkel, Sperren) mithilfe einer robusten indexbasierten Elementauswahl.

• analyze_assembly — liest Komponenten (Baumreihenfolge mit vollständigen Transformationen, einschließlich einer abgeflachten Blattansicht über Verschachtelungsebenen hinweg), Verknüpfungen (Erstellungsreihenfolge, locale-sichere Enum-Typen, Elementanker) oder die Flächen-/Kantenlisten einer Komponente.

• save_body_as_part — extrahiert einen Körper eines Mehrkörper-Bauteils in eine eigene Bauteildatei (für abgeflachte STEP-Importe von Baugruppen).

• compare_assemblies — objektiver Baugruppen-Diff (Komponentensatz, Transformationen pro Komponente bis ≤1 µm, Anzahl + Typen der Verknüpfungen, Masseneigenschaften) mit dem Urteil verified.

Analyse-Pipeline & IR-Roundtrip

Diese Tools implementieren die Reverse-Engineering-Schleife — „das LLM schlägt vor, der Roundtrip entscheidet“ —, die

• Das Rezept zur IR-Erzeugung wird als MCP-Ressourcen bereitgestellt, nicht als Tool (seit 2026-07-30): recipe://usage/index indiziert ein recipe://usage/<section> pro Regelabschnitt (Mapping/Kanonisierung/Vorwärts/Rückwärts/Verifikation/…), und schema://feature-graph + schema://analysis-artifact bedienen die beiden Verträge. Das Modell liest diese, bevor es ein IR schreibt. Sie sind nahezu statisch, für jeden Aufrufer identisch und tragen ttlMs/cacheScope-Frischehinweise — genau deshalb sind sie Ressourcen: Das zurückgezogene get_recipe-Tool kostete ~2.4 KB der Werkzeugliste bei jedem einzelnen Turn, ob gelesen oder nicht.

• save_analysis — schreibt ein Analyse-Artefakt für eine Bauteil- oder Baugruppendatei (Feature-Rezept / Komponenten- und Verknüpfungsbaum, treibende Parameter und einen optionalen Feature-Graph-IR-Block) nach <folder>/.solidpilot/.

• rebuild_from_ir — die Rückwärts-IR-Tür: führt den IR-Block eines Artefakts durch den deterministischen Compiler aus, um das Bauteil — oder die Baugruppe — in einem neuen Dokument neu aufzubauen, und warnt, wenn sich die Quelldatei unter dem Artefakt geändert hat (source_stale).

• submit_feature_graph — die Vorwärts-IR-Tür: baut ein Bauteil oder eine Baugruppe aus einem direkt vom Modell gelieferten Feature-Graph (Konstruktionsabsicht, kein Original zum Kopieren) durch denselben Compiler — zwei Türen, ein Compiler.

• compare_parts — objektiver Zwei-Bauteil-Vergleich (Topologie, Volumen, Fläche, Massenschwerpunkt) mit dem verified-Urteil des Projekts (topologieexakt und |ΔV| ≤ 1 % und |ΔA| ≤ 1 %).

Zeichnung

Die Zeichnungswerkzeuge wurden nach dem anfänglichen Satz an Bauteilmodellierungs-Werkzeugen hinzugefügt und sind inzwischen eine beachtliche — wenn auch noch reifende — Fähigkeit. Sie reichen aus, um ein Modell in eine bemaßte Mehransichten-Zeichnung zu überführen und eine Zeichnung für das Reverse Engineering zurückzulesen.

• create_drawing — erstellt ein Zeichnungsdokument (A3-Blatt).

• add_drawing_view — fügt eine Modellansicht hinzu: front, top, right, isometric, back, bottom, left; orthografische Ansichten standardmäßig auf „Hidden-Lines-Visible“ gemäß Zeichnungskonvention (display_mode überschreibbar).

• add_flat_pattern_view — fügt eine Blech-Abwicklungsansicht (Flat-Pattern) hinzu (der abgewickelte Zuschnitt mit Biegelinien und Biegehinweisen); die korrekte, standardgemäße Art, Blechteile zu detaillieren.

• auto_dimension_drawing — überträgt die treibenden Bemaßungen des Modells in die Ansichten (die Automatisierung „Insert Model Items“) — die robuste Alternative zum Platzieren von Bemaßungen per Koordinate.

• auto_center_marks — fügt automatisch Mittemarkierungen und Mittellinien an jeder Bohrung/Schlitz ein.

• add_hole_callout — fügt eine Bohrungsbeschriftung an einer Bohrungskante hinzu.

• add_drawing_dimension — fügt eine einzelne Bemaßung per Blattkoordinate hinzu.

• add_section_view — Schnittansicht entlang einer vorhandenen Kante oder einer gezeichneten Schnittlinie — die standardgemäße Methode, um innere/verdeckte Merkmale sichtbar zu machen und zu bemaßen (ein Schnitt pro separater Achse der Innentiefe).

• analyze_drawing — das Zeichnung → Bauteil-Frontend: liest eine 2D-Technische-Zeichnungsdatei (.DXF oder .DWG) und baut entweder das Bauteil daraus oder übergibt die Belege, um es zu bauen. Eine .DWG wird automatisch in DXF konvertiert. Was extrahiert wird: Maßstab pro Ansicht (bereits angewendet, sodass jede Zahl echte Modell-mm ist), erkannte Ansichten mit einer Kantenklasse pro Primitiv (sichtbar / verdeckt / Schnittlinie / Mitte), Konturen, die bereits zu geschlossenen Schleifen verkettet sind, Ansichtsausrichtungspaare, Bemaßungen mit der Zeichenkette, die das CAD-System tatsächlich gedruckt hat (die über dem gespeicherten Wert entscheidet — ein DWG-Roundtrip beschädigt Winkel und Radien), das Schriftfeld als Parametertabelle (frame_notes — Länge, Material, Gewicht, Projektionsstandard) und Blech-Biegehinweise, die über drei unabhängige Kanäle ihren Biegelinien zugeordnet sind. Es antwortet in einer von zwei Formen, und der Leser wählt: DIRECT_BUILDABLE + eine kompakte Zusammenfassung (dann baut mode='build' es in einem Aufruf), oder NOT_DIRECT | <reason> + die vollständige Analyse, die das Modell unter der Ressource recipe://usage/reverse liest. Alles, was es nicht zuordnen kann, wird als übersprungen gemeldet — nie geraten. (Der ältere Leser für native SolidWorks-Zeichnungen überlebt als analyze_slddrw_test — nur Test/Referenz: Eine .SLDDRW ist modellverknüpft; wenn Sie also eine haben, existiert das Bauteil bereits.)

Export

• export_document — STEP, IGES, STL, PDF, DWG, DXF (PDF/DWG/DXF erfordern ein Zeichnungsdokument).

• batch_export — Stapelexport.

Installation und Ausführung

Voraussetzungen

• Windows und SolidWorks 2026.

• .NET Framework 4.8 und MSBuild für die Ausführungsebene (wird mit Visual Studio 2022 geliefert).

• Python 3.x und das offizielle MCP Python SDK v2 (mcp>=2.0.0, Protokoll 2026-07-28) für den Adapter (Python-Abhängigkeiten werden über requirements.txt installiert).

• Ein MCP-fähiger KI-Client (z. B. Claude Desktop; OpenClaw, OpenAI-basierte Agenten und lokale LLMs sind ebenfalls vorgesehen).

Ausführungsebene (C#)

Erstellen Sie die Projektmappe:

& "C:\Program Files\Microsoft Visual Studio\2022\Community\MSBuild\Current\Bin\MSBuild.exe" execution\solidworks\SolidworksExecution.sln /t:Build /p:Configuration=Debug

Starten Sie den Server (headless, http://localhost:5000):

Start-Process execution\solidworks\SolidworksExecution\bin\Debug\SolidworksExecution.exe -WindowStyle Hidden

Adapter (Python)

cd adapters/claude
pip install -r requirements.txt
python server.py

Der Adapter verbindet sich mit der Ausführungsebene unter EXECUTION_BASE_URL (Standard http://localhost:5000; Überschreiben über .env).

Registrierung bei einem KI-Client (Installation)

Der Adapter wird bei einem MCP-fähigen KI-Client registriert, der server.py selbst startet. Für Claude Desktop befindet sich die Konfigurationsdatei unter:

C:\Users\<username>\AppData\Roaming\Claude\claude_desktop_config.json

Fügen Sie den folgenden Eintrag unter mcpServers hinzu:

"SolidPilot": {
  "command": "C:\\Users\\<username>\\AppData\\Local\\python\\bin\\python.exe",
  "args": ["C:\\Users\\<username>\\Desktop\\MCP Server\\adapters\\claude\\server.py"],
  "cwd": "C:\\Users\\<username>\\Desktop\\MCP Server\\adapters\\claude"
}

Aktualisieren Sie den Pfad, sodass er zu Ihrem eigenen System passt.

Starten Sie Claude Desktop nach jeder Konfigurationsänderung neu.

Da MCP ein offener Standard ist, können OpenClaw, OpenAI-basierte Agenten oder Clients mit lokalem LLM auf dieselbe Weise eine Verbindung herstellen, indem sie auf denselben server.py-Adapter zeigen.

Projektstatus

SolidPilot ist ein funktionierender Prototyp / frühe Alpha. Die Low-Level-Werkzeuge wurden Ende-zu-Ende gegen ein laufendes SolidWorks verifiziert; alle COM-Aufrufe werden auf einem einzigen dedizierten STA-Thread serialisiert.

Bauteile: Die Oberfläche zur Bauteilmodellierung ist am ausgereiftesten — Skizzen, Extrusion/Drehung/Sweep/Loft, Verrundungen/Fasen, Muster, Blech, Bezugsgeometrie sowie Bearbeitung (modify_dimension, edit_feature) und umfangreiche Analyse. Anfangs existierten nur die für die Bauteilerstellung benötigten Werkzeuge.

Technische Zeichnung: später hinzugefügt und inzwischen eine echte (wenn auch noch reifende) Fähigkeit — Mehransichten-Zeichnungen, Schnittansichten, automatische Bemaßung von Modellelementen, Mittemarkierungen, Bohrungsbeschriftungen, Blech-Abwicklungsansichten und ein Zeichnungsleser. Modell → Zeichnung wurde an realen Produktionsteilen demonstriert (eine bemaßte Fünf-Ansichten-Zeichnung inkl. zweier orthogonaler Schnittansichten, die allein aus der Analyse platziert wurden). Bekannte Einschränkung dort: Der Automatik-Bemaßungslauf ist zeichnungsblind (er kann Bemaßungen auslassen oder falsch platzieren und verdeckte Kanten bemaßen) — eine intelligentere Bemaßungsschicht steht auf der Roadmap.

Zeichnung → Modell ist die Richtung, die sich zuletzt am stärksten geändert hat, und sie funktioniert jetzt allein aus einer Zeichnungsdatei — kein Modell, kein SolidWorks-Zeichnungsdokument, nur die .DXF/.DWG, die ein Lieferant senden würde. Der Leser (cad-planner/drawing/, das einzige Modul, das DXF anfasst) verkettet Konturen durch striktes Grad-2-Endpunkt-Matching zu geschlossenen Schleifen, ordnet Biegehinweise Biegelinien zu, liest das Schriftfeld als Parametertabelle und behandelt die gedruckte Zeichenkette jeder Bemaßung als Ground Truth. Bisher rekonstruiert: vier interne Muster (zwei Blech, zwei gefräst) mit exakter Topologie gegenüber ihren Originalen, und fünf echte Produktionsfertigungsblätter — A4/A3/A1, Maßstäbe 1:1 bis 1:10, drei verschiedene Schriftfeldvorlagen — jedes gegen sein eigenes angegebenes Gewicht auf ≤ 0.02 % verifiziert, darunter eine 6.69 m lange Platte mit drei Biegungen und eine abgebrochene (unterbrochene) Ansicht, deren gezeichnete Länge nicht der Länge des Bauteils entspricht. Ehrliche Grenzen: Ortho-Ansichten werden noch nicht vollständig verkettet (eine Merkmalssilhouette, die mitten in einer Kante endet, ist eine T-Kreuzung, an der der Verketter anhält, statt zu raten — eine unaufgelöste Kontur wird als Lücke gemeldet), der Projektionsstandard wird aus der Konfiguration gelesen statt erkannt, und gefräste Teile benötigen weiterhin das Modell für die ingenieurtechnische Auswertung.

Baugruppe: Die Baugruppenoberfläche funktioniert jetzt Ende-zu-Ende — Erstellen von Baugruppen, Einfügen von Komponenten mit vollständigen Transformationen, indexbasiertes Verknüpfen, tiefes strukturelles Auslesen (analyze_assembly) und objektive Verifikation (compare_assemblies). Ein IR-Teilvokabular für Baugruppen (Komponenten + Verknüpfungen) wurde zum Feature-Graph-Schema hinzugefügt, und echte Beispielbaugruppen (bis zu ~17 Komponenten) wurden aus ihrem IR zu einer verified-Übereinstimmung reproduziert: exakte Komponentensätze, Transformationen bis in den Submikrometerbereich, übereinstimmende Verknüpfungsanzahlen und -typen.

Feature-Graph-IR + Compiler (der strategische Kern): jetzt das Rückgrat des Projekts und funktionsfähig. Das IR-Schema (cad-planner/contracts/feature-graph.schema.json) und ein deterministischer Python-Compiler (compiler/solidworks/pycompiler, Lowering + ein v0-Referenzauflöser, der auf geometrischen Ankern aufbaut) führen jeden Neuaufbau über einen einzigen Codepfad aus, mit einer Offline-Testsuite (kein laufendes SolidWorks nötig). Über den Rückwärts-Roundtrip — analyze_model → ein von einem LLM vorgeschlagenes IR → rebuild_from_ir → compare_parts — wurden echte Produktionsteile aus ihrem IR zu einer verified-Übereinstimmung reproduziert, darunter Drehungen, Kreismuster, beide Fasenmodi, Erhebungen und mehrfach gebogene Blechformen. Jedes Bauteil wird in einem neuen Dokument neu aufgebaut und vor der Verifizierung anhand exakter Topologie und Masseneigenschaften mit dem Original verglichen. Das IR-Vokabular wächst durch reale Bauteile; diese Arbeit hat ein eigenes Protokoll (logs-ir.md).

Das offene Problem — und das eigentliche Forschungsrisiko des Projekts — ist ein dauerhafter Referenzauflöser: Die v0-geometrischen Anker reproduzieren ein Bauteil in einem neuen Dokument exakt, überleben jedoch keine vorgelagerten Änderungen (eine geänderte Bemaßung verschiebt die Anker). Semantische Referenzen (top_face, eine bestimmte Kante) robust gegenüber Topologieänderungen zu machen, ist das noch ausstehende Modul, an dem sich alles entscheidet.

Zwei IR-Türen, ein Compiler. Die Rückwärts-Tür ist rebuild_from_ir (ein vorhandenes Bauteil aus seinem Artefakt reproduzieren). Die Vorwärts-Tür ist submit_feature_graph (aus Konstruktionsabsicht bauen, ohne ein Original zum Kopieren) — jetzt live und ohne Freischaltung und an realer Geometrie bewiesen: Sweep-Körper, die πr²·L auf sechs Stellen treffen, zusammengesetzte Musterraster, elliptische Prismen und Blechflansche. Beide Türen laufen durch denselben pycompiler, sodass jede Erkenntnis aus der einen die andere verbessert. Beachten Sie, dass die Vorwärts-Tür nicht dasselbe ist wie das Zusammenlegen der darunterliegenden Low-Level-Oberfläche — die rund 40 Low-Level-Werkzeuge bleiben bestehen, und ihre Ausmusterung wartet auf den unten genannten Referenzauflöser.

Testen: Vier automatisierte Suiten laufen vollständig offline (kein SolidWorks nötig) und in CI bei jedem Push — ein Tool-Vertragstest (adapters/claude/tests/test_schema_contract.py), der bei jeder Tool-/Parameterabweichung zwischen dem Adapter (server.py) und dem Ausführungsvertrag (tool-schemas.json) fehlschlägt; ein IR-Vertragstest (compiler/solidworks/pycompiler/tests/test_ir_schema_contract.py), der bei jeder Vokabularabweichung zwischen dem IR-Schema — das zugleich als Fähigkeitsregister dient — und dem Validator, der es durchsetzt, in beide Richtungen fehlschlägt; die Compiler-Suite (compiler/solidworks/pycompiler/tests/), die IR-Validierung, Lowering und Referenzauflösung gegen einen simulierten Ausführungsport abdeckt; und ein Zeichnungsleser-Gate (cad-planner/drawing/tests/), das das Vokabular des Zeichnungsdialekts in beide Richtungen per Diff prüft und eingefrorene DXF-Fixtures aus rohen Primitiven neu verkettet, wobei das von ihm ausgegebene IR gegen den eigenen Validator des Compilers validiert wird, sodass der Leser kein Vokabular erfinden kann, das der Compiler nicht bauen könnte. Die verhaltensbezogene Verifikation der CAD-Operationen selbst erfolgt manuell gegen ein laufendes SolidWorks, wie vorgesehen.

Hinweise:

• Der Python-MCP-Adapter unterstützt während des Betriebs kein Hot-Reload; nach dem Bearbeiten von server.py muss der MCP-Server neu verbunden werden.

• Da SolidPilot eine laufende SolidWorks-GUI-Sitzung steuert, warten die Analysetools gelegentlich auf einen Klick in SolidWorks, bevor sie fortfahren, und nach einer sehr langen Analyse können die MCP-Tools beginnen, Fehler zurückzugeben (eine clientseitige Begrenzung); sagen Sie dem Assistenten in beiden Fällen, er solle es erneut versuchen, und er wird fortfahren.

Roadmap

Das Projekt befindet sich in aktiver Entwicklung. Feature Graph IR und der deterministische Compiler funktionieren inzwischen für Bauteile (End-to-End an realen Produktionsbauteilen verifiziert); die wichtigsten nächsten Ziele:

• Dauerhafter Referenzauflöser / persistentes Benennen — das kritische Modul: semantische Referenzen (top_face, eine bestimmte Kante) müssen Dimensions- und Topologieänderungen überstehen und nicht nur bei der Wiedergabe in einem neuen Dokument funktionieren. Die aktuellen geometrischen Anker von v0 sind exakt, aber bei Bearbeitungen fragil.

• Baugruppentiefe — der Baugruppenkern (Einfügen, Verknüpfen, Analysieren, IR-Roundtrip) funktioniert; verbleibende Arbeiten sind Unterbaugruppen-Hierarchien als IR erster Klasse, Verknüpfungen für verformbare/eingesetzte Teile (z. B. O-Ringe in Nuten) sowie Baugruppenzeichnungen / Stücklisten.

• Breite der Analyse-Pipeline — ein Ordner-Scanner (der ein Verzeichnis von Bauteilen/Zeichnungen stapelweise in Artefakte analysiert), ein KI-Durchlauf, der IR pro Kategorie mit einem Abdeckungsbericht erzeugt, sowie die Wiederverwendung von Mustern über verifizierte IRs hinweg (parametrische Neuaufbauten ohne LLM).

• Reduzierung der Tool-Oberfläche — die vordere Tür (submit_feature_graph) ist live und das IR deckt inzwischen die gesamte Oberfläche der Bauteilmodellierung ab, sodass der verbleibende Schritt darin besteht, die darunterliegenden Low-Level-Tools auszumustern. Genau hier wird der Token-Kosten-Vorteil dieser Architektur tatsächlich realisiert; er wartet auf den Resolver, denn eine Ein-Tool-Schnittstelle ist nur nutzbar, wenn ihre Referenzen dauerhaft sind.

Bald verfügbar in bestehenden Bereichen:

• Technische Zeichnung: Die Kernwerkzeuge existieren; verbleibende Arbeiten sind eine zeichnungsbewusste Bemaßungsschicht (deterministische Schnittplanung, korrekte Platzierung der Maße), GD&T / Bezugselemente, Schriftfelder, Detailansichten und eine Stückliste (BOM).

Mitwirken

Richtlinien für Beiträge, die Einrichtung der Entwicklungsumgebung und eine Anleitung zum Hinzufügen neuer Funktionen findest du in CONTRIBUTING.md.

Lizenz

Copyright (c) 2025–2026 Çağatay Bakan.

SolidPilot ist freie Software, lizenziert unter der GNU Affero General Public License v3.0 (AGPL-3.0).

Du darfst es frei verwenden, untersuchen, modifizieren und verbreiten. Da SolidPilot Serversoftware ist, greift die Netzwerkklausel der AGPL (§13): Wenn du eine modifizierte Version ausführst und anderen erlaubst, über ein Netzwerk damit zu interagieren, musst du diesen Nutzern den vollständigen entsprechenden Quellcode deiner modifizierten Version unter derselben Lizenz anbieten. Die genauen Bedingungen findest du in der LICENSE.

Kommerzielle / proprietäre Lizenzierung

Die Copyleft-Verpflichtungen der AGPL passen nicht zu jeder Organisation. Wenn du SolidPilot in ein Closed-Source- oder proprietäres Produkt einbetten möchtest oder die AGPL aus anderen Gründen nicht einhalten kannst, ist eine separate kommerzielle Lizenz erhältlich. Beiträge werden unter der CLA des Projekts angenommen, wodurch diese Option der Doppellizenzierung offen bleibt.

Interessiert an einer kommerziellen Lizenz, einem Pilotprojekt oder einem Test-/Evaluierungsprogramm? Nimm Kontakt auf und wir finden die passenden Konditionen:

Email: cagataybkn@gmail.com

Änderungen von Constructo AI (AGPL §5)

Dieses Repository ist eine modifizierte Version von eyfel/mcp-server-solidworks. Die Ergänzungen von Constructo AI inc. (2026) — swkit.py, modeles/, INSTALLER.ps1, sowie die Erweiterungen von adapters/claude/server.py und execution/solidworks/contracts/tool-schemas.json — werden unter derselben AGPL-3.0-Lizenz veröffentlicht. Das Urheberrecht am Grundbestand verbleibt bei Çağatay Bakan.

Mit freundlicher Genehmigung von Sylvain Leduc — Constructo AI inc.

Intelligentes Ökosystem für das Bauwesen in Québec

www.constructoai.ca