Skip to main content
Glama
rokibul-mist

rhino-mcp

by rokibul-mist
OverviewSchemaSourceRelated ServersScoreDiscussionsAdmin
Python
Hybrid

rhino_execute_python

Run RhinoScript Python code in a live Rhino session to automate geometry creation and modification. Capture results using print() and receive clear error details for failed operations.

Instructions

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).

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
argsYes

Output Schema

TableJSON Schema
NameRequiredDescriptionDefault

No arguments

Schema Changelog

Changes observed during successful MCP inspections.

  1. First observedv1.0.0

TDQS

A4.5/5.0
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no safety annotations beyond a title, the description carries the full disclosure burden. It discloses the live-session nature, undo wrapping, rollback on failure, and return shape. It could go further in warning about arbitrary code side effects or long-running execution, but what it says is material and accurate.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Although longer than average, the description is tightly structured with numbered critical steps and bulleted code requirements. Every sentence contributes to correct usage. The critical warning is front-loaded, making it easy for an agent to follow before invoking.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a highly flexible code-execution tool, the description covers the full invocation path: prerequisite documentation lookup, code construction requirements, failure handling, undo behavior, and the expected response fields. The input schema supplies the exact parameter shapes, and the description fills the behavioral and procedural gaps.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The description adds important semantics beyond the schema: import rhinoscriptsyntax, use print() for return values, and handle None returns. However, the optional verified_functions parameter is not mentioned in the prose, even though the schema provides a reasonable description for it. The added code-requirement guidance is genuinely useful.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states a specific verb and resource: 'Execute RhinoScript Python code in a live Rhino session.' This immediately distinguishes it from C# execution and other Rhino command tools. It also provides the essential execution context without ambiguity.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description gives an explicit, ordered workflow: call rhino_get_rhinoscript_docs first, read signatures, write code using documented APIs, then execute. This is excellent usage guidance. However, it does not explicitly name alternatives or say when not to use this tool, such as when rhino_run_python or rhino_execute_csharp would be more appropriate.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server

Other Tools