SolidPilot

Automatización CAD impulsada por IA para SolidWorks: un servidor MCP (Model Context Protocol).

SolidPilot permite que un modelo de IA trabaje con SolidWorks a nivel de operaciones CAD. El objetivo es que el modelo razone en términos de «¿qué intención CAD estoy realizando?» en lugar de «¿qué método de API debería llamar?». La intención se convierte en una representación intermedia independiente del CAD, y un compilador determinista reduce esa representación a operaciones concretas de SolidWorks.

SolidPilot no es un plugin exclusivo de Claude; es un puente general entre SolidWorks y la IA. Debido a que MCP es un estándar abierto, cualquier cliente de IA compatible con MCP puede conectarse; además de Claude, también se contemplan OpenClaw, agentes basados en OpenAI y LLM locales. La arquitectura se diseñó para esta extensibilidad desde el principio: las capas de ejecución y planificación no saben qué cliente las está llamando; un adaptador ligero por cliente reutiliza un núcleo de puente compartido. adapters/claude/ es la implementación actual; dar soporte a un nuevo cliente de IA solo implica añadir un nuevo adaptador.

Repositorio: mcp-server-solidworks · Nombre público: SolidPilot · Versión objetivo: SolidWorks 2026

Distribución y extensiones — cortesía de Sylvain Leduc, presidente de Constructo AI inc.

Ecosistema inteligente para la construcción en Quebec · www.constructoai.ca

Este repositorio retoma eyfel/mcp-server-solidworks (AGPL-3.0, © Çağatay Bakan) y le añade la capa de producción de Constructo AI: swkit.py (canalización de scripts — coordenadas de modelo en metros, transacciones anulables, selección de aristas por coordenadas), cuatro modelos completos en modeles/, el instalador INSTALLER.ps1, y extensiones a server.py y tool-schemas.json.

Idea central

La API de SolidWorks expone miles de métodos. Presentar cada uno a la IA como una «herramienta» separada dispara el tamaño del contexto y el coste de tokens: el problema económico que frena proyectos similares.

SolidPilot lo resuelve elevando el nivel de abstracción:

• La IA produce la intención a nivel de operaciones (por ejemplo, «hacer un agujero en la cara superior»).

• Esa intención se expresa como un Feature Graph IR independiente del CAD.

• Un compilador determinista reduce el IR a operaciones ordenadas y concretas de SolidWorks.

• Por tanto, una sola operación se asigna a muchas operaciones de bajo nivel, y basta una llamada de modelo por solicitud.

Como el IR es la columna vertebral, la misma maquinaria funciona en sentido inverso: un plano técnico 2D es intención de diseño expresada en dos dimensiones, por lo que puede leerse en el mismo IR y construirse.

De un archivo de dibujo 2D a una pieza sólida

Dale a SolidPilot un .DXF o .DWG — el archivo que un proveedor o un cliente envía realmente, sin ningún modelo detrás — y reconstruye la pieza:

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

El lector decide cuál de las dos respuestas justifica el plano. Cuando cada decisión que necesita la pieza está impuesta por el propio plano — hoy en día, los desarrollos de chapa — reduce toda la pieza a IR por sí solo y analyze_drawing(mode='build') la construye en una sola llamada. Cuando el plano requiere una lectura de ingeniería real (el caso normal para una pieza mecanizada), lo indica y entrega el análisis estructurado, que el modelo interpreta bajo un conjunto de reglas versionado (el recurso recipe://usage/reverse) y construye mediante submit_feature_graph.

En cualquier caso, el resultado se comprueba, no se asume: el volumen esperado se calcula a partir de las dimensiones del propio plano antes de construir y se vuelve a leer después. Hasta ahora se han reconstruido así nueve planos reales: cuatro muestras internas (dos de ellas de chapa) y cinco láminas de fabricación de producción (A4/A3/A1, de 1:1 a 1:10, tres plantillas de cajetín diferentes), cada una verificada contra el peso de su propio cajetín con una tolerancia del 0,02 % o contra la pieza original con topología exacta.

Related MCP server: solidworks-mcp

Arquitectura

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

Lee el diagrama por estilo de línea: una línea gruesa funciona hoy, una línea discontinua está planificada. Dos puertas MCP están activas: las herramientas de bajo nivel (la vía principal hoy) y rebuild_from_ir, que impulsa el verdadero compilador determinista para reproducir una pieza —o un ensamblaje— a partir de su Feature Graph IR. La flecha inversa punteada es el paso de descubrimiento: analyze_model/analyze_drawing leen una pieza existente para poder proponer un IR para ella. La única pieza discontinua (aún planificada) es el colapso hacia adelante: una única herramienta submit_feature_graph que reemplazaría la superficie de bajo nivel para construir desde cero; pasa por el mismo compilador.

El sistema tiene cuatro capas:

MCP se sitúa en la parte superior: es el límite donde el cliente de IA se encuentra con el sistema, no un transporte interno. Todo lo que está por debajo del IR es determinista y se comunica a través de REST simple.

La capa adapters/ es específica del proveedor y reemplazable. Como las capas de ejecución y planificación no saben qué cliente está llamando, añadir un nuevo cliente de IA (OpenClaw, OpenAI, un LLM local, etc.) solo implica escribir un nuevo adaptador: las capas de IR, compilador y ejecución permanecen sin cambios.

Estado actual vs. objetivo: el Feature Graph IR y el compilador determinista ahora existen y funcionan — el compilador (compiler/solidworks/pycompiler, reducción + un resolvedor de referencias v0) ha reproducido piezas de producción reales de extremo a extremo desde su IR hasta una coincidencia verified (ver Estado del proyecto). Hoy se accede a él a través de la herramienta rebuild_from_ir (la dirección inversa/reproducción). Lo que aún queda por delante es el colapso hacia adelante: reemplazar la superficie de bajo nivel por una única herramienta submit_feature_graph para construir desde cero, y un resolvedor de referencias duradero que sobreviva a las ediciones (el módulo decisivo). Hasta entonces, las herramientas MCP de bajo nivel siguen siendo la vía principal para construir.

Lista de herramientas

El sistema expone actualmente 46 herramientas para hacer y 13 recursos MCP para leer. Una prueba de contrato mantiene ambas superficies honestas: el adaptador contra el contrato de ejecución, y cada URI de recurso mencionada en el adaptador contra lo que realmente está registrado (ver CONTRIBUTING.md). La mayoría de las herramientas son operaciones CAD de bajo nivel; unas pocas (save_analysis, rebuild_from_ir, submit_feature_graph, compare_parts, compare_assemblies) impulsan el ciclo de análisis / IR descrito a continuación. Todas las longitudes están en metros (unidades internas de SolidWorks).

Los recursos contienen el conjunto de reglas y los contratos, no el comportamiento: recipe://usage/index más un recipe://usage/<section> estático por sección de reglas, y schema://feature-graph + schema://analysis-artifact. La división es deliberada: la descripción de una herramienta se paga en cada turno, se use o no, mientras que el cuerpo de un recurso solo cuesta cuando se lee, por lo que el material de referencia casi estático pertenece al lado de los recursos.

Documento y ciclo de vida

• ensure_ready — inicia SolidWorks mediante COM y se adjunta si está cerrado (no abre un documento).

• open_new_part — abre un nuevo documento de pieza.

• open_document — abre un archivo existente desde el disco (.sldprt/.sldasm/.slddrw nativos; importa .ipt/.CATPart/STEP/IGES mediante 3D Interconnect cuando el traductor está disponible; de lo contrario, devuelve un claro OPEN_FAILED).

• activate_document — cambia entre documentos abiertos.

• save_document — guarda la pieza o el plano en el disco.

• close_document — cierra el documento.

Croquis

• create_sketch — inicia un croquis en un plano o en una cara seleccionada.

• edit_sketch — reabre un croquis existente para editarlo.

• add_sketch_entity — añade una entidad de croquis: línea, círculo, arco, arco por centro, elipse, spline, rectángulo, redondeo, chaflán.

• add_sketch_constraint — añade una relación de croquis (horizontal, coincidente, etc.).

• add_dimension — añade una cota al croquis.

Operaciones y modelado sólido

• extrude_feature — saliente, corte, revolución, barrido, loft.

• add_edge_feature — redondeo o chaflán en una arista sólida (chaflán: distancia-ángulo en cualquier ángulo, o distancia-distancia).

• create_rib — operación de nervio desde un perfil de croquis abierto.

• add_reference_geometry — plano de referencia, eje o punto.

• create_pattern — matriz lineal o circular.

• sheet_metal_feature — chapa metálica: base_flange, edge_flange (incl. pestañas de perfil personalizado), sketched_bend, flat_pattern.

Edición

• modify_dimension — cambia el valor de una cota nombrada (la base para las variantes).

• edit_feature — suprime, reactiva, elimina o renombra una operación.

Material

• set_part_material — asigna un material a la pieza.

Análisis y consulta

• analyze_model — modos geometry, mass_properties, bodies (huellas por cuerpo para piezas multicuerpo), features (una receta compacta a nivel de operaciones), edges, faces, sketch (los segmentos exactos de un croquis bajo demanda) y feature_map (topología consumida/creada por operación — la fuente de los anclajes del resolvedor de referencias).

• get_selection — lee la geometría que el usuario seleccionó en la interfaz de SolidWorks y la asigna al índice de análisis.

• verify_state — devuelve el estado actual y el árbol de operaciones.

Ensamblaje

• open_new_assembly — abre un nuevo documento de ensamblaje en blanco.

• insert_component — inserta un archivo de pieza como componente: punto de inserción o una transformación completa de 13 números, fija o flotante.

• add_mate — añade una relación de posición (coincidente, concéntrica, paralela, perpendicular, tangente, distancia, ángulo, bloqueo) mediante una selección de entidades basada en índices robusta.

• analyze_assembly — lee componentes (orden de árbol con transformaciones completas, incl. una vista plana de hojas a través de los niveles de anidamiento), relaciones de posición (orden de creación, tipos de enumeración a prueba de configuración regional, anclajes de entidades) o las listas de caras/aristas de un componente.

• save_body_as_part — extrae un cuerpo de una pieza multicuerpo a su propio archivo de pieza (para importaciones STEP de ensamblajes aplanados).

• compare_assemblies — diff objetivo de ensamblaje (conjunto de componentes, transformaciones por componente con ≤1 µm, número y tipos de relaciones de posición, propiedades de masa) con el veredicto verified.

Canal de análisis y ciclo IR

Estas herramientas implementan el bucle de ingeniería inversa — «el LLM propone, el ciclo decide» — que reproduce una pieza existente a partir de un Feature Graph IR independiente del CAD y verifica objetivamente el resultado.

• La receta de generación de IR se sirve como recursos MCP, no como una herramienta (desde 2026-07-30): recipe://usage/index indexa un recipe://usage/<section> por sección de reglas (mapping/canonicalization/forward/reverse/verification/…), y schema://feature-graph + schema://analysis-artifact sirven los dos contratos. El modelo los lee antes de escribir un IR. Son casi estáticos, idénticos para cada llamante, y llevan pistas de frescura ttlMs/cacheScope — por eso son recursos: la herramienta retirada get_recipe costaba ~2.4 KB de la lista de herramientas en cada turno, se leyera o no.

• save_analysis — escribe un artefacto de análisis para un archivo de pieza o ensamblaje (receta de operaciones / árbol de componentes + relaciones de posición, parámetros conductores y un bloque opcional de IR de Feature Graph) en <folder>/.solidpilot/.

• rebuild_from_ir — la puerta inversa del IR: ejecuta el bloque de IR de un artefacto a través del compilador determinista para reconstruir la pieza — o el ensamblaje — en un documento nuevo, y avisa cuando el archivo de origen ha cambiado bajo el artefacto (source_stale).

• submit_feature_graph — la puerta directa del IR: construye una pieza o ensamblaje a partir de un Feature Graph suministrado directamente por el modelo (intención de diseño, sin original que copiar), a través del mismo compilador — dos puertas, un compilador.

• compare_parts — diff objetivo entre dos piezas (topología, volumen, área, centro de masa) con el veredicto verified del proyecto (topología exacta y |ΔV| ≤ 1% y |ΔA| ≤ 1%).

Dibujo

Las herramientas de dibujo se añadieron después del conjunto inicial de modelado de piezas y ahora son una capacidad sustancial — aunque aún en maduración. Son suficientes para llevar un modelo a un dibujo multivista acotado, y para leer un dibujo de vuelta para ingeniería inversa.

• create_drawing — crea un documento de dibujo (lámina A3).

• add_drawing_view — añade una vista de modelo: front, top, right, isometric, back, bottom, left; las vistas ortográficas usan por defecto Hidden-Lines-Visible según la convención de dibujo técnico (display_mode se puede sobrescribir).

• add_flat_pattern_view — añade una vista de patrón plano de chapa metálica (el desarrollo desplegado con líneas de plegado y notas de plegado); la forma correcta y estándar de detallar piezas de chapa.

• auto_dimension_drawing — transfiere las cotas conductoras del modelo a las vistas (la automatización de "Insert Model Items") — la alternativa robusta a colocar cotas por coordenadas.

• auto_center_marks — inserta automáticamente marcas de centro y líneas de centro en cada agujero/ranura.

• add_hole_callout — añade una nota de agujero en el borde de un agujero.

• add_drawing_dimension — añade una cota individual por coordenada de lámina.

• add_section_view — vista de sección a lo largo de una arista existente o de una línea de corte dibujada — la forma estándar de exponer y acotar operaciones internas/ciegas (una sección por cada eje distinto de profundidad interna).

• analyze_drawing — el front-end dibujo → pieza: lee un archivo de dibujo técnico 2D (.DXF o .DWG) y o bien construye la pieza a partir de él o bien entrega la evidencia para construirla. Un .DWG se convierte a DXF automáticamente. Lo que extrae: escala por vista (ya aplicada, así que cada número son mm reales del modelo), vistas detectadas con una clase de borde por primitiva (visible / hidden / section cut line / centre), contornos ya encadenados en bucles cerrados, pares de alineación de vistas, cotas que llevan la cadena que el sistema CAD realmente imprimió (que arbitra sobre el valor almacenado — una ida y vuelta de DWG corrompe ángulos y radios), el cajetín como tabla de parámetros (frame_notes — longitud, material, peso, norma de proyección), y notas de plegado de chapa emparejadas con sus líneas de plegado en tres canales independientes. Responde con una de dos formas, y el lector elige: DIRECT_BUILDABLE + un resumen compacto (entonces mode='build' lo construye en una sola llamada), o NOT_DIRECT | <reason> + el análisis completo para que el modelo lo lea bajo el recurso recipe://usage/reverse. Cualquier cosa que no pueda atribuir se notifica como omitida — nunca adivinada. (El lector más antiguo para dibujos nativos de SolidWorks sobrevive como analyze_slddrw_test — solo prueba/referencia: un .SLDDRW está vinculado al modelo, así que si tienes uno, la pieza ya existe.)

Exportar

• export_document — STEP, IGES, STL, PDF, DWG, DXF (PDF/DWG/DXF requieren un documento de dibujo).

• batch_export — exportación por lotes.

Instalación y ejecución

Requisitos

• Windows y SolidWorks 2026.

• .NET Framework 4.8 y MSBuild para la capa de ejecución (se incluye con Visual Studio 2022).

• Python 3.x y el MCP Python SDK v2 oficial (mcp>=2.0.0, protocolo 2026-07-28) para el adaptador (las dependencias de Python se instalan mediante requirements.txt).

• Un cliente de IA compatible con MCP (p. ej. Claude Desktop; también se contemplan OpenClaw, agentes basados en OpenAI y LLM locales).

Capa de ejecución (C#)

Compile la solución:

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

Ejecute el servidor (sin interfaz, http://localhost:5000):

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

Adaptador (Python)

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

El adaptador se conecta a la capa de ejecución en EXECUTION_BASE_URL (por defecto http://localhost:5000; se puede sobrescribir mediante .env).

Registro con un cliente de IA (Cómo instalar)

El adaptador se registra con un cliente de IA compatible con MCP, que lanza server.py por sí mismo. Para Claude Desktop, el archivo de configuración está en:

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

Añada la siguiente entrada bajo mcpServers:

"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"
}

Actualice la ruta para que coincida con su propio sistema.

Reinicie Claude Desktop después de cualquier cambio de configuración.

Como MCP es un estándar abierto, OpenClaw, los agentes basados en OpenAI o los clientes que ejecutan un LLM local pueden conectarse de la misma manera apuntando al mismo adaptador server.py.

Estado del proyecto

SolidPilot es un prototipo funcional / alfa temprana. Las herramientas de bajo nivel se han verificado de extremo a extremo contra SolidWorks en vivo; todas las llamadas COM se serializan en un único hilo STA dedicado.

Piezas: la superficie de modelado de piezas es la más madura — croquis, extruir/revolucionar/barrer/solevar, redondeos/chaflanes, matrices, chapa metálica, geometría de referencia, además de edición (modify_dimension, edit_feature) y análisis enriquecido. Inicialmente solo existían las herramientas necesarias para la creación de piezas.

Dibujo técnico: añadido más tarde y ahora una capacidad real (aunque aún en maduración) — dibujos multivista, vistas de sección, acotación automática de elementos de modelo, marcas de centro, notas de agujero, vistas de patrón plano de chapa y un lector de dibujos. Modelo → dibujo se ha demostrado en piezas de producción reales (un dibujo acotado de cinco vistas, incl. dos vistas de sección ortogonales colocadas solo a partir del análisis). Limitación conocida: el paso de acotación automática es ciego al dibujo técnico (puede omitir o colocar mal cotas y acotar aristas ocultas) — una capa de acotación más inteligente está en la hoja de ruta.

Dibujo → modelo es la dirección que más ha cambiado recientemente, y ahora funciona a partir de un archivo de dibujo únicamente — sin modelo, sin documento de dibujo de SolidWorks, solo el .DXF/.DWG que enviaría un proveedor. El lector (cad-planner/drawing/, el único módulo que toca DXF) encadena contornos en bucles cerrados mediante emparejamiento estricto de extremos de grado 2, empareja notas de plegado con líneas de plegado, lee el cajetín como tabla de parámetros y toma la cadena impresa de cada cota como verdad de referencia. Reconstruido hasta ahora: cuatro muestras internas (dos de chapa, dos mecanizadas) con topología exacta frente a sus originales, y cinco láminas de fabricación reales de producción — A4/A3/A1, escalas 1:1 a 1:10, tres plantillas de cajetín distintas — cada una verificada contra su propio peso declarado con ≤ 0.02%, incluida una placa de 6.69 m con tres pliegues y una vista en rotura (interrumpida) cuya longitud dibujada no es la longitud de la pieza. Límites honestos: las vistas ortográficas aún no se encadenan por completo (una silueta de operación que termina a mitad de arista es una unión en T, donde el encadenador se detiene en lugar de adivinar — un contorno sin resolver se notifica como hueco), la norma de proyección se lee de la configuración en lugar de detectarse, y las piezas mecanizadas aún necesitan que el modelo haga la lectura de ingeniería.

Ensamblaje: la superficie de ensamblaje ahora funciona de extremo a extremo — creación de ensamblajes, inserción de componentes con transformaciones completas, relaciones de posición basadas en índices, lectura estructural profunda (analyze_assembly) y verificación objetiva (compare_assemblies). Se ha añadido un sub-vocabulario de IR de ensamblaje (componentes + relaciones de posición) al esquema de Feature Graph, y se han reproducido ensamblajes de muestra reales (hasta ~17 componentes) desde su IR hasta una coincidencia verified: conjuntos de componentes exactos, transformaciones con precisión submicrónica, y recuentos y tipos de relaciones de posición coincidentes.

IR de Feature Graph + compilador (el núcleo estratégico): ahora es la columna vertebral del proyecto y funciona. El esquema de IR (cad-planner/contracts/feature-graph.schema.json) y un compilador Python determinista (compiler/solidworks/pycompiler, reducción + un resolvedor de referencias v0 construido sobre anclas geométricas) ejecutan cada reconstrucción a través de una única ruta de código, con una suite de pruebas offline (sin necesidad de SolidWorks en vivo). Mediante la ida y vuelta inversa — analyze_model → un IR propuesto por LLM → rebuild_from_ir → compare_parts — se han reproducido piezas de producción reales desde su IR hasta una coincidencia verified, abarcando revoluciones, matrices circulares, ambos modos de chaflán, solevaciones y formas de chapa con múltiples pliegues. Cada pieza se reconstruye en un documento nuevo y se comprueba contra el original por topología exacta y propiedades de masa antes de contar como verificada. Ampliar el vocabulario de IR a partir de piezas reales es como avanza; este esfuerzo tiene su propio registro (logs-ir.md).

El problema abierto — y el riesgo real de investigación del proyecto — es un resolvedor de referencias duradero: las anclas geométricas v0 reproducen una pieza exactamente en un documento nuevo pero no sobreviven a ediciones aguas arriba (una cota cambiada mueve las anclas). Hacer que las referencias semánticas (top_face, una arista específica) sean robustas ante cambios de topología es el módulo decisivo que aún queda por delante.

Dos puertas de IR, un compilador. La puerta inversa es rebuild_from_ir (reproducir una pieza existente desde su artefacto). La puerta directa es submit_feature_graph (construir desde la intención de diseño, sin original que copiar) — ahora en vivo y sin restricciones, y probada en geometría real: sólidos barridos que coinciden con πr²·L hasta seis dígitos, rejillas de matrices compuestas, prismas elípticos y alas de chapa. Ambas puertas se ejecutan a través del mismo pycompiler, así que cada lección de una mejora la otra. Nótese que tener la puerta directa no es lo mismo que colapsar la superficie de bajo nivel que hay debajo — las más de 40 herramientas de bajo nivel siguen en pie, y retirarlas espera al resolvedor de referencias mencionado más abajo.

Pruebas: cuatro suites automatizadas se ejecutan completamente offline (sin necesidad de SolidWorks) y en CI en cada push — una prueba de contrato de herramientas (adapters/claude/tests/test_schema_contract.py) que falla ante cualquier desviación de herramienta/parámetro entre el adaptador (server.py) y el contrato de ejecución (tool-schemas.json); una prueba de contrato de IR (compiler/solidworks/pycompiler/tests/test_ir_schema_contract.py) que falla ante cualquier desviación de vocabulario entre el esquema de IR — que además actúa como registro de capacidades — y el validador que lo hace cumplir, en ambas direcciones; la suite del compilador (compiler/solidworks/pycompiler/tests/) que cubre la validación de IR, la reducción y la resolución de referencias contra un puerto de ejecución falso; y una puerta de lector de dibujos (cad-planner/drawing/tests/) que compara el vocabulario del dialecto de dibujo en ambos sentidos y vuelve a encadenar fixtures DXF congelados a partir de primitivas crudas, validando el IR que emite contra el propio validador del compilador para que el lector no pueda inventar vocabulario que el compilador no pudiera construir. La verificación de comportamiento de las operaciones CAD en sí mismas es manual contra SolidWorks en vivo, por diseño.

Notas:

• El adaptador MCP de Python no se recarga en caliente mientras se ejecuta; después de editar server.py, el servidor MCP debe reconectarse.

• Debido a que SolidPilot maneja una sesión GUI de SolidWorks en vivo, las herramientas de análisis pueden esperar ocasionalmente un clic en SolidWorks antes de continuar, y después de un análisis muy largo las herramientas MCP pueden empezar a devolver errores (un límite del lado del cliente); en cualquier caso, dile al asistente que reintente y continuará.

Hoja de ruta

El proyecto está en desarrollo activo. El IR de Feature Graph y el compilador determinista ya funcionan para piezas (verificado de extremo a extremo en piezas de producción reales); los principales próximos objetivos:

• Resolvedor de referencias duradero / nomenclatura persistente — el módulo crítico: hacer que las referencias semánticas (top_face, una arista específica) sobrevivan a cambios de dimensión y topología, no solo a la reproducción de documentos nuevos. Los anclajes geométricos v0 actuales son exactos pero frágiles ante ediciones.

• Profundidad de ensamblaje — el núcleo de ensamblaje (insertar, acoplar, analizar, round-trip de IR) funciona; el trabajo restante es jerarquías de subensamblajes como IR de primera clase, acoplamientos para piezas deformables/asentadas (p. ej., juntas tóricas en ranuras), y dibujos de ensamblaje / BOM.

• Amplitud del pipeline de análisis — un escáner de carpetas (analizar por lotes un directorio de piezas/dibujos en artefactos), un paso de IA que genera IR por categoría con un informe de cobertura, y reutilización de patrones entre IR verificados (reconstrucciones paramétricas sin un LLM).

• Reducción de la superficie de herramientas — la puerta de entrada (submit_feature_graph) está activa y el IR ahora cubre toda la superficie de modelado de piezas, por lo que el paso restante es retirar las herramientas de bajo nivel que están debajo. Ahí es donde se realiza realmente la ventaja en costo de tokens de esta arquitectura; espera al resolvedor, ya que una interfaz de una sola herramienta solo es utilizable si sus referencias son duraderas.

Próximamente en áreas existentes:

• Dibujo técnico: las herramientas principales existen; el trabajo restante es una capa de acotación orientada al dibujo (planificación determinista de secciones, colocación correcta de cotas), GD&T / datums, bloques de título, vistas de detalle y una lista de materiales (BOM).

Contribuciones

Para las pautas de contribución, la configuración del entorno de desarrollo y la guía para agregar nuevas capacidades, consulte CONTRIBUTING.md.

Licencia

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

SolidPilot es software libre, licenciado bajo la GNU Affero General Public License v3.0 (AGPL-3.0).

Puede usarlo, estudiarlo, modificarlo y distribuirlo libremente. Debido a que SolidPilot es software de servidor, la cláusula de red de AGPL (§13) se aplica: si ejecuta una versión modificada y permite que otros interactúen con ella a través de una red, debe ofrecer a esos usuarios el código fuente correspondiente completo de su versión modificada, bajo la misma licencia. Consulte la LICENCIA para conocer los términos exactos.

Licencia comercial / propietaria

Las obligaciones de copyleft de AGPL no se adaptan a todas las organizaciones. Si desea integrar SolidPilot en un producto de código cerrado o propietario, o de otro modo no puede cumplir con AGPL, hay una licencia comercial separada disponible. Las contribuciones se aceptan bajo el CLA del proyecto, lo que mantiene abierta esta opción de doble licencia.

¿Interesado en una licencia comercial, un piloto o un programa de prueba/evaluación? Póngase en contacto y podemos acordar los términos adecuados:

Correo electrónico: cagataybkn@gmail.com

Modificaciones realizadas por Constructo AI (AGPL §5)

Este repositorio es una versión modificada de eyfel/mcp-server-solidworks. Las adiciones de Constructo AI inc. (2026) — swkit.py, modeles/, INSTALLER.ps1, y las extensiones de adapters/claude/server.py y execution/solidworks/contracts/tool-schemas.json — se publican bajo la misma licencia AGPL-3.0. El copyright de la base sigue siendo de Çağatay Bakan.

Un cortesía de Sylvain Leduc — Constructo AI inc.

Ecosistema inteligente para la construcción en Quebec

www.constructoai.ca