convez.ai
MCP ServerAutomaçãoAvançado
davide3011

Studio Pinza — Simulador de Mecanismo com Cuneo-Rolo

davide3011/studio-pinza

Projete mecanismos a partir de especificações via IA + física simulada

Ver no GitHub
InicialPluginScore · de 0 a 100

MCP server que resolve problemas inversos em engenharia mecânica: dado uma força-alvo e restrições geométricas, o sistema converge iterativamente na combinação ótima de parâmetros (ângulo, comprimentos, rigidez) usando Claude como raciocínio físico acoplado a simulações cinemáticas e análise estática (PLV). Integra-se via protocolo MCP para interação conversacional entre IA e simulador.

Instalação

$npx convez-ai davide3011/studio-pinza

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
0
Forks
0
Acompanhando
0
Saúde
42%
Último commit
há 5 meses
Versão
v1.0.0
Issues abertas
0
Contribuidores
1

Casos de uso

  • Otimização reversa de pinças mecânicas e sistemas de transmissão de força
  • Problemas de design inverso em engenharia mecânica com múltiplas restrições
  • Exploração interativa de espaço de parâmetros com raciocínio físico-matemático

Veredito

Projeto altamente especializado que redefine a metodologia de design inverso em mecânica: acopla rigorosamente simulação física (cinemática + PLV) com raciocínio semântico do Claude para convergência inteligente. Maduro para engenheiros e pesquisadores; demanda domínio técnico profundo.

README

A tradução para o português deste README ainda está na fila.

Studio Pinza — Progettazione Inversa di Meccanismi via IA

License: MIT Claude

Abstract

La progettazione di meccanismi è tradizionalmente un problema diretto: il progettista sceglie una geometria, la simula, legge il risultato e itera a mano. Questo progetto inverte il paradigma.

Il problema da risolvere è la progettazione di una pinza meccanica a cuneo-rullo con specifiche note: data una forza di chiusura target, una corsa massima del cuneo, e vincoli geometrici dettati dall'ingombro fisico, trovare la combinazione di parametri (angolo del cuneo, lunghezze delle aste, posizione delle cerniere, rigidezza delle molle) che soddisfa tutte le specifiche.

Si tratta di un problema inverso: lo spazio dei parametri è continuo e multidimensionale, le relazioni tra input e output sono non lineari, e non esiste formula chiusa che mappi le specifiche alla geometria.

L'approccio proposto è nuovo: invece di affidarsi a ottimizzatori numerici che operano ciecamente, si espone il simulatore fisico direttamente a un modello di linguaggio (Claude AI) tramite il protocollo MCP. Claude comprende i vincoli del problema, formula ipotesi geometriche, esegue simulazioni in autonomia, interpreta i risultati nel contesto fisico e converge sulla soluzione spiegando ogni passo. L'obiettivo non è solo trovare i parametri, ma rivoluzionare l'approccio ai problemi inversi in ingegneria meccanica: dall'ottimizzazione cieca alla progettazione ragionata assistita da IA.


Il meccanismo

Schema del meccanismo

Il cinematismo è composto da un cuneo trapezoidale (MNPQ) che trasla orizzontalmente sotto la forza F_m. Le facce inclinate del cuneo spingono due rulli simmetrici verso l'esterno; ogni rullo è solidale a un'asta incernierata in un punto fisso (B / B'). Le estremità libere delle aste (C / C') costituiscono le ganasce della pinza e si avvicinano all'asse quando il cuneo avanza.

Il modello fisico, basato sul Principio dei Lavori Virtuali (PLV), calcola la forza di chiusura F in funzione dello spostamento x del cuneo:

F(x) = [F_m − 2·F_molla·(dDy/dx)] / [2·|dCy/dx|]

Le derivate sono calcolate numericamente per differenze finite su N_frames configurazioni.


Architettura del sistema

┌─────────────────────────────────────────────────────────────┐
│                        Claude Desktop                       │
│                                                             │
│   "Trovami una geometria che eroga 800 N con corsa 30 mm"   │
│               ↕  MCP (stdio JSON-RPC)                       │
├─────────────────────────────────────────────────────────────┤
│                        McpServer.exe                        │
│         Tool: run_simulation(MQ, LC, alpha, ...)            │
│               ↕  linked engine                              │
├─────────────────────────────────────────────────────────────┤
│                     SimulationEngine                        │
│    ComputeAll() → cinematica + PLV → F(x), deltaC(x)        │
└─────────────────────────────────────────────────────────────┘
                           ↕  stesso engine
┌─────────────────────────────────────────────────────────────┐
│                      StudioPinza.exe                        │
│   App WPF: configuratore grafico + visualizzazione F(x)     │
└─────────────────────────────────────────────────────────────┘

Il nucleo di calcolo (SimulationEngine) è condiviso tra l'app desktop e il server MCP tramite link simbolici a livello di progetto C#: nessuna duplicazione di codice, nessun disallineamento tra le due interfacce.


Moduli

1. StudioPinza/ — Simulatore desktop (C# WPF, .NET 10)

L'applicazione desktop è lo strumento di esplorazione diretta del problema: il progettista inserisce i parametri, avvia la simulazione e visualizza in tempo reale la geometria e il grafico F(x).

Architettura interna

StudioPinza/
├── Engine/
│   ├── Vec2.cs                  — vettore 2D con operatori e prodotti scalare/vettoriale
│   ├── SimConfig.cs             — snapshot immutabile della geometria per un frame (record)
│   └── SimulationEngine.cs      — ComputeAll(): cinematica + PLV su tutti i frame
├── Models/
│   └── ParametriSimulazione.cs  — INotifyPropertyChanged + IDataErrorInfo per binding WPF
├── MainWindow.xaml(.cs)         — configuratore: input manuale o caricamento JSON
├── SimulationWindow.xaml(.cs)   — canvas 2D + grafico F(x) + slider frame
└── App.xaml.cs                  — routing avvio: headless (stdin pipe) o GUI

Flusso di utilizzo

MainWindow raccoglie i parametri (con validazione in tempo reale: campi rossi se fuori vincolo) e li espone tramite data binding a ParametriSimulazione. Quando tutti i valori sono validi, il tasto ▶ Avvia simulazione diventa attivo e apre SimulationWindow.

La finestra di simulazione mostra:

  • Sinistra — rappresentazione grafica vettoriale del meccanismo nella posizione selezionata
  • Destra — grafico F(x): forza di chiusura in funzione dello spostamento del cuneo
  • Slider — navigazione tra le N_frames posizioni simulate

Modalità headless

App.xaml.cs rileva se stdin è una pipe reale tramite Win32 GetFileType(GetStdHandle(-10)) == FILE_TYPE_PIPE. Se sì, legge un payload JSON da stdin, esegue SimulationEngine.ComputeAll() e scrive il risultato su stdout — senza aprire alcuna finestra. Questo consente l'uso come sottoprocesso da script Python o altri strumenti.

// Input (stdin)
{ "MQ": 35, "LC": 51, "AlphaDeg": 18, "R": 11, "B_X": 118, "B_Y": 20,
  "L_AB": 110, "L_AD": 63, "L_BC": 210, "X_Min": 0, "X_Max": 50,
  "N_Frames": 150, "F_M": 3000, "F_Molla": 250 }

// Output (stdout)
{ "xs": [...], "F_eq": [...], "deltaC": [...], "F_min": 0, "F_max": 0, "F_mean": 0 }

Il motore di simulazione (SimulationEngine.cs)

ComputeAll(p) opera in due fasi:

  1. Cinematica — per ogni frame calcola la posizione di tutti i punti del meccanismo risolvendo l'intersezione cerchio-retta (posizione del rullo sulla faccia inclinata) con tracciamento di continuità tra frame adiacenti.

  2. Statica PLV — calcola il gradiente numerico di C_y e D_y rispetto a x (differenze centrali nei punti interni, laterali agli estremi) e applica la formula PLV per ottenere F(x).


2. mcpserver/ — Server MCP (C# console, .NET 10)

Il server MCP è il ponte tra Claude e il motore fisico. Implementa il protocollo Model Context Protocol su trasporto stdio, esponendo un unico tool run_simulation che accetta i 14 parametri del meccanismo e restituisce la risposta della simulazione.

Struttura

mcpserver/
├── Program.cs          — host .NET con MCP stdio transport, tutti i log su stderr
└── SimulationTool.cs   — [McpServerTool] RunSimulation(...) → JSON

I file del motore (Vec2, SimConfig, SimulationEngine, ParametriSimulazione) sono linkati da StudioPinza/ via <Compile Include="../StudioPinza/..." Link="..."/> nel .csproj.

Descrizioni semantiche degli argomenti

Ogni parametro del tool porta una [Description] precisa (unità, vincoli, range tipico). Questo è fondamentale: Claude usa queste descrizioni per formulare ipotesi geometricamente sensate senza conoscere a priori il modello fisico sottostante.

[Description("Semi-angolo di apertura del cuneo [°] (0 < α < 45)")]  double AlphaDeg,
[Description("Lunghezza asta A–B [mm]")]                              double L_AB,

Il problema inverso in azione

Claude riceve una specifica in linguaggio naturale (es. "forza minima 800 N, corsa max 30 mm, ingombro laterale < 150 mm") e può chiamare run_simulation quante volte vuole. A ogni chiamata riceve F_min, F_max, F_mean e la curva completa F_eq[]. Claude:

  1. Formula un'ipotesi geometrica iniziale basata sulla fisica del meccanismo
  2. Esegue la simulazione e analizza la risposta
  3. Identifica quale parametro è il "collo di bottiglia" rispetto alla specifica
  4. Modifica quel parametro con ragionamento fisico (non ricerca casuale)
  5. Converge sulla soluzione spiegando il trade-off di ogni scelta

Questo approccio è qualitativamente diverso dall'ottimizzazione numerica classica: il ragionamento è trasparente, spiegabile e contestualizzato nella fisica del meccanismo.


3. prototipo/ — Prototipo Python (matplotlib)

Il prototipo Python è il banco di sviluppo del modello fisico. È stato il primo ambiente in cui la cinematica e la statica sono state implementate e validate prima della trascrizione in C#.

prototipo/
├── parametri.py      — parametri condivisi da tutti gli script
├── simulazione.py    — visualizzazione interattiva con slider matplotlib
├── main.py           — animazione automatica frame-by-frame
├── tests.py          — test unitari della geometria
└── README.md         — derivazione completa delle equazioni PLV e verifica numerica

Il file prototipo/README.md contiene la derivazione analitica completa del modello statico: equilibrio del cuneo, equilibrio dell'asta (ΣF_x, ΣF_y, ΣM_B), derivazione PLV, e tabella di verifica numerica che confronta F_PLV con F_stat con residui di equilibrio zero macchina.


Parametri del modello

Tutti i valori geometrici in mm, forze in N, angoli in gradi.

ParametroSignificato
MQBase maggiore del cuneo
LCLunghezza del lato obliquo del cuneo
AlphaDegSemi-angolo di apertura del cuneo (0 < α < 45)
RRaggio dei rulli
B_XCoordinata X delle cerniere B e B'
B_YCoordinata Y di B (B' è a −Y)
L_ABLunghezza asta A–B
L_ADDistanza A–D lungo l'asta
L_BCDistanza B–C lungo l'asta
X_MinPosizione iniziale del cuneo
X_MaxPosizione finale del cuneo
N_FramesNumero di frame della simulazione (≥ 10)
F_MForza orizzontale applicata al cuneo
F_MollaForza molla in D e D'

File di esempio: params_example.json


Installazione e utilizzo

Requisiti

  • Windows (WPF richiede Windows)
  • .NET 10 SDK per la compilazione
  • Claude Desktop per l'integrazione MCP

Compilazione su un nuovo PC

Su un nuovo PC servono due publish: il server MCP (obbligatorio per Claude Desktop) e l'app desktop (per verificare la configurazione e usare il simulatore graficamente).

1. McpServer — ponte tra Claude Desktop e il motore fisico:

cd mcpserver
dotnet publish -c Release -r win-x64 --self-contained true -p:PublishSingleFile=true -o publish
# → mcpserver\publish\McpServer.exe

2. StudioPinza — app desktop WPF per simulazione interattiva:

cd StudioPinza
dotnet publish -c Release -r win-x64 --self-contained true -p:PublishSingleFile=true -p:IncludeNativeLibrariesForSelfExtract=true -o publish
# → StudioPinza\publish\StudioPinza.exe

Il mcpserver non dipende dal publish di StudioPinza: include i file del motore direttamente dal sorgente tramite link nel .csproj.

Configurazione Claude Desktop

Modifica:

%LOCALAPPDATA%\Packages\Claude_pzs8sxrjxfjjc\LocalCache\Roaming\Claude\claude_desktop_config.json
"mcpServers": {
    "studio-pinza": {
        "command": "C:\\percorso\\assoluto\\mcpserver\\publish\\McpServer.exe",
        "args": []
    }
}

Riavvia Claude Desktop. Il tool run_simulation sarà disponibile in tutte le conversazioni.

Prototipo Python

cd prototipo
pip install numpy matplotlib
python simulazione.py   # slider interattivo
python main.py          # animazione automatica
pytest                  # test unitari

Esempi di interazione con Claude

Una volta connesso il server MCP, puoi descrivere il problema in linguaggio naturale:

"Ho bisogno di una pinza che eserciti almeno 800 N di forza di chiusura con uno spostamento massimo del cuneo di 30 mm. L'ingombro laterale non può superare 150 mm. Trovami una geometria valida."

"Come cambia la curva F(x) se aumento l'angolo α da 15° a 25° mantenendo tutto il resto invariato? Qual è il trade-off fisico?"

"Trova la geometria che massimizza la forza media minimizzando il picco, per una forza applicata di 2000 N."

Claude chiamerà run_simulation in autonomia, interpreterà i risultati nel contesto fisico del meccanismo, e guiderà la progettazione con ragionamento esplicito — non con ricerca numerica cieca.


Licenza

Distribuito sotto licenza MIT. © 2026 Davide Grilli.

Ver o original no GitHub

Bom para

Relacionados