rhinomcp 0.1.1.2__tar.gz → 0.1.1.4__tar.gz

{rhinomcp-0.1.1.2 → rhinomcp-0.1.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rhinomcp
-Version: 0.1.1.2
+Version: 0.1.1.4
 Summary: Rhino integration through the Model Context Protocol
 Author-email: Jingcheng Chen <mail@jchen.ch>
 License: MIT

{rhinomcp-0.1.1.2 → rhinomcp-0.1.1.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "rhinomcp"
-version = "0.1.1.2"
+version = "0.1.1.4"
 description = "Rhino integration through the Model Context Protocol"
 readme = "README.md"
 requires-python = ">=3.10"

rhinomcp-0.1.1.4/src/rhinomcp/__init__.py

@@ -0,0 +1,20 @@
+"""Rhino integration through the Model Context Protocol."""
+
+__version__ = "0.1.0"
+
+# Expose key classes and functions for easier imports
+from .server import RhinoConnection, get_rhino_connection, mcp, logger
+
+from .prompts.assert_creation_strategy import asset_creation_strategy
+from .prompts.assert_query_strategy import assert_query_strategy
+
+from .tools.create_object import create_object
+from .tools.create_objects import create_objects
+from .tools.delete_object import delete_object
+from .tools.get_document_info import get_document_info
+from .tools.get_object_info import get_object_info
+from .tools.get_selected_objects_info import get_selected_objects_info
+from .tools.modify_object import modify_object
+from .tools.modify_objects import modify_objects
+from .tools.execute_rhinoscript_python_code import execute_rhinoscript_python_code
+

rhinomcp-0.1.1.4/src/rhinomcp/prompts/assert_creation_strategy.py

@@ -0,0 +1,21 @@
+from rhinomcp.server import mcp
+
+
+@mcp.prompt()
+def asset_creation_strategy() -> str:
+    """Defines the preferred strategy for creating assets in Rhino"""
+    return """When creating 3D content in Rhino, always start by checking if integrations are available:
+
+    0. Before anything, always check the document from get_document_info()
+    1. Please ALWAYS try to create the objects using the tool execute_rhinoscript_python_code() first.
+    2. If there are multiple objects, use the method create_objects() to create multiple objects at once. Do not attempt to create them one by one if they are more than 10.
+    3. When including an object into document, ALWAYS make sure that the name of the object is meanful.
+    4. Try to include as many objects as possible accurately and efficiently. If the command is not able to include
+       so many data, try to create the objects in batches.
+
+    When creating rhinoscript python code:
+    - do not hallucinate, only use the syntax that is supported by rhinoscriptsyntax or Rhino,Geometry.
+    - document the code that you are writing.
+    - when creating objects, ALWAYS make sure that the name of the object is meanful.
+    - double check the code if any of the code is not correct, and fix it.
+    """

rhinomcp-0.1.1.4/src/rhinomcp/prompts/assert_query_strategy.py

@@ -0,0 +1,10 @@
+from rhinomcp.server import mcp
+
+
+@mcp.prompt()
+def assert_query_strategy() -> str:
+    """Defines the preferred strategy for querying Object or Objects in Rhino"""
+    return """When querying Object or Objects in Rhino:
+    - if the id of the object is known, use the id to query the object.
+    - if the id is not known, use the name of the object to query the object.
+    """

{rhinomcp-0.1.1.2 → rhinomcp-0.1.1.4}/src/rhinomcp/server.py

@@ -12,6 +12,7 @@ from pathlib import Path
 import base64
 from urllib.parse import urlparse
 
+
 # Configure logging
 logging.basicConfig(level=logging.INFO, 
                     format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
@@ -21,7 +22,7 @@ logger = logging.getLogger("RhinoMCPServer")
 class RhinoConnection:
     host: str
     port: int
-    sock: socket.socket = None  # Changed from 'socket' to 'sock' to avoid naming conflict
+    sock: socket.socket | None = None  # Changed from 'socket' to 'sock' to avoid naming conflict
     
     def connect(self) -> bool:
         """Connect to the Rhino addon socket server"""
@@ -104,7 +105,7 @@ class RhinoConnection:
         else:
             raise Exception("No data received")
 
-    def send_command(self, command_type: str, params: Dict[str, Any] = None) -> Dict[str, Any]:
+    def send_command(self, command_type: str, params: Dict[str, Any] = {}) -> Dict[str, Any]:
         """Send a command to Rhino and return the response"""
         if not self.sock and not self.connect():
             raise ConnectionError("Not connected to Rhino")
@@ -117,6 +118,9 @@ class RhinoConnection:
         try:
             # Log the command being sent
             logger.info(f"Sending command: {command_type} with params: {params}")
+
+            if self.sock is None:
+                raise Exception("Socket is not connected")
             
             # Send the command
             self.sock.sendall(json.dumps(command).encode('utf-8'))
@@ -150,7 +154,7 @@ class RhinoConnection:
         except json.JSONDecodeError as e:
             logger.error(f"Invalid JSON response from Rhino: {str(e)}")
             # Try to log what was received
-            if 'response_data' in locals() and response_data:
+            if 'response_data' in locals() and response_data: # type: ignore
                 logger.error(f"Raw response (first 200 bytes): {response_data[:200]}")
             raise Exception(f"Invalid response from Rhino: {str(e)}")
         except Exception as e:
@@ -216,218 +220,7 @@ def get_rhino_connection():
     
     return _rhino_connection
 
-
-@mcp.tool()
-def get_document_info(ctx: Context) -> str:
-    """Get detailed information about the current Rhino document"""
-    try:
-        rhino = get_rhino_connection()
-        result = rhino.send_command("get_document_info")
-        
-        # Just return the JSON representation of what Rhino sent us
-        return json.dumps(result, indent=2)
-    except Exception as e:
-        logger.error(f"Error getting document info from Rhino: {str(e)}")
-        return f"Error getting document info: {str(e)}"
-
-@mcp.tool()
-def get_object_info(ctx: Context, id: str = None, name: str = None) -> str:
-    """
-    Get detailed information about a specific object in the Rhino document.
-    You can either provide the id or the object_name of the object to get information about.
-    If both are provided, the id will be used.
-    
-    Parameters:
-    - id: The id of the object to get information about
-    - name: The name of the object to get information about
-    """
-    try:
-        rhino = get_rhino_connection()
-        result = rhino.send_command("get_object_info", {"id": id, "name": name})
-        
-        # Just return the JSON representation of what Rhino sent us
-        return json.dumps(result, indent=2)
-    except Exception as e:
-        logger.error(f"Error getting object info from Rhino: {str(e)}")
-        return f"Error getting object info: {str(e)}"
-
-@mcp.tool()
-def get_selected_objects_info(ctx: Context) -> str:
-    """Get detailed information about the currently selected objects in Rhino"""
-    try:
-        rhino = get_rhino_connection()
-        result = rhino.send_command("get_selected_objects_info")
-        return json.dumps(result, indent=2)
-    except Exception as e:
-        logger.error(f"Error getting selected objects from Rhino: {str(e)}")
-        return f"Error getting selected objects: {str(e)}"
-
-
-@mcp.tool()
-def create_object(
-    ctx: Context,
-    type: str = "CUBE",
-    name: str = None,
-    location: List[float] = None,
-    rotation: List[float] = None,
-    scale: List[float] = None,
-    # Torus-specific parameters
-    align: str = "WORLD",
-    major_segments: int = 48,
-    minor_segments: int = 12,
-    mode: str = "MAJOR_MINOR",
-    major_radius: float = 1.0,
-    minor_radius: float = 0.25,
-    abso_major_rad: float = 1.25,
-    abso_minor_rad: float = 0.75,
-    generate_uvs: bool = True
-) -> str:
-    """
-    Create a new object in the Rhino document.
-    
-    Parameters:
-    - type: Object type (CUBE, SPHERE, CYLINDER, PLANE, CONE, TORUS, EMPTY, CAMERA, LIGHT)
-    - name: Optional name for the object
-    - location: Optional [x, y, z] location coordinates
-    - rotation: Optional [x, y, z] rotation in radians
-    - scale: Optional [x, y, z] scale factors (not used for TORUS)
-    
-    Torus-specific parameters (only used when type == "TORUS"):
-    - align: How to align the torus ('WORLD', 'VIEW', or 'CURSOR')
-    - major_segments: Number of segments for the main ring
-    - minor_segments: Number of segments for the cross-section
-    - mode: Dimension mode ('MAJOR_MINOR' or 'EXT_INT')
-    - major_radius: Radius from the origin to the center of the cross sections
-    - minor_radius: Radius of the torus' cross section
-    - abso_major_rad: Total exterior radius of the torus
-    - abso_minor_rad: Total interior radius of the torus
-    - generate_uvs: Whether to generate a default UV map
-    
-    Returns:
-    A message indicating the created object name.
-    """
-    try:
-        # Get the global connection
-        rhino = get_rhino_connection()
-        
-        # Set default values for missing parameters
-        loc = location or [0, 0, 0]
-        rot = rotation or [0, 0, 0]
-        sc = scale or [1, 1, 1]
-        
-        params = {
-            "type": type,
-            "location": loc,
-            "rotation": rot,
-        }
-        
-        if name:
-            params["name"] = name
-
-        if type == "TORUS":
-            # For torus, the scale is not used.
-            params.update({
-                "align": align,
-                "major_segments": major_segments,
-                "minor_segments": minor_segments,
-                "mode": mode,
-                "major_radius": major_radius,
-                "minor_radius": minor_radius,
-                "abso_major_rad": abso_major_rad,
-                "abso_minor_rad": abso_minor_rad,
-                "generate_uvs": generate_uvs
-            })
-            result = rhino.send_command("create_object", params)
-            return f"Created {type} object: {result['name']}"
-        else:
-            # For non-torus objects, include scale
-            params["scale"] = sc
-            result = rhino.send_command("create_object", params)
-            return f"Created {type} object: {result['name']}"
-    except Exception as e:
-        logger.error(f"Error creating object: {str(e)}")
-        return f"Error creating object: {str(e)}"
-
-@mcp.tool()
-def modify_object(
-    ctx: Context,
-    id: str = None,
-    name: str = None,
-    new_name: str = None,
-    location: List[float] = None,
-    rotation: List[float] = None,
-    scale: List[float] = None,
-    visible: bool = None
-) -> str:
-    """
-    Modify an existing object in the Rhino document.
-    
-    Parameters:
-    - id: The id of the object to modify
-    - name: The name of the object to modify
-    - new_name: Optional new name for the object
-    - location: Optional [x, y, z] location coordinates
-    - rotation: Optional [x, y, z] rotation in radians
-    - scale: Optional [x, y, z] scale factors
-    - visible: Optional boolean to set visibility
-    """
-    try:
-        # Get the global connection
-        rhino = get_rhino_connection()
-        
-        params = {"id": id, "name": name}
-        
-        if new_name is not None:
-            params["new_name"] = new_name
-        if location is not None:
-            params["location"] = location
-        if rotation is not None:
-            params["rotation"] = rotation
-        if scale is not None:
-            params["scale"] = scale
-        if visible is not None:
-            params["visible"] = visible
-            
-        result = rhino.send_command("modify_object", params)
-        return f"Modified object: {result['name']}"
-    except Exception as e:
-        logger.error(f"Error modifying object: {str(e)}")
-        return f"Error modifying object: {str(e)}"
-
-@mcp.tool()
-def delete_object(ctx: Context, id: str = None, name: str = None) -> str:
-    """
-    Delete an object from the Rhino document.
-    
-    Parameters:
-    - id: The id of the object to delete
-    - name: The name of the object to delete
-    """
-    try:
-        # Get the global connection
-        rhino = get_rhino_connection()
-        
-        result = rhino.send_command("delete_object", {"id": id, "name": name})
-        return f"Deleted object: {result['name']}"
-    except Exception as e:
-        logger.error(f"Error deleting object: {str(e)}")
-        return f"Error deleting object: {str(e)}"
-
-@mcp.prompt()
-def asset_creation_strategy() -> str:
-    """Defines the preferred strategy for creating assets in Rhino"""
-    return """When creating 3D content in Rhino, always start by checking if integrations are available:
-
-    0. Before anything, always check the document from get_document_info()
-    1. Use the method create_object() for basic primitives (CUBE, SPHERE, etc.)
-    2. When including an object into document, ALWAYS make sure that the name of the object is meanful.
-    3. After giving the tool location/scale/rotation information (via create_object() and modify_object()),
-       double check the related object's location, scale, rotation, and world_bounding_box using get_object_info(),
-       so that the object is in the desired location.
-    """
-
 # Main execution
-
 def main():
     """Run the MCP server"""
     mcp.run()

rhinomcp-0.1.1.4/src/rhinomcp/tools/create_object.py

@@ -0,0 +1,88 @@
+from mcp.server.fastmcp import Context
+import json
+from rhinomcp.server import get_rhino_connection, mcp, logger
+from typing import Any, List, Dict
+
+@mcp.tool()
+def create_object(
+    ctx: Context,
+    type: str = "BOX",
+    name: str = None,
+    color: List[int]= None,
+    params: Dict[str, Any] = {},
+    translation: List[float]= None,
+    rotation: List[float]= None,
+    scale: List[float]= None,
+) -> str:
+    """
+    Create a new object in the Rhino document.
+    
+    Parameters:
+    - type: Object type ("POINT", "LINE", "POLYLINE", "CURVE", "BOX", "SPHERE")
+    - name: Optional name for the object
+    - color: Optional [r, g, b] color values (0-255) for the object
+    - params: Type-specific parameters dictionary (see documentation for each type)
+    - translation: Optional [x, y, z] translation vector
+    - rotation: Optional [x, y, z] rotation in radians
+    - scale: Optional [x, y, z] scale factors
+
+    The params dictionary is type-specific.
+    For POINT, the params dictionary should be empty.
+
+    For LINE, the params dictionary should contain the following keys:
+    - start: [x, y, z] start point of the line
+    - end: [x, y, z] end point of the line
+
+    For POLYLINE, the params dictionary should contain the following keys:
+    - points: List of [x, y, z] points that define the polyline
+
+    For CURVE, the params dictionary should contain the following keys:
+    - points: List of [x, y, z] control points that define the curve
+    - degree: Degree of the curve (default is 3, if user asked for smoother curve, degree can be higher)
+
+    For BOX, the params dictionary should contain the following keys:
+    - width: Width of the box along X axis of the object
+    - length: Length of the box along Y axis of the object
+    - height: Height of the box along Z axis of the object
+
+    For SPHERE, the params dictionary should contain the following key:
+    - radius: Radius of the sphere
+    
+    Returns:
+    A message indicating the created object name.
+    
+    Examples of params:
+    - POINT: {} (no additional parameters because the point location is defined by the translation vector)
+    - LINE: {"start": [0, 0, 0], "end": [1, 1, 1]}
+    - POLYLINE: {"points": [[0, 0, 0], [1, 1, 1], [2, 2, 2]]}
+    - CURVE: {"points": [[0, 0, 0], [1, 1, 1], [2, 2, 2]], "degree": 3}
+    - BOX: {"width": 1.0, "length": 1.0, "height": 1.0}
+    - SPHERE: {"radius": 1.0}
+    """
+    try:
+        # Get the global connection
+        rhino = get_rhino_connection()
+        # Set default values for missing parameters
+        trans = translation or [0, 0, 0]
+        rot = rotation or [0, 0, 0]
+        sc = scale or [1, 1, 1]
+        
+        command_params = {
+            "type": type,
+            "translation": trans,
+            "rotation": rot,
+            "scale": sc,
+            "params": params
+        }
+
+        if name: command_params["name"] = name
+        if color: command_params["color"] = color
+
+        # Create the object
+        result = result = rhino.send_command("create_object", command_params)  
+        
+        return f"Created {type} object: {result['name']}"
+    except Exception as e:
+        logger.error(f"Error creating object: {str(e)}")
+        return f"Error creating object: {str(e)}"
+ 

rhinomcp-0.1.1.4/src/rhinomcp/tools/create_objects.py

@@ -0,0 +1,85 @@
+from mcp.server.fastmcp import Context
+import json
+from rhinomcp.server import get_rhino_connection, mcp, logger
+from typing import Any, List, Dict
+
+
+@mcp.tool()
+def create_objects(
+    ctx: Context,
+    objects: List[Dict[str, Any]]
+) -> str:
+    """
+    Create multiple objects at once in the Rhino document.
+    
+    Parameters:
+    - objects: A list of dictionaries, each containing the parameters for a single object
+
+    Each object should have the following values:
+    - type: Object type ("POINT", "LINE", "POLYLINE", "BOX", "SPHERE", etc.)
+    - name: Optional name for the object
+    - color: Optional [r, g, b] color values (0-255) for the object
+    - params: Type-specific parameters dictionary (see documentation for each type in create_object() function)
+    - translation: Optional [x, y, z] translation vector
+    - rotation: Optional [x, y, z] rotation in radians
+    - scale: Optional [x, y, z] scale factors
+
+    Returns:
+    A message indicating the created objects.
+    
+    Examples of params:
+    [
+        {
+            "type": "POINT",
+            "name": "Point 1",
+            "translation": [0, 0, 0]
+        },
+        {
+            "type": "LINE",
+            "name": "Line 1",
+            "params": {"start": [0, 0, 0], "end": [1, 1, 1]}
+        },
+        {
+            "type": "POLYLINE",
+            "name": "Polyline 1",
+            "params": {"points": [[0, 0, 0], [1, 1, 1], [2, 2, 2]]}
+        },
+        {
+            "type": "CURVE",
+            "name": "Curve 1",
+            "params": {"points": [[0, 0, 0], [1, 1, 1], [2, 2, 2]], "degree": 3}
+        },
+        {
+            "type": "BOX",
+            "name": "Box 1",
+            "color": [255, 0, 0],
+            "params": {"width": 1.0, "length": 1.0, "height": 1.0},
+            "translation": [0, 0, 0],
+            "rotation": [0, 0, 0],
+            "scale": [1, 1, 1]
+        },
+        {
+            "type": "SPHERE",
+            "name": "Sphere 1",
+            "color": [0, 255, 0],
+            "params": {"radius": 1.0},
+            "translation": [0, 0, 0],
+            "rotation": [0, 0, 0],
+            "scale": [1, 1, 1]
+        }
+    ]
+    """
+    try:
+        # Get the global connection
+        rhino = get_rhino_connection()
+        command_params = {}
+        for obj in objects:
+            command_params[obj["name"]] = obj
+        result = rhino.send_command("create_objects", command_params)
+  
+        
+        return f"Created {len(result)} objects"
+    except Exception as e:
+        logger.error(f"Error creating object: {str(e)}")
+        return f"Error creating object: {str(e)}"
+

rhinomcp-0.1.1.4/src/rhinomcp/tools/delete_object.py

@@ -0,0 +1,34 @@
+from mcp.server.fastmcp import Context
+import json
+from rhinomcp.server import get_rhino_connection, mcp, logger
+from typing import Any, List, Dict
+
+
+
+@mcp.tool()
+def delete_object(ctx: Context, id: str = None, name: str = None, all: bool = None) -> str:
+    """
+    Delete an object from the Rhino document.
+    
+    Parameters:
+    - id: The id of the object to delete
+    - name: The name of the object to delete
+    """
+    try:
+        # Get the global connection
+        rhino = get_rhino_connection()
+
+        commandParams = {}
+        if id is not None:
+            commandParams["id"] = id
+        if name is not None:
+            commandParams["name"] = name
+        if all:
+            commandParams["all"] = all
+        
+        result = rhino.send_command("delete_object", commandParams)
+
+        return f"Deleted object: {result['name']}"
+    except Exception as e:
+        logger.error(f"Error deleting object: {str(e)}")
+        return f"Error deleting object: {str(e)}"

rhinomcp-0.1.1.4/src/rhinomcp/tools/execute_rhinoscript_python_code.py

@@ -0,0 +1,54 @@
+from mcp.server.fastmcp import Context
+import json
+from rhinomcp.server import get_rhino_connection, mcp, logger
+from typing import Any, List, Dict
+
+
+@mcp.tool()
+def execute_rhinoscript_python_code(ctx: Context, code: str) -> str:
+    """
+    Execute arbitrary RhinoScript code in Rhino.
+    
+    Parameters:
+    - code: The RhinoScript code to execute
+
+    References:
+
+    AddBox(corners)
+        Adds a box shaped polysurface to the document
+    Parameters:
+        corners ([point, point, point ,point, point, point ,point,point]) 8 points that define the corners of the box. Points need to
+        be in counter-clockwise order starting with the bottom rectangle of the box
+    Returns:
+        guid: identifier of the new object on success
+    Example:
+        import rhinoscriptsyntax as rs
+        box = rs.GetBox()
+        if box: rs.AddBox(box)
+
+    AddSphere(center_or_plane, radius)
+        Add a spherical surface to the document
+    Parameters:
+        center_or_plane (point|plane): center point of the sphere. If a plane is input,
+        the origin of the plane will be the center of the sphere
+        radius (number): radius of the sphere in the current model units
+    Returns:
+        guid: identifier of the new object on success
+        None: on error
+    Example:
+        import rhinoscriptsyntax as rs
+        radius = 2
+        center = rs.GetPoint("Center of sphere")
+        if center: rs.AddSphere(center, radius)
+
+
+    """
+    try:
+        # Get the global connection
+        rhino = get_rhino_connection()
+        
+        result = rhino.send_command("execute_rhinoscript_python_code", {"code": code})
+        return f"Code executed successfully: {result.get('result', '')}"
+    except Exception as e:
+        logger.error(f"Error executing code: {str(e)}")
+        return f"Error executing code: {str(e)}"

rhinomcp-0.1.1.4/src/rhinomcp/tools/get_document_info.py

@@ -0,0 +1,16 @@
+from mcp.server.fastmcp import Context
+import json
+from rhinomcp import get_rhino_connection, mcp, logger
+
+@mcp.tool()
+def get_document_info(ctx: Context) -> str:
+    """Get detailed information about the current Rhino document"""
+    try:
+        rhino = get_rhino_connection()
+        result = rhino.send_command("get_document_info")
+        
+        # Just return the JSON representation of what Rhino sent us
+        return json.dumps(result, indent=2)
+    except Exception as e:
+        logger.error(f"Error getting document info from Rhino: {str(e)}")
+        return f"Error getting document info: {str(e)}"

rhinomcp-0.1.1.4/src/rhinomcp/tools/get_object_info.py

@@ -0,0 +1,24 @@
+from mcp.server.fastmcp import Context
+import json
+from rhinomcp import get_rhino_connection, mcp, logger
+
+@mcp.tool()
+def get_object_info(ctx: Context, id: str = None, name: str = None) -> str:
+    """
+    Get detailed information about a specific object in the Rhino document.
+    You can either provide the id or the object_name of the object to get information about.
+    If both are provided, the id will be used.
+    
+    Parameters:
+    - id: The id of the object to get information about
+    - name: The name of the object to get information about
+    """
+    try:
+        rhino = get_rhino_connection()
+        result = rhino.send_command("get_object_info", {"id": id, "name": name})
+        
+        # Just return the JSON representation of what Rhino sent us
+        return json.dumps(result, indent=2)
+    except Exception as e:
+        logger.error(f"Error getting object info from Rhino: {str(e)}")
+        return f"Error getting object info: {str(e)}"

rhinomcp-0.1.1.4/src/rhinomcp/tools/get_selected_objects_info.py

@@ -0,0 +1,15 @@
+from mcp.server.fastmcp import Context
+import json
+from rhinomcp import get_rhino_connection, mcp, logger
+
+@mcp.tool()
+def get_selected_objects_info(ctx: Context) -> str:
+    """Get detailed information about the currently selected objects in Rhino"""
+    try:
+        rhino = get_rhino_connection()
+        result = rhino.send_command("get_selected_objects_info")
+        return json.dumps(result, indent=2)
+    except Exception as e:
+        logger.error(f"Error getting selected objects from Rhino: {str(e)}")
+        return f"Error getting selected objects: {str(e)}"
+

rhinomcp-0.1.1.4/src/rhinomcp/tools/modify_object.py

@@ -0,0 +1,59 @@
+from mcp.server.fastmcp import Context
+import json
+from rhinomcp.server import get_rhino_connection, mcp, logger
+from typing import Any, List, Dict
+
+
+@mcp.tool()
+def modify_object(
+    ctx: Context,
+    id: str = None,
+    name: str = None,
+    new_name: str = None,
+    new_color: List[int] = None,
+    translation: List[float] = None,
+    rotation: List[float] = None,
+    scale: List[float] = None,
+    visible: bool = None
+) -> str:
+    """
+    Modify an existing object in the Rhino document.
+    
+    Parameters:
+    - id: The id of the object to modify
+    - name: The name of the object to modify
+    - new_name: Optional new name for the object
+    - new_color: Optional [r, g, b] color values (0-255) for the object
+    - translation: Optional [x, y, z] translation vector
+    - rotation: Optional [x, y, z] rotation in radians
+    - scale: Optional [x, y, z] scale factors
+    - visible: Optional boolean to set visibility
+    """
+    try:
+        # Get the global connection
+        rhino = get_rhino_connection()
+        
+        params : Dict[str, Any] = {}
+        
+        if id is not None:
+            params["id"] = id
+        if name is not None:
+            params["name"] = name
+        if new_name is not None:
+            params["new_name"] = new_name
+        if new_color is not None:
+            params["new_color"] = new_color
+        if translation is not None:
+            params["translation"] = translation
+        if rotation is not None:
+            params["rotation"] = rotation
+        if scale is not None:
+            params["scale"] = scale
+        if visible is not None:
+            params["visible"] = visible
+            
+        result = rhino.send_command("modify_object", params)
+        return f"Modified object: {result['name']}"
+    except Exception as e:
+        logger.error(f"Error modifying object: {str(e)}")
+        return f"Error modifying object: {str(e)}"

rhinomcp-0.1.1.4/src/rhinomcp/tools/modify_objects.py

@@ -0,0 +1,45 @@
+from mcp.server.fastmcp import Context
+import json
+from rhinomcp.server import get_rhino_connection, mcp, logger
+from typing import Any, List, Dict
+
+
+@mcp.tool()
+def modify_objects(
+    ctx: Context,
+    objects: List[Dict[str, Any]],
+    all: bool = None
+) -> str:
+    """
+    Create multiple objects at once in the Rhino document.
+    
+    Parameters:
+    - objects: A List of objects, each containing the parameters for a single object modification 
+    - all: Optional boolean to modify all objects, if true, only one object is required in the objects dictionary
+
+    Each object can have the following parameters:
+    - id: The id of the object to modify
+    - new_color: Optional [r, g, b] color values (0-255) for the object
+    - translation: Optional [x, y, z] translation vector
+    - rotation: Optional [x, y, z] rotation in radians
+    - scale: Optional [x, y, z] scale factors
+    - visible: Optional boolean to set visibility
+
+    Returns:
+    A message indicating the modified objects.
+    """
+    try:
+        # Get the global connection
+        rhino = get_rhino_connection()
+        command_params = {}
+        command_params["objects"] = objects
+        if all:
+            command_params["all"] = all
+        result = rhino.send_command("modify_objects", command_params)
+  
+        
+        return f"Modified {result['modified']} objects"
+    except Exception as e:
+        logger.error(f"Error modifying objects: {str(e)}")
+        return f"Error modifying objects: {str(e)}"
+

{rhinomcp-0.1.1.2 → rhinomcp-0.1.1.4}/src/rhinomcp.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rhinomcp
-Version: 0.1.1.2
+Version: 0.1.1.4
 Summary: Rhino integration through the Model Context Protocol
 Author-email: Jingcheng Chen <mail@jchen.ch>
 License: MIT

rhinomcp-0.1.1.4/src/rhinomcp.egg-info/SOURCES.txt

@@ -0,0 +1,21 @@
+README.md
+pyproject.toml
+src/rhinomcp/__init__.py
+src/rhinomcp/server.py
+src/rhinomcp.egg-info/PKG-INFO
+src/rhinomcp.egg-info/SOURCES.txt
+src/rhinomcp.egg-info/dependency_links.txt
+src/rhinomcp.egg-info/entry_points.txt
+src/rhinomcp.egg-info/requires.txt
+src/rhinomcp.egg-info/top_level.txt
+src/rhinomcp/prompts/assert_creation_strategy.py
+src/rhinomcp/prompts/assert_query_strategy.py
+src/rhinomcp/tools/create_object.py
+src/rhinomcp/tools/create_objects.py
+src/rhinomcp/tools/delete_object.py
+src/rhinomcp/tools/execute_rhinoscript_python_code.py
+src/rhinomcp/tools/get_document_info.py
+src/rhinomcp/tools/get_object_info.py
+src/rhinomcp/tools/get_selected_objects_info.py
+src/rhinomcp/tools/modify_object.py
+src/rhinomcp/tools/modify_objects.py

rhinomcp-0.1.1.2/src/rhinomcp/__init__.py

@@ -1,6 +0,0 @@
-"""Rhino integration through the Model Context Protocol."""
-
-__version__ = "0.1.0"
-
-# Expose key classes and functions for easier imports
-from .server import RhinoConnection, get_rhino_connection

rhinomcp-0.1.1.2/src/rhinomcp.egg-info/SOURCES.txt

@@ -1,10 +0,0 @@
-README.md
-pyproject.toml
-src/rhinomcp/__init__.py
-src/rhinomcp/server.py
-src/rhinomcp.egg-info/PKG-INFO
-src/rhinomcp.egg-info/SOURCES.txt
-src/rhinomcp.egg-info/dependency_links.txt
-src/rhinomcp.egg-info/entry_points.txt
-src/rhinomcp.egg-info/requires.txt
-src/rhinomcp.egg-info/top_level.txt