rhinomcp 0.1.1.3__tar.gz → 0.1.2.0__tar.gz

{rhinomcp-0.1.1.3 → rhinomcp-0.1.2.0}/PKG-INFO

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

{rhinomcp-0.1.1.3 → rhinomcp-0.1.2.0}/pyproject.toml

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

{rhinomcp-0.1.1.3 → rhinomcp-0.1.2.0}/src/rhinomcp/__init__.py

@@ -5,8 +5,7 @@ __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 .prompts.assert_general_strategy import asset_general_strategy
 
 from .tools.create_object import create_object
 from .tools.create_objects import create_objects
@@ -15,5 +14,8 @@ 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
+from .tools.select_objects import select_objects
 
+from .resources.rhinoscriptsyntax_resource import  get_rhinoscriptsyntax_resource

rhinomcp-0.1.1.3/src/rhinomcp/prompts/assert_creation_strategy.py → rhinomcp-0.1.2.0/src/rhinomcp/prompts/assert_general_strategy.py

@@ -2,20 +2,24 @@ from rhinomcp.server import mcp
 
 
 @mcp.prompt()
-def asset_creation_strategy() -> str:
+def asset_general_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:
+    return """
+    
+    QUERY STRATEGY:
+    - 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.
 
-    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.
+
+    CREATION STRATEGY:
+
+    0. Before anything, always check the document from get_document_info().
+    1. If the execute_rhinoscript_python_code() function is not able to create the objects, use the create_objects() function.
     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.
+    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.2.0/src/rhinomcp/resources/rhinoscriptsyntax_resource.py

@@ -0,0 +1,59 @@
+import mcp.types as types
+from rhinomcp.server import mcp
+from pydantic import FileUrl
+
+
+import os
+from pathlib import Path
+
+# Define path to static folder
+STATIC_FOLDER = Path("./static")
+
+
+@mcp.tool()
+def get_rhinoscriptsyntax_resource(category: str) -> str:
+    """
+    Return the RhinoScriptsyntax for a specific category.
+
+    Parameters:
+    - category: The category of the RhinoScriptsyntax to get.
+
+    The following categories are available:
+    - application
+    - block
+    - compat
+    - curve
+    - dimension
+    - document
+    - geometry
+    - grips
+    - group
+    - hatch
+    - layer
+    - light
+    - line
+    - linetype
+    - material
+    - mesh
+    - object
+    - plane
+    - pointvector
+    - selection
+    - surface
+    - toolbar
+    - transformation
+    - userdata
+    - userinterface
+    - utility
+    - view
+    """
+
+    for file_path in STATIC_FOLDER.glob("*.py"):
+        if file_path.name == f"{category}.py":
+            try:
+                with open(file_path, "r", encoding="utf-8") as f:
+                    return f.read()
+            except Exception as e:
+                print(f"Error reading {file_path}: {e}")
+
+                

{rhinomcp-0.1.1.3 → rhinomcp-0.1.2.0}/src/rhinomcp/tools/create_object.py

@@ -18,7 +18,7 @@ def create_object(
     Create a new object in the Rhino document.
     
     Parameters:
-    - type: Object type ("BOX", "SPHERE")
+    - 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)
@@ -27,48 +27,60 @@ def create_object(
     - scale: Optional [x, y, z] scale factors
 
     The params dictionary is type-specific.
+    For POINT, the params dictionary should contain the following keys:
+    - x: x coordinate of the point
+    - y: y coordinate of the point
+    - z: z coordinate of the point
+
+    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)
+    If the curve is closed, the first and last points should be the same.
+
     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: {"x": 0, "y": 0, "z": 0}
+    - 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 translation is not None: command_params["translation"] = translation
+        if rotation is not None: command_params["rotation"] = rotation
+        if scale is not None: command_params["scale"] = scale
+
         if name: command_params["name"] = name
         if color: command_params["color"] = color
 
         # Create the object
-        result = {}
-        if (type == "BOX"):
-            command_params["width"] = params["width"]
-            command_params["length"] = params["length"]
-            command_params["height"] = params["height"]
-            result = rhino.send_command("create_object", command_params)
-        elif (type == "SPHERE"):
-            result = rhino.send_command("create_object", command_params)
-        # elif (type == "CYLINDER"):
-        #     result = rhino.send_command("create_cylinder", command_params)
-            
+        result = result = rhino.send_command("create_object", command_params)  
         
         return f"Created {type} object: {result['name']}"
     except Exception as e:

{rhinomcp-0.1.1.3 → rhinomcp-0.1.2.0}/src/rhinomcp/tools/create_objects.py

@@ -15,11 +15,11 @@ def create_objects(
     Parameters:
     - objects: A list of dictionaries, each containing the parameters for a single object
 
-    Each object should have the following keys:
-    - type: Object type ("BOX")
+    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)
+    - 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
@@ -29,6 +29,26 @@ def create_objects(
     
     Examples of params:
     [
+        {
+            "type": "POINT",
+            "name": "Point 1",
+            "params": {"x": 0, "y": 0, "z": 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",
@@ -37,6 +57,15 @@ def create_objects(
             "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]
         }
     ]
     """

{rhinomcp-0.1.1.3 → rhinomcp-0.1.2.0}/src/rhinomcp/tools/delete_object.py

@@ -6,7 +6,7 @@ from typing import Any, List, Dict
 
 
 @mcp.tool()
-def delete_object(ctx: Context, id: str = None, name: str = None) -> str:
+def delete_object(ctx: Context, id: str = None, name: str = None, all: bool = None) -> str:
     """
     Delete an object from the Rhino document.
     
@@ -17,8 +17,17 @@ def delete_object(ctx: Context, id: str = None, name: str = None) -> str:
     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", {"id": id, "name": name})
+        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)}")

rhinomcp-0.1.2.0/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.2.0/src/rhinomcp/tools/select_objects.py

@@ -0,0 +1,53 @@
+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 select_objects(
+    ctx: Context,
+    filters: Dict[str, Any] = {},
+    filters_type: str = "and",
+) -> str:
+    """
+    Select objects in the Rhino document.
+    
+    Parameters:
+    - filters: A dictionary containing the filters. The filters parameter is necessary, unless it's empty, in which case all objects will be selected.
+    - filters_type: The type of the filters, it's "and" or "or", default is "and"
+
+    The filters dictionary can contain the following keys:
+    - name: The name of the object
+    - color: The color of the object, for example [255, 0, 0]
+
+    Additionaly, rhino allows to have user custom attributes, which can be used to filters the objects.
+    For example, if the object has a user custom attribute called "category", the filters dictionary can contain:
+    - category: custom_attribute_value
+
+    Example:
+    filters = {
+        "name": "object_name",
+        "category": "custom_attribute_value"
+    },
+    filters_type = "or"
+    
+
+    Returns:
+    A number indicating the number of objects that have been selected.
+    """
+    try:
+        # Get the global connection
+        rhino = get_rhino_connection()
+        command_params = {
+            "filters": filters,
+            "filters_type": filters_type
+        }
+
+        result = rhino.send_command("select_objects", command_params)
+          
+        return f"Selected {result['count']} objects"
+    except Exception as e:
+        logger.error(f"Error selecting objects: {str(e)}")
+        return f"Error selecting objects: {str(e)}"
+

{rhinomcp-0.1.1.3 → rhinomcp-0.1.2.0}/src/rhinomcp.egg-info/PKG-INFO

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

{rhinomcp-0.1.1.3 → rhinomcp-0.1.2.0}/src/rhinomcp.egg-info/SOURCES.txt

@@ -8,8 +8,8 @@ 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/prompts/assert_general_strategy.py
+src/rhinomcp/resources/rhinoscriptsyntax_resource.py
 src/rhinomcp/tools/create_object.py
 src/rhinomcp/tools/create_objects.py
 src/rhinomcp/tools/delete_object.py
@@ -17,4 +17,6 @@ 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_object.py
+src/rhinomcp/tools/modify_objects.py
+src/rhinomcp/tools/select_objects.py

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

@@ -1,10 +0,0 @@
-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.
-    """