rootly-mcp-server 0.0.1__py3-none-any.whl

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',
+] 

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() 

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) 

rootly_mcp_server/server.py

@@ -0,0 +1,340 @@
+"""
+Rootly MCP Server - A Model Context Protocol server for Rootly API integration.
+
+This module implements a server that dynamically generates MCP tools based on
+the Rootly API's OpenAPI (Swagger) specification.
+"""
+
+import json
+import os
+import re
+import logging
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple, Union, Callable
+
+import mcp
+from mcp.server.fastmcp import FastMCP
+from pydantic import BaseModel, Field
+
+from .client import RootlyClient
+
+# Set up logger
+logger = logging.getLogger(__name__)
+
+
+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):
+        """
+        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.
+        """
+        logger.info(f"Initializing RootlyMCPServer with name: {name}")
+        super().__init__(name)
+        
+        # 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")
+        
+        # Register tools based on the Swagger spec
+        logger.info("Registering tools based on Swagger spec")
+        self._register_tools()
+    
+    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 current directory and parent directories.
+        
+        Returns:
+            The Swagger specification as a dictionary.
+        """
+        if swagger_path:
+            # Use the provided path
+            logger.info(f"Using provided Swagger path: {swagger_path}")
+            if not os.path.isfile(swagger_path):
+                raise FileNotFoundError(f"Swagger file not found at {swagger_path}")
+            with open(swagger_path, "r") as f:
+                return json.load(f)
+        else:
+            # 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"
+                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)
+            
+            # If we get here, we didn't find the file
+            raise FileNotFoundError("Could not find swagger.json in current directory or parent directories")
+    
+    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.
+        """
+        paths = self.swagger_spec.get("paths", {})
+        logger.info(f"Found {len(paths)} paths in Swagger spec")
+        
+        # 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 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(),
+                        "summary": summary,
+                        "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():
+            # 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")
+    
+    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.
+        """
+        # Create a basic schema
+        schema = {
+            "type": "object",
+            "properties": {},
+            "required": [],
+            "additionalProperties": False
+        }
+        
+        # Extract path parameters
+        path_params = re.findall(r"\{([^}]+)\}", path)
+        for param in path_params:
+            schema["properties"][param] = {
+                "type": "string",
+                "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}")
+        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(
+                method=method.upper(),
+                path=actual_path,
+                query_params=query_params if query_params else None,
+                json_data=body_params if body_params else None
+            )
+            return response
+        except Exception as e:
+            logger.error(f"Error calling Rootly API: {e}")
+            return json.dumps({"error": str(e)}) 

rootly_mcp_server/test_client.py

@@ -0,0 +1,67 @@
+"""
+Test script for Rootly MCP Server.
+
+This script tests the default pagination for incidents endpoints.
+"""
+
+import json
+import logging
+import os
+import sys
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+
+# 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 import RootlyMCPServer
+
+def test_incidents_pagination():
+    """Test that incidents endpoints have default pagination."""
+    
+    # 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)
+        
+        # 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}")
+            
+            if pagination.get("per_page") == 5:
+                logging.info("✅ Default pagination applied successfully!")
+            else:
+                logging.warning(f"❌ Default pagination not applied. Per page: {pagination.get('per_page')}")
+        else:
+            logging.warning("❌ No pagination info found in response")
+            
+        # 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:
+        logging.error(f"Error testing pagination: {e}")
+
+if __name__ == "__main__":
+    test_incidents_pagination()