rootly-mcp-server 1.0.0__py3-none-any.whl → 2.0.1__py3-none-any.whl

rootly_mcp_server/test_client.py

@@ -1,67 +1,148 @@
+#!/usr/bin/env python3
 """
-Test script for Rootly MCP Server.
+Test client for the Rootly MCP Server
 
-This script tests the default pagination for incidents endpoints.
+This script demonstrates how to use the Rootly MCP Server.
 """
 
-import json
-import logging
+import asyncio
 import os
 import sys
+from pathlib import Path
 
-# Configure logging
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-)
+# Add the src directory to the Python path
+sys.path.insert(0, str(Path(__file__).parent.parent))
 
-# Add the parent directory to the path so we can import the package
-sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '../..')))
+from rootly_mcp_server.server import create_rootly_mcp_server
 
-from rootly_mcp_server import RootlyMCPServer
 
-def test_incidents_pagination():
-    """Test that incidents endpoints have default pagination."""
+async def test_server():
+    """Test the Rootly MCP server."""
+    print("Creating Rootly MCP Server...")
     
-    # Create a server instance
-    server = RootlyMCPServer(default_page_size=5)  # Use a smaller page size for testing
-    
-    # Find an incidents endpoint tool
-    incidents_tool = None
-    for tool_name in server.list_tools():
-        if "incidents" in tool_name and tool_name.endswith("_get"):
-            incidents_tool = tool_name
-            break
-    
-    if not incidents_tool:
-        logging.error("No incidents GET endpoint found")
-        return
-    
-    logging.info(f"Testing pagination with tool: {incidents_tool}")
-    
-    # Call the tool
     try:
-        result = server.invoke_tool(incidents_tool, {})
-        result_json = json.loads(result)
+        # Create the server with a subset of endpoints for testing
+        server = create_rootly_mcp_server(
+            name="TestRootly",
+            allowed_paths=[
+                "/incidents",
+                "/alerts",
+                "/teams",
+                "/services"
+            ],
+            hosted=False  # Use local API token
+        )
         
-        # Check if the result has pagination info
-        if "meta" in result_json and "pagination" in result_json["meta"]:
-            pagination = result_json["meta"]["pagination"]
-            logging.info(f"Pagination info: {pagination}")
+        print(f"✅ Server created successfully")
+        print(f"Server type: {type(server)}")
+        
+        # Use the get_tools method to access tools
+        try:
+            tools = await server.get_tools()
+            print(f"Tools type: {type(tools)}")
+            print(f"Tools: {tools}")
+            
+            # Handle both dict and list cases
+            if isinstance(tools, dict):
+                tools_list = list(tools.values())
+                tools_names = list(tools.keys())
+                tool_count = len(tools)
+            elif isinstance(tools, list):
+                tools_list = tools
+                tools_names = [getattr(tool, 'name', f'tool_{i}') for i, tool in enumerate(tools)]
+                tool_count = len(tools)
+            else:
+                tools_list = []
+                tools_names = []
+                tool_count = 0
+            
+            print(f"Found {tool_count} tools via get_tools() method")
             
-            if pagination.get("per_page") == 5:
-                logging.info("✅ Default pagination applied successfully!")
+            # List the registered tools
+            if tool_count > 0:
+                print(f"\n📋 Registered tools ({tool_count}):")
+                for i, tool in enumerate(tools_list):
+                    if isinstance(tools, dict):
+                        tool_name = tools_names[i]
+                    else:
+                        tool_name = getattr(tool, 'name', f'tool_{i}')
+                    
+                    description = getattr(tool, 'description', 'No description')
+                    print(f"  • {tool_name}: {description[:100]}...")
+                    print(f"    Tool type: {type(tool)}")
+                    print(f"    Tool attributes: {[attr for attr in dir(tool) if not attr.startswith('_')][:10]}")
+                    
+                    # Show parameter schema if available
+                    if hasattr(tool, 'inputSchema') and tool.inputSchema:
+                        props = tool.inputSchema.get('properties', {})
+                        if props:
+                            print(f"    Parameters: {', '.join(props.keys())}")
             else:
-                logging.warning(f"❌ Default pagination not applied. Per page: {pagination.get('per_page')}")
-        else:
-            logging.warning("❌ No pagination info found in response")
+                print(f"\n⚠️  No tools found")
+                
+            # Test accessing a specific tool
+            if tool_count > 0:
+                print(f"\n🔍 Testing tool access...")
+                if isinstance(tools, dict):
+                    first_tool_name = tools_names[0]
+                    first_tool = tools[first_tool_name]
+                else:
+                    first_tool = tools_list[0]
+                    first_tool_name = getattr(first_tool, 'name', 'unknown')
+                
+                print(f"  ✅ First tool: {first_tool_name}")
+                print(f"  Tool details: {first_tool}")
+                
+                # Try to get tool by name
+                try:
+                    retrieved_tool = await server.get_tool(first_tool_name)
+                    if retrieved_tool:
+                        print(f"  ✅ Successfully retrieved tool by name: {first_tool_name}")
+                    else:
+                        print(f"  ❌ Could not retrieve tool by name: {first_tool_name}")
+                except Exception as e:
+                    print(f"  ❌ Error retrieving tool: {e}")
             
-        # Log the number of items returned
-        if "data" in result_json:
-            logging.info(f"Number of items returned: {len(result_json['data'])}")
+        except Exception as e:
+            print(f"❌ Error accessing tools: {e}")
+            import traceback
+            traceback.print_exc()
+            tool_count = 0
+        
+        print(f"\n🎉 Test completed successfully!")
+        print(f"Total tools found: {tool_count}")
         
     except Exception as e:
-        logging.error(f"Error testing pagination: {e}")
+        print(f"❌ Error creating server: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+    
+    return True
+
+
+def main():
+    """Main function."""
+    print("Rootly MCP Server Test")
+    print("=" * 50)
+    
+    # Check for API token
+    api_token = os.getenv("ROOTLY_API_TOKEN")
+    if not api_token:
+        print("⚠️  Warning: ROOTLY_API_TOKEN not set. Server will use mock client.")
+    else:
+        print(f"✅ API token found: {api_token[:10]}...")
+    
+    # Run the test
+    success = asyncio.run(test_server())
+    
+    if success:
+        print("\n🎉 All tests passed!")
+        sys.exit(0)
+    else:
+        print("\n❌ Tests failed!")
+        sys.exit(1)
+
 
 if __name__ == "__main__":
-    test_incidents_pagination() 
+    main() 

rootly_mcp_server-2.0.1.dist-info/METADATA

@@ -0,0 +1,225 @@
+Metadata-Version: 2.4
+Name: rootly-mcp-server
+Version: 2.0.1
+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 :: 5 - Production/Stable
+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: fastmcp==2.4.0
+Requires-Dist: httpx>=0.24.0
+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 the [Rootly API](https://docs.rootly.com/api-reference/overview) that integrates seamlessly with MCP-compatible editors like Cursor, Windsurf, and Claude. Resolve production incidents in under a minute without leaving your IDE.
+
+[![Install MCP Server](https://cursor.com/deeplink/mcp-install-dark.svg)](https://cursor.com/install-mcp?name=rootly&config=eyJjb21tYW5kIjoibnB4IC15IG1jcC1yZW1vdGUgaHR0cHM6Ly9tY3Aucm9vdGx5LmNvbS9zc2UgLS1oZWFkZXIgQXV0aG9yaXphdGlvbjoke1JPT1RMWV9BVVRIX0hFQURFUn0iLCJlbnYiOnsiUk9PVExZX0FVVEhfSEVBREVSIjoiQmVhcmVyIDxZT1VSX1JPT1RMWV9BUElfVE9LRU4%2BIn19)
+
+![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)
+
+## Installation
+
+Install via our [PyPi package](https://pypi.org/project/rootly-mcp-server/) or by cloning this repository.
+
+Configure your MCP-compatible editor (tested with Cursor and Windsurf) with the following:
+
+### With uv
+
+```json
+{
+  "mcpServers": {
+    "rootly": {
+      "command": "uv",
+      "args": [
+        "tool",
+        "run",
+        "--from",
+        "rootly-mcp-server",
+        "rootly-mcp-server",
+      ],      
+      "env": {
+        "ROOTLY_API_TOKEN": "<YOUR_ROOTLY_API_TOKEN>"
+      }
+    }
+  }
+}
+```
+
+### With uv-tool-uvx
+
+```json
+{
+  "mcpServers": {
+    "rootly": {
+      "command": "uvx",
+      "args": [
+        "--from",
+        "rootly-mcp-server",
+        "rootly-mcp-server",
+      ],      
+      "env": {
+        "ROOTLY_API_TOKEN": "<YOUR_ROOTLY_API_TOKEN>"
+      }
+    }
+  }
+}
+```
+
+To customize `allowed_paths` and access additional Rootly API paths, clone the repository and use this configuration:
+
+```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
+
+- **Dynamic Tool Generation**: Automatically creates MCP resources from Rootly's OpenAPI (Swagger) specification
+- **Smart Pagination**: Defaults to 10 items per request for incident endpoints to prevent context window overflow
+- **API Filtering**: Limits exposed API endpoints for security and performance
+
+### Whitelisted Endpoints
+
+By default, the following Rootly API endpoints are exposed to the AI agent (see `allowed_paths` in `src/rootly_mcp_server/server.py`):
+
+```
+/v1/incidents
+/v1/incidents/{incident_id}/alerts
+/v1/alerts
+/v1/alerts/{alert_id}
+/v1/severities
+/v1/severities/{severity_id}
+/v1/teams
+/v1/teams/{team_id}
+/v1/services
+/v1/services/{service_id}
+/v1/functionalities
+/v1/functionalities/{functionality_id}
+/v1/incident_types
+/v1/incident_types/{incident_type_id}
+/v1/incident_action_items
+/v1/incident_action_items/{incident_action_item_id}
+/v1/incidents/{incident_id}/action_items
+/v1/workflows
+/v1/workflows/{workflow_id}
+/v1/workflow_runs
+/v1/workflow_runs/{workflow_run_id}
+/v1/environments
+/v1/environments/{environment_id}
+/v1/users
+/v1/users/{user_id}
+/v1/users/me
+/v1/status_pages
+/v1/status_pages/{status_page_id}
+```
+
+### Why Path Limiting?
+
+We limit exposed API paths for two key reasons:
+
+1. **Context Management**: Rootly's comprehensive API can overwhelm AI agents, affecting their ability to perform simple tasks effectively
+2. **Security**: Control which information and actions are accessible through the MCP server
+
+To expose additional paths, modify the `allowed_paths` variable in `src/rootly_mcp_server/server.py`.
+
+## About Rootly AI Labs
+
+This project was developed by [Rootly AI Labs](https://labs.rootly.ai/), where we're building the future of system reliability and operational excellence. As an open-source incubator, we share ideas, experiment, and rapidly prototype solutions that benefit the entire community.
+![Rootly AI logo](https://github.com/Rootly-AI-Labs/EventOrOutage/raw/main/rootly-ai.png)
+
+## Developer Setup & Troubleshooting
+
+### Prerequisites
+- Python 3.12 or higher
+- [`uv`](https://github.com/astral-sh/uv) for dependency management
+
+### 1. Set Up Virtual Environment
+
+Create and activate a virtual environment:
+
+```bash
+uv venv .venv
+source .venv/bin/activate  # Always activate before running scripts
+```
+
+### 2. Install Dependencies
+
+Install all project dependencies:
+
+```bash
+uv pip install .
+```
+
+To add new dependencies during development:
+```bash
+uv pip install <package>
+```
+
+### 3. Verify Installation
+
+Run the test client to ensure everything is configured correctly:
+
+```bash
+python test_mcp_client.py
+```
+
+### Connect to Hosted MCP Server
+
+Alternatively, connect directly to our hosted MCP server:
+
+```json
+{
+  "mcpServers": {
+    "rootly": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "mcp-remote",
+        "https://mcp.rootly.com/sse",
+        "--header",
+        "Authorization:${ROOTLY_AUTH_HEADER}"
+      ],
+      "env": {
+        "ROOTLY_AUTH_HEADER": "Bearer <YOUR_ROOTLY_API_TOKEN>"
+      }
+    }
+  }
+}
+```

rootly_mcp_server-2.0.1.dist-info/RECORD

@@ -0,0 +1,12 @@
+rootly_mcp_server/__init__.py,sha256=H3Dd4Od-PEff8VdbMgnblS6cCEBCb9XqYdI_-wmtQqk,628
+rootly_mcp_server/__main__.py,sha256=yOBEaQWEMZvsC7zT5no7yo1ISIvfeq7NlIPflBMoAFI,6447
+rootly_mcp_server/client.py,sha256=05TsHVJ3WtLH0k4R19Yzwwx4xcmjCKH6hS3uKcTMwRA,4678
+rootly_mcp_server/routemap_server.py,sha256=SloHu4ZTaFBusoIlhM2h7jfB8kFtMQrT3M_n7JAekug,6101
+rootly_mcp_server/server.py,sha256=2paE39caYRVuQG4yWEEOqZewbvpFREmf-J01lPQ5elw,19756
+rootly_mcp_server/test_client.py,sha256=8p1aJHrEt_Tj2NuJzTnTHw-ZeW816P99fJi5bhPidyc,5119
+rootly_mcp_server/data/__init__.py,sha256=fO8a0bQnRVEoRMHKvhFzj10bhoaw7VsI51czc2MsUm4,143
+rootly_mcp_server-2.0.1.dist-info/METADATA,sha256=SNQJLqa2_tBEV3ZRycB8NgnDt6jaw5UvuW1zMbI_R-A,6140
+rootly_mcp_server-2.0.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+rootly_mcp_server-2.0.1.dist-info/entry_points.txt,sha256=NE33b8VgigVPGBkboyo6pvN1Vz35HZtLybxMO4Q03PI,70
+rootly_mcp_server-2.0.1.dist-info/licenses/LICENSE,sha256=c9w9ZZGl14r54tsP40oaq5adTVX_HMNHozPIH2ymzmw,11341
+rootly_mcp_server-2.0.1.dist-info/RECORD,,