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 GitHubMCP 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-pinza1 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
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
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

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:
-
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.
-
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:
- Formula un'ipotesi geometrica iniziale basata sulla fisica del meccanismo
- Esegue la simulazione e analizza la risposta
- Identifica quale parametro è il "collo di bottiglia" rispetto alla specifica
- Modifica quel parametro con ragionamento fisico (non ricerca casuale)
- 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.
| Parametro | Significato |
|---|---|
MQ | Base maggiore del cuneo |
LC | Lunghezza del lato obliquo del cuneo |
AlphaDeg | Semi-angolo di apertura del cuneo (0 < α < 45) |
R | Raggio dei rulli |
B_X | Coordinata X delle cerniere B e B' |
B_Y | Coordinata Y di B (B' è a −Y) |
L_AB | Lunghezza asta A–B |
L_AD | Distanza A–D lungo l'asta |
L_BC | Distanza B–C lungo l'asta |
X_Min | Posizione iniziale del cuneo |
X_Max | Posizione finale del cuneo |
N_Frames | Numero di frame della simulazione (≥ 10) |
F_M | Forza orizzontale applicata al cuneo |
F_Molla | Forza 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.