init

Author: christomitov

.gitignore

@@ -172,3 +172,5 @@ cython_debug/
 
 # PyPI configuration file
 .pypirc
+
+.cursor

README.md

@@ -0,0 +1,81 @@
+# Rootly MCP Server
+
+A Model Context Protocol (MCP) server for Rootly API. This server dynamically generates MCP resources based on Rootly's OpenAPI (Swagger) specification.
+
+## Features
+
+- Dynamically generated MCP tools based on Rootly's OpenAPI specification
+- Authentication via Rootly API token
+- Default pagination (10 items) for incidents endpoints to prevent context window overflow
+- Easy integration with Claude and other MCP-compatible LLMs
+
+## Prerequisites
+
+- Python 3.12 or higher
+- `uv` package manager
+  ```bash
+  # Install UV if you haven't already
+  curl -LsSf https://astral.sh/uv/install.sh | sh
+  ```
+- Rootly API token
+
+## Setup
+
+1. Create and activate a virtual environment:
+```bash
+# Create a new virtual environment
+uv venv
+
+# Activate the virtual environment
+# On macOS/Linux:
+source .venv/bin/activate
+# On Windows:
+.venv\Scripts\activate
+```
+
+2. Install the package in development mode:
+```bash
+# Install all dependencies
+uv pip install -e .
+
+# Install dev dependencies (optional)
+uv pip install -e ".[dev]"
+```
+
+3. Set your Rootly API token:
+```bash
+export ROOTLY_API_TOKEN="your-api-token-here"
+```
+
+## Running the Server
+
+Start the server:
+```bash
+rootly-mcp
+```
+
+## MCP Configuration
+
+The server configuration is defined in `mcp.json`. To use this server with Claude or other MCP clients, add the following configuration to your MCP configuration file:
+
+```json
+{
+    "mcpServers": {
+      "rootly": {
+        "command": "uv",
+        "args": [
+          "run",
+          "--directory",
+          "/path/to/rootly-mcp-server",
+          "rootly-mcp"
+        ],
+        "env": {
+          "ROOTLY_API_TOKEN": "YOUR_ROOTLY_API_TOKEN"
+        }
+      }
+    }
+  }
+```
+
+Replace `/path/to/rootly-mcp-server` with the absolute path to your project directory.
+

pyproject.toml

@@ -0,0 +1,53 @@
+[project]
+name = "rootly-mcp-server"
+version = "0.1.0"
+description = "A Model Context Protocol server for Rootly APIs using OpenAPI spec"
+readme = "README.md"
+requires-python = ">=3.12"
+authors = [{ name = "Anthropic, PBC." }]
+keywords = ["rootly", "mcp", "llm", "automation", "incidents"]
+license = { text = "MIT" }
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+]
+dependencies = [
+    "mcp>=1.1.2",           # MCP Python SDK
+    "requests>=2.28.0",     # For API calls
+    "pydantic>=2.0.0",      # For data validation
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/rootly_mcp_server"]
+
+[tool.hatch.metadata]
+allow-direct-references = true
+
+[project.scripts]
+rootly-mcp = "rootly_mcp_server.__main__:main"
+
+[project.optional-dependencies]
+dev = [
+    "black>=23.0.0",
+    "isort>=5.0.0",
+]
+
+[tool.uv]
+dev-dependencies = [
+    "pyright>=1.1.389",
+    "ruff>=0.7.3",
+    "pytest>=8.0.0"
+]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = "test_*.py"
+python_classes = "Test*"
+python_functions = "test_*" 

src/rootly_mcp_server/__init__.py

@@ -0,0 +1,20 @@
+"""
+Rootly MCP Server - A Model Context Protocol server for Rootly API integration.
+
+This package provides a Model Context Protocol (MCP) server for Rootly API integration.
+It dynamically generates MCP tools based on the Rootly API's OpenAPI (Swagger) specification.
+
+Features:
+- Automatic tool generation from Swagger spec
+- Authentication via ROOTLY_API_TOKEN environment variable
+- Default pagination (10 items) for incidents endpoints to prevent context window overflow
+"""
+
+from .server import RootlyMCPServer
+from .client import RootlyClient
+
+__version__ = "0.1.0"
+__all__ = [
+    'RootlyMCPServer',
+    'RootlyClient',
+] 

src/rootly_mcp_server/__main__.py

@@ -0,0 +1,123 @@
+"""
+Command-line interface for starting the Rootly MCP server.
+"""
+
+import argparse
+import logging
+import os
+import sys
+from pathlib import Path
+
+from .server import RootlyMCPServer
+
+
+def parse_args():
+    """Parse command-line arguments."""
+    parser = argparse.ArgumentParser(
+        description="Start the Rootly MCP server for API integration."
+    )
+    parser.add_argument(
+        "--swagger-path",
+        type=str,
+        help="Path to the Swagger JSON file. If not provided, will look for swagger.json in the current directory and parent directories.",
+    )
+    parser.add_argument(
+        "--log-level",
+        type=str,
+        choices=["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"],
+        default="INFO",
+        help="Set the logging level. Default: INFO",
+    )
+    parser.add_argument(
+        "--name",
+        type=str,
+        default="Rootly",
+        help="Name of the MCP server. Default: Rootly",
+    )
+    parser.add_argument(
+        "--transport",
+        type=str,
+        choices=["stdio", "sse"],
+        default="stdio",
+        help="Transport protocol to use. Default: stdio",
+    )
+    parser.add_argument(
+        "--debug",
+        action="store_true",
+        help="Enable debug mode (equivalent to --log-level DEBUG)",
+    )
+    return parser.parse_args()
+
+
+def setup_logging(log_level, debug=False):
+    """Set up logging configuration."""
+    if debug or os.getenv("DEBUG", "").lower() in ("true", "1", "yes"):
+        log_level = "DEBUG"
+    
+    numeric_level = getattr(logging, log_level.upper(), None)
+    if not isinstance(numeric_level, int):
+        raise ValueError(f"Invalid log level: {log_level}")
+    
+    # Configure root logger
+    logging.basicConfig(
+        level=numeric_level,
+        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+        handlers=[logging.StreamHandler(sys.stderr)],  # Log to stderr for stdio transport
+    )
+    
+    # Set specific logger levels
+    logging.getLogger("rootly_mcp_server").setLevel(numeric_level)
+    logging.getLogger("mcp").setLevel(numeric_level)
+    
+    # Log the configuration
+    logger = logging.getLogger(__name__)
+    logger.info(f"Logging configured with level: {log_level}")
+    logger.debug(f"Python version: {sys.version}")
+    logger.debug(f"Current directory: {Path.cwd()}")
+    logger.debug(f"Environment variables: {', '.join([f'{k}={v[:3]}...' if k.endswith('TOKEN') else f'{k}={v}' for k, v in os.environ.items() if k.startswith('ROOTLY_') or k in ['DEBUG']])}")
+
+
+def check_api_token():
+    """Check if the Rootly API token is set."""
+    logger = logging.getLogger(__name__)
+    
+    api_token = os.environ.get("ROOTLY_API_TOKEN")
+    if not api_token:
+        logger.error("ROOTLY_API_TOKEN environment variable is not set.")
+        print("Error: ROOTLY_API_TOKEN environment variable is not set.", file=sys.stderr)
+        print("Please set it with: export ROOTLY_API_TOKEN='your-api-token-here'", file=sys.stderr)
+        sys.exit(1)
+    else:
+        logger.info("ROOTLY_API_TOKEN is set")
+        # Log the first few characters of the token for debugging
+        logger.debug(f"Token starts with: {api_token[:5]}...")
+
+
+def main():
+    """Entry point for the Rootly MCP server."""
+    args = parse_args()
+    setup_logging(args.log_level, args.debug)
+    
+    logger = logging.getLogger(__name__)
+    logger.info("Starting Rootly MCP Server")
+    
+    check_api_token()
+    
+    try:
+        logger.info(f"Initializing server with name: {args.name}")
+        server = RootlyMCPServer(swagger_path=args.swagger_path, name=args.name)
+        
+        logger.info(f"Running server with transport: {args.transport}...")
+        server.run(transport=args.transport)
+    except FileNotFoundError as e:
+        logger.error(f"File not found: {e}")
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+    except Exception as e:
+        logger.error(f"Failed to start server: {e}", exc_info=True)
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main() 

src/rootly_mcp_server/client.py

@@ -0,0 +1,102 @@
+"""
+Rootly API client for making authenticated requests to the Rootly API.
+"""
+
+import os
+import json
+import logging
+import requests
+from typing import Optional, Dict, Any, Union
+
+# Set up logger
+logger = logging.getLogger(__name__)
+
+class RootlyClient:
+    def __init__(self, base_url: Optional[str] = None):
+        self.base_url = base_url or "https://api.rootly.com"
+        self._api_token = self._get_api_token()
+        logger.debug(f"Initialized RootlyClient with base_url: {self.base_url}")
+
+    def _get_api_token(self) -> str:
+        """Get the API token from environment variables."""
+        api_token = os.getenv("ROOTLY_API_TOKEN")
+        if not api_token:
+            raise ValueError("ROOTLY_API_TOKEN environment variable is not set")
+        return api_token
+
+    def make_request(self, method: str, path: str, query_params: Optional[Dict[str, Any]] = None, json_data: Optional[Dict[str, Any]] = None) -> str:
+        """
+        Make an authenticated request to the Rootly API.
+        
+        Args:
+            method: The HTTP method to use.
+            path: The API path.
+            query_params: Query parameters for the request.
+            json_data: JSON data for the request body.
+            
+        Returns:
+            The API response as a JSON string.
+        """
+        headers = {
+            "Authorization": f"Bearer {self._api_token}",
+            "Content-Type": "application/json",
+            "Accept": "application/json"
+        }
+        
+        # Ensure path starts with a slash
+        if not path.startswith("/"):
+            path = f"/{path}"
+            
+        # Ensure path starts with /v1 if not already
+        if not path.startswith("/v1"):
+            path = f"/v1{path}"
+            
+        url = f"{self.base_url}{path}"
+        
+        logger.debug(f"Making {method} request to {url}")
+        logger.debug(f"Headers: {headers}")
+        logger.debug(f"Query params: {query_params}")
+        logger.debug(f"JSON data: {json_data}")
+        
+        try:
+            response = requests.request(
+                method=method.upper(),
+                url=url,
+                headers=headers,
+                params=query_params,
+                json=json_data,
+                timeout=30  # Add a timeout to prevent hanging
+            )
+            
+            # Log the response status and headers
+            logger.debug(f"Response status: {response.status_code}")
+            logger.debug(f"Response headers: {response.headers}")
+            
+            # Try to parse the response as JSON
+            try:
+                response_json = response.json()
+                logger.debug(f"Response parsed as JSON: {json.dumps(response_json)[:200]}...")
+                response.raise_for_status()
+                return json.dumps(response_json, indent=2)
+            except ValueError:
+                # If the response is not JSON, return the text
+                logger.debug(f"Response is not JSON: {response.text[:200]}...")
+                response.raise_for_status()
+                return json.dumps({"text": response.text}, indent=2)
+                
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Request failed: {e}")
+            error_response = {"error": str(e)}
+            
+            # Add response details if available
+            if hasattr(e, 'response') and e.response is not None:
+                try:
+                    error_response["status_code"] = e.response.status_code
+                    error_response["response_text"] = e.response.text
+                except:
+                    pass
+                
+            return json.dumps(error_response, indent=2)
+        except Exception as e:
+            logger.error(f"Unexpected error: {e}")
+            return json.dumps({"error": f"Unexpected error: {str(e)}"}, indent=2)