Skip to content
Back to search

Fusion-360-MCP-Server

Control Fusion 360 with any AI through Model Context Protocol (MCP)

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/aurafriday--fusion-360-mcp-server/badge.svg)](/listings/aurafriday--fusion-360-mcp-server)

HTML

<a href="/listings/aurafriday--fusion-360-mcp-server"><img src="/api/listings/aurafriday--fusion-360-mcp-server/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Prerequisites

1. **Download MCP-Link Server** Get the latest release: https://github.com/AuraFriday/mcp-link-server/releases/tag/latest

2. **Install the Add-In** Official link: https://apps.autodesk.com/FUSION/en/Detail/Index?id=7269770001970905100

Optional manual install

2b. **Clone This Repository**

   git clone https://github.com/AuraFriday/Fusion-360-MCP-Server.git

2c. **Load as Fusion Add-in** - Open Fusion - Press `Shift+S` to open Scripts and Add-Ins - Click the **Add-Ins** tab - Click the green **+** button next to "My Add-Ins" - Navigate to the cloned repository folder - Select the folder and click **OK** - Click **Run** to start the add-in

Configuration

The add-in auto-connects to the MCP server on startup. Check the **TEXT COMMANDS** window in Fusion to see connection logs.

---

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 675 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # Autodesk Fusion MCP Server Add-in
  2. **Control Fusion with AI !**
  3. This add-in for Autodesk Fusion connects to the Aura Friday MCP-Link server, making Fusion available as a remote tool that AI agents can control. [Official Store Link](https://apps.autodesk.com/FUSION/en/Detail/Index?id=7269770001970905100)
  4. [![Watch Demo](https://img.youtube.com/vi/0T2XU4tzudQ/maxresdefault.jpg)](https://www.youtube.com/watch?v=0T2XU4tzudQ)
  5. *Click above to watch AI create "Fusion Rocks!" in 3D*
  6. ---
  7. ## 🚀 What's New
  8. ### Latest: Enhanced Python Integration (January 2026)
  9. - 🔥 **Pre-injected shortcuts** - `app`, `ui`, `design`, `rootComponent` available immediately in Python
  10. - 🔥 **Cross-operation context** - Access objects stored via `store_as` from Python using `fusion_context`
  11. - 🔥 **ValueInput support** - Generic API now constructs ValueInput objects automatically
  12. - 🔥 **Triple documentation sources** - Introspection + Online docs + Best practices
  13. - 🔥 **Rich API docs with samples** - Fetch from Autodesk's cloudhelp with code examples
  14. - 🔥 **Automatic updates** - Secure, signature-verified updates without reinstalling
  15. ### Thread-Safe Architecture (November 2025)
  16. - ✅ **Rock-solid stability** - All Fusion API calls now execute on main thread
  17. - ✅ **Zero crashes** - Work queue system prevents threading issues
  18. - ✅ **Centralized logging** - Thread-safe diagnostics from all components
  19. - ✅ **Production ready** - Handles heavy loads without instability
  20. ### Python Execution + MCP Tool Integration
  21. **AI can now run arbitrary Python code directly inside Fusion** with full access to:
  22. - ✅ Entire Fusion API (`adsk.core`, `adsk.fusion`, `adsk.cam`)
  23. - ✅ All loaded add-ins (access your custom add-ins automatically!)
  24. - ✅ SQLite databases (store and query design data)
  25. - ✅ Browser automation (open documentation, extract data)
  26. - ✅ User popups (show results, get input)
  27. - ✅ 500+ AI models via OpenRouter
  28. - ✅ Local AI models (offline inference)
  29. - ✅ Desktop automation (Windows control)
  30. **Example**: AI analyzes your AirfoilTools add-in, finds the best airfoil from 1,538 profiles, stores results in SQLite, and shows a popup—all in one command!
  31. ---
  32. ## What This Is
  33. A Fusion add-in that gives AI **unlimited access** to Fusion through three powerful capabilities:
  34. ### 1. 🎯 Generic API Calls
  35. Execute any Fusion API command without custom code:
  36. ```python
  37. fusion360.execute({
  38. "api_path": "design.rootComponent.sketches.add",
  39. "args": ["design.rootComponent.xYConstructionPlane"]
  40. })
  41. ```
  42. ### 2. 🐍 Python Execution (NEW!)
  43. Run arbitrary Python with full Fusion access:
  44. ```python
  45. fusion360.execute({
  46. "operation": "execute_python",
  47. "code": """
  48. import adsk.core, adsk.fusion
  49. # Create sketch
  50. sketch = design.rootComponent.sketches.add(design.rootComponent.xYConstructionPlane)
  51. # Store in database
  52. mcp.call('sqlite', {
  53. 'input': {'sql': 'INSERT INTO designs (name) VALUES (?)',
  54. 'params': [sketch.name]}
  55. })
  56. # Show popup
  57. mcp.call('user', {
  58. 'input': {'operation': 'show_popup',
  59. 'html': f'<h1>Created {sketch.name}!</h1>'}
  60. })
  61. """
  62. })
  63. ```
  64. ### 3. 🔗 MCP Tool Integration (NEW!)
  65. Access 10+ built-in tools from Fusion:
  66. - SQLite databases
  67. - Browser automation
  68. - User popups
  69. - Python execution
  70. - AI models (local & cloud)
  71. - Desktop automation
  72. - And more!
  73. ### 4. 📚 Multi-Source Documentation (NEW!)
  74. AI has access to three complementary documentation sources:
  75. **Quick Search (Introspection)**:
  76. ```python
  77. fusion360.execute({
  78. "operation": "get_api_documentation",
  79. "search_term": "ExtrudeFeature",
  80. "category": "class_name"
  81. })
  82. ```
  83. **Rich Docs with Samples (Online)**:
  84. ```python
  85. fusion360.execute({
  86. "operation": "get_online_documentation",
  87. "class_name": "ExtrudeFeatures",
  88. "member_name": "createInput"
  89. })
  90. # Returns: parameter tables, return types, and 8+ working code samples!
  91. ```
  92. **Best Practices Guide**:
  93. ```python
  94. fusion360.execute({
  95. "operation": "get_best_practices"
  96. })
  97. # Returns: coordinate systems, body naming, PTransaction patterns, etc.
  98. ```
  99. ---
  100. ## 🎯 What AI Can Do
  101. ### Basic Operations
  102. - ✅ Create parametric sketches with precise dimensions
  103. - ✅ Add text and extrude it to 3D
  104. - ✅ Generate mounting holes, brackets, mechanical parts
  105. - ✅ Execute any Fusion API command
  106. ### Advanced Workflows (NEW!)
  107. - 🔥 **Access your custom add-ins** - AI discovers and uses ANY loaded add-in
  108. - 🔥 **Store design data** - Save analysis results to SQLite
  109. - 🔥 **Query databases** - Find optimal designs from your data
  110. - 🔥 **Show results** - Display popups with charts, tables, forms
  111. - 🔥 **Automate workflows** - Combine Fusion + database + browser + AI
  112. - 🔥 **Call AI models** - Get design suggestions from 500+ models
  113. - 🔥 **Rich documentation** - Access Autodesk's official docs with code samples
  114. - 🔥 **Auto-updates** - Get new features without reinstalling
  115. ### Real-World Example
  116. ```python
  117. # AI analyzes AirfoilTools add-in (15,000+ users!)
  118. # Finds best airfoil from 1,538 profiles
  119. # Stores in SQLite
  120. # Shows results in popup
  121. # All in one Python command!
  122. ```
  123. ---
  124. ## 🛠️ Built-in MCP Tools
  125. **Everything you need. Nothing you don't.**
  126. These tools ship with MCP-Link and work immediately. No configuration, no API keys, no setup.
  127. | Tool | Description |
  128. |------|-------------|
  129. | 🌐 **Browser** | Automate Chrome: read, click, type, navigate, extract data |
  130. | 🧠 **SQLite** | Database with semantic search and embeddings |
  131. | 🐍 **Python** | Execute code locally with full MCP tool access |
  132. | 🤖 **OpenRouter** | Access 500+ AI models (free and paid) |
  133. | 🤗 **HuggingFace** | Run AI models offline (no internet needed) |
  134. | 📚 **Context7** | Pull live documentation for any library |
  135. | 🖥️ **Desktop** | Control Windows apps (click, type, read) |
  136. | 💬 **User** | Show HTML popups for forms, confirmations |
  137. | 🔗 **Remote** | Let external systems offer tools (like Fusion!) |
  138. | 🔌 **Connector** | Add any 3rd party MCP tools |
  139. **Want more?** Add any third-party MCP tools or build your own!
  140. ---
  141. ## 📦 Installation
  142. ### Prerequisites
  143. 1. **Download MCP-Link Server**
  144. Get the latest release: https://github.com/AuraFriday/mcp-link-server/releases/tag/latest
  145. 2. **Install the Add-In**
  146. Official link: https://apps.autodesk.com/FUSION/en/Detail/Index?id=7269770001970905100
  147. ### Optional manual install
  148. 2b. **Clone This Repository**
  149. ```bash
  150. git clone https://github.com/AuraFriday/Fusion-360-MCP-Server.git
  151. ```
  152. 2c. **Load as Fusion Add-in**
  153. - Open Fusion
  154. - Press `Shift+S` to open Scripts and Add-Ins
  155. - Click the **Add-Ins** tab
  156. - Click the green **+** button next to "My Add-Ins"
  157. - Navigate to the cloned repository folder
  158. - Select the folder and click **OK**
  159. - Click **Run** to start the add-in
  160. ### Configuration
  161. The add-in auto-connects to the MCP server on startup. Check the **TEXT COMMANDS** window in Fusion to see connection logs.
  162. ---
  163. ## 🎬 Quick Start Examples
  164. ### Example 1: Get API Documentation (NEW!)
  165. ```python
  166. # Quick search by class name
  167. fusion360.execute({
  168. "operation": "get_api_documentation",
  169. "search_term": "Sketch",
  170. "category": "class_name",
  171. "max_results": 3
  172. })
  173. # Get rich docs with code samples
  174. fusion360.execute({
  175. "operation": "get_online_documentation",
  176. "class_name": "ExtrudeFeatures",
  177. "member_name": "createInput"
  178. })
  179. # Returns: Full parameter descriptions, return types, and 8 working examples!
  180. # Get best practices guide
  181. fusion360.execute({
  182. "operation": "get_best_practices"
  183. })
  184. # Returns: Coordinate systems, body naming, construction planes, PTransaction patterns
  185. ```
  186. ### Example 2: Simple Sketch (Generic API)
  187. ```python
  188. # Create a sketch
  189. fusion360.execute({
  190. "api_path": "design.rootComponent.sketches.add",
  191. "args": ["design.rootComponent.xYConstructionPlane"],
  192. "store_as": "my_sketch"
  193. })
  194. # Add a rectangle
  195. fusion360.execute({
  196. "api_path": "$my_sketch.sketchCurves.sketchLines.addTwoPointRectangle",
  197. "args": [
  198. {"type": "Point3D", "x": 0, "y": 0, "z": 0},
  199. {"type": "Point3D", "x": 10, "y": 5, "z": 0}
  200. ]
  201. })
  202. ```
  203. ### Example 3: Python with Database (NEW!)
  204. ```python
  205. fusion360.execute({
  206. "operation": "execute_python",
  207. "code": """
  208. import adsk.core, adsk.fusion
  209. # Create mounting plate
  210. sketch = design.rootComponent.sketches.add(design.rootComponent.xYConstructionPlane)
  211. lines = sketch.sketchCurves.sketchLines
  212. lines.addTwoPointRectangle(
  213. adsk.core.Point3D.create(0, 0, 0),
  214. adsk.core.Point3D.create(10, 8, 0)
  215. )
  216. # Add mounting holes
  217. circles = sketch.sketchCurves.sketchCircles
  218. for x, y in [(1, 1), (9, 1), (1, 7), (9, 7)]:
  219. circles.addByCenterRadius(adsk.core.Point3D.create(x, y, 0), 0.25)
  220. # Store in database
  221. mcp.call('sqlite', {
  222. 'input': {
  223. 'sql': 'INSERT INTO parts (name, holes) VALUES (?, ?)',
  224. 'params': [sketch.name, 4],
  225. 'database': 'designs.db',
  226. 'tool_unlock_token': '29e63eb5'
  227. }
  228. })
  229. print(f'Created {sketch.name} with 4 mounting holes')
  230. """
  231. })
  232. ```
  233. ### Example 4: Access Custom Add-ins (NEW!)
  234. ```python
  235. fusion360.execute({
  236. "operation": "execute_python",
  237. "code": """
  238. import sys
  239. # Find loaded add-ins
  240. addins = [name for name in sys.modules.keys() if 'addin' in name.lower()]
  241. print(f'Found {len(addins)} add-ins')
  242. # Access AirfoilTools (if loaded)
  243. if 'AirfoilTools' in str(addins):
  244. airfoil_main = sys.modules['...AirfoilTools_py']
  245. foildb = airfoil_main.foildb2020.Foildb2020()
  246. # Find best airfoil
  247. best = max(foildb, key=lambda x: x['clcd'])
  248. print(f'Best L/D ratio: {best["clcd"]:.2f}')
  249. # Store in database
  250. mcp.call('sqlite', {
  251. 'input': {
  252. 'sql': 'INSERT INTO airfoils (name, ld_ratio) VALUES (?, ?)',
  253. 'params': [best['Foil_fn'], best['clcd']],
  254. 'database': 'airfoils.db',
  255. 'tool_unlock_token': '29e63eb5'
  256. }
  257. })
  258. """
  259. })
  260. ```
  261. ---
  262. ## 🏗️ Architecture
  263. ### How It Works
  264. 1. **Add-in loads** and connects to local MCP-Link server
  265. 2. **Registers itself** as a `fusion360` tool via reverse connection
  266. 3. **AI sends commands** with three operation types:
  267. - Generic API calls (simple operations)
  268. - Python execution (complex workflows)
  269. - MCP tool calls (cross-tool integration)
  270. 4. **Generic handler** resolves paths, constructs objects, executes API calls
  271. 5. **Python executor** runs code with TRUE INLINE access to Fusion environment
  272. 6. **Results returned** to AI with full context and type information
  273. ### Components
  274. - **MCP-Link Server** - Routes AI requests to the add-in
  275. - **Generic API Handler** - Dynamically executes any Fusion API call
  276. - **Python Executor** (NEW!) - Runs arbitrary Python with full access
  277. - **MCP Bridge** (NEW!) - Allows Python to call other MCP tools
  278. - **Context Manager** - Stores intermediate objects for multi-step operations
  279. - **Enhanced Reporting** - Provides detailed success/error information
  280. - **Thread-Safe Proxy** (NEW!) - Ensures all Fusion API calls happen on main thread
  281. - **Centralized Logger** (NEW!) - Thread-safe logging from any component
  282. - **Documentation System** (NEW!) - Three-tier docs: introspection, online, best practices
  283. - **Auto-Updater** (NEW!) - Secure, signature-verified automatic updates
  284. ---
  285. ## 🎨 Supported Patterns
  286. ### API Paths
  287. ```python
  288. "design.rootComponent.sketches.add" # Access via app object
  289. "$sketch.sketchCurves.sketchCircles.addByCenterRadius" # Use stored objects
  290. "adsk.core.Point3D.create" # Full module paths
  291. "adsk.core.ValueInput.createByString" # Static methods
  292. ```
  293. ### Object Construction
  294. ```python
  295. {"type": "Point3D", "x": 5, "y": 10, "z": 0} # Construct from dict
  296. {"type": "Vector3D", "x": 1, "y": 0, "z": 0} # 3D vector
  297. {"type": "ValueInput", "value": 2.5} # Real value (cm)
  298. {"type": "ValueInput", "expression": "2.5 cm"} # String expression
  299. {"type": "ObjectCollection"} # Empty collection
  300. "$my_sketch.originPoint" # Reference stored object
  301. 0 # Enum as integer
  302. ```
  303. ### Context Storage
  304. ```python
  305. "store_as": "my_object" # Store result as $my_object
  306. "$my_object.someMethod" # Use in next command
  307. ```
  308. ### Python Execution
  309. ```python
  310. "operation": "execute_python" # Run Python code
  311. "code": "import adsk.core\n..." # Python code string
  312. "session_id": "my_session" # Persistent session
  313. "persistent": true # Variables persist
  314. # Pre-injected variables available in your code:
  315. # - app : adsk.core.Application.get()
  316. # - ui : app.userInterface
  317. # - design : Active design (if document open)
  318. # - rootComponent: design.rootComponent (if document open)
  319. # - fusion_context: Dict of objects stored via store_as
  320. # - mcp : MCP bridge for calling other tools
  321. ```
  322. ### MCP Tool Calling (NEW!)
  323. ```python
  324. "operation": "call_tool" # Call another MCP tool
  325. "tool_name": "sqlite" # Tool to call
  326. "arguments": {"input": {...}} # Tool arguments
  327. ```
  328. ### Documentation Operations (NEW!)
  329. ```python
  330. "operation": "get_api_documentation" # Search API by introspection
  331. "search_term": "ExtrudeFeature" # What to search for
  332. "category": "class_name" # class_name, member_name, description, all
  333. "max_results": 3 # Limit results
  334. "operation": "get_online_documentation" # Fetch rich docs from Autodesk
  335. "class_name": "ExtrudeFeatures" # Required: class name
  336. "member_name": "createInput" # Optional: method/property name
  337. "operation": "get_best_practices" # Get design guidelines
  338. ```
  339. ---
  340. ## 🎨 Advanced Capabilities
  341. ### Electronics Design
  342. Fusion 360 includes **complete electronics design capabilities** accessible via API:
  343. **Workspaces Available**:
  344. - ✅ Schematic Editor - Circuit schematic capture
  345. - ✅ PCB Editor - PCB layout with auto-routing
  346. - ✅ 3D PCB - Visualize PCB in mechanical context
  347. - ✅ Symbol/Footprint editors - Create custom components
  348. **Use Cases**:
  349. - Design PCBs and mechanical enclosures together
  350. - 3D visualization of PCB in product design
  351. - Export Gerber files for manufacturing
  352. - Component library management
  353. ### CAM/Manufacturing
  354. Full manufacturing capabilities with **280+ CAM classes**:
  355. **Capabilities**:
  356. - 2D/3D milling toolpaths
  357. - Turning operations (lathe)
  358. - Additive manufacturing (3D printing)
  359. - Post-processing for CNC machines
  360. - Toolpath simulation
  361. **Module**: `adsk.cam` fully accessible via Python
  362. ### McMaster-Carr Integration
  363. Direct access to **500,000+ industrial components**:
  364. **Command**: `InsertMcMasterCarrComponentCommand`
  365. **Categories**:
  366. - Bearings, fasteners, gears, motors
  367. - Pneumatics, hydraulics, electronics
  368. - Raw materials, tools, safety equipment
  369. **Limitation**: Opens interactive dialog (user must select part)
  370. ### Simulation & Analysis
  371. - Static stress analysis
  372. - Modal analysis (vibration)
  373. - Thermal analysis
  374. - Shape optimization
  375. - Event simulation (drop tests)
  376. ### Generative Design
  377. - AI-driven design exploration
  378. - Hundreds of design alternatives
  379. - Optimization for weight, strength, manufacturing
  380. - Cloud-based computation
  381. ---
  382. ## 💡 Use Cases
  383. ### AI Design Assistants
  384. - Natural language to CAD: "Create a mounting bracket with 4 holes"
  385. - Design exploration: "Try 10 variations of this part"
  386. - Parameter optimization: "Find the best dimensions for strength"
  387. ### Data-Driven Design (NEW!)
  388. - Query databases: "Find the best airfoil for Re=500,000"
  389. - Store analysis: "Save this design's mass and volume"
  390. - Compare designs: "Show me all brackets lighter than 100g"
  391. ### Workflow Automation (NEW!)
  392. - Multi-tool workflows: Create design → Store in DB → Show popup
  393. - Access custom add-ins: Use your existing add-ins via AI
  394. - Batch operations: Process 100 designs automatically
  395. ### Educational Tools
  396. - Learn Fusion API through AI guidance
  397. - Interactive tutorials with instant feedback
  398. - Explore aerodynamics with AirfoilTools integration
  399. ### CAM Automation
  400. - AI-driven toolpath generation
  401. - Optimize cutting parameters
  402. - Batch process manufacturing jobs
  403. ---
  404. ## 🎯 Real-World Example: AirfoilTools Integration
  405. **Scenario**: You have the AirfoilTools add-in (15,000+ users) loaded in Fusion.
  406. **AI can**:
  407. 1. Discover the add-in automatically
  408. 2. Access 1,538 airfoil profiles
  409. 3. Find the best airfoil (L/D ratio: 505.02!)
  410. 4. Store results in SQLite
  411. 5. Create geometry in Fusion
  412. 6. Show results in popup
  413. **All without any custom integration code!**
  414. See [`AUTODESK_DEMO_AIRFOILTOOLS.md`](AUTODESK_DEMO_AIRFOILTOOLS.md) for the complete demo.
  415. ---
  416. ## 📚 Documentation
  417. - **[Quick Start Guide](TESTING_PYTHON_INTEGRATION.md)** - 10 comprehensive tests
  418. - **[Python Integration](docs/PYTHON_INTEGRATION_COMPLETE.md)** - Full capabilities
  419. - **[Demo Scripts](demo.md)** - Working examples
  420. - **[AirfoilTools Demo](AUTODESK_DEMO_AIRFOILTOOLS.md)** - Real-world integration
  421. ---
  422. ## 🔧 Technical Details
  423. ### Core Architecture
  424. - Built with Fusion's native Python API
  425. - Uses Server-Sent Events (SSE) for MCP connection
  426. - JSON-RPC protocol for command execution
  427. - TRUE INLINE Python execution (no sandboxing)
  428. - Zero overhead on Fusion performance
  429. - All operations run locally (no cloud dependencies)
  430. - Auto-reconnection with exponential backoff
  431. - Native messaging protocol for server discovery
  432. ### Thread Safety & Stability
  433. - **Main Thread Execution**: All Fusion API calls execute on Fusion's main UI thread
  434. - **Work Queue System**: Background threads queue work items for safe main thread processing
  435. - **Custom Event Handler**: Uses Fusion's `CustomEvent` system to safely trigger API calls
  436. - **Centralized Logging**: Thread-safe log buffer ensures reliable diagnostics from any thread
  437. - **Crash Prevention**: Robust architecture prevents crashes even under heavy load
  438. ### Documentation System (NEW!)
  439. - **Three-Tier Approach**: Introspection → Online docs → Best practices
  440. - **Introspection**: Live API search using Python's `inspect` module
  441. - **Online Docs**: Fetches from Autodesk's cloudhelp with predictable URLs
  442. - **Best Practices**: Built-in guide covering coordinate systems, body naming, PTransaction patterns
  443. - **Rich Content**: Parameter tables, return types, and working code samples
  444. ### Auto-Update System (NEW!)
  445. - **Secure Updates**: RSA signature verification ensures authenticity
  446. - **Static Loader**: Minimal stub that never updates itself
  447. - **Safe Overwrites**: Updates applied before modules load
  448. - **Background Downloads**: Non-blocking update checks
  449. - **Version Tracking**: `VERSION.txt` for reliable version comparison
  450. - **Platform-Specific**: Separate packages for Windows/Mac
  451. ---
  452. ## ⚠️ Limitations
  453. - Enum values must be passed as integers (e.g., `0` for `NewBodyFeatureOperation`)
  454. - Some complex objects need specific construction patterns
  455. - Context is lost when add-in is reloaded (working as intended for session isolation)
  456. - Python execution has FULL system access (use responsibly!)
  457. ---
  458. ## 🚀 Future Enhancements
  459. - ~~Semantic search integration for auto-documentation~~ ✅ **DONE** (Multi-source docs)
  460. - ~~Auto-update system~~ ✅ **DONE** (Secure signature-verified updates)
  461. - Batch operation optimization
  462. - Extended enum handling
  463. - More intuitive object construction patterns
  464. - Script library for common operations
  465. - Visual workflow builder
  466. - Electronics design automation (PCB layout, schematic capture)
  467. - CAM toolpath generation via AI
  468. ---
  469. ## 🤝 Contributing
  470. **Want to contribute?** PRs welcome! This is the future of AI-powered CAD.
  471. ### Ideas for Contributors
  472. - Add example workflows
  473. - Improve error messages
  474. - Create tutorial videos
  475. - Test with different add-ins
  476. - Build integration with other CAD tools
  477. ---
  478. ## 📄 License
  479. Proprietary - See LICENSE file for details
  480. ---
  481. ## 👤 Author
  482. Created by [AuraFriday](https://github.com/AuraFriday)
  483. With 15,000+ users trusting previous Fusion add-ins
  484. ---
  485. ## 🔗 Links
  486. - **MCP-Link Server**: https://github.com/AuraFriday/mcp-link-server
  487. - **Offical Store Add-in**: https://apps.autodesk.com/FUSION/en/Detail/Index?id=7269770001970905100
  488. - **Model Context Protocol**: https://modelcontextprotocol.io
  489. - **Fusion API**: https://help.autodesk.com/view/fusion360/ENU/?guid=GUID-A92A4B10-3781-4925-94C6-47DA85A4F65A
  490. ---
  491. ## ❓ FAQ
  492. **Q: Does this work with my existing add-ins?**
  493. A: Yes! AI can discover and use ANY loaded add-in automatically.
  494. **Q: Do I need to write custom integration code?**
  495. A: No! The generic API handler works with everything.
  496. **Q: Can AI access my databases?**
  497. A: Yes! Use the SQLite tool to store and query design data.
  498. **Q: Is this secure?**
  499. A: Python execution has full system access. Only run code you trust.
  500. **Q: Does this work offline?**
  501. A: Yes! All operations run locally. Optional: use local AI models.
  502. **Q: Can I use this with Claude/ChatGPT/etc?**
  503. A: Yes! Works with any AI that supports MCP protocol.
  504. **Q: Is it stable? Will it crash Fusion?**
  505. A: Very stable! Thread-safe architecture ensures all API calls happen on main thread, preventing crashes.
  506. **Q: Can I use this in production?**
  507. A: Yes! The add-in is production-ready with robust error handling and stability features.
  508. **Q: How do updates work?**
  509. A: Automatic! The add-in checks for updates in the background and applies them on next restart. All updates are cryptographically signed for security.
  510. **Q: Can AI access Fusion's documentation?**
  511. A: Yes! Three ways: (1) Live API introspection, (2) Autodesk's official cloudhelp docs with code samples, (3) Built-in best practices guide.
  512. **Q: Does this work with electronics design?**
  513. A: Yes! Full access to PCB design, schematic capture, 3D PCB visualization, and component libraries.
  514. **Q: Can I use this for manufacturing (CAM)?**
  515. A: Yes! The `adsk.cam` module provides 280+ classes for milling, turning, additive manufacturing, and toolpath generation.
  516. ---
  517. ## 🌟 Star This Project!
  518. If you find this useful, please star the repository and share with the Fusion community!
  519. **Questions?** Open an issue or check the documentation in [`docs/`](docs/)
  520. ---
  521. **This is the future of AI-powered CAD.** 🚀

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.