rootly-mcp-server 2.0.0__tar.gz → 2.0.2__tar.gz

{rootly_mcp_server-2.0.0 → rootly_mcp_server-2.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rootly-mcp-server
-Version: 2.0.0
+Version: 2.0.2
 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
@@ -14,7 +14,7 @@ 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: fastmcp==2.10.5
 Requires-Dist: httpx>=0.24.0
 Requires-Dist: pydantic>=2.0.0
 Requires-Dist: requests>=2.28.0
@@ -25,7 +25,7 @@ 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.
+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)
 
@@ -40,18 +40,46 @@ An MCP server for [Rootly API](https://docs.rootly.com/api-reference/overview) t
   ```
 - [Rootly API token](https://docs.rootly.com/api-reference/overview#how-to-generate-an-api-key%3F)
 
-## Run it in your IDE
+## Installation
 
-Install with our [PyPi package](https://pypi.org/project/rootly-mcp-server/) or by cloning this repo.
+Install via our [PyPi package](https://pypi.org/project/rootly-mcp-server/) or by cloning this repository.
 
-To set it up in your favorite MCP-compatible editor (we tested it with Cursor and Windsurf), here is the config :
+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"],
+      "args": [
+        "--from",
+        "rootly-mcp-server",
+        "rootly-mcp-server",
+      ],      
       "env": {
         "ROOTLY_API_TOKEN": "<YOUR_ROOTLY_API_TOKEN>"
       }
@@ -60,7 +88,7 @@ To set it up in your favorite MCP-compatible editor (we tested it with Cursor an
 }
 ```
 
-If you want to customize `allowed_paths` to access more Rootly API paths, clone the package and use this config.
+To customize `allowed_paths` and access additional Rootly API paths, clone the repository and use this configuration:
 
 ```json
 {
@@ -83,11 +111,9 @@ If you want to customize `allowed_paths` to access more Rootly API paths, clone
 
 ## 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
+- **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
 
@@ -124,54 +150,59 @@ By default, the following Rootly API endpoints are exposed to the AI agent (see
 /v1/status_pages/{status_page_id}
 ```
 
-We limited the number of API paths exposed for 2 reasons:
+### Why Path Limiting?
+
+We limit exposed API paths for two key 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.
-- Security: if you want to limit the type of information or actions that users can access through the MCP server
+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
 
-If you want to make more paths available, edit the variable `allowed_paths` in `src/rootly_mcp_server/server.py`.
+To expose additional paths, modify the `allowed_paths` variable in `src/rootly_mcp_server/server.py`.
 
-## About the Rootly AI Labs
+## About 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.
+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
 
-### 1. Install dependencies with `uv`
+### Prerequisites
+- Python 3.12 or higher
+- [`uv`](https://github.com/astral-sh/uv) for dependency management
+
+### 1. Set Up Virtual Environment
 
-This project uses [`uv`](https://github.com/astral-sh/uv) for fast dependency management. To install all dependencies from your `pyproject.toml`:
+Create and activate a virtual environment:
 
 ```bash
-uv pip install .
+uv venv .venv
+source .venv/bin/activate  # Always activate before running scripts
 ```
 
-### 2. Using a virtual environment
+### 2. Install Dependencies
 
-It is recommended to use a virtual environment for development:
+Install all project dependencies:
 
 ```bash
-uv venv .venv
-source .venv/bin/activate
+uv pip install .
 ```
 
-### 3. Running the test client
+To add new dependencies during development:
+```bash
+uv pip install <package>
+```
 
-To run the test client and verify your setup:
+### 3. Verify Installation
+
+Run the test client to ensure everything is configured correctly:
 
 ```bash
 python test_mcp_client.py
 ```
 
-### 5. General tips
-
-- Always activate your virtual environment before running scripts.
-- If you add new dependencies, use `uv pip install <package>` to keep your environment up to date.
-- If you encounter issues, check your Python version and ensure it matches the project's requirements.
-
-### 6. Connecting to Our MCP Server
+### Connect to Hosted MCP Server
 
-You can configure your client to connect directly to our hosted MCP server:
+Alternatively, connect directly to our hosted MCP server:
 
 ```json
 {

rootly_mcp_server-2.0.2/README.md

@@ -0,0 +1,200 @@
+# 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.0 → rootly_mcp_server-2.0.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "rootly-mcp-server"
-version = "2.0.0"
+version = "2.0.2"
 description = "A Model Context Protocol server for Rootly APIs using OpenAPI spec"
 readme = "README.md"
 requires-python = ">=3.12"
@@ -16,9 +16,9 @@ classifiers = [
     "Programming Language :: Python :: 3.12",
 ]
 dependencies = [
-    # Pinned to 2.4.0 to avoid unexpected breaking changes - to upgrade, just bump the pinned version here
+    # Pinned to 2.10.5 to avoid unexpected breaking changes - to upgrade, just bump the pinned version here
     # and run `uv sync` to update the lockfile.
-    "fastmcp==2.4.0",
+    "fastmcp==2.10.5",
     "requests>=2.28.0", # For API calls
     "httpx>=0.24.0",    # For async HTTP client
     "pydantic>=2.0.0",  # For data validation

{rootly_mcp_server-2.0.0 → rootly_mcp_server-2.0.2}/src/rootly_mcp_server/__main__.py

@@ -12,7 +12,7 @@ import sys
 from pathlib import Path
 from typing import Optional, List
 
-from rootly_mcp_server.server import create_rootly_mcp_server
+from .routemap_server import create_rootly_mcp_server
 
 
 def parse_args():

rootly_mcp_server-2.0.2/src/rootly_mcp_server/routemap_server.py

@@ -0,0 +1,206 @@
+#!/usr/bin/env python3
+"""
+Rootly FastMCP Server (RouteMap Version)
+
+Alternative implementation using FastMCP's RouteMap system for filtering
+instead of pre-filtering the OpenAPI spec.
+"""
+
+import httpx
+from fastmcp import FastMCP
+from fastmcp.server.openapi import RouteMap, MCPType
+import os
+import logging
+import sys
+from pathlib import Path
+from typing import Optional, List
+
+# Import the shared OpenAPI loader
+sys.path.append(str(Path(__file__).parent.parent.parent))
+from rootly_openapi_loader import load_rootly_openapi_spec
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+def create_rootly_mcp_server(
+    swagger_path: Optional[str] = None,
+    name: str = "Rootly API Server (RouteMap Filtered)",
+    allowed_paths: Optional[List[str]] = None,
+    hosted: bool = False,
+    base_url: Optional[str] = None,
+):
+    """Create and configure the Rootly MCP server using RouteMap filtering."""
+    
+    # Get Rootly API token from environment
+    ROOTLY_API_TOKEN = os.getenv("ROOTLY_API_TOKEN")
+    if not ROOTLY_API_TOKEN:
+        raise ValueError("ROOTLY_API_TOKEN environment variable is required")
+    
+    logger.info("Creating authenticated HTTP client...")
+    # Create authenticated HTTP client
+    client = httpx.AsyncClient(
+        base_url=base_url or "https://api.rootly.com",
+        headers={
+            "Authorization": f"Bearer {ROOTLY_API_TOKEN}",
+            "Content-Type": "application/vnd.api+json",
+            "User-Agent": "Rootly-FastMCP-Server/1.0"
+        },
+        timeout=30.0
+    )
+    
+    logger.info("Loading OpenAPI specification...")
+    # Load OpenAPI spec with smart fallback logic
+    openapi_spec = load_rootly_openapi_spec()
+    logger.info("✅ Successfully loaded OpenAPI specification")
+    
+    logger.info("Fixing OpenAPI spec for FastMCP compatibility...")
+    # Fix array types for FastMCP compatibility
+    def fix_array_types(obj):
+        if isinstance(obj, dict):
+            keys_to_process = list(obj.keys())
+            for key in keys_to_process:
+                value = obj[key]
+                if key == 'type' and isinstance(value, list):
+                    non_null_types = [t for t in value if t != 'null']
+                    if len(non_null_types) >= 1:
+                        obj[key] = non_null_types[0]
+                        obj['nullable'] = True
+                else:
+                    fix_array_types(value)
+        elif isinstance(obj, list):
+            for item in obj:
+                fix_array_types(item)
+    
+    fix_array_types(openapi_spec)
+    logger.info("✅ Fixed OpenAPI spec compatibility issues")
+    
+    logger.info("Creating FastMCP server with RouteMap filtering...")
+    
+    # Define custom route maps for filtering specific endpoints
+    route_maps = [
+        # Core incident management
+        RouteMap(
+            pattern=r"^/v1/incidents$",
+            mcp_type=MCPType.TOOL
+        ),
+        RouteMap(
+            pattern=r"^/v1/incidents/\{incident_id\}/alerts$",
+            mcp_type=MCPType.TOOL
+        ),
+        RouteMap(
+            pattern=r"^/v1/incidents/\{incident_id\}/action_items$",
+            mcp_type=MCPType.TOOL
+        ),
+        
+        # Alert management
+        RouteMap(
+            pattern=r"^/v1/alerts$",
+            mcp_type=MCPType.TOOL
+        ),
+        RouteMap(
+            pattern=r"^/v1/alerts/\{id\}$",
+            mcp_type=MCPType.TOOL
+        ),
+        
+        # Configuration entities
+        RouteMap(
+            pattern=r"^/v1/severities(\{id\})?$",
+            mcp_type=MCPType.TOOL
+        ),
+        RouteMap(
+            pattern=r"^/v1/incident_types(\{id\})?$",
+            mcp_type=MCPType.TOOL
+        ),
+        RouteMap(
+            pattern=r"^/v1/functionalities(\{id\})?$",
+            mcp_type=MCPType.TOOL
+        ),
+        
+        # Organization
+        RouteMap(
+            pattern=r"^/v1/teams(\{id\})?$",
+            mcp_type=MCPType.TOOL
+        ),
+        RouteMap(
+            pattern=r"^/v1/users(\{id\}|/me)?$",
+            mcp_type=MCPType.TOOL
+        ),
+        
+        # Infrastructure
+        RouteMap(
+            pattern=r"^/v1/services(\{id\})?$",
+            mcp_type=MCPType.TOOL
+        ),
+        RouteMap(
+            pattern=r"^/v1/environments(\{id\})?$",
+            mcp_type=MCPType.TOOL
+        ),
+        
+        # Action items
+        RouteMap(
+            pattern=r"^/v1/incident_action_items(\{id\})?$",
+            mcp_type=MCPType.TOOL
+        ),
+        
+        # Workflows
+        RouteMap(
+            pattern=r"^/v1/workflows(\{id\})?$",
+            mcp_type=MCPType.TOOL
+        ),
+        RouteMap(
+            pattern=r"^/v1/workflow_runs(\{id\})?$",
+            mcp_type=MCPType.TOOL
+        ),
+        
+        # Status pages
+        RouteMap(
+            pattern=r"^/v1/status_pages(\{id\})?$",
+            mcp_type=MCPType.TOOL
+        ),
+        
+        # Exclude everything else
+        RouteMap(
+            pattern=r".*",
+            mcp_type=MCPType.EXCLUDE
+        )
+    ]
+    
+    # Create MCP server with custom route maps
+    mcp = FastMCP.from_openapi(
+        openapi_spec=openapi_spec,
+        client=client,
+        name=name,
+        timeout=30.0,
+        tags={"rootly", "incident-management", "evaluation"},
+        route_maps=route_maps
+    )
+    
+    logger.info(f"✅ Created MCP server with RouteMap filtering successfully")
+    logger.info("🚀 Selected Rootly API endpoints are now available as MCP tools")
+    
+    return mcp
+
+
+
+
+def main():
+    """Main entry point."""
+    try:
+        logger.info("🚀 Starting Rootly FastMCP Server (RouteMap Version)...")
+        mcp = create_rootly_mcp_server()
+        
+        logger.info("🌐 Server starting on stdio transport...")
+        logger.info("Ready for MCP client connections!")
+        
+        # Run the MCP server
+        mcp.run()
+        
+    except KeyboardInterrupt:
+        logger.info("🛑 Server stopped by user")
+    except Exception as e:
+        logger.error(f"❌ Server error: {e}")
+        raise
+
+if __name__ == "__main__":
+    main()

rootly_mcp_server-2.0.0/README.md

@@ -1,169 +0,0 @@
-# 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.
-
-[![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)
-
-## 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
-
-### 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}
-```
-
-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.
-- 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 paths available, edit the variable `allowed_paths` in `src/rootly_mcp_server/server.py`.
-
-## 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)
-
-## Developer Setup & Troubleshooting
-
-### 1. Install dependencies with `uv`
-
-This project uses [`uv`](https://github.com/astral-sh/uv) for fast dependency management. To install all dependencies from your `pyproject.toml`:
-
-```bash
-uv pip install .
-```
-
-### 2. Using a virtual environment
-
-It is recommended to use a virtual environment for development:
-
-```bash
-uv venv .venv
-source .venv/bin/activate
-```
-
-### 3. Running the test client
-
-To run the test client and verify your setup:
-
-```bash
-python test_mcp_client.py
-```
-
-### 5. General tips
-
-- Always activate your virtual environment before running scripts.
-- If you add new dependencies, use `uv pip install <package>` to keep your environment up to date.
-- If you encounter issues, check your Python version and ensure it matches the project's requirements.
-
-### 6. Connecting to Our MCP Server
-
-You can configure your client to 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>"
-      }
-    }
-  }
-}
-```