rhino-mcp
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@rhino-mcp Model a helix curve and export it as STEP"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
rhino-mcp
Drive McNeel Rhino 8 and Grasshopper from Claude through the Model Context Protocol.
Overview
rhino-mcp is a Model Context Protocol server that lets Claude (or any MCP client) drive Rhino 8 — creating geometry, manipulating layers and materials, baking Grasshopper output, exporting STEP/IGES/STL/OBJ — through plain natural-language tool calls.
It runs in two modes:
Standalone (default): backed by
rhino3dmfor headless.3dmfile authoring; works without Rhino installed and exposes ~242 tools (geometry, file-I/O, transform, layer, material, analysis, RhinoScript docs, composition, document hygiene, geometry validation, GH template catalogue, freeform skin / panelisation / curvature / fields, drawing-set sheet + title block, schedule / quantity, block definition, sun-position + shadow projection, BIM metadata tagging, 19 physical material presets, BRE daylight factor + Bird DNI clear-sky model, and multi-Rhino announcement-file discovery).Bridge: when the C# bridge plugin is loaded in a live Rhino 8 session, the server transparently forwards every call (booleans, lofts, sweeps, viewport image capture + zoom-to-object / zoom-to-layer, render, scripting (Python and gated Roslyn C# with timeouts and extra references), deformation, NURBS editing, SubD, paneling, freeform analysis with true Gaussian curvature, drawing-set view placement + section cuts + PDF export, accurate Brep-area schedules, block explode/redefine, ray-cast solar exposure + Brep ray probe, IFC / gbXML import-export, HDRI environment, camera / light / render / turntable automation, layer-material binding, and every Grasshopper operation including batched
connect_manywiring and slider placement) to RhinoCommon and Grasshopper.Instances, exposing ~245 tools.
Related MCP server: GOLEM-3DMCP-Rhino-
Features
Full geometry catalogue — points, lines, polylines, arcs, circles, ellipses, polygons, helixes, NURBS curves, rebuilds.
Solids and meshes — boxes, spheres, cylinders, cones, tori, mesh boxes; booleans / sweeps / lofts / fillets via the bridge.
Transforms — move, rotate, scale, mirror, plane-to-plane orient, linear/polar/rectangular arrays.
Script execution — run arbitrary RhinoScript Python (IronPython) or RhinoCommon C# (Roslyn) code in a live Rhino session, with built-in RhinoScript API documentation search (899 functions).
Advanced modeling — deformation (bend/twist/taper/flow), NURBS editing (rebuild/unroll/evaluate), SubD, surface matching, extraction (dup edge/border/isocurve/Make2D), control points, and paneling tools.
Drawing-set authoring — sheet / title block / north arrow / scale bar in standalone; multi-view placement, section cuts, and PDF export through the bridge.
Quantity & schedule — per-layer / per-material / per-
user_textaggregation with CSV export; bridge mode usesAreaMassProperties/VolumeMassPropertiesfor accurate Brep area + volume.Block / instance reuse — define / insert / list blocks in standalone; explode / redefine in bridge mode for synchronized component edits.
Environmental analysis — sun position + monthly sun-path polylines + shadow projection (NOAA SPA approximation); ray-cast solar exposure in bridge mode. Daylight precision adds Bird DNI clear-sky model with Kasten-Young air mass and Linke turbidity, plus BRE simplified daylight factor.
BIM interchange — IFC2x3 / IFC4 / IFC4x3 import & export, gbXML export, and IFC PropertySet metadata tagging that round-trips through
user_text.Material presets + HDRI — 19 bundled physical presets (concrete / brick / steel / aluminium / glass / timber / stone / plaster / fabric / landscape) keyed by category; HDRI environment for rendering.
Render automation — camera / light / render-engine setup, render-to-file, and parametric turntable sequences (bridge mode).
Undo / redo and batch operations — every bridge operation is wrapped in undo records; batch modify changes many objects in a single call.
Layers, materials, blocks, groups — full attribute control on the document.
File I/O — open/save
.3dm, export OBJ/STL standalone; STEP/IGES/DXF and screenshots via the bridge.Inline base64 screenshots —
rhino_screenshot(as_base64=True)returns the PNG payload inline for visual verification by the LLM.Rich object selection —
rhino_object_selectfilters by glob name pattern, layer, RGB color, object type, and user-text key/value pairs.Pagination on bulk queries —
rhino_list_objectsreturns apagination: {total, offset, limit, returned, has_more}block so large documents stay manageable.Scene composition shortcuts (v0.2) —
rhino_place_grid,rhino_stack_floors,rhino_scatter,rhino_replicate_along_curvecollapse "loop + transform" into a single tool call.Document hygiene tools (v0.2) — query/set units, tolerances, and base point (
rhino_document_units_*,rhino_tolerance_*,rhino_origin_set);rhino_document_summaryexposes them so the LLM can verify scale before issuing geometry calls.Geometry validation (v0.2) —
rhino_validate_brep,rhino_report_mesh_health,rhino_curve_continuity, plusrhino_check_naked_edges(bridge) for explicit topology diagnostics before booleans / exports.Grasshopper template loader (v0.2) —
gh_template_listreads a manifest of pre-wired definitions;gh_load_template,gh_bind_template_parameter,gh_run_template(bridge) load, parameterise, and bake them.Free-form architecture toolkit —
rhino_skin_from_sections,rhino_uv_grid_panels,rhino_panel_planarity,rhino_panel_curvature_classify,rhino_surface_developable_score,rhino_attractor_displace_points,rhino_smooth_polyline. Bridge mode adds true Gaussian / mean / principal curvature, world-axis slicing, and waffle ribs.Strategy prompts for the LLM — seven
@mcp.prompt()guides (general_strategy,rhinoscript_workflow,viewport_workflow,parametric_workflow,bim_authoring_workflow,design_dialogue_workflow,freeform_workflow) help Claude pick the right tool, avoid hallucinated APIs, and keep the user in the loop on design decisions.Async-capable tools — read-only query tools run on
async defso concurrent bridge round-trips don't stall the MCP transport.Robust connection layer — JSON-RPC over named pipe / Unix socket / TCP with
MSG_PEEKliveness probes and exponential backoff with jitter on reconnect.Grasshopper automation — open
.ghfiles, drop components, wire them, set sliders/panels/toggles, run, bake, read DataTrees.Three transports — stdio (Claude Desktop), Streamable HTTP, Docker/TCP.
Capability-aware registration — bridge-only tools are simply not registered when no bridge is reachable; no stub functions, ever.
Actionable errors — every failure carries a category, a remediation hint, and details the agent can act on.
Architecture
┌──────────────┐ stdio | HTTP ┌────────────────┐
│ Claude / │ ◀──────────────────▶ │ rhino-mcp │
│ MCP client │ │ (Python) │
└──────────────┘ └─────┬──────────┘
│
JSON-RPC 2.0 │ (named pipe / unix socket / TCP)
│
┌─────────▼──────────┐
│ C# Bridge Plugin │
│ (inside Rhino 8) │
│ ──────────────── │
│ RhinoCommon │
│ Grasshopper │
│ Roslyn (C# exec) │
│ IronPython (Py) │
└────────────────────┘In standalone mode the right-hand side is replaced by an in-process rhino3dm.File3dm document; bridge-only tools are unregistered.
Requirements
Python 3.11 or newer
rhino3dm >= 8.9,mcp[cli] >= 1.2,pydantic >= 2.6(installed automatically)Optional: McNeel Rhino 8 (any platform) — needed only for bridge mode
Optional: .NET 8 SDK — to build the C# bridge plugin (
dotnet build)Optional:
pywin32on Windows for the named-pipe transport
Installation
Using uv (recommended)
uv tool install rhino-mcp
# or, from a checkout:
uv sync && uv run rhino-mcpUsing pip
pip install rhino3dm-mcp
rhino-mcp --versionOne-shot Claude Desktop wiring
After installing the package, register the server with Claude Desktop in a single command instead of editing claude_desktop_config.json by hand:
rhino-mcp install # auto-detect launcher (uvx / rhino-mcp / python)
rhino-mcp install --mode bridge # force bridge mode in the env block
rhino-mcp install --force # overwrite an existing entry
rhino-mcp install --dry-run # preview the JSON without writingThe command writes a timestamped .bak.* copy of the existing config before saving, and is idempotent — re-running with the same flags is a no-op.
Restart Claude Desktop afterwards to pick up the change.
From inside Rhino — _McpInstall
If the bridge plugin is loaded, type _McpInstall on the Rhino command line.
The command is non-interactive: it locates uvx / rhino-mcp / python on PATH (with ~/.local/bin, ~/.cargo/bin, /opt/homebrew/bin, and /usr/local/bin searched on macOS so the GUI-app PATH is enough), runs the same install pipeline as rhino-mcp install, and streams the outcome to the Rhino command line.
The MCP server is registered with --mode auto so Claude Desktop attaches to the bridge when Rhino is running and falls back to standalone (rhino3dm) when it is not.
Docker
docker compose -f docker/docker-compose.yml up --buildThe container exposes the server over Streamable HTTP on TCP :8765.
Running the server
rhino-mcp is normally launched by an MCP client (Claude Desktop / Cursor / claude.ai connector) via the command + args you put into the client's config.
You can also run it manually for debugging.
Launch modes
Use case | Command |
Stdio (Claude Desktop default) |
|
Streamable HTTP (local dev / Cursor) |
|
Streamable HTTP (claude.ai connector) |
|
Docker (HTTP on |
|
Force standalone (no Rhino needed) |
|
Force bridge (fail fast if Rhino down) |
|
Force bridge with HTTP fallback |
|
Show all CLI flags |
|
The HTTP endpoint is http://<host>:<port>/mcp.
Use --allow-external only when exposing the server through ngrok / Cloudflare Tunnel / etc.
— it disables DNS-rebinding protection.
Claude Desktop (stdio)
claude_desktop_config.json lives at:
OS | Path |
macOS |
|
Windows |
|
Linux |
|
Paste this entry under mcpServers:
{
"mcpServers": {
"rhino-mcp": {
"command": "uvx",
"args": ["rhino3dm-mcp"],
"env": {
"RHINO_MCP_TRANSPORT": "stdio",
"RHINO_HOST": "127.0.0.1",
"RHINO_PORT": "4242",
"RHINO_MCP_LOG_LEVEL": "INFO"
}
}
}
}Prefer a checkout?
Point command at uv and run from the repo:
{
"mcpServers": {
"rhino-mcp": {
"command": "uv",
"args": ["--directory", "/absolute/path/to/rhino-mcp", "run", "rhino-mcp"],
"env": { "RHINO_MCP_LOG_LEVEL": "DEBUG" }
}
}
}Restart Claude Desktop; the rhino-mcp tools and the three strategy prompts (general_strategy, rhinoscript_workflow, viewport_workflow) appear in the palette.
Cursor IDE
Cursor reads ~/.cursor/mcp.json (global) or <project>/.cursor/mcp.json (per-project):
{
"mcpServers": {
"rhino-mcp": {
"command": "uvx",
"args": ["rhino3dm-mcp"],
"env": { "RHINO_MCP_FORCE_MODE": "bridge" }
}
}
}claude.ai remote connector (Streamable HTTP)
Run the server with HTTP + external access:
rhino-mcp --transport http --host 0.0.0.0 --port 8765 --allow-external --statelessTunnel it (e.g.
ngrok http 8765) and grab the public HTTPS URL.In claude.ai → Settings → Connectors → Add custom connector, set the URL to
https://<your-tunnel>/mcp.
Generic stdio MCP clients
Any MCP-compatible client (mcp-inspector, Continue, Claude Code, etc.) that can spawn a subprocess will work — give it uvx rhino3dm-mcp or the path to your rhino-mcp entry-point and inherit env vars from the table below.
Rhino-side bridge plugin (C# — recommended)
Build and install the C# plugin for full 235 tool support.
The included helper script wraps dotnet build and verifies the post-build install location:
./scripts/build-plugin.sh # debug build + install
./scripts/build-plugin.sh --release # release build
./scripts/build-plugin.sh --clean # clean + rebuild
# Or invoke dotnet directly:
dotnet build rhino_plugin/csharp/RhinoMCPPlugin.csproj -c ReleasePost-build targets copy the .rhp:
OS | Path |
macOS |
|
Windows |
|
Restart Rhino 8 — the bridge starts automatically on load (TCP :4242 by default).
Then restart rhino-mcp (or set RHINO_MCP_FORCE_MODE=bridge) and the bridge-only tools become available.
Quick start
# After "rhino-mcp" is configured in Claude Desktop, ask Claude:
# "Create a 10-unit sphere at the origin and save the document to /tmp/demo.3dm"
# Behind the scenes Claude calls rhino_sphere → rhino_save.Strategy prompts
Three MCP prompts are registered automatically and surfaced in the client's prompt picker:
Prompt | When to use |
| Decision tree for orienting in a document → choosing the right tool → best practices. |
| Mandatory steps before invoking |
| How to combine |
Telling Claude "use the general_strategy prompt before you start" gives much better tool selection on long sessions.
Visual verification with base64 screenshots
"Build a 5x5x5 box on layer 'Demo', then take a 1280x720 base64 screenshot so you can confirm it landed."Claude calls rhino_box → rhino_zoom_extent → rhino_screenshot(as_base64=True) and reads the inline PNG from the response (image_base64 field) on the next turn.
Pagination & rich filtering
"List the first 50 curves on the 'Walls' layer, then select every object whose name matches 'Pillar_*' on layer 'Structure'."rhino_list_objects returns a pagination block; iterate with offset += limit until has_more is false. rhino_object_select accepts name_pattern, layer, color, object_type, user_text, and deselect_first.
Standalone smoke run from the shell:
RHINO_MCP_FORCE_MODE=standalone uv run python - <<'PY'
import asyncio
from rhino_mcp.server import build_server
from rhino_mcp.utils.registry import Mode
mcp, count = build_server(runtime_mode=Mode.STANDALONE, bridge_client=None)
print(f"{count} tools registered")
sphere = asyncio.run(
mcp._tool_manager._tools["rhino_sphere"].run(
{"args": {"center": {"x": 0, "y": 0, "z": 0}, "radius": 10.0}}
)
)
print(sphere)
PYTools reference (summary)
Category | Standalone | + Bridge | Notable members |
Geometry | 14 | 14 |
|
Curves | 3 | 3 |
|
Solids | 5 | 10 |
|
Surfaces | 0 | 11 |
|
Mesh | 1 | 8 |
|
Transform | 9 | 11 |
|
Annotation | 2 | 8 |
|
Layer / Object | 6 | 8 |
|
Material | 2 | 3 |
|
File I/O | 5 | 9 |
|
Analysis | 4 | 9 |
|
Query | 7 | 8 |
|
Display | 0 | 5 |
|
Scripting | 0 | 2 |
|
RS Docs | 4 | 4 |
|
History | 0 | 2 |
|
Batch | 0 | 1 |
|
Deformation | 0 | 4 |
|
NURBS | 0 | 5 |
|
SubD | 0 | 2 |
|
Srf Match | 0 | 3 |
|
Extraction | 0 | 4 |
|
Ctrl Points | 0 | 2 |
|
Paneling | 0 | 3 |
|
Grasshopper | 0 | 22 |
|
Drawing | 2 | 5 |
|
Schedule | 5 | 5 |
|
Blocks | 3 | 5 |
|
Environment | 3 | 4 |
|
Freeform | 8 | 11 |
|
BIM I/O | 1 | 4 |
|
Materials+ | 2 | 3 |
|
Render | 0 | 5 |
|
Daylight | 2 | 2 |
|
Detailed signatures live in docs/en/tools-reference.md.
Grasshopper integration
1. Start Rhino 8 → open Grasshopper → load your `.gh` definition.
2. Ensure the C# bridge plugin (`rhino-mcp.rhp`) is loaded in Rhino.
3. Set `RHINO_MCP_FORCE_MODE=bridge` and restart rhino-mcp.
4. From Claude:
- "Open /work/wing.gh, set the 'span' slider to 12.5, run, bake to layer 'Wing'."
- "Read the output of the 'Voronoi' component as a DataTree."See docs/en/grasshopper-guide.md for canvas/component/cluster recipes.
Configuration
Every knob is controlled by an environment variable. CLI flags override env where applicable.
Variable | Default | Purpose |
|
|
|
| (auto) | Force |
|
| When |
| (auto) | Bridge transport selector: |
|
| TCP transport endpoint |
|
| Windows named-pipe name |
| (XDG runtime) | Unix socket path override |
|
| Seconds to wait for a bridge ping |
|
| Max reconnect attempts after a transient transport failure |
|
| Base delay (seconds) for exponential backoff |
|
| Symmetric jitter ratio ( |
|
| Stderr log level. Set |
Development
git clone https://github.com/easehee/rhino-mcp.git
cd rhino-mcp
uv venv && source .venv/bin/activate
uv pip install -e '.[dev]'
# Tests + coverage
uv run pytest --cov=src/rhino_mcp
# Lint + type check
uv run ruff check src/ tests/
uv run mypy src/rhino_mcp
# Build the C# bridge plugin (auto-installs into Rhino on macOS/Windows)
./scripts/build-plugin.sh --release
# Wheel + sdist
./scripts/build.shManual smoke test against a running server
# Terminal A — start the server with verbose logging
RHINO_MCP_LOG_LEVEL=DEBUG rhino-mcp --transport http --port 8765
# Terminal B — list tools via the MCP inspector or a curl probe
npx @modelcontextprotocol/inspector http://127.0.0.1:8765/mcpTroubleshooting
Symptom | Likely cause / remediation |
| Start Rhino 8 with the C# bridge plugin loaded; verify |
Bridge-only tool absent in Claude | Server is in standalone mode — load the bridge plugin or set |
| Standalone supports only |
| Standalone import is |
| The bridge crashed or Rhino was closed — |
Stdout corrupted under stdio transport | Always log to stderr; rhino-mcp does this — verify no third-party libraries print to stdout. |
| Caller passed |
Pagination loops forever | Always advance |
| Filters AND together — try removing one filter at a time; the |
More in docs/en/troubleshooting.md.
License
MIT — see LICENSE.
Available Tools
542 toolsgh_add_componentB
Drop a Grasshopper component onto the active canvas.
Inputs: args (required). Returns: object
gh_bake_to_rhinoB
Bake the output of one or more components into the active Rhino document.
Inputs: args (required). Returns: object
gh_bind_template_parameterA
Set a single named parameter on a loaded template (slider / panel / toggle).
Inputs: args (required). Returns: object
gh_cluster_createB
Group components into a named cluster.
Inputs: args (required). Returns: object
gh_cluster_expandC
Expand a cluster back into its constituent components.
Inputs: args (required). Returns: object
gh_component_listARead-onlyIdempotent
List components currently on the active canvas (optionally filtered).
Inputs: args (required). Returns: object
gh_components_searchARead-onlyIdempotent
Search the Grasshopper component catalog (built-in + plugin-supplied).
Returns ``rows`` of ``{guid, name, nickname, category, subcategory,
description, plugin}`` and a ``summary`` block with match counts.
Use this to find the GUID needed by ``gh_add_component`` before
dropping a component on the canvas.
Inputs: args (required). Returns: object
gh_connect_componentsB
Create a wire from one component output to another component input.
Inputs: args (required). Returns: object
gh_connect_manyA
Add multiple wires in a single round-trip.
Returns a per-row ``results`` array so partial failures are visible
(each row carries ``status`` and, on error, ``error``).
Inputs: args (required). Returns: object
gh_data_tree_getBRead-only
Read a component output as a DataTree (list of branches).
Inputs: args (required). Returns: object
gh_data_tree_get_batchARead-only
Read multiple component outputs in a single bridge round-trip.
Inputs: args (required). Returns: object
gh_data_tree_setC
Push a DataTree into a component input.
Inputs: args (required). Returns: object
gh_data_tree_set_batchA
Apply many DataTree assignments at once with a single GH solve.
With ``defer_solve=True`` (default) the GH document is paused while
the assignments are applied and recomputed exactly once at the end —
critical for parameter sweeps where N independent ``set`` calls
would otherwise trigger N solver runs.
Inputs: args (required). Returns: object
gh_delete_componentBDestructive
Remove a component from the canvas.
Inputs: args (required). Returns: object
gh_get_parameterBRead-only
Read the current value of a component parameter.
Inputs: args (required). Returns: object
gh_load_templateC
Open a bundled template on the canvas and return its template_id + parameter map.
Inputs: args (required). Returns: object
gh_new_canvasB
Create a fresh empty Grasshopper canvas.
Inputs: args (required). Returns: object
gh_open_fileC
Open a Grasshopper definition.
Inputs: args (required). Returns: object
gh_place_sliderA
Create a Number Slider on the canvas with bounds and initial value.
Returns the new ``component_id`` so subsequent ``gh_connect_components``
or ``gh_set_slider`` calls can target it.
Inputs: args (required). Returns: object
gh_plugin_listARead-onlyIdempotent
Enumerate Grasshopper plugin libraries currently loaded.
Returns one entry per ``GH_AssemblyInfo`` library: id, name, author,
version, description, and the on-disk path. Useful for the LLM to
discover whether the user has LunchBox / Ladybug / Kangaroo etc.
installed before attempting to drop in a custom component.
Inputs: args (required). Returns: object
gh_preview_toggleA
Toggle preview on/off for a list of components (or all).
Inputs: args (required). Returns: object
gh_resetADestructive
Reset the canvas (clear cached solution).
Inputs: no named parameters. Returns: object
gh_runC
Run the current solution.
Inputs: args (required). Returns: object
gh_run_templateC
Force a fresh solution and (optionally) bake the declared outputs.
Inputs: args (required). Returns: object
gh_save_fileA
Save the active Grasshopper definition.
Inputs: args (required). Returns: object
gh_set_panelB
Set the text contents of a Panel component.
Inputs: args (required). Returns: object
gh_set_parameterC
Push a value into a component parameter.
Inputs: args (required). Returns: object
gh_set_sliderC
Set a Number Slider component to a numeric value.
Inputs: args (required). Returns: object
gh_set_toggleB
Set a Boolean Toggle component to true or false.
Inputs: args (required). Returns: object
gh_template_listARead-only
List bundled Grasshopper templates with their parameter contracts.
``available=False`` means the .gh binary has not been shipped yet —
the contract is described in the manifest but loading it will fail
until the binary is placed alongside the manifest.
Inputs: args (required). Returns: object
rhino_1viewA
Maximize the active viewport to fill the entire viewport area.
Inputs: no named parameters. Returns: result
rhino_3viewA
Switch to the three-viewport layout.
Inputs: no named parameters. Returns: result
rhino_4viewA
Switch to the standard four-viewport layout (Top, Front, Right, Perspective).
Inputs: no named parameters. Returns: result
rhino_add_clipping_planeD
Enter clipping plane creation mode.
Inputs: no named parameters. Returns: result
rhino_add_control_pointA
Add a control point to the end of a selected NURBS curve in the U direction.
Inputs: no named parameters. Returns: result
rhino_add_dimension_angularB
Enter angular dimension placement mode.
Inputs: no named parameters. Returns: result
rhino_add_dimension_linearB
Enter linear dimension placement mode.
Inputs: no named parameters. Returns: result
rhino_add_dimension_ordinateC
Enter ordinate dimension placement mode.
Inputs: no named parameters. Returns: result
rhino_add_dimension_radialB
Enter radial (radius) dimension placement mode.
Inputs: no named parameters. Returns: result
rhino_add_directional_lightC
Add a directional light to the scene.
Args:
direction_x, direction_y, direction_z: Light direction vector.
Inputs: direction_x, direction_y, direction_z. Returns: result
rhino_add_dotC
Add a small text dot annotation at a 3D location.
Args:
text: Dot label text.
x, y, z: Location coordinates.
Inputs: x, y, z, text. Returns: result
rhino_add_hatchB
Add a hatch fill to a selected closed curve.
Args:
hatch_pattern: Hatch pattern name (e.g. 'Solid', 'Grid', 'Dots').
scale: Pattern scale factor.
Inputs: scale, hatch_pattern. Returns: result
rhino_add_leaderB
Enter leader annotation placement mode.
Inputs: no named parameters. Returns: result
rhino_add_objects_to_blockA
Add currently selected objects to an existing block definition.
Args:
name: Block definition name to add objects into.
Inputs: name (required). Returns: result
rhino_add_pointA
Add a single point object at the given coordinates.
Args:
x, y, z: Point coordinates.
Inputs: x, y, z. Returns: result
rhino_add_point_cloudC
Add a point cloud object from a list of 3D coordinates.
Args:
points: List of (x, y, z) tuples.
Inputs: points (required). Returns: result
rhino_add_point_lightA
Add an omnidirectional point light at the specified location.
Args:
x, y, z: Light position.
Inputs: x, y, z. Returns: result
rhino_add_spotlightA
Add a spotlight to the scene.
Args:
x, y, z: Spotlight position.
target_x, target_y, target_z: Target/aim point.
radius: Spotlight cone radius.
Inputs: x, y, z, radius, +3 more. Returns: result
rhino_add_textB
Add a 3D text annotation object at a specific location.
Args:
text: The text string to display.
x, y, z: Insertion point coordinates.
height: Text height in model units.
font: Font face name.
Inputs: text (required), x, y, z, +2 more. Returns: result
rhino_add_text_objectC
Add a text object via Rhino command.
Args:
text: Text string.
x, y, z: Insertion point.
height: Text height.
Inputs: text (required), x, y, z, +1 more. Returns: result
rhino_alignC
Align selected objects in a given direction.
Valid directions: Left, Right, Top, Bottom, Vertical, Horizontal,
Center, Middle.
Args:
controller: RhinoController instance.
direction: Alignment direction keyword.
Returns:
Dict with command result.
Inputs: direction. Returns: result
rhino_align_mesh_verticesB
Align mesh vertices that are within the given tolerance of each other.
Args:
controller: RhinoController instance.
tolerance: Distance tolerance for vertex alignment.
Inputs: tolerance. Returns: result
rhino_angleB
Measure the angle between two lines (interactive).
Args:
controller: RhinoController instance.
Returns:
Dict with command result.
Inputs: no named parameters. Returns: result
rhino_annotation_calloutC
Add a callout (leader + balloon or boxed label).
Inputs: args (required). Returns: object
rhino_annotation_dimension_styleC
Register a reusable dimension style (bridge only — Rhino DimStyle table).
Inputs: args (required). Returns: object
rhino_annotation_north_arrowA
Draw a north arrow centred on location.
``angle_deg`` rotates the arrow clockwise from world +Y so callers can
adapt to a site whose true north differs from grid north.
Inputs: args (required). Returns: object
rhino_annotation_revision_cloudA
Draw a revision cloud (bumpy polyline) around a region of interest with a revision label.
Inputs: args (required). Returns: object
rhino_annotation_scale_barA
Draw a divided scale bar with a label.
Bar is drawn in document units; the label reports the represented
real-world distance based on ``scale_denominator``.
Inputs: args (required). Returns: object
rhino_arcB
Add an arc by centre, radius, and sweep angle (in degrees).
Inputs: args (required). Returns: object
rhino_areaARead-onlyIdempotent
Compute the surface area of a mesh (Brep area requires bridge).
Inputs: args (required). Returns: object
rhino_area_centroidA
Calculate the area centroid (centre of mass) of selected surfaces.
Args:
controller: RhinoController instance.
Returns:
Dict with command result containing centroid coordinates.
Inputs: no named parameters. Returns: result
rhino_array_linearC
Array objects along a vector with constant spacing.
Inputs: args (required). Returns: object
rhino_array_on_curveB
Array selected objects along a curve.
The curve must be selected after the objects (interactive).
Args:
controller: RhinoController instance.
count: Number of copies along the curve.
Returns:
Dict with command result.
Inputs: count. Returns: result
rhino_array_polarC
Array objects in a polar pattern.
Inputs: args (required). Returns: object
rhino_array_rectangularC
Array objects in a 3D rectangular grid.
Inputs: args (required). Returns: object
rhino_assign_material_to_objectB
Assign a named material to the currently selected objects.
Args:
material_name: Name of the render material to assign.
Inputs: material_name (required). Returns: result
rhino_attractor_displace_pointsA
Displace each input point along the vector to an attractor with a falloff.
Positive ``strength`` pulls toward the attractor; negative pushes
away. The attractor is either a fixed point (``attractor_point``)
or a curve (``attractor_curve_id``); for curves each point's
attractor is the closest sample on the curve.
Returns the *new* point IDs (the originals are deleted; this is a
form-finding move, not a duplicating one).
Inputs: args (required). Returns: object
rhino_axis_ribsA
Generate two orthogonal sets of section ribs (waffle-style fabrication, bridge only).
Inputs: args (required). Returns: object
rhino_batch_callA
Dispatch multiple bridge methods in a single round-trip.
IMPORTANT: ``steps[].method`` is a **bridge dispatcher route**, not
an MCP tool name. The MCP tool ``rhino_layer_create`` maps to the
dispatcher route ``rhino.layer.create``; ``rhino_document_summary``
maps to ``rhino.query.document_summary`` (NOT ``rhino.document.summary``).
Standalone-only tools (``rhino_set_user_text`` etc. that have no
``bridge_call`` path) cannot be batched. A wrong route name returns
an ``error`` row with ``HandlerError``; the batch aborts when
``on_error='stop'``.
Measured impact (v0.6.x, localhost): direct sequential layer.create
~580ms/op vs batched ~340ms/op — N x ~240ms saved per batch (the
MCP↔bridge round-trip cost paid once instead of N times). Effective
for any workflow that issues >5 bridge calls back-to-back.
Returns ``{summary: {total, ok, failed, on_error}, results: [...]}``
where each ``results`` entry has ``index``, ``method``, ``status``
(``"ok"`` | ``"error"``), and either ``result`` or ``error``.
Inputs: args (required). Returns: object
rhino_batch_modifyA
Modify many objects in a single call.
Each spec can include any combination of: translation, rotation,
scale, colour, layer, visibility, and name. All changes are wrapped
in one undo record — ``rhino_undo(steps=1)`` reverts the entire batch.
When ``apply_to_all`` is ``True``, the modifications from the first
spec are applied to every object in the document.
Inputs: args (required). Returns: object
rhino_bendC
Bend objects along an axis through a specified point.
Inputs: args (required). Returns: object
rhino_bim_metadata_setA
Tag objects with IFC entity + property-set metadata.
Standalone writes ``Pset_RhinoMcp::<key>`` user_text on each object;
bridge mode does the same and additionally pushes into Rhino's IFC
property-set table so a subsequent IFC export carries them across.
Inputs: args (required). Returns: object
rhino_bim_pset_deleteBDestructive
Remove every property under a named PropertySet from an object.
Inputs: args (required). Returns: object
rhino_bim_pset_getARead-onlyIdempotent
Read PropertySet entries off an object.
Bridge mode reads from the live RhinoCommon UserString table; standalone
mode reads from rhino3dm UserStrings on the saved 3dm document. The
result groups properties by PropertySet name (``psets`` field).
Inputs: args (required). Returns: object
rhino_bim_pset_setC
Persist a PropertySet block on an object.
Inputs: args (required). Returns: object
rhino_blend_srfA
Create a blend surface between two surface edges.
Pre-select the two naked edges before calling.
Args:
controller: RhinoController instance.
Returns:
Dict with 'status' and 'command' keys.
Inputs: no named parameters. Returns: result
rhino_blend_surfaceB
Create a blend surface between two edges.
Inputs: args (required). Returns: object
rhino_blend_surface_edgesB
Create a blend surface connecting two surface edges with continuity control.
Inputs: args (required). Returns: object
rhino_block_defineA
Create a block definition from a list of objects.
Standalone uses ``rhino3dm.InstanceDefinitionGeometry`` to register
the geometry under ``name``. Bridge mode mirrors that and additionally
replaces the source objects with a single instance at the base point
when ``replace_objects=True``.
Inputs: args (required). Returns: object
rhino_block_explodeC
Explode a block instance into individual objects (bridge only).
Inputs: args (required). Returns: object
rhino_block_insertB
Insert a block instance at insertion_point with optional scale + rotation.
Standalone constructs a ``rhino3dm.InstanceReferenceGeometry`` and
applies the transform to it. Bridge mode forwards to RhinoCommon's
``Doc.Objects.AddInstanceObject`` which honours the active layer
and links the instance to the definition.
Inputs: args (required). Returns: object
rhino_block_instance_countC
Return the number of instances of a specific block definition.
Args:
name: Block definition name.
Inputs: name (required). Returns: result
rhino_block_listBRead-only
List every block definition with a per-definition object + instance count.
Inputs: args (required). Returns: object
rhino_block_managerB
Open the Block Manager dialog.
Inputs: no named parameters. Returns: result
rhino_block_redefineA
Replace a block definition's geometry, propagating to every instance (bridge only).
Inputs: args (required). Returns: object
rhino_boolean_differenceADestructive
Subtract b_ids from a_ids. Bridge required.
Inputs: args (required). Returns: object
rhino_boolean_intersectionBDestructive
Intersect a_ids with b_ids. Bridge required.
Inputs: args (required). Returns: object
rhino_boolean_splitC
Boolean split: split objects with cutting surfaces / polysurfaces.
Args:
controller: RhinoController instance.
Inputs: no named parameters. Returns: result
rhino_boolean_unionBDestructive
Boolean-union the given Brep groups. Bridge required.
Inputs: args (required). Returns: object
rhino_bounding_boxBRead-onlyIdempotent
Return the union bounding box of one or more objects.
Inputs: args (required). Returns: object
rhino_boxC
Add a rectangular box (axis-aligned in standalone mode).
Inputs: args (required). Returns: object
rhino_bridge_list_instancesARead-onlyIdempotent
Enumerate live Rhino bridge endpoints discovered via announcement files.
Returns one row per running Rhino on this host. Each row carries
``pid``, ``host``, ``port``, ``doc_path``, ``doc_title``, version, and
an ``alive`` flag derived from a cheap TCP probe.
Inputs: args (required). Returns: object
rhino_bridge_select_instanceA
Switch the next bridge call to target a specific Rhino session.
Exactly one selector among ``pid``, ``port``, ``doc_path_contains``,
and ``index`` should be set. The active bridge client is closed; the
next tool call goes through lazy promotion against the new endpoint.
Inputs: args (required). Returns: object
rhino_cage_editC
Deform objects with a control cage (bridge only).
Inputs: args (required). Returns: object
rhino_camera_setB
Position the active viewport's camera (location + target + lens length).
Inputs: args (required). Returns: object
rhino_cap_holesB
Cap all open holes of a Brep.
Inputs: args (required). Returns: object
rhino_cap_planar_holesA
Cap planar holes in open polysurfaces to create closed solids.
Args:
controller: RhinoController instance.
Inputs: no named parameters. Returns: result
rhino_chamfer_edgesB
Chamfer the selected edges of a polysurface or solid.
Args:
controller: RhinoController instance.
distance: Chamfer distance.
Returns:
Dict with command result.
Inputs: distance. Returns: result
rhino_chamfer_surfaceB
Create a chamfer surface between two selected surfaces.
Args:
controller: RhinoController instance.
distance: Chamfer distance.
Returns:
Dict with command result.
Inputs: distance. Returns: result
rhino_check_bad_objectsA
Check selected objects for validity and report solid status.
Uses rhinoscriptsyntax to inspect each selected object and report
whether it is valid/solid or has issues.
Args:
controller: RhinoController instance.
Returns:
Dict with command result containing validity report.
Inputs: no named parameters. Returns: result
rhino_check_naked_edgesARead-only
Enumerate naked edges of a Brep with their lengths (bridge only).
Standalone rhino3dm cannot enumerate naked edges. In bridge mode this
forwards to ``Rhino.Geometry.Brep.GetNakedEdges`` and returns
``[{edge_index, length}, ...]`` plus the gap count.
Inputs: args (required). Returns: object
rhino_circleA
Add a circle by centre and radius (optionally on a custom plane).
Inputs: args (required). Returns: object
rhino_clipping_planeB
Add a clipping plane to all viewports.
Inputs: args (required). Returns: object
rhino_close_holeB
Close (cap) a planar hole in an open polysurface or mesh.
Args:
controller: RhinoController instance.
Inputs: no named parameters. Returns: result
rhino_cmd_arcA
Draw an arc by center, radius, and angular span.
Rhino's Arc command (center mode) prompts:
center -> radius -> start angle -> end angle.
Args:
controller: RhinoController instance.
cx, cy, cz: Center of the arc circle.
radius: Arc radius.
start_angle: Starting angle in degrees (measured from +X axis).
end_angle: Ending angle in degrees.
Returns:
Dict with 'status' and 'command' keys.
Inputs: cx (required), cy (required), cz (required), radius (required), +2 more. Returns: result
rhino_cmd_areaB
Calculate the area of selected closed curves, hatches, or surfaces.
Args:
controller: RhinoController instance.
Returns:
Dict with command result containing area information.
Inputs: no named parameters. Returns: result
rhino_cmd_array_linearC
Create a rectangular/linear array of selected objects.
Args:
controller: RhinoController instance.
count_x: Number of items in X direction.
count_y: Number of items in Y direction.
count_z: Number of items in Z direction.
spacing_x: Spacing between items in X.
spacing_y: Spacing between items in Y.
spacing_z: Spacing between items in Z.
Returns:
Dict with command result.
Inputs: count_x, count_y, count_z, spacing_x, +2 more. Returns: result
rhino_cmd_array_polarB
Create a polar array of selected objects around a center point.
Args:
controller: RhinoController instance.
count: Total number of items (including original).
angle: Total angle to fill in degrees.
cx: X coordinate of the array center.
cy: Y coordinate of the array center.
cz: Z coordinate of the array center.
Returns:
Dict with command result.
Inputs: cx, cy, cz, angle, +1 more. Returns: result
rhino_cmd_bendB
Apply a bend deformation to selected objects.
Args:
controller: RhinoController instance.
angle: Bend angle in degrees.
symmetric: If True, bend is symmetric about the midpoint.
Returns:
Dict with command result.
Inputs: angle, symmetric. Returns: result
rhino_cmd_boolean_differenceC
Boolean difference: subtract selected cutters from base objects.
Args:
controller: RhinoController instance.
delete_input: Delete input cutter objects after the operation.
Inputs: delete_input. Returns: result
rhino_cmd_boolean_intersectionC
Boolean intersection of selected closed polysurfaces / solids.
Args:
controller: RhinoController instance.
Inputs: no named parameters. Returns: result
rhino_cmd_boolean_unionC
Boolean union of selected closed polysurfaces / solids.
Args:
controller: RhinoController instance.
Inputs: no named parameters. Returns: result
rhino_cmd_bounding_boxA
Return the world-axis-aligned bounding box of selected objects.
Uses rhinoscriptsyntax so that the result can be parsed programmatically.
Args:
controller: RhinoController instance.
Returns:
Dict with command result containing bounding-box corner points.
Inputs: no named parameters. Returns: result
rhino_cmd_boxA
Create a box (rectangular cuboid) in Rhino.
The box is defined by its bottom-left-front corner (x, y, z) and its
opposite corner derived from length/width, then extruded to *height*.
Args:
controller: RhinoController instance.
x, y, z: World-space origin of the box base corner.
length: Size along the X axis.
width: Size along the Y axis.
height: Extrusion height along the Z axis.
Returns:
Dict with 'status' and 'command' keys.
Inputs: x, y, z, width, +2 more. Returns: result
rhino_cmd_circleB
Draw a circle by center and radius.
Args:
controller: RhinoController instance.
cx, cy, cz: World-space center of the circle.
radius: Circle radius.
Returns:
Dict with 'status' and 'command' keys.
Inputs: cx (required), cy (required), cz (required), radius (required). Returns: result
rhino_cmd_coneA
Create a cone in Rhino.
Args:
controller: RhinoController instance.
x, y, z: Center of the base circle.
radius: Base radius.
height: Height of the cone (apex above base).
Returns:
Dict with 'status' and 'command' keys.
Inputs: x, y, z, height, +1 more. Returns: result
rhino_cmd_contourA
Create contour curves on selected surfaces or meshes.
The contour base point and direction are picked interactively.
Args:
controller: RhinoController instance.
spacing: Distance between contour planes.
Returns:
Dict with command result.
Inputs: spacing. Returns: result
rhino_cmd_curvature_analysisB
Display curvature analysis on selected surfaces.
Valid styles: Gaussian, Mean, MinRadius, MaxRadius.
Args:
controller: RhinoController instance.
style: Type of curvature analysis to display.
Returns:
Dict with command result.
Inputs: style. Returns: result
rhino_cmd_cylinderB
Create a closed cylinder in Rhino.
Args:
controller: RhinoController instance.
x, y, z: Center of the base circle.
radius: Base radius.
height: Height of the cylinder.
Returns:
Dict with 'status' and 'command' keys.
Inputs: x, y, z, height, +1 more. Returns: result
rhino_cmd_distanceB
Measure the distance between two points.
If pt1/pt2 are provided they should be formatted as "x,y,z" strings.
Otherwise the command runs interactively.
Args:
controller: RhinoController instance.
pt1: Optional first point as "x,y,z".
pt2: Optional second point as "x,y,z".
Returns:
Dict with command result.
Inputs: pt1, pt2. Returns: result
rhino_cmd_ellipseB
Draw an ellipse by center, X semi-axis, and Y semi-axis.
Args:
controller: RhinoController instance.
cx, cy, cz: Center of the ellipse.
rx: Semi-axis radius along X.
ry: Semi-axis radius along Y.
Returns:
Dict with 'status' and 'command' keys.
Inputs: cx (required), cy (required), cz (required), rx (required), +1 more. Returns: result
rhino_cmd_fillet_surfaceC
Create a fillet surface between two selected surfaces.
Args:
controller: RhinoController instance.
radius: Fillet radius.
Returns:
Dict with command result.
Inputs: radius. Returns: result
rhino_cmd_flow_along_curveA
Flow (morph) selected objects along a curve.
Requires an existing base curve and a target curve to be selected
interactively.
Args:
controller: RhinoController instance.
preserve_structure: If True, the original NURBS structure is preserved.
Returns:
Dict with command result.
Inputs: preserve_structure. Returns: result
rhino_cmd_get_user_textB
Retrieve custom user text value for a given key from selected objects.
Args:
key: Attribute key name.
Inputs: key (required). Returns: result
rhino_cmd_helixA
Create a cylindrical helix curve in Rhino.
This is a special case of rhino_spiral where start_radius == end_radius.
Args:
controller: RhinoController instance.
x, y, z: Base point (axis start).
pitch: Vertical distance per full turn.
turns: Number of full turns.
radius: Constant radius of the helix.
Returns:
Dict with 'status' and 'command' keys.
Inputs: x (required), y (required), z (required), pitch, +2 more. Returns: result
rhino_cmd_importC
Import geometry from an external file into the current document.
Args:
controller: RhinoController instance.
file_path: Absolute path to the file to import.
Returns:
Dict with command result.
Inputs: file_path (required). Returns: result
rhino_cmd_layer_createB
Create a new layer.
Args:
name: Layer name (supports :: for sub-layers, e.g. 'Parent::Child').
color_rgb: Optional comma-separated RGB string, e.g. '255,0,0'.
parent: Optional parent layer name.
Inputs: name (required), parent, color_rgb. Returns: result
rhino_cmd_layer_deleteB
Delete a layer and all its objects.
Args:
name: Name of the layer to delete.
Inputs: name (required). Returns: result
rhino_cmd_layer_listA
Return a list of all layer names in the document.
Inputs: no named parameters. Returns: result
rhino_cmd_lineC
Draw a straight line between two world-space points.
Args:
controller: RhinoController instance.
x1, y1, z1: Start point.
x2, y2, z2: End point.
Returns:
Dict with 'status' and 'command' keys.
Inputs: x1 (required), x2 (required), y1 (required), y2 (required), +2 more. Returns: result
rhino_cmd_loftA
Loft through a set of profile curves.
The curves are first selected using *curve_selection*, then the Loft
command is run with the requested style.
Args:
controller: RhinoController instance.
curve_selection: Rhino command to select the profile curves
(default '_SelLast').
style: Loft style keyword: Normal | Loose | Tight |
Straight | Developable | Uniform.
closed: If True, adds '_Closed=_Yes' to create a
closed (periodic) loft.
Returns:
Dict with 'status' and 'command' keys.
Inputs: style, closed, curve_selection. Returns: result
rhino_cmd_mesh_boolean_differenceC
Boolean difference of selected closed meshes.
Args:
controller: RhinoController instance.
Inputs: no named parameters. Returns: result
rhino_cmd_mesh_boolean_unionC
Boolean union of selected closed meshes.
Args:
controller: RhinoController instance.
Inputs: no named parameters. Returns: result
rhino_cmd_mirrorB
Mirror selected objects about a named world plane.
Supported planes: 'WorldXY', 'WorldYZ', 'WorldXZ'.
Args:
controller: RhinoController instance.
plane: Mirror plane identifier.
Returns:
Dict with command result.
Inputs: plane. Returns: result
rhino_cmd_moveB
Move selected objects by a displacement vector (dx, dy, dz).
Uses a Python script via rhinoscriptsyntax so that the displacement can be
applied programmatically to every currently-selected object.
Args:
controller: RhinoController instance.
dx: Displacement along X axis.
dy: Displacement along Y axis.
dz: Displacement along Z axis.
Returns:
Dict with command result.
Inputs: dx, dy, dz. Returns: result
rhino_cmd_offset_surfaceB
Offset a selected surface or polysurface.
Args:
controller: RhinoController instance.
distance: Offset distance.
solid: If True, create a solid (shelled) offset.
Returns:
Dict with command result.
Inputs: solid, distance. Returns: result
rhino_cmd_patchB
Fit a patch surface to the selected curves or point objects.
Args:
controller: RhinoController instance.
u_spans: Number of surface spans in the U direction.
v_spans: Number of surface spans in the V direction.
Returns:
Dict with 'status' and 'command' keys.
Inputs: u_spans, v_spans. Returns: result
rhino_cmd_plane_surfaceB
Create a flat rectangular NURBS surface in Rhino.
Args:
controller: RhinoController instance.
x, y, z: First corner of the surface.
length: Size along the X axis.
width: Size along the Y axis.
Returns:
Dict with 'status' and 'command' keys.
Inputs: x, y, z, width, +1 more. Returns: result
rhino_cmd_polygonA
Draw a regular polygon by center and circumradius.
Args:
controller: RhinoController instance.
cx, cy, cz: Center of the polygon.
sides: Number of sides (>= 3).
radius: Circumradius (vertex distance from center).
inscribed: If True, polygon is inscribed in a circle of *radius*;
if False, polygon is circumscribed around that circle.
Returns:
Dict with 'status' and 'command' keys.
Inputs: cx (required), cy (required), cz (required), sides, +2 more. Returns: result
rhino_cmd_polylineC
Draw an open polyline through a list of 3-D points.
Args:
controller: RhinoController instance.
points: Ordered list of (x, y, z) tuples (>= 2 required).
Returns:
Dict with 'status' and 'command' keys.
Inputs: points (required). Returns: result
rhino_cmd_rebuild_curveB
Rebuild the selected curve with a specified number of control points and degree.
The curve must be pre-selected before calling this function.
Args:
controller: RhinoController instance.
point_count: Target number of control points.
degree: Target polynomial degree.
Returns:
Dict with 'status' and 'command' keys.
Inputs: degree, point_count. Returns: result
rhino_cmd_rectangleC
Draw a planar rectangle defined by two corner points.
Args:
controller: RhinoController instance.
x, y, z: First corner of the rectangle.
width: Size along the X axis.
height: Size along the Y axis.
Returns:
Dict with 'status' and 'command' keys.
Inputs: x (required), y (required), z (required), width (required), +1 more. Returns: result
rhino_cmd_redoC
Redo one or more operations.
Args:
controller: RhinoController instance.
steps: Number of redo steps (default 1).
Returns:
Dict with the result of the last redo command.
Inputs: steps. Returns: result
rhino_cmd_reduce_meshB
Reduce the polygon count of selected meshes.
Args:
controller: RhinoController instance.
polygon_percentage: Target polygon count as a percentage of original.
allow_distortion: Allow some geometric distortion to achieve target count.
Inputs: allow_distortion, polygon_percentage. Returns: result
rhino_cmd_render_to_fileB
Render the scene and save the result to a file.
Args:
file_name: Output filename (saved to D:/RhinoFiles/).
width: Render width in pixels.
height: Render height in pixels.
Inputs: width, height, file_name. Returns: result
rhino_cmd_revolveA
Revolve the selected profile curve around the World Z axis.
The profile curve and axis start/end points must be pre-selected or
implied by the current selection. The axis is assumed to run along
the world Z axis through the origin (0,0,0) -> (0,0,1).
Args:
controller: RhinoController instance.
angle: Total revolution angle in degrees (360 = full solid).
start_angle: Starting angle in degrees (0 = +X direction).
Returns:
Dict with 'status' and 'command' keys.
Inputs: angle, start_angle. Returns: result
rhino_cmd_rotateA
Rotate selected objects around a center point in the active construction plane.
For a true 3-D axis rotation use :func:`rhino_rotate_3d` instead.
Args:
controller: RhinoController instance.
cx: X coordinate of the rotation center.
cy: Y coordinate of the rotation center.
cz: Z coordinate of the rotation center (ignored for planar rotate).
angle: Rotation angle in degrees.
axis: Axis hint ('x', 'y', 'z') – kept for API symmetry; planar Rotate
always rotates about the CPlane normal.
Returns:
Dict with command result.
Inputs: cx, cy, cz, axis, +1 more. Returns: result
rhino_cmd_saveB
Save the current document to its existing file path.
Args:
controller: RhinoController instance.
Returns:
Dict with command result.
Inputs: no named parameters. Returns: result
rhino_cmd_scaleB
Uniformly scale selected objects about a center point.
Args:
controller: RhinoController instance.
cx: X coordinate of the scale origin.
cy: Y coordinate of the scale origin.
cz: Z coordinate of the scale origin.
factor: Scale factor (>1 enlarges, <1 shrinks).
Returns:
Dict with command result.
Inputs: cx, cy, cz, factor. Returns: result
rhino_cmd_sectionA
Create a cross-section curve through selected surfaces at a plane.
The plane origin and normal are set interactively in Rhino.
Args:
controller: RhinoController instance.
plane: Named plane hint ('WorldXY', 'WorldYZ', 'WorldXZ').
Returns:
Dict with command result.
Inputs: plane. Returns: result
rhino_cmd_set_user_textC
Attach custom key/value user text metadata to selected objects.
Args:
key: Attribute key name.
value: Attribute value string.
Inputs: key (required), value (required). Returns: result
rhino_cmd_shellB
Shell selected solid, removing one or more faces and offsetting the rest.
Args:
controller: RhinoController instance.
thickness: Shell wall thickness.
Inputs: thickness. Returns: result
rhino_cmd_sphereC
Create a sphere in Rhino.
Args:
controller: RhinoController instance.
x, y, z: World-space center point.
radius: Sphere radius.
Returns:
Dict with 'status' and 'command' keys.
Inputs: x, y, z, radius. Returns: result
rhino_cmd_spiralA
Create a spiral (conical helix) curve in Rhino.
Rhino Spiral prompts: axis start -> axis end -> start radius -> end radius.
We place the axis start at (x, y, z) and axis end at (x, y, z + pitch*turns).
Args:
controller: RhinoController instance.
x, y, z: Base point (axis start).
pitch: Vertical distance per turn.
turns: Number of full turns.
start_radius: Radius at the base of the spiral.
end_radius: Radius at the top of the spiral.
Returns:
Dict with 'status' and 'command' keys.
Inputs: x (required), y (required), z (required), pitch, +3 more. Returns: result
rhino_cmd_sweep1B
Sweep a profile curve along a single rail curve.
Typical workflow:
1. Select the rail curve with *rail_select*.
2. Select the profile curve(s) with *profile_select*.
3. Run Sweep1 and accept defaults.
Args:
controller: RhinoController instance.
rail_select: Rhino command to select the rail curve.
profile_select: Rhino command to select the profile curve(s).
closed: If True, produces a closed sweep.
Returns:
Dict with 'status' and 'command' keys.
Inputs: closed, rail_select, profile_select. Returns: result
rhino_cmd_sweep2A
Sweep a profile along two rail curves.
Pre-select the two rail curves and at least one profile curve before
calling this function.
Args:
controller: RhinoController instance.
Returns:
Dict with 'status' and 'command' keys.
Inputs: no named parameters. Returns: result
rhino_cmd_taperB
Apply a taper deformation to selected objects.
The taper axis and extent are picked interactively after the command starts.
Args:
controller: RhinoController instance.
angle: Taper angle in degrees.
Returns:
Dict with command result.
Inputs: angle. Returns: result
rhino_cmd_torusB
Create a torus in Rhino.
Args:
controller: RhinoController instance.
x, y, z: World-space center of the torus.
major_radius: Distance from the torus center to the tube center.
minor_radius: Radius of the tube cross-section.
Returns:
Dict with 'status' and 'command' keys.
Inputs: x, y, z, major_radius, +1 more. Returns: result
rhino_cmd_turntableB
Animate the viewport in turntable rotation.
Args:
frames: Number of animation frames.
pause: Pause duration between frames in seconds.
Inputs: pause, frames. Returns: result
rhino_cmd_twistC
Apply a twist deformation to selected objects.
The twist axis is picked interactively.
Args:
controller: RhinoController instance.
angle: Total twist angle in degrees.
Returns:
Dict with command result.
Inputs: angle. Returns: result
rhino_cmd_undoC
Undo one or more operations.
Args:
controller: RhinoController instance.
steps: Number of undo steps (default 1).
Returns:
Dict with the result of the last undo command.
Inputs: steps. Returns: result
rhino_cmd_unweld_meshB
Unweld mesh vertices where the edge angle exceeds the tolerance.
Args:
controller: RhinoController instance.
angle: Minimum angle (degrees) to unweld at.
Inputs: angle. Returns: result
rhino_cmd_volumeB
Calculate the volume of selected closed polysurfaces or meshes.
Args:
controller: RhinoController instance.
Returns:
Dict with command result containing volume information.
Inputs: no named parameters. Returns: result
rhino_cmd_weld_meshB
Weld mesh vertices within the given angle tolerance.
Args:
controller: RhinoController instance.
angle_tolerance: Maximum angle (degrees) between faces to weld vertices.
Inputs: angle_tolerance. Returns: result
rhino_coneB
Add a cone primitive (bridge required for non-Z axes).
Inputs: args (required). Returns: object
rhino_contourC
Generate equally spaced section curves (bridge required).
Inputs: args (required). Returns: object
rhino_count_objectsB
Return a count of all objects in the document, broken down by geometry type.
Inputs: no named parameters. Returns: result
rhino_create_blockB
Create a block definition from currently selected objects.
Args:
name: Name for the new block definition.
base_x, base_y, base_z: Base insertion point coordinates.
Inputs: name (required), base_x, base_y, base_z. Returns: result
rhino_create_subdB
Create a SubD object from an existing mesh.
Inputs: args (required). Returns: object
rhino_create_uv_gridB
Create a point grid on a surface at even UV intervals.
Inputs: args (required). Returns: object
rhino_curvature_analysisARead-only
Sample Gaussian/mean curvature of a surface (bridge required).
Inputs: args (required). Returns: object
rhino_curvature_graphB
Display a curvature graph on selected curves.
Args:
controller: RhinoController instance.
density: Number of hair samples along the curve.
scale: Scale of the curvature hairs.
Returns:
Dict with command result.
Inputs: scale, density. Returns: result
rhino_curve_continuityBRead-only
Curve sanity — span count, closed flag, planarity, periodic, validity log.
Inputs: args (required). Returns: object
rhino_curve_lengthARead-onlyIdempotent
Return the curve's parametric domain and approximate length.
Inputs: args (required). Returns: object
rhino_curve_point_atARead-onlyIdempotent
Evaluate position and tangent at a parameter on the curve.
Inputs: args (required). Returns: object
rhino_curve_splitA
Split a curve at the given parameters; original is preserved.
Inputs: args (required). Returns: object
rhino_cylinderC
Add a cylinder; in standalone mode the axis must be world Z.
Inputs: args (required). Returns: object
rhino_daylight_factorARead-onlyIdempotent
BRE simplified daylight factor for a side-lit room.
DF = (W * theta * tau * M) / (A_total * (1 - R^2)) (% as decimal).
For early-stage architectural studies; for radiance-grade accuracy
use ladybug-tools or DAYSIM.
Inputs: args (required). Returns: object
rhino_delete_selectedA
Delete the currently selected objects.
Inputs: no named parameters. Returns: result
rhino_dimension_alignedB
Add an aligned dimension between two points.
Inputs: args (required). Returns: object
rhino_dimension_angularC
Add an angular dimension at a vertex.
Inputs: args (required). Returns: object
rhino_dimension_linearC
Add a linear dimension between two points.
Inputs: args (required). Returns: object
rhino_dimension_styleB
Open the Annotation Styles (dimension style) manager.
Inputs: no named parameters. Returns: result
rhino_direct_irradianceARead-onlyIdempotent
Direct Normal Irradiance (W/m^2) clear-sky estimate via Bird + Kasten-Young air mass.
Includes Linke turbidity (1 = very clear, 7 = industrial haze) and site altitude. Pure calculation — no doc edits.
Inputs: args (required). Returns: object
rhino_display_mode_setA
Switch the active viewport's display mode.
Inputs: args (required). Returns: object
rhino_display_show_edgesB
Toggle display of surface/mesh edges.
Args:
show: True to show edges, False to hide.
Inputs: show. Returns: result
rhino_distanceBRead-onlyIdempotent
Euclidean distance between two points.
Inputs: args (required). Returns: object
rhino_distributeA
Distribute selected objects evenly along a direction.
Uses rhinoscriptsyntax to compute bounding-box centres and re-space them.
Args:
controller: RhinoController instance.
direction: 'Horizontal' (X), 'Vertical' (Y), or 'Depth' (Z).
Returns:
Dict with command result.
Inputs: direction. Returns: result
rhino_document_propertiesC
Open the Document Properties dialog.
Args:
controller: RhinoController instance.
Returns:
Dict with command result.
Inputs: no named parameters. Returns: result
rhino_document_settingsARead-only
Bundled units / tolerances / base point in one call.
Inputs: args (required). Returns: object
rhino_document_summaryBRead-only
Get a high-level summary of the document (object counts, layers, etc.).
Inputs: args (required). Returns: object
rhino_document_units_getBRead-only
Read the current document unit system.
Inputs: args (required). Returns: object
rhino_document_units_setB
Set the document unit system, optionally scaling existing geometry.
Inputs: args (required). Returns: object
rhino_draft_angleCRead-only
Compute draft angles relative to the world Z axis (bridge required).
Inputs: args (required). Returns: object
rhino_draft_angle_analysisC
Display draft-angle analysis on selected surfaces.
Args:
controller: RhinoController instance.
draft_angle: Reference draft angle in degrees.
Returns:
Dict with command result.
Inputs: draft_angle. Returns: result
rhino_drawing_export_pdfC
Export a sheet to PDF (bridge only).
Inputs: args (required). Returns: object
rhino_drawing_section_cutC
Cut a section through objects with a plane and place the trace on a sheet (bridge only).
Inputs: args (required). Returns: object
rhino_drawing_sheet_createA
Create a sheet container — a rectangle on layer Sheets::<name> carrying user_text metadata.
The rectangle's corners define the sheet bounds; user_text holds the
sheet name, paper size (mm), and scale denominator so subsequent
view-placement / title-block / export tools can re-derive it.
Inputs: args (required). Returns: object
rhino_drawing_title_block_addB
Add the bottom-right title block, north arrow, and scale bar to a sheet.
Inputs: args (required). Returns: object
rhino_drawing_view_placeA
Project objects to a 2-D view (Make2D) and place the result on a sheet (bridge only).
Inputs: args (required). Returns: object
rhino_dup_borderC
Extract border curves from a surface or mesh.
Inputs: args (required). Returns: object
rhino_dup_edgeC
Extract edge curves from a Brep (all or specific indices).
Inputs: args (required). Returns: object
rhino_edge_srfA
Build a surface from 2, 3, or 4 edge/curve inputs.
Pre-select the bounding edges (2-4) before calling.
Args:
controller: RhinoController instance.
num_edges: Number of edge curves (2, 3, or 4).
Returns:
Dict with 'status' and 'command' keys.
Inputs: num_edges. Returns: result
rhino_edit_points_offA
Turn off edit point display for selected curves or surfaces.
Inputs: no named parameters. Returns: result
rhino_edit_points_onA
Turn on edit point display for selected curves or surfaces.
Inputs: no named parameters. Returns: result
rhino_ellipseB
Add an ellipse on the world XY plane (rhino3dm builds it as a NURBS approximation).
Inputs: args (required). Returns: object
rhino_ellipsoidA
Create an ellipsoid in Rhino.
Rhino prompts: center -> end of first axis -> end of second axis ->
end of third axis. We supply the three semi-axis end-points along
the world X, Y, Z directions respectively.
Args:
controller: RhinoController instance.
x, y, z: Center of the ellipsoid.
rx: Semi-axis length along X.
ry: Semi-axis length along Y.
rz: Semi-axis length along Z.
Returns:
Dict with 'status' and 'command' keys.
Inputs: x, y, z, rx, +2 more. Returns: result
rhino_environment_setA
Attach an HDRI/EXR environment used for lighting + background (bridge only).
Inputs: args (required). Returns: object
rhino_eval_expressionC
Evaluate a Python expression inside Rhino and return the result.
Args:
expression: A valid Python expression string (e.g. '2 + 2' or 'rs.WorldXYPlane()').
Inputs: expression (required). Returns: result
rhino_evaluate_surfaceARead-only
Evaluate a surface at UV parameters to get 3D point, normal, and tangents.
Inputs: args (required). Returns: object
rhino_execute_csharpADestructive
Execute RhinoCommon C# code in a live Rhino session using Roslyn.
SAFETY: This tool runs arbitrary code with full RhinoCommon access.
It is gated behind ``RHINO_MCP_ALLOW_CSHARP=1`` so it cannot fire
accidentally. Set the env var only in trusted sessions.
Globals available to the script:
- ``doc``: the active ``RhinoDoc``
- ``output``: a ``StringBuilder`` — call ``output.AppendLine("...")``
to return text to the caller.
Pre-imported namespaces: System, System.Collections.Generic,
System.Linq, System.Text, Rhino, Rhino.Geometry, Rhino.DocObjects,
Rhino.Commands. Pass ``references`` to load extra assemblies (e.g.
``Grasshopper``).
Example — create a sphere::
var sphere = new Sphere(Point3d.Origin, 5.0);
doc.Objects.AddBrep(sphere.ToBrep());
doc.Views.Redraw();
output.AppendLine("Created sphere");
Changes are wrapped in an undo record. ``timeout_s`` caps total
execution time (default 30s); on timeout the call returns
``success: false`` and the script is best-effort cancelled.
Inputs: args (required). Returns: object
rhino_execute_pythonA
Execute RhinoScript Python code in a live Rhino session.
CRITICAL — BEFORE USING THIS TOOL:
1. Call rhino_get_rhinoscript_docs(topic) to find correct signatures.
2. Read the documentation carefully — note exact parameter types.
3. Write code using ONLY the documented signatures.
4. Call this tool with the code.
Code requirements:
- Import rhinoscriptsyntax: ``import rhinoscriptsyntax as rs``
- Use ``print()`` to return output/results to the caller.
- Handle ``None`` returns from functions that might fail.
Changes are wrapped in an undo record and will be reverted on failure.
Returns ``success``, ``output`` (print capture), and ``message``
(error details on failure).
Inputs: args (required). Returns: object
rhino_explodeB
Explode selected polysurfaces, blocks, or groups into component parts.
Args:
controller: RhinoController instance.
Inputs: no named parameters. Returns: result
rhino_explode_blockB
Explode selected block instances into their constituent geometry.
Inputs: no named parameters. Returns: result
rhino_exportA
Select all geometry and export to a file.
The export format is inferred from the file extension; ``export_type``
is used as the extension if ``file_name`` has none.
Args:
controller: RhinoController instance.
file_name: Output filename (e.g. 'model.stl') or full path.
folder: Optional folder override.
export_type: File extension / format if not included in file_name
(default 'stl').
Returns:
Dict with command result.
Inputs: file_name (required), folder, export_type. Returns: result
rhino_export_dxfB
Export to DXF (bridge required).
Inputs: args (required). Returns: object
rhino_export_gbxmlB
Export thermal / structural BIM payload to gbXML (bridge only).
Inputs: args (required). Returns: object
rhino_export_ifcA
Export the active document (or a subset) to IFC2x3 / IFC4 / IFC4x3 (bridge only).
Inputs: args (required). Returns: object
rhino_export_igesC
Export to IGES (bridge required).
Inputs: args (required). Returns: object
rhino_export_objA
Export selected (or all) objects to a Wavefront OBJ file (mesh-only).
Inputs: args (required). Returns: object
rhino_export_stepA
Export to STEP (bridge required).
Inputs: args (required). Returns: object
rhino_export_stlB
Export meshes to an ASCII STL file.
Inputs: args (required). Returns: object
rhino_extend_curveC
Extend the selected curve by a fixed length from one or both ends.
The curve must be pre-selected before calling this function.
Args:
controller: RhinoController instance.
length: Extension length.
Returns:
Dict with 'status' and 'command' keys.
Inputs: length. Returns: result
rhino_extend_surfaceB
Extend a surface edge by a specified distance.
The edge to extend is selected interactively.
Args:
controller: RhinoController instance.
distance: Extension distance.
Returns:
Dict with command result.
Inputs: distance. Returns: result
rhino_extrudeB
Linearly extrude a profile curve by distance along direction.
Inputs: args (required). Returns: object
rhino_extrude_curveB
Extrude selected curve(s) to create a solid or surface.
Args:
controller: RhinoController instance.
distance: Extrusion distance.
both_sides: Extrude in both directions symmetrically.
solid: Create a closed solid (cap ends).
delete_input: Delete the input curve after extrusion.
Inputs: solid, distance, both_sides, delete_input. Returns: result
rhino_extrude_surfaceB
Extrude selected surface(s) by a given distance.
Args:
controller: RhinoController instance.
distance: Extrusion distance.
both_sides: Extrude in both directions symmetrically.
solid: Create a closed solid.
Inputs: solid, distance, both_sides. Returns: result
rhino_fair_curveA
Fair (smooth) the selected curve using Rhino's FairCrv command.
The curve must be pre-selected before calling this function.
Args:
controller: RhinoController instance.
Returns:
Dict with 'status' and 'command' keys.
Inputs: no named parameters. Returns: result
rhino_fillet_edgesB
Fillet the selected edges of a polysurface or solid.
Args:
controller: RhinoController instance.
radius: Fillet radius.
Returns:
Dict with command result.
Inputs: radius. Returns: result
rhino_fillet_surfaceB
Create a constant-radius fillet between two surfaces.
Inputs: args (required). Returns: object
rhino_flipA
Flip the normal direction of selected surfaces.
Args:
controller: RhinoController instance.
Returns:
Dict with command result.
Inputs: no named parameters. Returns: result
rhino_flip_mesh_normalsB
Flip the normals of selected mesh faces.
Args:
controller: RhinoController instance.
Inputs: no named parameters. Returns: result
rhino_flowC
Flow objects from one curve onto another (bridge only).
Inputs: args (required). Returns: object
rhino_flow_along_curveC
Reposition objects from a base curve onto a target curve.
Inputs: args (required). Returns: object
rhino_freeform_curveA
Create a control-point (freeform) NURBS spline.
The curve is defined by its control polygon; it does NOT pass through
interior points (only through the first and last control point when the
degree allows).
Args:
controller: RhinoController instance.
points: Control polygon vertices as (x, y, z) tuples.
degree: Polynomial degree (default 3 = cubic B-spline).
Returns:
Dict with 'status' and 'command' keys.
Inputs: points (required), degree. Returns: result
rhino_get_control_pointsARead-only
Get all control points (and weights) of a NURBS curve or surface.
Inputs: args (required). Returns: object
rhino_get_document_textA
Retrieve a document-level user text value by key.
Args:
key: Key name.
Inputs: key (required). Returns: result
rhino_get_module_functionsARead-only
Get all functions in a specific RhinoScript module with signatures.
Use rhino_list_rhinoscript_modules() first to see available modules,
then call this to browse a module's full API.
Inputs: args (required). Returns: object
rhino_get_object_infoA
Return information (type, layer, name, color) for all currently selected objects.
Inputs: no named parameters. Returns: result
rhino_get_object_nameA
Return the name of each currently selected object.
Inputs: no named parameters. Returns: result
rhino_get_rhinoscript_docsARead-only
Get comprehensive RhinoScript documentation for a topic.
CRITICAL: You MUST call this tool before using rhino_execute_python.
Returns full signatures, parameter descriptions, return values, and
optional code examples for the most relevant functions.
Inputs: args (required). Returns: object
rhino_get_user_textARead-only
Read user text (key-value metadata) attached to an object.
Inputs: args (required). Returns: object
rhino_groupC
Group objects together under a (named) group.
Inputs: args (required). Returns: object
rhino_group_selectedA
Group the currently selected objects.
Args:
name: Optional name for the group. If None, Rhino auto-assigns a name.
Inputs: name. Returns: result
rhino_hatchC
Add a hatch over the given closed curves.
Inputs: args (required). Returns: object
rhino_helixB
Add a helix sampled into a NURBS curve.
Inputs: args (required). Returns: object
rhino_hide_selectedA
Hide currently selected objects.
Inputs: no named parameters. Returns: result
rhino_importC
Import an external file into the active document (bridge required for non-3DM).
Inputs: args (required). Returns: object
rhino_import_ifcA
Import an IFC file, mapping each entity to a layer under target_layer_root (bridge only).
Inputs: args (required). Returns: object
rhino_insert_blockB
Insert a block instance into the document.
Args:
name: Block definition name to insert.
x, y, z: Insertion point.
scale: Uniform scale factor.
rotation: Rotation angle in degrees.
Inputs: name (required), x, y, z, +2 more. Returns: result
rhino_interpcrvC
Create an interpolated NURBS curve that passes through all given points.
Args:
controller: RhinoController instance.
points: Ordered list of (x, y, z) tuples (>= 2).
degree: Polynomial degree of the resulting curve (default 3 = cubic).
Returns:
Dict with 'status' and 'command' keys.
Inputs: points (required), degree. Returns: result
rhino_interpolate_curveB
Add an interpolated NURBS curve passing through the given points.
Inputs: args (required). Returns: object
rhino_isocurveB
Extract an isocurve from a surface at a specific U or V parameter.
Inputs: args (required). Returns: object
rhino_joinB
Join selected surfaces, curves, or polysurfaces into a single object.
Args:
controller: RhinoController instance.
Inputs: no named parameters. Returns: result
rhino_launchB
Launch Rhino and wait for it to become ready.
Args:
controller: RhinoController instance.
wait_seconds: Seconds to wait for Rhino to start (default 12).
Returns:
Dict with launch result.
Inputs: wait_seconds. Returns: result
rhino_layer_colorB
Set a layer's display color.
Args:
name: Layer name.
r, g, b: RGB color components (0-255).
Inputs: name (required), b, g, r. Returns: result
rhino_layer_countA
Return the total number of layers in the document.
Inputs: no named parameters. Returns: result
rhino_layer_createB
Create a layer with optional colour and visibility.
Inputs: args (required). Returns: object
rhino_layer_deleteADestructive
Delete a layer by name (in standalone mode the layer is hidden + name-prefixed).
Inputs: args (required). Returns: object
rhino_layer_get_currentA
Return the name of the current (active) layer.
Inputs: no named parameters. Returns: result
rhino_layer_isolateA
Isolate a layer by hiding all other layers.
Args:
name: Layer to keep visible.
Inputs: name (required). Returns: result
rhino_layer_listBRead-only
List all layers with their properties (color, visibility, object count).
Inputs: args (required). Returns: object
rhino_layer_lockB
Lock or unlock a layer.
Args:
name: Layer name.
locked: True to lock, False to unlock.
Inputs: name (required), locked. Returns: result
rhino_layer_purge_unusedA
Delete all layers that contain no objects and have no sub-layers.
Inputs: no named parameters. Returns: result
rhino_layer_renameC
Rename an existing layer.
Args:
old_name: Current layer name.
new_name: New layer name.
Inputs: new_name (required), old_name (required). Returns: result
rhino_layer_set_colorB
Change a layer's display colour.
Inputs: args (required). Returns: object
rhino_layer_set_currentC
Set the active (current) layer.
Args:
name: Name of the layer to make current.
Inputs: name (required). Returns: result
rhino_layer_set_materialA
Bind a render material to a layer so layer-source objects inherit it.
Bridge-only: rhino3dm exposes ``material_index`` on the layer but the
in-document material table is read-only. Use ``rhino_material_create``
first to define the material.
Inputs: args (required). Returns: object
rhino_layer_unisolateA
Show all layers (undo isolation).
Inputs: no named parameters. Returns: result
rhino_layer_visibleA
Show or hide a layer.
Args:
name: Layer name.
visible: True to show, False to hide.
Inputs: name (required), visible. Returns: result
rhino_leaderB
Add a multi-point leader (with optional text).
Inputs: args (required). Returns: object
rhino_lengthB
Measure the length of selected curves.
Args:
controller: RhinoController instance.
Returns:
Dict with command result containing curve length.
Inputs: no named parameters. Returns: result
rhino_light_addB
Add a point / spot / directional / rectangular / linear light to the document.
Inputs: args (required). Returns: object
rhino_lineB
Add a line between two points.
Inputs: args (required). Returns: object
rhino_list_blocksA
Return a list of all block definition names in the document.
Inputs: no named parameters. Returns: result
rhino_list_objectsARead-only
List objects in the document with optional layer/type filter.
Returns up to ``limit`` objects starting at ``offset`` (after filters).
The response carries a ``pagination`` block — ``{total, offset, limit,
returned, has_more}`` — so the caller can iterate without guessing.
Async so concurrent ``rhino_*`` queries don't block FastMCP's event
loop while the bridge round-trip is in flight.
Inputs: args (required). Returns: object
rhino_list_rhinoscript_modulesARead-only
List all available RhinoScript modules with function counts.
Use this to discover what areas of the API are available when you are not sure which module contains the functions you need.
Inputs: no named parameters. Returns: object
rhino_list_saved_filesB
List all files in the default RhinoFiles directory (D:/RhinoFiles).
Args:
controller: RhinoController instance.
Returns:
Dict with 'files' key containing list of file info dicts,
and 'directory' key with the scanned path.
Inputs: no named parameters. Returns: result
rhino_lock_selectedA
Lock currently selected objects so they cannot be selected or modified.
Inputs: no named parameters. Returns: result
rhino_loftB
Loft a sequence of profile curves into a surface.
Inputs: args (required). Returns: object
rhino_make2dC
Generate a 2D drawing projection of 3D objects.
Inputs: args (required). Returns: object
rhino_match_srfB
Match the edge of one surface to another for G0/G1/G2 continuity.
Pre-select the edge to adjust before calling.
Args:
controller: RhinoController instance.
continuity: Continuity type: 'Position', 'Tangency', or 'Curvature'.
Returns:
Dict with 'status' and 'command' keys.
Inputs: continuity. Returns: result
rhino_match_surfaceC
Adjust a surface edge to match the continuity of a target surface.
Inputs: args (required). Returns: object
rhino_material_assignB
Assign an existing material to one or more objects.
Inputs: args (required). Returns: object
rhino_material_createB
Create a material with diffuse colour, transparency, and glossiness.
Inputs: args (required). Returns: object
rhino_material_preset_createA
Create a document material from a bundled physical preset.
Standalone uses rhino3dm's basic Material (diffuse / transparency / shine). Bridge mode also pushes the matching Rhino PBR render content + IOR for photoreal output.
Inputs: args (required). Returns: object
rhino_material_preset_listARead-onlyIdempotent
List physical-material presets bundled with rhino-mcp.
Returns the full catalogue (or a single category subset) so the LLM
can pick a known-good name before calling ``rhino_material_preset_create``.
Inputs: args (required). Returns: object
rhino_materials_managerA
Open the Rendering / Materials panel.
Inputs: no named parameters. Returns: result
rhino_merge_all_coplanar_facesA
Merge all coplanar faces of selected polysurfaces into single faces.
Args:
controller: RhinoController instance.
Returns:
Dict with command result.
Inputs: no named parameters. Returns: result
rhino_merge_all_facesB
Merge all coplanar adjacent faces in selected polysurfaces.
Args:
controller: RhinoController instance.
Inputs: no named parameters. Returns: result
rhino_merge_edgeB
Merge selected adjacent edges of a surface.
Args:
controller: RhinoController instance.
Returns:
Dict with command result.
Inputs: no named parameters. Returns: result
rhino_merge_surfacesC
Merge multiple surfaces into a single surface.
Inputs: args (required). Returns: object
rhino_mesh_boolean_differenceBDestructive
Boolean-difference meshes (a - b).
Inputs: args (required). Returns: object
rhino_mesh_boolean_intersectionB
Boolean intersection of selected closed meshes.
Args:
controller: RhinoController instance.
Inputs: no named parameters. Returns: result
rhino_mesh_boolean_unionCDestructive
Boolean-union meshes.
Inputs: args (required). Returns: object
rhino_mesh_boxC
Add a quad mesh box with the given subdivisions.
Inputs: args (required). Returns: object
rhino_mesh_from_brepC
Mesh a Brep (bridge only).
Inputs: args (required). Returns: object
rhino_mesh_from_nurbsA
Convert selected NURBS surfaces / polysurfaces to a render mesh.
Args:
controller: RhinoController instance.
max_angle: Maximum angle between mesh normals (degrees).
max_aspect: Maximum aspect ratio of mesh faces (0 = ignore).
max_distance: Maximum distance from mesh edge to surface.
max_edge: Maximum mesh edge length (0 = ignore).
min_edge: Minimum mesh edge length.
min_initial_grid: Minimum initial grid quads per surface.
refine: Refine the mesh for better quality.
jagged_seams: Allow jagged seams between surfaces.
Inputs: refine, max_edge, min_edge, max_angle, +4 more. Returns: result
rhino_mesh_from_surfaceC
Mesh a surface (bridge only).
Inputs: args (required). Returns: object
rhino_mesh_repairB
Launch the MeshRepair wizard for selected meshes.
Args:
controller: RhinoController instance.
Inputs: no named parameters. Returns: result
rhino_mesh_splitB
Split a mesh with another mesh or surface.
Args:
controller: RhinoController instance.
Inputs: no named parameters. Returns: result
rhino_mesh_to_nurbsB
Convert selected mesh objects to NURBS surfaces.
Args:
controller: RhinoController instance.
Inputs: no named parameters. Returns: result
rhino_mesh_trimC
Trim a mesh with a cutting curve or surface.
Args:
controller: RhinoController instance.
Inputs: no named parameters. Returns: result
rhino_mirrorB
Mirror objects across a plane (copies by default).
Inputs: args (required). Returns: object
rhino_modify_offset_curveC
Offset a selected curve by a given distance.
Args:
controller: RhinoController instance.
distance: Offset distance.
both_sides: If True, offset to both sides of the curve.
cap: If True, add end caps (for open curves with BothSides=Yes).
Returns:
Dict with command result.
Inputs: cap, distance, both_sides. Returns: result
rhino_moveC
Translate (or copy) the given objects by a vector.
Inputs: args (required). Returns: object
rhino_move_objects_to_layerA
Move currently selected objects to the specified layer.
Args:
layer_name: Target layer name.
Inputs: layer_name (required). Returns: result
rhino_move_uvnC
Enter MoveUVN mode to move control points along U, V, N directions.
Inputs: no named parameters. Returns: result
rhino_multi_pipeA
Create a multi-pipe from selected curves.
Args:
controller: RhinoController instance.
radius: Pipe radius at each curve.
Inputs: radius. Returns: result
rhino_named_viewsB
Manage named views: list, save, restore, or delete.
Args:
controller: RhinoController instance.
action: One of 'list', 'save', 'restore', 'delete'.
view_name: Name of the view (required for save/restore/delete).
Returns:
Dict with command result or list of named views.
Inputs: action, view_name. Returns: result
rhino_named_view_saveB
Save the current camera as a named view.
Inputs: args (required). Returns: object
rhino_network_srfA
Build a surface through a network of intersecting curves.
Pre-select the network curves before calling.
Args:
controller: RhinoController instance.
Returns:
Dict with 'status' and 'command' keys.
Inputs: no named parameters. Returns: result
rhino_network_surfaceB
Build a surface from a network of crossing curves.
Inputs: args (required). Returns: object
rhino_new_documentB
Create a new Rhino document, optionally from a template.
Args:
controller: RhinoController instance.
template: Path to a .3dm template file. If empty, opens a blank document.
Returns:
Dict with command result.
Inputs: template. Returns: result
rhino_nurbs_curveB
Add a NURBS curve from a control polygon.
Inputs: args (required). Returns: object
rhino_object_deleteCDestructive
Delete the given objects from the document.
Inputs: args (required). Returns: object
rhino_object_infoARead-only
Get detailed info about a single object (geometry type, layer, bbox, etc.).
Inputs: args (required). Returns: object
rhino_object_move_to_layerB
Reassign one or more objects to a different layer (creating it if absent).
Inputs: args (required). Returns: object
rhino_object_properties_dialogB
Open the Object Properties panel for the selected object.
Inputs: no named parameters. Returns: result
rhino_object_quantityBRead-only
Per-object measurement table — one row per object_id with the requested fields.
Inputs: args (required). Returns: object
rhino_object_selectB
Select objects by ID and/or attribute filters.
Filter fields combine with AND semantics. ``object_ids`` short-circuits
the other filters when provided. Standalone mode marks matches with the
``rhino_mcp_selected`` user-string (since rhino3dm has no selection
state); bridge mode delegates to Rhino's native selection.
Inputs: args (required). Returns: object
rhino_offset_curveA
Offset the currently selected curve by a specified distance.
The curve must be pre-selected before calling this function.
Args:
controller: RhinoController instance.
distance: Perpendicular offset distance.
through_point: Optional 'x,y,z' string to offset through a point
instead of using *distance*.
Returns:
Dict with 'status' and 'command' keys.
Inputs: distance, through_point. Returns: result
rhino_offset_meshB
Offset selected mesh faces by a given distance.
Args:
controller: RhinoController instance.
distance: Offset distance (along face normals).
Inputs: distance. Returns: result
rhino_offset_srfA
Offset a surface by a specified distance, optionally creating a solid.
Pre-select the surface before calling.
Args:
controller: RhinoController instance.
distance: Offset distance (positive = outward along normals).
solid: If True, caps the sides to create a closed solid.
Returns:
Dict with 'status' and 'command' keys.
Inputs: solid, distance. Returns: result
rhino_offset_subdB
Offset a SubD object by a given distance, optionally creating a solid.
Args:
controller: RhinoController instance.
distance: Offset distance.
solid: Create a solid (closed) offset.
Inputs: solid, distance. Returns: result
rhino_offset_surfaceB
Offset a surface by distance along its normal.
Inputs: args (required). Returns: object
rhino_openC
Open a .3dm file and bind it to a doc_id.
Inputs: args (required). Returns: object
rhino_open_fileC
Open an existing Rhino file.
Args:
controller: RhinoController instance.
file_path: Absolute path to the .3dm file to open.
Returns:
Dict with command result.
Inputs: file_path (required). Returns: result
rhino_orientA
Orient objects from one plane to another (PlaneToPlane transform).
Inputs: args (required). Returns: object
rhino_orient_3ptB
Orient selected objects using three reference points (interactive).
Args:
controller: RhinoController instance.
Returns:
Dict with command result.
Inputs: no named parameters. Returns: result
rhino_orient_on_crvC
Orient selected objects along a curve (interactive).
Args:
controller: RhinoController instance.
Returns:
Dict with command result.
Inputs: no named parameters. Returns: result
rhino_orient_on_srfB
Orient selected objects on a surface (interactive).
Args:
controller: RhinoController instance.
Returns:
Dict with command result.
Inputs: no named parameters. Returns: result
rhino_origin_setA
Set the model base point.
``mode='reference'`` stores the point as metadata only — useful for
geo-referencing without disturbing existing geometry. ``mode='translate'``
shifts every object so the supplied point becomes the new (0,0,0).
Inputs: args (required). Returns: object
rhino_pack_texturesA
Pack all external textures into the document for portability.
Inputs: no named parameters. Returns: result
rhino_panC
Pan the active viewport.
Args:
dx: Horizontal pan amount.
dy: Vertical pan amount.
Inputs: dx, dy. Returns: result
rhino_panel_curvature_classifyBRead-only
Classify each UxV panel by curvature class (planar / single_* / synclastic / anticlastic).
Standalone uses a 4-corner normal heuristic (no full Gaussian K).
Bridge mode reports true Gaussian + mean curvature per cell.
Inputs: args (required). Returns: object
rhino_panel_framesCRead-only
Generate oriented frames (planes) at panel centres for construction.
Inputs: args (required). Returns: object
rhino_panelize_surfaceC
Subdivide a surface into panels (quad, triangle, or diamond).
Inputs: args (required). Returns: object
rhino_panel_planarityARead-only
Per-panel planarity report on a UxV grid sampled from a surface.
Each cell's planarity error = distance of the 4th corner from the
plane fitted through the first three. Cells whose error > tolerance
are flagged. The returned ``stats`` block summarises max / mean /
non-planar count for high-level reporting.
Inputs: args (required). Returns: object
rhino_paraboloidA
Create a paraboloid surface in Rhino using the Paraboloid command.
Rhino prompts: focus/apex point -> radius at base -> height.
Args:
controller: RhinoController instance.
x, y, z: Apex (tip) of the paraboloid.
radius: Radius of the open base circle.
height: Height from apex to base.
Returns:
Dict with 'status' and 'command' keys.
Inputs: x, y, z, height, +1 more. Returns: result
rhino_patchC
Patch a region defined by boundary curves.
Inputs: args (required). Returns: object
rhino_perspective_angleA
Set the perspective viewport camera lens angle.
Args:
angle: Lens angle in degrees (e.g. 45, 60).
Inputs: angle. Returns: result
rhino_pipe_from_curveA
Create a pipe solid around a previously created (or selected) curve.
The function first runs *curve_select_cmd* to select the rail curve,
then runs the Pipe command with the given radius and cap style.
Args:
controller: RhinoController instance.
curve_select_cmd: Rhino command used to select the curve before
piping (default: '_SelLast' selects the most
recently created object).
radius: Pipe outer radius.
cap: If True, caps the pipe ends (solid); otherwise
leaves them open.
Returns:
Dict with 'status' and 'command' keys.
Inputs: cap, radius, curve_select_cmd. Returns: result
rhino_place_gridA
Replicate a source object on a count_x x count_y grid with given spacing.
Returns the new object IDs in row-major (x outer, y inner) order. The
source is preserved; when ``skip_origin`` is True the (0,0) cell is
left untouched and the source itself fills it.
Inputs: args (required). Returns: object
rhino_planar_srfA
Fill planar closed curves with a planar surface.
Pre-select the boundary curves before calling.
Args:
controller: RhinoController instance.
Returns:
Dict with 'status' and 'command' keys.
Inputs: no named parameters. Returns: result
rhino_plane_surfaceB
Add a finite plane (rectangular trim) on the given plane.
Inputs: args (required). Returns: object
rhino_pointC
Add a single point to the document.
Inputs: args (required). Returns: object
rhino_point_deviationA
Analyse the deviation between point clouds and a reference surface.
Objects must be selected before calling; the command runs interactively.
Args:
controller: RhinoController instance.
Returns:
Dict with command result.
Inputs: no named parameters. Returns: result
rhino_points_offA
Turn off control point display for selected objects.
Inputs: no named parameters. Returns: result
rhino_points_onA
Turn on control point display for selected objects.
Inputs: no named parameters. Returns: result
rhino_points_solid_onB
Enable solid point display for solid/closed objects.
Inputs: no named parameters. Returns: result
rhino_polygonC
Add a regular polygon (inscribed or circumscribed) on the XY plane.
Inputs: args (required). Returns: object
rhino_polylineB
Add a polyline through the given points; optionally closed.
Inputs: args (required). Returns: object
rhino_probe_intersectionBRead-onlyIdempotent
Cast a ray and report intersection points against Breps/Extrusions.
Returns ``hits`` sorted by distance from the ray origin. Bridge-only —
rhino3dm has no ray-shoot primitive.
Inputs: args (required). Returns: object
rhino_project_to_cplaneA
Project selected objects onto the active construction plane.
Original objects are not kept.
Args:
controller: RhinoController instance.
Returns:
Dict with command result.
Inputs: no named parameters. Returns: result
rhino_purgeB
Purge unused document objects to reduce file size.
Args:
controller: RhinoController instance.
purge_unused_layers: Remove layers with no geometry (default True).
purge_unused_blocks: Remove unreferenced block definitions (default True).
purge_unused_materials: Remove unreferenced materials (default True).
Returns:
Dict with command result.
Inputs: purge_unused_blocks, purge_unused_layers, purge_unused_materials. Returns: result
rhino_push_pullB
Push or pull a selected sub-face of a solid by a given distance.
Args:
controller: RhinoController instance.
distance: Push/pull distance (positive = outward, negative = inward).
Inputs: distance. Returns: result
rhino_pyramidB
Create a regular pyramid in Rhino.
Args:
controller: RhinoController instance.
x, y, z: Center of the base polygon.
sides: Number of sides for the base polygon (>= 3).
radius: Circumradius of the base polygon.
height: Height of the pyramid apex above the base.
Returns:
Dict with 'status' and 'command' keys.
Inputs: x, y, z, sides, +2 more. Returns: result
rhino_quadrangulate_meshC
Convert triangular faces in selected meshes to quads where possible.
Args:
controller: RhinoController instance.
Inputs: no named parameters. Returns: result
rhino_quad_remeshB
Remesh selected objects into a uniform quad mesh.
Args:
controller: RhinoController instance.
target_quad_count: Target number of quad faces.
adaptive_size: Adaptive size percentage (0–100).
detect_hard_edges: Preserve hard edges during remeshing.
Inputs: adaptive_size, detect_hard_edges, target_quad_count. Returns: result
rhino_radiusA
Measure the radius of a selected arc or circle (interactive).
Args:
controller: RhinoController instance.
Returns:
Dict with command result.
Inputs: no named parameters. Returns: result
rhino_rail_revolveA
Rail-revolve: revolve a profile along a rail path curve.
Pre-select the profile curve and rail curve before calling.
Args:
controller: RhinoController instance.
Returns:
Dict with 'status' and 'command' keys.
Inputs: no named parameters. Returns: result
rhino_rebuildC
Rebuild selected curves or surfaces with specified point count and degree.
Args:
controller: RhinoController instance.
point_count: Number of control points.
degree: NURBS degree.
Returns:
Dict with command result.
Inputs: degree, point_count. Returns: result
rhino_rebuild_curveB
Rebuild an existing curve with a new point count and degree.
Inputs: args (required). Returns: object
rhino_rebuild_meshC
Rebuild selected meshes to clean up topology.
Args:
controller: RhinoController instance.
Inputs: no named parameters. Returns: result
rhino_rebuild_surfaceC
Rebuild a surface with new point counts and degrees in U/V.
Inputs: args (required). Returns: object
rhino_rebuild_uvC
Rebuild a surface in U and V directions independently.
Args:
controller: RhinoController instance.
u_count: Control-point count in U direction.
v_count: Control-point count in V direction.
Returns:
Dict with command result.
Inputs: u_count, v_count. Returns: result
rhino_rectangleB
Add a rectangle as a closed polyline on the XY plane.
Inputs: args (required). Returns: object
rhino_redoC
Redo the last undone operation(s) in the Rhino document.
Inputs: args (required). Returns: object
rhino_reduce_meshBDestructive
Reduce a mesh to a target face count.
Inputs: args (required). Returns: object
rhino_refit_trimB
Refit the trim curves of selected surfaces.
Args:
controller: RhinoController instance.
Returns:
Dict with command result.
Inputs: no named parameters. Returns: result
rhino_remove_control_pointA
Remove a selected control point from a NURBS curve or surface.
Inputs: no named parameters. Returns: result
rhino_remove_creaseA
Remove the crease from selected SubD edges (smooth them).
Args:
controller: RhinoController instance.
Inputs: no named parameters. Returns: result
rhino_renderC
Render the scene using the current render settings.
Inputs: no named parameters. Returns: result
rhino_render_previewB
Start a quick preview render.
Inputs: no named parameters. Returns: result
rhino_render_queue_cancelA
Cancel a running or queued render job.
Inputs: args (required). Returns: object
rhino_render_queue_listARead-onlyIdempotent
List recent render jobs and their progress.
Inputs: args (required). Returns: object
rhino_render_queue_statusARead-onlyIdempotent
Inspect a queued render job's status, progress, and completed frames.
Inputs: args (required). Returns: object
rhino_render_queue_submitA
Submit a frame sequence to the bridge render queue (bridge only).
Returns a ``job_id`` immediately while frames are captured on a
background worker. Use ``rhino_render_queue_status`` to poll
progress and ``rhino_render_queue_cancel`` to interrupt. The v0.5
backend captures viewport frames (``_-ViewCaptureToFile``); true
photo-realistic engine integration is on the roadmap.
Inputs: args (required). Returns: object
rhino_render_setupB
Set render resolution / samples / engine / transparency on the active render context.
Inputs: args (required). Returns: object
rhino_render_to_fileC
Execute the configured render and write the result to output_path.
Inputs: args (required). Returns: object
rhino_render_viewportB
Render the active viewport to an image file (bridge required).
Inputs: args (required). Returns: object
rhino_repair_subdB
Repair selected SubD objects to fix topology issues.
Args:
controller: RhinoController instance.
Inputs: no named parameters. Returns: result
rhino_reparameterizeB
Reparameterize selected curves or surfaces to natural parameterization.
Args:
controller: RhinoController instance.
Returns:
Dict with command result.
Inputs: no named parameters. Returns: result
rhino_replace_blockC
Replace selected block instances with a different block definition.
Args:
new_name: Name of the replacement block definition.
Inputs: new_name (required). Returns: result
rhino_replicate_along_curveB
Distribute copies of a source object along a curve at evenly-spaced parameters.
With ``align_to_tangent`` (default), each copy is reoriented so that
the world-X direction maps to the curve tangent at its sample point.
``include_endpoints`` controls whether the first/last samples land on
the curve's start/end points.
Inputs: args (required). Returns: object
rhino_report_mesh_healthBRead-only
Mesh health — closed, manifold, vertex/face counts, validity log.
Inputs: args (required). Returns: object
rhino_revertC
Revert the current document to its last saved state.
Args:
controller: RhinoController instance.
Returns:
Dict with command result.
Inputs: no named parameters. Returns: result
rhino_revolveC
Revolve a profile curve about an axis.
Inputs: args (required). Returns: object
rhino_ribC
Create a rib feature on a solid from selected curves.
Args:
controller: RhinoController instance.
width: Rib width.
thickness: Rib thickness.
Inputs: width, thickness. Returns: result
rhino_rotateC
Rotate objects about an axis through a centre point.
Inputs: args (required). Returns: object
rhino_rotate_3dC
Rotate selected objects around an arbitrary 3-D axis.
Args:
controller: RhinoController instance.
axis_start: Start point of the rotation axis.
axis_end: End point of the rotation axis.
angle: Rotation angle in degrees.
Returns:
Dict with command result.
Inputs: angle, axis_end, axis_start. Returns: result
rhino_run_commandA
Send a raw Rhino command string.
Args:
command: Full Rhino command string (including parameters and Enter tokens).
rhino_id: Optional Rhino instance ID.
Inputs: command (required), rhino_id. Returns: result
rhino_run_macroA
Execute a sequence of Rhino commands (macro) one step at a time.
Args:
macro_steps: List of command strings to execute in order.
Returns:
Dict with 'steps' containing per-step results and overall 'success' flag.
Inputs: macro_steps (required). Returns: result
rhino_run_pythonB
Execute arbitrary Python code inside Rhino's runtime environment.
Args:
code: Python source code string to execute.
rhino_id: Optional Rhino instance ID (for multi-instance setups).
Inputs: code (required), rhino_id. Returns: result
rhino_run_script_fileB
Execute a Python script file inside Rhino.
Args:
file_path: Absolute path to the .py script file.
Inputs: file_path (required). Returns: result
rhino_saveC
Write the document to disk.
Inputs: args (required). Returns: object
rhino_save_asA
Save the current document under a new name/location.
If ``file_name`` is not an absolute path it is resolved relative to
D:/RhinoFiles (or ``folder`` if provided).
Args:
controller: RhinoController instance.
file_name: Desired filename (e.g. 'mymodel.3dm') or full path.
folder: Optional folder override.
Returns:
Dict with command result.
Inputs: file_name (required), folder. Returns: result
rhino_save_copyA
Save a copy of the current document without changing the active file path.
Args:
controller: RhinoController instance.
file_name: Desired filename or full path for the copy.
folder: Optional folder override.
Returns:
Dict with command result.
Inputs: file_name (required), folder. Returns: result
rhino_save_script_to_fileB
Save a Python code string to the temp scripts folder and return its path.
Args:
code: Python source code to save.
filename: Filename (e.g. 'my_script.py'); .py extension added if missing.
Returns:
Dict with 'success', 'path' of saved file.
Inputs: code (required), filename (required). Returns: result
rhino_scaleB
Scale objects non-uniformly about a centre.
Inputs: args (required). Returns: object
rhino_scale_1dB
Scale selected objects in one direction (1-D scale).
The user must pick the origin and scale direction interactively.
Args:
controller: RhinoController instance.
factor: Scale factor.
Returns:
Dict with command result.
Inputs: factor. Returns: result
rhino_scale_2dC
Scale selected objects in two directions simultaneously (2-D scale).
Args:
controller: RhinoController instance.
factor: Scale factor applied to both directions.
Returns:
Dict with command result.
Inputs: factor. Returns: result
rhino_scale_nuA
Scale selected objects non-uniformly along X, Y, Z.
Args:
controller: RhinoController instance.
x_factor: Scale factor in X.
y_factor: Scale factor in Y.
z_factor: Scale factor in Z.
Returns:
Dict with command result.
Inputs: x_factor, y_factor, z_factor. Returns: result
rhino_scatterA
Scatter count copies of a source inside a 2-D AABB with optional Z-rotation jitter.
The boundary is interpreted in world XY; Z is taken from
``boundary_min.z``. Use ``seed`` for deterministic output.
Inputs: args (required). Returns: object
rhino_schedule_by_layerBRead-only
Aggregate objects per layer with optional filter and sublayer merging.
Returns ``rows`` (one entry per layer) plus a ``totals`` block.
Inputs: args (required). Returns: object
rhino_schedule_by_materialARead-only
Aggregate objects grouped by assigned material name.
Standalone treats ``MaterialIndex == -1`` (default material) as
'Default'. Bridge mode resolves each object's effective material via
Rhino's render content lookup.
Inputs: args (required). Returns: object
rhino_schedule_by_user_textARead-only
Aggregate objects grouping by user_text[group_key] value.
Useful for BIM-style schedules: ``group_key='assembly_type'`` produces a
wall/window schedule, ``group_key='material'`` produces a material BOM.
Inputs: args (required). Returns: object
rhino_schedule_export_csvA
Write rows produced by any rhino_schedule_* tool to CSV.
Inputs: args (required). Returns: object
rhino_screenshotA
Capture a viewport screenshot (bridge required).
With ``as_base64=True`` the response includes ``image_base64`` so
the LLM can inspect the render inline. The PNG is also written to
``path`` regardless, for the user to save/share.
Inputs: args (required). Returns: object
rhino_seamB
Adjust the seam location of a closed surface (interactive).
Args:
controller: RhinoController instance.
Returns:
Dict with command result.
Inputs: no named parameters. Returns: result
rhino_search_rhinoscript_functionsARead-only
Search RhinoScript functions by keyword or description.
Use this BEFORE writing any RhinoScript Python code to find correct
function names and signatures. Returns matching functions sorted by
relevance.
Example queries: "loft surface", "boolean union", "rotate object",
"create curve", "extrude".
Inputs: args (required). Returns: object
rhino_sectionC
Slice the listed objects with a plane (bridge required).
Inputs: args (required). Returns: object
rhino_section_at_axisA
Slice a surface (or Brep / mesh in bridge) into count section curves.
Standalone supports ``axis='u'`` and ``axis='v'`` (surface isocurves).
World-axis slicing (``axis='x'/'y'/'z'``) requires bridge mode.
Inputs: args (required). Returns: object
rhino_sel_allA
Select all objects in the document.
Inputs: no named parameters. Returns: result
rhino_sel_bad_objectsB
Select geometrically invalid (bad) objects.
Inputs: no named parameters. Returns: result
rhino_sel_by_colorA
Select objects by display color.
Args:
color_rgb: Comma-separated RGB string, e.g. '255,0,0' for red.
Inputs: color_rgb. Returns: result
rhino_sel_by_nameB
Select objects by their name attribute.
Inputs: name (required). Returns: result
rhino_sel_by_typeA
Select objects by type.
Supported types:
'curve', 'surface', 'mesh', 'subd', 'point', 'polysurface',
'all_curves', 'line', 'polyline', 'arc', 'circle', 'ellipse',
'solid', 'extrusion', 'annotation', 'block', 'light', 'hatch'
Inputs: object_type (required). Returns: result
rhino_sel_chainA
Select a chain of connected curves from the current selection seed.
Inputs: no named parameters. Returns: result
rhino_sel_connectedA
Select all objects connected to the currently selected object.
Inputs: no named parameters. Returns: result
rhino_sel_duplicatesB
Select duplicate objects.
Inputs: no named parameters. Returns: result
rhino_selection_bboxDRead-only
Return the union bounding box of all objects in the document.
Inputs: args (required). Returns: object
rhino_sel_invertA
Invert the current selection using rhinoscriptsyntax.
Inputs: no named parameters. Returns: result
rhino_sel_lastA
Re-select the previously selected set of objects.
Inputs: no named parameters. Returns: result
rhino_sel_layerC
Select all objects on a specific layer.
Inputs: layer_name (required). Returns: result
rhino_sel_noneA
Deselect all objects.
Inputs: no named parameters. Returns: result
rhino_sel_small_objectsB
Select objects smaller than the given tolerance.
Args:
tolerance: Maximum bounding box size threshold.
Inputs: tolerance. Returns: result
rhino_set_background_colorA
Set the viewport background color via a Python script.
Args:
r, g, b: RGB color components (0-255).
Inputs: b, g, r. Returns: result
rhino_set_control_pointsC
Replace control points of a NURBS curve or surface.
Inputs: args (required). Returns: object
rhino_set_cplaneC
Set the construction plane origin for the specified viewport.
Args:
controller: RhinoController instance.
view: Viewport name (Perspective, Top, Front, Right, etc.).
origin_x: X coordinate of the new CPlane origin.
origin_y: Y coordinate of the new CPlane origin.
origin_z: Z coordinate of the new CPlane origin.
Returns:
Dict with command result.
Inputs: view, origin_x, origin_y, origin_z. Returns: result
rhino_set_display_modeA
Set the active viewport display mode.
Args:
mode: One of Wireframe, Shaded, Rendered, Ghosted, Raytraced,
ArtisticRendering, Pen, Technical.
Inputs: mode. Returns: result
rhino_set_document_textA
Store a document-level key/value string (persists in the .3dm file).
Args:
key: Key name.
value: Value string.
Inputs: key (required), value (required). Returns: result
rhino_set_gridB
Configure viewport grid settings.
Args:
controller: RhinoController instance.
grid_snap: Snap spacing size (default 1.0).
minor_gridlines: Number of minor grid lines (default 10).
major_gridlines: Number of major grid lines per minor (default 10).
Returns:
Dict with command result.
Inputs: grid_snap, major_gridlines, minor_gridlines. Returns: result
rhino_set_object_colorA
Set the display color for selected objects.
Args:
r, g, b: RGB color components (0-255).
use_layer_color: If True, reset to layer color instead of setting a custom color.
Inputs: b, g, r, use_layer_color. Returns: result
rhino_set_object_layerB
Move all currently selected objects to the specified layer.
Args:
layer_name: Target layer name.
Inputs: layer_name (required). Returns: result
rhino_set_object_materialC
Assign a named render material to currently selected objects.
Args:
material_name: Name of the render material.
Inputs: material_name (required). Returns: result
rhino_set_object_nameA
Set the name attribute on all currently selected objects.
Args:
name: Name string to assign.
Inputs: name (required). Returns: result
rhino_set_osnapB
Set active object snap modes.
Args:
controller: RhinoController instance.
modes: List of osnap mode names to enable, e.g.
['End', 'Mid', 'Cen', 'Int', 'Near', 'Point'].
Pass an empty list to disable all.
Defaults to ['End', 'Mid', 'Cen', 'Int', 'Near'].
Returns:
Dict with command result.
Inputs: modes. Returns: result
rhino_set_point_weightB
Set the weight of selected NURBS control points (for rational surfaces/curves).
Args:
weight: Control point weight value.
Inputs: weight. Returns: result
rhino_set_render_resolutionC
Set the document render output resolution.
Args:
width: Render width in pixels.
height: Render height in pixels.
Inputs: width, height. Returns: result
rhino_set_snapA
Enable or disable grid snap and set snap spacing.
Args:
controller: RhinoController instance.
enabled: True to enable snap, False to disable.
snap_size: The snap grid size (default 1.0).
Returns:
Dict with command result.
Inputs: enabled, snap_size. Returns: result
rhino_set_unitsB
Set the document unit system.
Args:
controller: RhinoController instance.
unit_system: One of Millimeters, Meters, Centimeters, Inches, Feet, etc.
Returns:
Dict with command result.
Inputs: unit_system. Returns: result
rhino_set_user_textB
Attach a key-value user text entry to an object.
Inputs: args (required). Returns: object
rhino_set_viewB
Set the active viewport to a standard view.
Args:
view_name: One of Top, Front, Right, Perspective, Back, Left, Bottom, Isometric.
viewport: Optional viewport name to target.
Inputs: viewport, view_name. Returns: result
rhino_shadow_projectB
Project objects' bounding-box corners along sun_vector to the ground plane.
Standalone produces a coarse 4-corner shadow polygon per object
(suitable for sketch-grade studies). Bridge mode emits accurate
wireframe-projection shadow polygons.
Inputs: args (required). Returns: object
rhino_shellCDestructive
Hollow a closed Brep, optionally leaving the listed faces open.
Inputs: args (required). Returns: object
rhino_show_dirB
Show the normal and/or curve direction of selected objects.
Args:
controller: RhinoController instance.
Returns:
Dict with command result.
Inputs: no named parameters. Returns: result
rhino_show_edgesB
Highlight edges of selected surfaces by type.
Valid modes: Naked, Non-manifold, All.
Args:
controller: RhinoController instance.
mode: Edge type to display.
Returns:
Dict with command result.
Inputs: mode. Returns: result
rhino_show_endpointsB
Toggle display of curve endpoints.
Args:
show: True to show endpoints, False to hide.
Inputs: show. Returns: result
rhino_show_selectedC
Show all hidden objects.
Inputs: no named parameters. Returns: result
rhino_shrink_trimmed_srfA
Shrink the underlying surface to its trim boundary.
Pre-select the trimmed surface before calling.
Args:
controller: RhinoController instance.
Returns:
Dict with 'status' and 'command' keys.
Inputs: no named parameters. Returns: result
rhino_shrink_wrapC
Shrink-wrap selected geometry into a watertight mesh.
Args:
controller: RhinoController instance.
resolution: Target voxel resolution for the wrap.
Inputs: resolution. Returns: result
rhino_silhouetteA
Extract silhouette curves from selected surfaces or meshes.
Args:
controller: RhinoController instance.
Returns:
Dict with command result.
Inputs: no named parameters. Returns: result
rhino_skin_from_sectionsA
Generate a skin (loft-equivalent) through ordered section curves.
- Standalone: chains ``CreateRuledSurface`` between adjacent section
pairs and returns the list of surface IDs; the caller can join them
downstream if needed.
- Bridge: emits a single Brep loft via ``Brep.CreateFromLoft``.
Inputs: args (required). Returns: object
rhino_slabC
Create a slab (extruded planar surface with thickness) from curves.
Args:
controller: RhinoController instance.
thickness: Slab thickness.
Inputs: thickness. Returns: result
rhino_smoothA
Smooth selected objects by averaging control-point positions.
Args:
controller: RhinoController instance.
strength: Smoothing strength (0–1).
iterations: Number of smoothing passes.
Returns:
Dict with command result.
Inputs: strength, iterations. Returns: result
rhino_smooth_polylineA
Apply Laplacian smoothing to a polyline (or NURBS curve via its control points).
Each iteration replaces every interior point P_i with
``(1 - factor) * P_i + factor * (P_{i-1} + P_{i+1}) / 2``.
With ``pin_endpoints=True`` the first and last points are held.
Returns the new curve's object_id (the input is replaced).
Inputs: args (required). Returns: object
rhino_soft_edit_curveB
Apply soft (smooth falloff) editing to a selected curve.
Inputs: no named parameters. Returns: result
rhino_soft_edit_surfaceA
Apply soft (smooth falloff) editing to a selected surface.
Inputs: no named parameters. Returns: result
rhino_solar_exposure_estimateARead-only
Estimate cumulative solar exposure (lit minutes / total minutes) on an object (bridge only).
Bridge implementation samples the time range, casts a ray from the target's centroid toward the sun at each step, and counts lit samples (no obstruction along the ray). Returns a 0-1 ratio.
Inputs: args (required). Returns: object
rhino_solid_pt_onB
Enable solid point editing for selected polysurfaces.
Args:
controller: RhinoController instance.
Inputs: no named parameters. Returns: result
rhino_sphereC
Add a sphere primitive.
Inputs: args (required). Returns: object
rhino_spiralC
Add a tapered spiral sampled into a NURBS curve.
Inputs: args (required). Returns: object
rhino_splitC
Split selected objects with cutting objects (interactive).
Args:
controller: RhinoController instance.
Returns:
Dict with command result.
Inputs: no named parameters. Returns: result
rhino_srf_from_3_4_ptsB
Create a surface from 3 or 4 corner points.
Args:
controller: RhinoController instance.
pts: List of 3 or 4 points; each element is an (x, y, z) tuple
or a 'x,y,z' string.
Returns:
Dict with 'status' and 'command' keys.
Inputs: pts (required). Returns: result
rhino_stack_floorsA
Replicate a source object N times along world +Z with constant spacing.
Architectural shortcut for "stack this slab N floors high". The source
sits at level 0; copies populate levels 1 .. floor_count.
Inputs: args (required). Returns: object
rhino_statusC
Return the current Rhino connection status plus the default files directory.
Args:
controller: RhinoController instance.
Returns:
Dict containing status info and rhino_files_dir.
Inputs: no named parameters. Returns: result
rhino_stitchC
Stitch selected surface edges together within a tolerance.
Args:
controller: RhinoController instance.
tolerance: Stitching tolerance.
Returns:
Dict with command result.
Inputs: tolerance. Returns: result
rhino_subd_boxA
Create a SubD box primitive.
Args:
controller: RhinoController instance.
x: X coordinate of base corner.
y: Y coordinate of base corner.
z: Z coordinate of base corner.
length: Box length along X.
width: Box width along Y.
height: Box height along Z.
face_x: Number of faces along X.
face_y: Number of faces along Y.
face_z: Number of faces along Z.
Inputs: x, y, z, width, +5 more. Returns: result
rhino_subd_coneB
Create a SubD cone primitive.
Args:
controller: RhinoController instance.
x: X coordinate of base center.
y: Y coordinate of base center.
z: Z coordinate of base center.
radius: Cone base radius.
height: Cone height.
Inputs: x, y, z, height, +1 more. Returns: result
rhino_subd_creaseA
Add a crease to selected SubD edges, making them sharp.
Args:
controller: RhinoController instance.
Inputs: no named parameters. Returns: result
rhino_subd_cylinderA
Create a SubD cylinder primitive.
Args:
controller: RhinoController instance.
x: X coordinate of base center.
y: Y coordinate of base center.
z: Z coordinate of base center.
radius: Cylinder radius.
height: Cylinder height.
Inputs: x, y, z, height, +1 more. Returns: result
rhino_subd_display_toggleB
Toggle SubD display between smooth and box (control polygon) modes.
Args:
controller: RhinoController instance.
Inputs: no named parameters. Returns: result
rhino_subd_expand_edgesB
Expand selected SubD edges outward by a given distance.
Args:
controller: RhinoController instance.
distance: Expansion distance.
Inputs: distance. Returns: result
rhino_subdivideC
Subdivide selected SubD objects a given number of times.
Args:
controller: RhinoController instance.
count: Number of subdivision iterations.
Inputs: count. Returns: result
rhino_subd_loftA
Create a SubD loft surface through selected curves.
Args:
controller: RhinoController instance.
closed: Create a closed (periodic) loft.
Inputs: closed. Returns: result
rhino_subd_planeB
Create a SubD plane primitive.
Args:
controller: RhinoController instance.
x: X coordinate of start corner.
y: Y coordinate of start corner.
z: Z coordinate of start corner.
length: Plane length along U.
width: Plane width along V.
count_u: Number of faces along U.
count_v: Number of faces along V.
Inputs: x, y, z, width, +3 more. Returns: result
rhino_subd_sphereB
Create a SubD sphere primitive.
Args:
controller: RhinoController instance.
x: X coordinate of center.
y: Y coordinate of center.
z: Z coordinate of center.
radius: Sphere radius.
subdivisions: Number of subdivision levels.
Inputs: x, y, z, radius, +1 more. Returns: result
rhino_subd_sweep1B
Create a SubD sweep along one rail curve.
Args:
controller: RhinoController instance.
Inputs: no named parameters. Returns: result
rhino_subd_sweep2B
Create a SubD sweep along two rail curves.
Args:
controller: RhinoController instance.
Inputs: no named parameters. Returns: result
rhino_subd_to_nurbsC
Convert a SubD object to a NURBS polysurface (Brep).
Inputs: args (required). Returns: object
rhino_subd_torusA
Create a SubD torus primitive.
Args:
controller: RhinoController instance.
x: X coordinate of center.
y: Y coordinate of center.
z: Z coordinate of center.
major_radius: Torus major (outer) radius.
minor_radius: Torus minor (tube) radius.
Inputs: x, y, z, major_radius, +1 more. Returns: result
rhino_sun_pathB
Draw monthly sun-path polylines on a hemisphere of given radius around center_point.
Standalone draws into the active rhino3dm document; bridge mode
forwards so the path is visible in Rhino's viewport.
Inputs: args (required). Returns: object
rhino_sun_positionBRead-onlyIdempotent
Compute solar azimuth + altitude for a location/time. Pure calculation, no doc edits.
Inputs: args (required). Returns: object
rhino_sun_settingsB
Configure the Rhino sun/sky system via Python.
Args:
enabled: Enable or disable the sun.
latitude: Observer latitude in degrees.
longitude: Observer longitude in degrees.
year, month, day: Date settings.
hour: Hour of day (24h float, e.g. 14.5 = 2:30 PM).
Inputs: day, hour, year, month, +3 more. Returns: result
rhino_surface_closest_pointARead-only
Find the UV parameters and 3D point closest to a test point on a surface.
Inputs: args (required). Returns: object
rhino_surface_curvature_atBRead-only
Evaluate true Gaussian / mean / principal curvatures at (u, v) (bridge only).
Inputs: args (required). Returns: object
rhino_surface_developable_scoreARead-only
Estimate how far a surface deviates from being developable.
Samples a (sample_u+1) x (sample_v+1) grid of normals; for each
interior 2x2 block computes the maximum angle (in radians) between
adjacent normals. Reports max / mean / RMS over the whole sheet
plus a 0..1 normalised score (0 = perfectly developable,
1 = π/2 normal swing within a single cell).
A truly developable surface (cone, cylinder, plane) returns ~0;
a sphere section returns a positive value proportional to the
spanned solid angle.
Inputs: args (required). Returns: object
rhino_surface_from_pointsB
Create a NURBS surface from a 2D grid of control points.
Inputs: args (required). Returns: object
rhino_surface_normal_atARead-only
Evaluate the surface unit normal at a normalised (u, v).
``u`` and ``v`` are 0..1 ratios over the surface's domain; the
actual parameters are computed internally so the LLM doesn't need
to know the domain bounds.
Inputs: args (required). Returns: object
rhino_sweep1A
Sweep profiles along a single rail.
Inputs: args (required). Returns: object
rhino_sweep2C
Sweep profiles along two rails.
Inputs: args (required). Returns: object
rhino_system_infoB
Retrieve Rhino system information.
Args:
controller: RhinoController instance.
Returns:
Dict with system info output.
Inputs: no named parameters. Returns: result
rhino_taperC
Taper objects along an axis with start/end radii.
Inputs: args (required). Returns: object
rhino_textC
Add 3D text annotation. Bridge mode honours the active dim style; standalone uses text-dot fallback.
Inputs: args (required). Returns: object
rhino_text_dotA
Add a small label that always faces the camera in Rhino.
Inputs: args (required). Returns: object
rhino_thickness_analysisA
Display a thickness analysis on selected closed polysurfaces.
Args:
controller: RhinoController instance.
max_thickness: Maximum thickness value for the colour scale.
Returns:
Dict with command result.
Inputs: max_thickness. Returns: result
rhino_toggle_gridA
Toggle the viewport construction grid on/off.
Inputs: no named parameters. Returns: result
rhino_tolerance_getARead-only
Read absolute / angle / relative model tolerances.
Inputs: args (required). Returns: object
rhino_tolerance_setA
Set absolute / angle / (optional) relative tolerances on the document.
Inputs: args (required). Returns: object
rhino_to_nurbsB
Convert selected SubD objects to NURBS surfaces.
Args:
controller: RhinoController instance.
Inputs: no named parameters. Returns: result
rhino_torusB
Add a torus primitive (mesh approximation in standalone mode).
Inputs: args (required). Returns: object
rhino_to_subdB
Convert selected NURBS or mesh objects to SubD.
Args:
controller: RhinoController instance.
method: Conversion method (e.g., 'FromNURBS', 'FromMesh').
Inputs: method. Returns: result
rhino_triangulate_meshA
Convert all quad faces in selected meshes to triangles.
Args:
controller: RhinoController instance.
Inputs: no named parameters. Returns: result
rhino_trimB
Trim objects using selected cutting objects (interactive).
Args:
controller: RhinoController instance.
Returns:
Dict with command result.
Inputs: no named parameters. Returns: result
rhino_truncated_coneA
Create a truncated cone (frustum) in Rhino using the TruncatedCone command.
Rhino prompts: base center -> base radius -> height -> top radius.
Args:
controller: RhinoController instance.
x, y, z: Center of the base circle.
bottom_radius: Radius of the base (larger) circle.
top_radius: Radius of the top (smaller) circle.
height: Height between the two circles.
Returns:
Dict with 'status' and 'command' keys.
Inputs: x, y, z, height, +2 more. Returns: result
rhino_tubeB
Create a hollow cylindrical tube in Rhino.
Args:
controller: RhinoController instance.
x, y, z: Center of the base annulus.
outer_radius: Outer radius of the tube.
thickness: Wall thickness (inner_radius = outer_radius - thickness).
height: Height of the tube.
Returns:
Dict with 'status' and 'command' keys.
Inputs: x, y, z, height, +2 more. Returns: result
rhino_turntableC
Render a turntable animation to output_path (PNG sequence or GIF).
Inputs: args (required). Returns: object
rhino_turntable_renderC
Render a turntable sequence (camera orbits around target) to output_dir.
Inputs: args (required). Returns: object
rhino_tween_surfacesA
Generate tween (morphed intermediate) surfaces between two surfaces.
Pre-select the two source surfaces before calling.
Args:
controller: RhinoController instance.
count: Number of intermediate tween surfaces to generate.
Returns:
Dict with 'status' and 'command' keys.
Inputs: count. Returns: result
rhino_twistC
Twist objects around an axis by a specified angle.
Inputs: args (required). Returns: object
rhino_undoA
Undo the last operation(s) in the Rhino document.
Each step reverses one undo record. Changes made by MCP tools are grouped into undo records automatically.
Inputs: args (required). Returns: object
rhino_ungroupA
Ungroup selected groups, releasing individual objects.
Inputs: no named parameters. Returns: result
rhino_unify_mesh_normalsB
Unify the normals of selected mesh faces to all point outward.
Args:
controller: RhinoController instance.
Inputs: no named parameters. Returns: result
rhino_unjoin_edgeB
Un-join selected edges from a polysurface.
Args:
controller: RhinoController instance.
Returns:
Dict with command result.
Inputs: no named parameters. Returns: result
rhino_unlock_allA
Unlock all locked objects in the document.
Inputs: no named parameters. Returns: result
rhino_unrollA
Unroll a developable surface or polysurface flat.
Inputs: args (required). Returns: object
rhino_untrimA
Remove trim boundaries from selected surfaces.
Args:
controller: RhinoController instance.
Returns:
Dict with command result.
Inputs: no named parameters. Returns: result
rhino_unweld_meshC
Unweld vertices to break mesh smoothing.
Inputs: args (required). Returns: object
rhino_uv_grid_panelsA
Sample a surface on a regular UxV grid and emit it as panels.
``output='mesh'`` writes a single quad mesh (one face per panel) to
the doc; ``'curves'`` writes count_u+count_v isocurves; ``'corners'``
only returns the (count_u+1) x (count_v+1) sample points without
writing geometry.
Inputs: args (required). Returns: object
rhino_validate_brepBRead-only
Validate a Brep — closed/solid/manifold, face/edge counts, log of issues.
Standalone surfaces ``IsValid``/``IsSolid``/``IsManifold``/edge+face
counts and the rhino3dm validation log. Bridge mode adds a list of
naked-edge identifiers and lengths via RhinoCommon.
Inputs: args (required). Returns: object
rhino_variable_blend_srfA
Create a variable-radius blend surface between two surface edges.
Pre-select the two naked edges before calling.
Args:
controller: RhinoController instance.
Returns:
Dict with 'status' and 'command' keys.
Inputs: no named parameters. Returns: result
rhino_variable_filletA
Create a variable-radius fillet surface between two surfaces.
The start/end radii are passed as option overrides; edge selection
is performed interactively.
Args:
controller: RhinoController instance.
start_radius: Fillet radius at the start of the edge.
end_radius: Fillet radius at the end of the edge.
Returns:
Dict with command result.
Inputs: end_radius, start_radius. Returns: result
rhino_view_capture_to_clipboardA
Capture the active viewport to the clipboard.
Args:
width: Image width in pixels.
height: Image height in pixels.
Inputs: width, height. Returns: result
rhino_view_capture_to_fileA
Capture the active viewport to a PNG file.
Args:
file_name: Output filename (saved to D:/RhinoFiles/).
width: Image width in pixels.
height: Image height in pixels.
Inputs: width, height, file_name. Returns: result
rhino_viewport_imageA
Save the current viewport pixels to a PNG file.
Lightweight alternative to ``rhino_render_to_file`` — no render engine
is invoked, just a viewport bitmap dump. Use 0 for ``width``/``height``
to inherit the on-screen viewport size.
Inputs: args (required). Returns: object
rhino_viewport_previewA
Capture a viewport preview restricted to a selection or layer set.
Spotlights ``selection_ids`` and/or objects on ``layers``; everything
else is either ghosted (default) or hidden during the capture and
restored afterwards. Useful for multi-step LLM verification flows
where only the recently added objects need to be visualised. Bridge
only.
Inputs: args (required). Returns: object
rhino_view_setC
Activate a saved named view.
Inputs: args (required). Returns: object
rhino_volumeARead-onlyIdempotent
Compute the volume of a closed mesh (Brep volume requires bridge).
Inputs: args (required). Returns: object
rhino_volume_centroidA
Calculate the volume centroid of selected closed solids.
Args:
controller: RhinoController instance.
Returns:
Dict with command result containing centroid coordinates.
Inputs: no named parameters. Returns: result
rhino_weld_meshB
Weld coincident vertices in a mesh.
Inputs: args (required). Returns: object
rhino_whatB
Display detailed properties of selected objects.
Args:
controller: RhinoController instance.
Returns:
Dict with command result containing object information.
Inputs: no named parameters. Returns: result
rhino_wire_cutB
Cut a solid with a wire (curve) extruded through the object.
Args:
controller: RhinoController instance.
depth: Cut depth (extrusion distance of the wire).
Inputs: depth. Returns: result
rhino_zebraCRead-only
Run zebra-stripe surface continuity analysis (bridge required).
Inputs: args (required). Returns: object
rhino_zebra_analysisC
Display zebra stripe analysis on selected surfaces.
Args:
controller: RhinoController instance.
stripe_direction: 'Horizontal' or 'Vertical'.
stripe_size: Size of the zebra stripes.
Returns:
Dict with command result.
Inputs: stripe_size, stripe_direction. Returns: result
rhino_zoom_extentA
Zoom the active view to the extent of selected (or all) objects.
Inputs: args (required). Returns: object
rhino_zoom_extentsA
Zoom to the extents of all geometry.
Args:
all_viewports: If True, zoom all viewports; otherwise only the active one.
Inputs: all_viewports. Returns: result
rhino_zoom_layerA
Zoom the active viewport to fit every object on layer.
Inputs: args (required). Returns: object
rhino_zoom_objectA
Zoom the active viewport to fit the given object ids exactly.
Inputs: args (required). Returns: object
rhino_zoom_selectedA
Zoom to fit the currently selected objects.
Inputs: no named parameters. Returns: result
rhino_zoom_windowA
Enter zoom-window mode (user draws a rectangle to zoom into).
Inputs: no named parameters. Returns: result
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 542 tools
Dozens of tools appear to do the same thing: rhino_box and rhino_cmd_box, rhino_sphere and rhino_cmd_sphere, rhino_boolean_union and rhino_cmd_boolean_union, rhino_execute_python and rhino_run_python, plus many overlapping render/capture tools. An agent cannot reliably tell which variant to call without extensive inferencing.
The rhino_ prefix and mostly snake_case naming provide some consistency, but conventions are mixed across what look like multiple API generations: rhino_cmd_* coexists with direct rhino_* calls, run_* coexists with execute_*, sel_* coexists with object_select, and some pairs reverse verb order (rhino_set_view vs rhino_view_set, rhino_set_display_mode vs rhino_display_mode_set). The gh_* tools add a second naming world.
542 tools is an extreme mismatch for a coherent MCP surface, even for a broad CAD application. The count is inflated by large numbers of duplicate and near-duplicate operations rather than by genuinely distinct capabilities.
The set covers an unusually broad range of Rhino domains: primitives, curves, surfaces, meshes, SubD, booleans, transforms, layers, materials, rendering, annotations, blocks, BIM, analysis, import/export, and Grasshopper. There are minor gaps such as curve-level fillet/chamfer and some bridge-only limitations, but the generic rhino_run_command and rhino_execute_python tools let agents work around most omissions.
Maintenance
Related MCP Connectors
Connect ChatGPT and Claude to your Mac, Windows or Linux with secure MCP remote access.
Use AI models for chat, image, and video generation from Claude Code and other MCP hosts.
Create projects, nodes, and tasks in UluP Spaces by conversation with Claude.
A comprehensive Model Context Protocol (MCP) server that enables AI assistants to interact with yo…
Related MCP Servers
- FlicenseNot gradedqualityDmaintenanceConnects Rhino3D to Claude AI via the Model Context Protocol, enabling AI-assisted 3D modeling and design workflows through direct control of Rhino's functionality.13-
- AlicenseNot gradedqualityDmaintenanceGOLEM-3DMCP implements the Model Context Protocol to give AI agents direct, programmatic control of Rhino 8 — create geometry, run booleans, drive Grasshopper, capture viewports, and execute arbitrary Python scripts, all through natural language. Works with Claude Code, Cursor, Windsurf, and any MCP-compatible host.16MIT
- AlicenseCqualityBmaintenanceEnables Claude to drive Rhino 8 and Grasshopper for geometry creation, manipulation, and analysis via natural language.246292 PyPI9MIT
- AlicenseNot gradedqualityDmaintenanceConnects Rhino and Grasshopper to Claude AI via the Model Context Protocol, enabling prompt-assisted 3D modeling, scene manipulation, and control through tools like object creation, layer management, and code execution.32MIT