# RhinoMCP: controlling Rhino 8 and Grasshopper from an AI agent

> RhinoMCP is an MIT-licensed MCP server plus a Rhino plugin that lets assistants like Claude, Codex and Cursor build geometry and wire Grasshopper graphs in plain language. It targets Rhino 8 on Windows and macOS, and it is only as useful as the client you connect it to.

**jingcheng-chen/rhinomcp** — RhinoMCP connects Rhino 3D to AI Agent through the Model Context Protocol (MCP)

- Repository: https://github.com/jingcheng-chen/rhinomcp
- Stars: 1,117 · Forks: 104
- Language: Python
- License: MIT
- Published: 2026-09-10 · Updated: 2026-09-10 · Language: en
- Canonical page: https://hysenlabs.com/projects/jingcheng-chen-rhinomcp

## What RhinoMCP actually solves for Rhino 8 users

Rhino has always been scriptable. RhinoScript, Python and RhinoCommon are all there, and the README lists all three as things the AI can reach. The gap RhinoMCP addresses is not automation, it is authorship. Writing a Grasshopper definition by hand means knowing which component to search for, what its inputs and outputs are called, and how to wire them; the README describes the AI doing exactly that, finding components, inspecting their inputs and outputs before placing them, connecting parameters, driving sliders and toggles, and solving the graph. That is a real task, not a demo of a chat box.

The intended user is someone who already works in Rhino 8 and already uses an agentic assistant. The README points at Codex, Claude Code, Cursor and Cline by name. If you do not have one of those, the plugin has nothing to talk to. The second intended user is the person who wants the assistant to see the model: the README lists viewport capture, so the agent works from what is on screen rather than from a description you typed. For a designer iterating on a form, that closes the loop between what exists and what gets built next.

## Plugin plus MCP server: the two halves and how they talk

The repository is split into a plugin/ directory and a server/ directory, with contracts/ holding the shared definitions and docs/ holding assets. The plugin installs inside Rhino. The server is a Python package published to PyPI as rhinomcp and launched through uvx. Your AI client starts that process, the process speaks MCP to the client, and the plugin is what actually touches the Rhino document.

The environment variable RHINO_MCP_HOST is set to 127.0.0.1 in the README's examples, which tells you the bridge is a local connection rather than a hosted service. That matters for how you deploy it: there is no remote endpoint to configure, and the README notes that ChatGPT's apps and MCP connectors currently reach remote MCP servers rather than local stdio commands like uvx rhinomcp, so a ChatGPT user needs developer mode with a remote or tunneled endpoint instead.

The capability surface is broad and deliberately layered. At the simple end, the AI creates points, lines, polylines, circles, arcs, ellipses, curves, boxes, spheres, cones, cylinders and surfaces, moves and rotates them, and reads document summaries. In the middle it does loft, extrude, sweep, offset, pipe, and boolean union, difference and intersection, plus layer management and filtered selection by name, color or category with AND / OR logic. At the deep end it falls back to running any Rhino command, RhinoScript-Python, or RhinoCommon C#, with a built-in RhinoScript docs lookup. That escape hatch is the design decision worth noticing: rather than trying to wrap every Rhino operation as a typed tool, the project lets the model write code when the tool list runs out. It is more capable and less predictable at the same time.

## Installing RhinoMCP and running a first prompt

The quick start is three steps: install the plugin, connect the client, start the bridge in Rhino. The plugin comes from Rhino's own package manager, not from pip. Open Tools, then Package Manager, search for rhinomcp, click Install, and restart Rhino. The README states the target is Rhino 8 on Windows and macOS, so a Rhino 7 install is out of scope.

For the client side, the README's recommended route is to paste a prompt into an agentic assistant and let it do the configuration. The exact prompt is short:

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

If you would rather do it yourself, Codex takes one command. Note the RHINO_MCP_HOST value, which pins the server to localhost:

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

Claude Code takes a shorter one:

```bash
claude mcp add rhino -- uvx rhinomcp@latest
```

Both rely on uvx, which ships with uv. The README gives the install line for each platform: brew install uv on macOS, or the PowerShell one-liner on Windows. If you prefer to edit the client config by hand, the README shows the shape of the entry:

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

After that, start the bridge inside Rhino and ask for something concrete. A first prompt that exercises the read path before the write path is the safer order: ask the assistant to summarise the current document, then ask it to create a box and move it. The README's own example category for this is the two-way interaction demo, where the AI both creates and reads geometry. One warning from the README is easy to miss and worth repeating: run only one RhinoMCP server at a time.

## Where RhinoMCP stops being the right tool

The Rhino 8 requirement is the first hard boundary. If your studio is on Rhino 7, none of this applies, and the README does not describe a compatibility path.

The client requirement is the second. ChatGPT's app and connector route reaches remote MCP servers, not local stdio commands, and the README's answer is to use Codex for local setup or to stand up a remote or tunneled endpoint in developer mode. That is a meaningful amount of infrastructure for someone who just wanted to chat with their model. If your assistant of choice is not on the supported list, the plugin is inert.

The third boundary is about trust. The README lists running any Rhino command and executing RhinoScript-Python or RhinoCommon C# among the capabilities. That is powerful in the obvious sense and risky in the less obvious one: an agent that can run arbitrary commands inside your Rhino session can also delete objects, and the README lists delete among the transform and edit operations. Nothing in the README describes an undo guard, a confirmation step, or a dry-run mode. The README also does not document rollback. Work on a copy of the file, or save before you let an agent loose on a model you care about.

Finally, the project is young. The release history shows 0.3.2 in June 2026, then 0.4.0 and 0.4.1 in September 2026. The last push was on 2026-09-10. That is recent, but it also means the tool surface is still moving, and a client config you write today may need revisiting after the next minor release.

## RhinoMCP against writing RhinoScript yourself

The honest alternative is not another MCP server. It is the scripting you already have. RhinoScript-Python and RhinoCommon are documented, stable, and deterministic: the same script produces the same geometry every time, and you can read it before it runs. RhinoMCP trades that determinism for intent. You describe a loft between two curves and the agent decides which command to call and in what order. When it works, you skipped the lookup. When it does not, you are debugging a decision you did not write.

Grasshopper users have a second alternative: building the definition by hand. That is slower for a one-off graph and faster for a graph you will maintain, because you understand every wire. RhinoMCP's batch operation, which constructs and wires a whole graph in one shot, is aimed at the exploratory case rather than the maintained one. The README does not claim the generated definitions are idiomatic or readable afterward, and it would be reasonable to assume they are not.

The case where the comparison clearly favors RhinoMCP is inspection. Asking an agent to summarise a document, measure length, area or volume, or capture the viewport is a read-only operation with a low cost of being wrong. That is where the tool earns its place first.

## Licence, maintenance and what an upgrade costs you

RhinoMCP is MIT licensed, and the LICENSE file sits at the top level of the repository alongside CHANGELOG.md and README.md. MIT is permissive: you can use it commercially, modify it, and redistribute it, provided the copyright notice and permission notice travel with it. That is the general shape of the licence, not legal advice for your situation.

The practical licence question is not RhinoMCP's own terms but the surrounding stack. Rhino is commercial software, and the plugin runs inside it, so your Rhino licence governs the work you produce. The README does not discuss licensing of generated geometry or scripts, and it does not need to: that is between you and your Rhino licence.

Upgrade cost is where the pinned version matters. The client configs in the README use uvx rhinomcp@latest, which means every client start pulls the newest published version. That keeps you current without thinking about it, and it also means a release can change behaviour under a config you never touched. If you want reproducible behaviour, pin a version in the args array instead of using @latest, and check CHANGELOG.md before moving the pin. The repository ships a ruff.toml, so the Python side is linted, and the presence of a contracts/ directory suggests the plugin and server share a defined interface, which is the thing to watch when versions drift apart.

## Conclusion

Adopt RhinoMCP if you already run Rhino 8 on Windows or macOS and a local stdio MCP client such as Claude Code, Codex or Cursor, and you want geometry and Grasshopper work driven from a chat window. Do not adopt it if you are on Rhino 7, if your only client is ChatGPT, or if you need a documented rollback path. Before trusting it on real work, verify three things yourself: that the plugin appears in Rhino's Package Manager as rhinomcp, that your client launches uvx rhinomcp@latest without error, and that the bridge is running, since the README warns that only one RhinoMCP server should run at a time.

## FAQ

### Is there an MCP for Rhino?

Yes. RhinoMCP connects Rhino 3D and Grasshopper to AI agents through the Model Context Protocol, and it targets Rhino 8 on Windows and macOS. It ships as a Rhino plugin plus a Python MCP server published on PyPI.

### What is RhinoMCP used for?

It lets an assistant create and edit geometry, inspect the document, capture the viewport, and build or modify Grasshopper definitions from plain language. The README also lists running native Rhino commands, RhinoScript-Python and RhinoCommon C# when the built-in tools are not enough.

### How do I install RhinoMCP?

Install the plugin from Rhino's Tools menu under Package Manager by searching for rhinomcp, then restart Rhino. For the server, the README recommends asking your assistant to install the repository as a local MCP server named rhino, or running claude mcp add rhino -- uvx rhinomcp@latest. Both routes need uvx, which comes from uv.

### How do I use RhinoMCP after it is installed?

Start the bridge inside Rhino, then describe what you want in your AI client. The README advises running only one RhinoMCP server at a time, and a first prompt that asks for a document summary is a low-risk way to confirm the connection before asking for geometry.

## Sources

- [Issues](https://github.com/jingcheng-chen/rhinomcp/issues)
- [jingcheng-chen/rhinomcp on GitHub](https://github.com/jingcheng-chen/rhinomcp)
- [License: MIT](https://github.com/jingcheng-chen/rhinomcp/blob/main/LICENSE)
- [README](https://github.com/jingcheng-chen/rhinomcp/blob/main/README.md)
- [Releases](https://github.com/jingcheng-chen/rhinomcp/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/jingcheng-chen-rhinomcp