Skip to content
Back to search

rhinomcp

RhinoMCP connects Rhino 3D to AI Agent through the 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/jingcheng-chen--rhinomcp/badge.svg)](/listings/jingcheng-chen--rhinomcp)

HTML

<a href="/listings/jingcheng-chen--rhinomcp"><img src="/api/listings/jingcheng-chen--rhinomcp/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.

These steps run a script from the network that findsafeskills does not scan.

Three steps: install the Rhino plugin, connect your AI client, then start the bridge in Rhino.

1. Install the Rhino plugin

In Rhino, open **Tools → Package Manager**, search for **`rhinomcp`**, and click **Install**. Restart Rhino.

2. Connect your AI client

Option A: ask your AI assistant to install it (recommended)

If you use an agentic assistant (Codex, Claude Code, Cursor, Cline, and the like), paste this prompt:

Please install https://github.com/jingcheng-chen/rhinomcp as a local MCP server named `rhino`.

Option B: Install the mcp server or manually edit the config yourself

**Codex**, in one command:

codex mcp add rhino --env RHINO_MCP_HOST=127.0.0.1 -- uvx rhinomcp@latest

**Claude Code**, in one command:

claude mcp add rhino -- uvx rhinomcp@latest

**ChatGPT:** use Codex for the local setup above. ChatGPT apps/MCP connectors currently connect to remote MCP servers, not local stdio commands like `uvx rhinomcp`. If you want to build a ChatGPT app around RhinoMCP, use ChatGPT developer mode with a remote or tunneled MCP endpoint.

You can also manually edit the config yourself:

{
  "mcpServers": {
    "rhino": {
      "command": "uvx",
      "args": ["rhinomcp@latest"],
      "env": {
        "RHINO_MCP_HOST": "127.0.0.1"
      }
    }
  }
}

> [!IMPORTANT] > The launcher `uvx` comes from [**uv**](https://docs.astral.sh/uv/). If you don't have it yet: > macOS `brew install uv` · Windows `powershell -c "irm https://astral.sh/uv/install.ps1 | iex"` > > Run **only one** RhinoMCP server at a time (Codex, Claude, Cursor, etc. — not several at once).

<details> <summary>Auto-restart the server with your AI client (optional)</summary>

To clean up a stale `rhinomcp` process each time your client launches:

**macOS / Linux**

{
  "mcpServers": {
    "rhino": {
      "command": "sh",
      "args": ["-c", "killall rhinomcp 2>/dev/null; uvx rhinomcp@latest"]
    }
  }
}

**Windows**

{
  "mcpServers": {
    "rhino": {
      "command": "cmd",
      "args": ["/c", "taskkill /F /IM rhinomcp.exe 2>nul & uvx rhinomcp@latest"]
    }
  }
}

</details>

3. Start the Rhino bridge

With Rhino open, type **`mcpstart`** in the command line. This starts the TCP bridge the server connects to (`mcpstop` ends it). Run it once per Rhino session.

`mcpstatus` prints the port, the document and the connected clients. On Windows, `mcpwindow` opens the tray window that lists every running Rhino (see "Several Rhino instances at once").

<details> <summary>Several Rhino instances at once</summary>

Each Rhino runs its own bridge on its own port. Without a port, `mcpstart` takes the first free one from 1999 to 2008, so the first Rhino keeps 1999 and the next one gets 2000. To pin a port, use `-mcpstart Port=2000` (in a startup macro: `_-mcpstart _Port=2000 _Enter`), or start Rhino with the `RHINO_MCP_PORT` environment variable set. The port appears in the command line, in `mcpstatus` and, on Windows, at the start of the window title (`[MCP:2000] Rhinoceros 8`).

Give the MCP client one server entry per instance, differing only in `RHINO_MCP_PORT`:

{
  "mcpServers": {
    "rhino":   { "command": "uvx", "args": ["rhinomcp"], "env": { "RHINO_MCP_PORT": "1999" } },
    "rhino-2": { "command": "uvx", "args": ["rhinomcp"], "env": { "RHINO_MCP_PORT": "2000" } }
  }
}

If the port is taken, `mcpstart` says so and starts nothing rather than reaching the wrong Rhino.

On Windows, `mcpstart` also puts a RhinoMCP icon in the notification area. One icon serves every Rhino: click it (or run `mcpwindow`) for a list of the running instances with their port, the MCP entry that reaches each one (read from `~/.claude.json`), the open Rhino and Grasshopper documents, and the connected clients with their latest command. Clicking an instance brings that Rhino to the front. Each Rhino writes its state to `%LOCALAPPDATA%\RhinoMCP\instances`; the icon goes away once

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.

.claude-plugin/marketplace.json · Manifest · 15 lines

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

  1. {
  2. "name": "rhinomcp",
  3. "owner": {
  4. "name": "Jingcheng Chen"
  5. },
  6. "description": "Claude Code plugins for RhinoMCP, the MCP bridge between AI agents and Rhino 3D.",
  7. "plugins": [
  8. {
  9. "name": "rhinomcp",
  10. "source": "./cc-plugin",
  11. "description": "Rhino modeler, inspector and Grasshopper builder agents plus /scene and /snapshot commands for the RhinoMCP server.",
  12. "version": "0.5.1"
  13. }
  14. ]
  15. }
README.md · README · 415 lines

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

  1. <div align="center">
  2. <img src="docs/assets/rhinomcp_logo.svg" alt="RhinoMCP Logo" width="140">
  3. # RhinoMCP
  4. **Control Rhino 3D and Grasshopper with AI, in plain language.**
  5. RhinoMCP connects Rhino to AI agents through the [Model Context Protocol](https://modelcontextprotocol.io),
  6. so assistants like Claude and Cursor can model geometry, read your document, and build
  7. Grasshopper definitions for you, just by chatting.
  8. [![PyPI](https://img.shields.io/pypi/v/rhinomcp?logo=pypi&logoColor=white&label=PyPI&color=3775A9)](https://pypi.org/project/rhinomcp/)
  9. [![Rhino 8](https://img.shields.io/badge/Rhino-8-178600?logo=rhinoceros&logoColor=white)](https://www.rhino3d.com/)
  10. [![Python 3.10+](https://img.shields.io/badge/Python-3.10+-3776AB?logo=python&logoColor=white)](https://www.python.org/)
  11. [![MCP](https://img.shields.io/badge/MCP-Model_Context_Protocol-000000)](https://modelcontextprotocol.io/)
  12. [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
  13. [Quick start](#quick-start) · [What it can do](#what-it-can-do) · [Usage](#usage) · [Examples](#example-prompts) · [Tool reference](#tool-reference)
  14. **English** · [简体中文](README.zh-CN.md)
  15. </div>
  16. ---
  17. ## Highlights
  18. For development of the autonomous improvement experiments, start with the
  19. [continuation guide](experiments/CONTINUE.md).
  20. - Describe what you want and the assistant builds it in Rhino.
  21. - It reads your document and can capture the viewport, so it works from what is actually on screen.
  22. - It scripts Grasshopper for you: finding components, wiring them, setting sliders, and solving.
  23. - A single plugin and a single config entry cover both Rhino and Grasshopper.
  24. - When you need more control, it can run native Rhino commands, RhinoScript-Python, or RhinoCommon C#.
  25. > [!NOTE]
  26. > RhinoMCP targets **Rhino 8** on Windows and macOS.
  27. ## Demos
  28. <table>
  29. <tr>
  30. <td width="50%" align="center">
  31. [![Two-way interaction demo](docs/assets/demo2.jpg)](https://youtu.be/pi6dbqUuhI4)
  32. **Two-way interaction:** the AI both creates and reads geometry.
  33. </td>
  34. <td width="50%" align="center">
  35. [![Custom script demo](docs/assets/demo1.jpg)](https://youtu.be/NFOF_Pjp3qY)
  36. **Custom scripts:** the AI writes and runs scripts inside Rhino.
  37. </td>
  38. </tr>
  39. </table>
  40. Prefer a walkthrough? Nate made a showcase and install [tutorial on YouTube](https://www.youtube.com/watch?v=z2IBP81ABRM).
  41. ## What it can do
  42. ### <img width="30" height="30" src="https://img.icons8.com/color/48/rhinoceros-6.png" alt="rhinoceros-6"/> Rhino
  43. | Area | What the AI can do |
  44. | ------------------- | -------------------------------------------------------------------------------------------------------------------------------------- |
  45. | Create geometry | Points, lines, polylines, circles, arcs, ellipses, curves, boxes, spheres, cones, cylinders, and surfaces, one at a time or in batches |
  46. | Transform & edit | Move, rotate, scale, recolor, rename, and delete objects |
  47. | Advanced modeling | Loft, extrude, sweep, offset, pipe; boolean union, difference, and intersection |
  48. | Curve operations | Project, intersect, and split curves |
  49. | Layers & attributes | Create, delete, and switch layers; read and write object attributes |
  50. | Inspect & select | Document summaries, object info, and filtered selection (by name, color, or category, with AND / OR logic) |
  51. | See the model | Capture the viewport so the AI gets visual feedback |
  52. | Analyze | Measure length, area, volume, bounding boxes, and more |
  53. | Go deeper | Run any Rhino command, execute RhinoScript-Python, or run RhinoCommon C#, with built-in RhinoScript docs lookup |
  54. ### <img width="30" height="30" src="https://img.icons8.com/officel/80/grasshopper.png" alt="grasshopper"/> Grasshopper
  55. | Area | What the AI can do |
  56. | ----------------- | ----------------------------------------------------------------------------------------------------- |
  57. | Find components | Search the installed component library and inspect a component's inputs and outputs before placing it |
  58. | Build canvases | Add, position, lay out, update, and delete components |
  59. | Wire it up | Connect and disconnect parameters between components |
  60. | Set & read values | Drive sliders, toggles, panels, and value lists; read structured data back out of outputs |
  61. | Solve | Run the solution and surface runtime warnings and errors |
  62. | Build in one shot | Construct and wire a whole graph, or mutate an existing one, in a single batched operation |
  63. ## Quick start
  64. Three steps: install the Rhino plugin, connect your AI client, then start the bridge in Rhino.
  65. ### 1. Install the Rhino plugin
  66. In Rhino, open **Tools → Package Manager**, search for **`rhinomcp`**, and click **Install**. Restart Rhino.
  67. ### 2. Connect your AI client
  68. #### Option A: ask your AI assistant to install it (recommended)
  69. If you use an agentic assistant (Codex, Claude Code, Cursor, Cline, and the like), paste this prompt:
  70. ```
  71. Please install https://github.com/jingcheng-chen/rhinomcp as a local MCP server named `rhino`.
  72. ```
  73. #### Option B: Install the mcp server or manually edit the config yourself
  74. **Codex**, in one command:
  75. ```bash
  76. codex mcp add rhino --env RHINO_MCP_HOST=127.0.0.1 -- uvx rhinomcp@latest
  77. ```
  78. **Claude Code**, in one command:
  79. ```bash
  80. claude mcp add rhino -- uvx rhinomcp@latest
  81. ```
  82. **ChatGPT:** use Codex for the local setup above. ChatGPT apps/MCP connectors currently connect
  83. to remote MCP servers, not local stdio commands like `uvx rhinomcp`. If you want to build a
  84. ChatGPT app around RhinoMCP, use ChatGPT developer mode with a remote or tunneled MCP endpoint.
  85. You can also manually edit the config yourself:
  86. ```json
  87. {
  88. "mcpServers": {
  89. "rhino": {
  90. "command": "uvx",
  91. "args": ["rhinomcp@latest"],
  92. "env": {
  93. "RHINO_MCP_HOST": "127.0.0.1"
  94. }
  95. }
  96. }
  97. }
  98. ```
  99. > [!IMPORTANT]
  100. > The launcher `uvx` comes from [**uv**](https://docs.astral.sh/uv/). If you don't have it yet:
  101. > macOS `brew install uv` · Windows `powershell -c "irm https://astral.sh/uv/install.ps1 | iex"`
  102. >
  103. > Run **only one** RhinoMCP server at a time (Codex, Claude, Cursor, etc. — not several at once).
  104. <details>
  105. <summary>Auto-restart the server with your AI client (optional)</summary>
  106. To clean up a stale `rhinomcp` process each time your client launches:
  107. **macOS / Linux**
  108. ```json
  109. {
  110. "mcpServers": {
  111. "rhino": {
  112. "command": "sh",
  113. "args": ["-c", "killall rhinomcp 2>/dev/null; uvx rhinomcp@latest"]
  114. }
  115. }
  116. }
  117. ```
  118. **Windows**
  119. ```json
  120. {
  121. "mcpServers": {
  122. "rhino": {
  123. "command": "cmd",
  124. "args": ["/c", "taskkill /F /IM rhinomcp.exe 2>nul & uvx rhinomcp@latest"]
  125. }
  126. }
  127. }
  128. ```
  129. </details>
  130. ### 3. Start the Rhino bridge
  131. With Rhino open, type **`mcpstart`** in the command line. This starts the TCP bridge the server
  132. connects to (`mcpstop` ends it). Run it once per Rhino session.
  133. `mcpstatus` prints the port, the document and the connected clients. On Windows, `mcpwindow` opens
  134. the tray window that lists every running Rhino (see "Several Rhino instances at once").
  135. <details>
  136. <summary>Several Rhino instances at once</summary>
  137. Each Rhino runs its own bridge on its own port. Without a port, `mcpstart` takes the first free one
  138. from 1999 to 2008, so the first Rhino keeps 1999 and the next one gets 2000. To pin a port, use
  139. `-mcpstart Port=2000` (in a startup macro: `_-mcpstart _Port=2000 _Enter`), or start Rhino with the
  140. `RHINO_MCP_PORT` environment variable set. The port appears in the command line, in `mcpstatus`
  141. and, on Windows, at the start of the window title (`[MCP:2000] Rhinoceros 8`).
  142. Give the MCP client one server entry per instance, differing only in `RHINO_MCP_PORT`:
  143. ```json
  144. {
  145. "mcpServers": {
  146. "rhino": { "command": "uvx", "args": ["rhinomcp"], "env": { "RHINO_MCP_PORT": "1999" } },
  147. "rhino-2": { "command": "uvx", "args": ["rhinomcp"], "env": { "RHINO_MCP_PORT": "2000" } }
  148. }
  149. }
  150. ```
  151. If the port is taken, `mcpstart` says so and starts nothing rather than reaching the wrong Rhino.
  152. On Windows, `mcpstart` also puts a RhinoMCP icon in the notification area. One icon serves every
  153. Rhino: click it (or run `mcpwindow`) for a list of the running instances with their port, the MCP
  154. entry that reaches each one (read from `~/.claude.json`), the open Rhino and Grasshopper documents,
  155. and the connected clients with their latest command. Clicking an instance brings that Rhino to the
  156. front. Each Rhino writes its state to `%LOCALAPPDATA%\RhinoMCP\instances`; the icon goes away once
  157. no Rhino runs a server.
  158. </details>
  159. ### Staying up to date
  160. RhinoMCP has three parts that update separately:
  161. - **Python server.** `uvx rhinomcp@latest` asks PyPI for the newest release every time your
  162. client starts the server; plain `uvx rhinomcp` keeps the first version it downloaded. If you
  163. work offline, install it once with `uv tool install rhinomcp` and run `uv tool upgrade rhinomcp`
  164. when convenient.
  165. - **Rhino plugin.** Installed through the Package Manager, Rhino checks for updates at startup and
  166. installs them when "Automatically update packages when Rhino starts" is enabled; the new version
  167. loads on the next restart. A plugin installed by dragging a `.rhp` into Rhino is not updated.
  168. - **AI client.** It reads the tool list when it launches the server, so restart the client (or
  169. reconnect the server) after an update.
  170. The server reads the plugin's version when it connects and warns in its log when the two differ.
  171. A tool that needs a newer plugin fails with an update instruction instead of silently doing
  172. something else, and `describe_capabilities` reports both versions.
  173. ### Claude Code plugin (optional)
  174. This repository is also a Claude Code plugin marketplace. The `rhinomcp` plugin adds three agents
  175. (`rhino-modeler`, `rhino-inspector` and `grasshopper-builder`) and two commands: `/scene`
  176. summarizes the open document and `/snapshot [display mode]` captures the viewport and reports what
  177. it shows.
  178. ```bash
  179. claude plugin marketplace add jingcheng-chen/rhinomcp
  180. claude plugin install rhinomcp@rhinomcp
  181. ```
  182. Inside a Claude Code session the same steps are `/plugin marketplace add jingcheng-chen/rhinomcp`
  183. and `/plugin install rhinomcp@rhinomcp`. The plugin does not start the MCP server: configure it
  184. as `rhino` as described in step 2 above, since the agents call tools named `mcp__rhino__*`.
  185. ## Usage
  186. With the bridge running and your client connected, you'll see the RhinoMCP tools. From there, just
  187. chat: ask the assistant to model something, inspect your scene, or build a Grasshopper graph.
  188. <img src="docs/assets/rhino_plugin_instruction.jpg" alt="mcpstart in the Rhino command line"></td>
  189. <img src="docs/assets/claude_example.jpg" alt="RhinoMCP tools in Claude"></td>
  190. For Grasshopper, you only need Rhino open with `mcpstart` running. The assistant can open or create
  191. the Grasshopper document itself, then build the definition. For example: _"create a point attractor
  192. pattern with cylinders that have different heights."_
  193. ## Example prompts
  194. > Create 6×6×6 boxes on a 10-unit grid from the origin, sizes ramping from 1 to 5,
  195. > with a blue-to-red gradient color based on size. Use RhinoScript Python.
  196. > Make a Rhinoceros animal out of cubic blocks in cartoon colors. Then change its head to red,
  197. > and rotate the selected object 90° around the Z axis.
  198. > Create a point attractor pattern in Grasshopper: a grid of cylinders whose heights change with
  199. > their distance from an attractor point, with a slider to move the point.
  200. ## Tool reference
  201. <details>
  202. <summary><b>Rhino tools</b></summary>
  203. | Tool | Purpose |
  204. | ------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------ |
  205. | `create_object` / `create_objects` | Create one or many objects |
  206. | `modify_object` / `modify_objects` | Transform or edit one or many objects |
  207. | `delete_object` | Delete an object |
  208. | `boolean_union` / `boolean_difference` / `boolean_intersection` | Boolean operations |
  209. | `loft` / `extrude_curve` / `sweep1` / `offset_curve` / `pipe` | Advanced surface and solid modeling |
  210. | `project_curve` / `intersect_curves` / `split_curve` | Curve operations |
  211. | `analyze_objects` | Measure length, area, volume, bounding boxes, and more |
  212. | `select_objects` | Select by ids, layer, type, hidden, locked, name, color, custom attributes; AND / OR |
  213. | `get_objects` | List by ids, layer, type, bbox or selection; hidden and locked switches; paged |
  214. | `get_object_info` / `get_selected_objects_info` | Query objects |
  215. | `get_object_attributes` / `update_object_attributes` | Read and write object attributes |
  216. | `create_layer` / `delete_layer` / `get_or_set_current_layer` | Layer management |
  217. | `get_context` | Bounded snapshot: units, layer, selection, camera |
  218. | `get_document_summary` | Overview of the current document |
  219. | `capture_viewport` | Image + metadata; display mode, camera, framing, JPEG |
  220. | `set_camera` | Set camera location, target, up, lens, projection |
  221. | `zoom_to` | Frame all, the selection, object ids or a layer |
  222. | `run_command` | Run any native Rhino command |
  223. | `execute_rhinoscript_python_code` | Execute RhinoScript-Python |
  224. | `execute_rhinocommon_csharp_code` | Execute RhinoCommon C# |
  225. | `search_rhinoscript_functions` / `get_rhinoscript_docs` / `list_rhinoscript_modules` / `get_module_functions` | RhinoScript API docs lookup |
  226. | `get_commands` | List available commands |
  227. | `undo` / `redo` | Undo and redo |
  228. </details>
  229. <details>
  230. <summary><b>Grasshopper tools</b></summary>
  231. | Tool | Purpose |
  232. | --------------------------------------------------------------------- | ------------------------------------------------- |
  233. | `gh_create_document` / `gh_get_document_info` / `gh_get_canvas_state` | Document and canvas inspection |
  234. | `gh_search_components` / `gh_batch_search_components` | Search the component library |
  235. | `gh_list_component_categories` / `gh_get_available_components` | Browse installed components |
  236. | `gh_get_component_type_info` / `gh_get_component_info` | Inspect a component type or instance |
  237. | `gh_list_components` | List components on the canvas |
  238. | `gh_add_component` / `gh_update_component` / `gh_delete_component` | Add, update, or delete components |
  239. | `gh_layout_components` | Auto-lay-out the canvas |
  240. | `gh_clear_canvas` | Clear the canvas |
  241. | `gh_connect_components` / `gh_disconnect_components` | Wire or unwire parameters |
  242. | `gh_set_parameter_value` / `gh_get_parameter_value` | Drive inputs, read outputs |
  243. | `gh_run_solution` / `gh_expire_solution` | Solve or expire the solution |
  244. | `gh_build_graph` / `gh_mutate_graph` | Build or mutate a whole graph in one batched call |
  245. | `gh_get_graph` / `gh_clear_graph` | Inspect or clear objects by graph id |
  246. </details>
  247. ## How it works
  248. ```
  249. AI client ──MCP (stdio)──► rhinomcp (Python) ──TCP 127.0.0.1:1999──► Rhino plugin ──► Rhino + Grasshopper
  250. ```
  251. 1. `server/`: a Python [MCP](https://modelcontextprotocol.io) server (official Python SDK 2.x) that exposes each tool and forwards it to Rhino.
  252. 2. `plugin/`: a RhinoCommon C# plugin that runs a TCP listener inside Rhino and executes commands on the main thread. Start and stop it with the `mcpstart` / `mcpstop` Rhino commands.
  253. 3. `contracts/`: JSON Schema definitions that keep the wire protocol between the two tiers in sync.
  254. `IMPLEMENTATION.md` has a deeper tour of the code.
  255. ## Security
  256. The Python server and the Rhino plugin talk over an unauthenticated TCP loopback link
  257. (`127.0.0.1:1999`). Tools such as `run_command`, `execute_rhinoscript_python_code`, and
  258. `execute_rhinocommon_csharp_code` give the model an open execution surface inside Rhino. This is
  259. fine for local agent use. Do not expose it beyond the loopback interface without adding
  260. authentication.
  261. <details>
  262. <summary>Operator switches (environment variables)</summary>
  263. | Variable | Default | Effect |
  264. | ------------------------------ | ----------- | ----------------------------------------------------------------------------- |
  265. | `RHINO_MCP_HOST` | `127.0.0.1` | Connect target. Refuses non-loopback hosts unless `RHINO_MCP_ALLOW_REMOTE=1`. |
  266. | `RHINO_MCP_PORT` | `1999` | TCP port. Also read by `mcpstart` in Rhino. |
  267. | `RHINO_MCP_ENABLE_RUN_COMMAND` | `1` | Set `0` to disable the `run_command` tool. |
  268. | `RHINO_MCP_ENABLE_RHINOSCRIPT` | `1` | Set `0` to disable RhinoScript-Python execution. |
  269. | `RHINO_MCP_ENABLE_CSHARP` | `1` | Set `0` to disable RhinoCommon C# execution. |
  270. | `RHINO_MCP_VALIDATE` | `warn` | Pre-flight schema validation: `off` / `warn` / `strict`. |
  271. | `RHINO_MCP_TIMEOUT` | `15.0` | Socket timeout in seconds. |
  272. | `RHINO_MCP_DEBUG` | `0` | Verbose logging. |
  273. </details>
  274. ## For developers
  275. <details>
  276. <summary>Build, test, and publish</summary>
  277. **Python server** (run from `server/`)
  278. ```bash
  279. uv venv && uv pip install -e ".[dev]" # set up
  280. uv run pytest # run tests (no Rhino needed; uses a mock server)
  281. uv run ruff check src/rhinomcp # lint
  282. uv run python ../contracts/test_schemas.py # validate JSON schemas
  283. uv build && uv publish # publish to PyPI
  284. ```
  285. **C# plugin**
  286. ```bash
  287. dotnet restore plugin/rhinomcp.sln
  288. dotnet build plugin/rhinomcp.sln --configuration Release
  289. ```
  290. To publish the plugin: build in Release, copy `manifest.yml` into `bin/Release`, then run
  291. `yak build` and `yak push rhinomcp_xxxx.yak`.
  292. </details>
  293. ## Contributing
  294. Contributions are welcome. Feel free to open an issue or submit a pull request.
  295. ## Disclaimer
  296. This is a third-party integration and is not made by McNeel. Built by
  297. [Jingcheng Chen](https://github.com/jingcheng-chen).
  298. ## Star history
  299. [![Star History Chart](https://api.star-history.com/svg?repos=jingcheng-chen/rhinomcp&type=Date)](https://www.star-history.com/#jingcheng-chen/rhinomcp&Date)
  300. ### Modeling guidance distributed with the server
  301. The Python package includes reusable guidance for transforms, planar regions,
  302. organization, verification and recovery. Use `get_modeling_guidance("overview")`,
  303. the `asset_general_strategy` MCP prompt, or the `rhinomcp://guidance/{topic}` resource.
  304. Essential tool semantics stay in tool descriptions. No local experiment folder or
  305. separate skill is needed. See [packaged guidance](server/README.md#bundled-modeling-guidance)
  306. for available topics and release details.

Ratings and comments

Sign in to rate this skill.

Sign in

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