rootly-mcp-server 0.0.3__py3-none-any.whl → 0.0.5__py3-none-any.whl

rootly_mcp_server/__main__.py

@@ -67,7 +67,11 @@ def setup_logging(log_level, debug=False):
     
     # Set specific logger levels
     logging.getLogger("rootly_mcp_server").setLevel(numeric_level)
-    logging.getLogger("mcp").setLevel(numeric_level)
+    logging.getLogger("rootly_mcp_server.server").setLevel(logging.WARNING)  # Reduce server-specific logs
+    
+    # Always set MCP logger to ERROR level to fix Cline UI issue
+    # This prevents INFO logs from causing problems with Cline tool display
+    logging.getLogger("mcp").setLevel(logging.ERROR)
     
     # Log the configuration
     logger = logging.getLogger(__name__)

rootly_mcp_server/server.py

@@ -30,51 +30,69 @@ SWAGGER_URL = "https://rootly-heroku.s3.amazonaws.com/swagger/v1/swagger.json"
 class RootlyMCPServer(FastMCP):
     """
     A Model Context Protocol server for Rootly API integration.
-    
+
     This server dynamically generates MCP tools based on the Rootly API's
     OpenAPI (Swagger) specification.
     """
-    
-    def __init__(self, swagger_path: Optional[str] = None, name: str = "Rootly", default_page_size: int = 10):
+
+    def __init__(self,
+                 swagger_path: Optional[str] = None,
+                 name: str = "Rootly",
+                 default_page_size: int = 10,
+                 allowed_paths: Optional[List[str]] = None):
         """
         Initialize the Rootly MCP Server.
-        
+
         Args:
             swagger_path: Path to the Swagger JSON file. If None, will look for
                           swagger.json in the current directory and parent directories.
             name: Name of the MCP server.
             default_page_size: Default number of items to return per page for paginated endpoints.
-                              This helps prevent context window overflow.
+            allowed_paths: List of API paths to load. If None, all paths will be loaded.
+                         Paths should be specified without the /v1 prefix.
+                         Example: ["/incidents", "/incidents/{incident_id}/alerts"]
         """
-        logger.info(f"Initializing RootlyMCPServer with name: {name}")
-        super().__init__(name)
-        
+        # Set default allowed paths if none provided
+        self.allowed_paths = allowed_paths or [
+            "/incidents",
+            "/incidents/{incident_id}/alerts"
+        ]
+        # Add /v1 prefix to paths if not present
+        self.allowed_paths = [
+            f"/v1{path}" if not path.startswith("/v1") else path
+            for path in self.allowed_paths
+        ]
+
+        logger.info(f"Initializing RootlyMCPServer with allowed paths: {self.allowed_paths}")
+        # Initialize FastMCP with ERROR log level to fix Cline UI issue
+        super().__init__(name, log_level="ERROR")
+
         # Initialize the Rootly API client
         self.client = RootlyClient()
-        
+
         # Store default page size
         self.default_page_size = default_page_size
         logger.info(f"Using default page size: {default_page_size}")
-        
+
         # Load the Swagger specification
         logger.info("Loading Swagger specification")
         self.swagger_spec = self._load_swagger_spec(swagger_path)
-        logger.info(f"Loaded Swagger spec with {len(self.swagger_spec.get('paths', {}))} paths")
-        
+        logger.info(f"Loaded Swagger spec with {len(self.swagger_spec.get('paths', {}))} total paths")
+
         # Register tools based on the Swagger spec
         logger.info("Registering tools based on Swagger spec")
         self._register_tools()
-    
+
     def _fetch_swagger_from_url(self, url: str = SWAGGER_URL) -> Dict[str, Any]:
         """
         Fetch the Swagger specification from the specified URL.
-        
+
         Args:
             url: URL of the Swagger JSON file.
-        
+
         Returns:
             The Swagger specification as a dictionary.
-            
+
         Raises:
             Exception: If the request fails or the response is not valid JSON.
         """
@@ -89,18 +107,18 @@ class RootlyMCPServer(FastMCP):
         except json.JSONDecodeError as e:
             logger.error(f"Failed to parse Swagger spec: {e}")
             raise Exception(f"Failed to parse Swagger specification: {e}")
-    
+
     def _load_swagger_spec(self, swagger_path: Optional[str] = None) -> Dict[str, Any]:
         """
         Load the Swagger specification from a file.
-        
+
         Args:
             swagger_path: Path to the Swagger JSON file. If None, will look for
                           swagger.json in the following locations (in order):
                           1. package data directory
                           2. current directory and parent directories
                           3. download from the URL
-        
+
         Returns:
             The Swagger specification as a dictionary.
         """
@@ -121,18 +139,18 @@ class RootlyMCPServer(FastMCP):
                         return json.load(f)
             except Exception as e:
                 logger.debug(f"Could not load Swagger file from package data: {e}")
-            
+
             # Then, look for swagger.json in the current directory and parent directories
             logger.info("Looking for swagger.json in current directory and parent directories")
             current_dir = Path.cwd()
-            
+
             # Check current directory first
             swagger_path = current_dir / "swagger.json"
             if swagger_path.is_file():
                 logger.info(f"Found Swagger file at {swagger_path}")
                 with open(swagger_path, "r") as f:
                     return json.load(f)
-            
+
             # Check parent directories
             for parent in current_dir.parents:
                 swagger_path = parent / "swagger.json"
@@ -140,11 +158,11 @@ class RootlyMCPServer(FastMCP):
                     logger.info(f"Found Swagger file at {swagger_path}")
                     with open(swagger_path, "r") as f:
                         return json.load(f)
-            
+
             # If the file wasn't found, fetch it from the URL and save it
             logger.info("Swagger file not found locally, fetching from URL")
             swagger_spec = self._fetch_swagger_from_url()
-            
+
             # Save the fetched spec to the current directory
             swagger_path = current_dir / "swagger.json"
             logger.info(f"Saving Swagger file to {swagger_path}")
@@ -154,32 +172,38 @@ class RootlyMCPServer(FastMCP):
                 logger.info(f"Saved Swagger file to {swagger_path}")
             except Exception as e:
                 logger.warning(f"Failed to save Swagger file: {e}")
-            
+
             return swagger_spec
-    
+
     def _register_tools(self) -> None:
         """
         Register MCP tools based on the Swagger specification.
-        
-        This method iterates through the paths and operations in the Swagger spec
-        and creates corresponding MCP tools.
+        Only registers tools for paths specified in allowed_paths.
         """
         paths = self.swagger_spec.get("paths", {})
-        logger.info(f"Found {len(paths)} paths in Swagger spec")
-        
+
+        # Filter paths based on allowed_paths
+        filtered_paths = {
+            path: path_item
+            for path, path_item in paths.items()
+            if path in self.allowed_paths
+        }
+
+        logger.info(f"Registering {len(filtered_paths)} paths out of {len(paths)} total paths")
+
         # Register the list_endpoints tool
         @self.tool()
         def list_endpoints() -> str:
             """List all available Rootly API endpoints."""
             endpoints = []
-            for path, path_item in paths.items():
+            for path, path_item in filtered_paths.items():
                 for method, operation in path_item.items():
                     if method.lower() not in ["get", "post", "put", "delete", "patch"]:
                         continue
-                    
+
                     summary = operation.get("summary", "")
                     description = operation.get("description", "")
-                    
+
                     endpoints.append({
                         "path": path,
                         "method": method.upper(),
@@ -187,92 +211,89 @@ class RootlyMCPServer(FastMCP):
                         "description": description,
                         "tool_name": self._create_tool_name(path, method)
                     })
-            
+
             return json.dumps(endpoints, indent=2)
-        
+
         # Register a tool for each endpoint
         tool_count = 0
-        
-        for path, path_item in paths.items():
+
+        for path, path_item in filtered_paths.items():
             # Skip path parameters
             if "parameters" in path_item:
                 path_item = {k: v for k, v in path_item.items() if k != "parameters"}
-            
+
             for method, operation in path_item.items():
                 if method.lower() not in ["get", "post", "put", "delete", "patch"]:
                     continue
-                
+
                 # Create a tool name based on the path and method
                 tool_name = self._create_tool_name(path, method)
-                
+
                 # Create a tool description
                 description = operation.get("summary", "") or operation.get("description", "")
                 if not description:
                     description = f"{method.upper()} {path}"
-                
-                # Create the input schema
-                input_schema = self._create_input_schema(path, operation)
-                
+
                 # Register the tool using the direct method
                 try:
                     # Define the tool function
                     def create_tool_fn(p=path, m=method, op=operation):
                         def tool_fn(**kwargs):
                             return self._handle_api_request(p, m, op, **kwargs)
-                        
+
                         # Set the function name and docstring
                         tool_fn.__name__ = tool_name
                         tool_fn.__doc__ = description
                         return tool_fn
-                    
+
                     # Create the tool function
                     tool_fn = create_tool_fn()
-                    
+
                     # Register the tool with FastMCP
                     self.add_tool(
                         name=tool_name,
                         description=description,
                         fn=tool_fn
                     )
-                    
+
                     tool_count += 1
                     logger.info(f"Registered tool: {tool_name}")
                 except Exception as e:
                     logger.error(f"Error registering tool {tool_name}: {e}")
-        
-        logger.info(f"Registered {tool_count} tools in total")
-    
+
+        logger.info(f"Registered {tool_count} tools in total. Modify allowed_paths to register more paths from the Rootly API.")
+
     def _create_tool_name(self, path: str, method: str) -> str:
         """
         Create a tool name based on the path and method.
-        
+
         Args:
             path: The API path.
             method: The HTTP method.
-        
+
         Returns:
             A tool name string.
         """
         # Remove the /v1 prefix if present
         if path.startswith("/v1"):
             path = path[3:]
-        
+
         # Replace path parameters with "by_id"
         path = re.sub(r"\{([^}]+)\}", r"by_\1", path)
-        
+
         # Replace slashes with underscores and remove leading/trailing underscores
         path = path.replace("/", "_").strip("_")
-        
+
         return f"{path}_{method.lower()}"
-    
+
     def _create_input_schema(self, path: str, operation: Dict[str, Any]) -> Dict[str, Any]:
         """
         Create an input schema for the tool.
-        
+
         Args:
             path: The API path.
             operation: The Swagger operation object.
-        
+
         Returns:
             An input schema dictionary.
         """
@@ -283,7 +304,7 @@ class RootlyMCPServer(FastMCP):
             "required": [],
             "additionalProperties": False
         }
-        
+
         # Extract path parameters
         path_params = re.findall(r"\{([^}]+)\}", path)
         for param in path_params:
@@ -292,96 +313,96 @@ class RootlyMCPServer(FastMCP):
                 "description": f"Path parameter: {param}"
             }
             schema["required"].append(param)
-        
+
         # Add operation parameters
         for param in operation.get("parameters", []):
             param_name = param.get("name")
             param_in = param.get("in")
-            
+
             if param_in in ["query", "header"]:
                 param_schema = param.get("schema", {})
                 param_type = param_schema.get("type", "string")
-                
+
                 schema["properties"][param_name] = {
                     "type": param_type,
                     "description": param.get("description", f"{param_in} parameter: {param_name}")
                 }
-                
+
                 if param.get("required", False):
                     schema["required"].append(param_name)
-        
+
         # Add request body for POST, PUT, PATCH methods
         if "requestBody" in operation:
             content = operation["requestBody"].get("content", {})
             if "application/json" in content:
                 body_schema = content["application/json"].get("schema", {})
-                
+
                 if "properties" in body_schema:
                     for prop_name, prop_schema in body_schema["properties"].items():
                         schema["properties"][prop_name] = {
                             "type": prop_schema.get("type", "string"),
                             "description": prop_schema.get("description", f"Body parameter: {prop_name}")
                         }
-                
+
                 if "required" in body_schema:
                     schema["required"].extend(body_schema["required"])
-        
+
         return schema
-    
+
     def _handle_api_request(self, path: str, method: str, operation: Dict[str, Any], **kwargs) -> str:
         """
         Handle an API request to the Rootly API.
-        
+
         Args:
             path: The API path.
             method: The HTTP method.
             operation: The Swagger operation object.
             **kwargs: The parameters for the request.
-        
+
         Returns:
             The API response as a JSON string.
         """
         logger.debug(f"Handling API request: {method} {path}")
         logger.debug(f"Request parameters: {kwargs}")
-        
+
         # Extract path parameters
         path_params = re.findall(r"\{([^}]+)\}", path)
         actual_path = path
-        
+
         # Replace path parameters in the URL
         for param in path_params:
             if param in kwargs:
                 actual_path = actual_path.replace(f"{{{param}}}", str(kwargs.pop(param)))
-        
+
         # Separate query parameters and body parameters
         query_params = {}
         body_params = {}
-        
+
         if method.lower() == "get":
             # For GET requests, all remaining parameters are query parameters
             query_params = kwargs
-            
+
             # Add default pagination for incident-related endpoints
             if "incidents" in path and method.lower() == "get":
                 # Check if pagination parameters are already specified
                 has_pagination = any(param.startswith("page[") for param in query_params.keys())
-                
+
                 # If no pagination parameters are specified, add default page size
                 if not has_pagination:
                     query_params["page[size]"] = self.default_page_size
-                    logger.info(f"Added default pagination (page[size]={self.default_page_size}) for incidents endpoint: {path}")
+                    logger.debug(f"Added default pagination (page[size]={self.default_page_size}) for incidents endpoint: {path}")
         else:
             # For other methods, check which parameters are query parameters
             for param in operation.get("parameters", []):
                 param_name = param.get("name")
                 param_in = param.get("in")
-                
+
                 if param_in == "query" and param_name in kwargs:
                     query_params[param_name] = kwargs.pop(param_name)
-            
+
             # All remaining parameters go in the request body
             body_params = kwargs
-        
+
         # Make the API request
         try:
             response = self.client.make_request(
@@ -393,4 +414,4 @@ class RootlyMCPServer(FastMCP):
             return response
         except Exception as e:
             logger.error(f"Error calling Rootly API: {e}")
-            return json.dumps({"error": str(e)}) 
+            return json.dumps({"error": str(e)})

rootly_mcp_server-0.0.5.dist-info/METADATA

@@ -0,0 +1,103 @@
+Metadata-Version: 2.4
+Name: rootly-mcp-server
+Version: 0.0.5
+Summary: A Model Context Protocol server for Rootly APIs using OpenAPI spec
+Project-URL: Homepage, https://github.com/Rootly-AI-Labs/Rootly-MCP-server
+Project-URL: Issues, https://github.com/Rootly-AI-Labs/Rootly-MCP-server/issues
+Author-email: Rootly AI Labs <support@rootly.com>
+License-Expression: Apache-2.0
+License-File: LICENSE
+Keywords: automation,incidents,llm,mcp,rootly
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Build Tools
+Requires-Python: >=3.12
+Requires-Dist: mcp>=1.1.2
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: requests>=2.28.0
+Provides-Extra: dev
+Requires-Dist: black>=23.0.0; extra == 'dev'
+Requires-Dist: isort>=5.0.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+
+# Rootly MCP Server
+
+An MCP server for [Rootly API](https://docs.rootly.com/api-reference/overview) that you can plug into your favorite MCP-compatible editors like Cursor, Windsurf, and Claude. Resolve production incidents in under a minute without leaving your IDE.
+<br>
+<br>
+
+![Demo GIF](rootly-mcp-server-demo.gif)
+
+
+## Prerequisites
+
+- Python 3.12 or higher
+- `uv` package manager
+  ```bash
+  curl -LsSf https://astral.sh/uv/install.sh | sh
+  ```
+- [Rootly API token](https://docs.rootly.com/api-reference/overview#how-to-generate-an-api-key%3F)
+
+## Run it in your IDE
+Install with our [PyPi package](https://pypi.org/project/rootly-mcp-server/) or by cloning this repo.
+
+To set it up in your favorite MCP-compatible editor (we tested it with Cursor and Windsurf), here is the config :
+```json
+{
+  "mcpServers": {
+    "rootly": {
+      "command": "uvx",
+      "args": [
+        "--from",
+        "rootly-mcp-server",
+        "rootly-mcp-server"
+      ],
+      "env": {
+        "ROOTLY_API_TOKEN": "<YOUR_ROOTLY_API_TOKEN>"
+      }
+    }
+  }
+}
+```
+If you want to customize `allowed_paths` to access more Rootly API paths, clone the package and use this config.
+```json
+{
+    "mcpServers": {
+      "rootly": {
+        "command": "uv",
+        "args": [
+          "run",
+          "--directory",
+          "/path/to/rootly-mcp-server",
+          "rootly-mcp-server"
+        ],
+        "env": {
+          "ROOTLY_API_TOKEN": "<YOUR_ROOTLY_API_TOKEN>"
+        }
+      }
+    }
+  }
+```
+
+## Features
+This server dynamically generates MCP resources based on Rootly's OpenAPI (Swagger) specification:
+- Dynamically generated MCP tools based on Rootly's OpenAPI specification
+- Default pagination (10 items) for incident endpoints to prevent context window overflow
+- Limits the number of API paths exposed to the AI agent
+
+We limited the number of API paths exposed for 2 reasons
+* Context size: because [Rootly's API](https://docs.rootly.com/api-reference/overview) is very rich in paths, AI agents can get overwhelmed and not perform simple actions properly. As of now we only expose the [/incidents](https://docs.rootly.com/api-reference/incidents/list-incidents) and [/incidents/{incident_id}/alerts](https://docs.rootly.com/api-reference/incidentevents/list-incident-events).
+* Security: if you want to limit the type of information or actions that users can access through the MCP server
+
+If you want to make more path available, edit the variable `allowed_paths` in `src/rootly_mcp_server/server.py`.
+
+## Disclaimer
+This project is a prototype and not intended for production use. If you have featured ideas or spotted some issues, feel free to submit a PR or open an issue.
+
+## About the Rootly AI Labs
+This project was developed by the [Rootly AI Labs](https://labs.rootly.ai/). The AI Labs is building the future of system reliability and operational excellence. We operate as an open-source incubator, sharing ideas, experimenting, and rapidly prototyping. We're committed to ensuring our research benefits the entire community.
+![Rootly AI logo](https://github.com/Rootly-AI-Labs/EventOrOutage/raw/main/rootly-ai.png)
+

rootly_mcp_server-0.0.5.dist-info/RECORD

@@ -0,0 +1,12 @@
+rootly_mcp_server/__init__.py,sha256=n-YajkwxYg0eoVvtYfYTY6slaktHTYvQbasg15HwGKo,628
+rootly_mcp_server/__main__.py,sha256=yVbn4s2WGDy7ASbcLULMi2ro4Qt6WgVZbHVD0p0ibrs,4311
+rootly_mcp_server/client.py,sha256=vvaY_UaYLobeHbJwgsmFNX-2ABpYoKxMTie8DRBo_xk,3865
+rootly_mcp_server/server.py,sha256=iYOSmS7UfxF28w09X3PjDI6he9VLE1h3U9U3qsJ8K5M,16273
+rootly_mcp_server/test_client.py,sha256=xFQ4cfUpD6qs-aLidy56B3nnV38EFvUe_eBHOqZOC9o,2191
+rootly_mcp_server/data/__init__.py,sha256=fO8a0bQnRVEoRMHKvhFzj10bhoaw7VsI51czc2MsUm4,143
+rootly_mcp_server/data/swagger.json,sha256=8Ag4COTnS3WSC6vBaa2Q7hq3RxIQ8fGrmwsnNSnPheA,2046619
+rootly_mcp_server-0.0.5.dist-info/METADATA,sha256=r9dctRmxTaFySuSdiyoELmxJT019AHoLbaO9dXbF_2g,4074
+rootly_mcp_server-0.0.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+rootly_mcp_server-0.0.5.dist-info/entry_points.txt,sha256=NE33b8VgigVPGBkboyo6pvN1Vz35HZtLybxMO4Q03PI,70
+rootly_mcp_server-0.0.5.dist-info/licenses/LICENSE,sha256=c9w9ZZGl14r54tsP40oaq5adTVX_HMNHozPIH2ymzmw,11341
+rootly_mcp_server-0.0.5.dist-info/RECORD,,