Rootly MCP server

Instructions

{
  "key": "value"
}

{
  "key": "value"
}

{
  "key": "value"
}

Implementation Reference

• src/rootly_mcp_server/server.py:337-344 (registration)

  Registers all OpenAPI-derived tools including 'createAlert' using FastMCP.from_openapi with the filtered spec containing POST /v1/alerts endpoint.

  # By default, all routes become tools which is what we want
  mcp = FastMCP.from_openapi(
      openapi_spec=filtered_spec,
      client=http_client.client,
      name=name,
      timeout=30.0,
      tags={"rootly", "incident-management"},
  )

• src/rootly_mcp_server/server.py:122-123 (registration)

  DEFAULT_ALLOWED_PATHS includes "/alerts" (line 123) which enables the POST /v1/alerts endpoint, generating the 'createAlert' tool.

  "/incidents/{incident_id}/alerts",
  "/alerts",

• src/rootly_mcp_server/server.py:175-277 (handler)

  AuthenticatedHTTPXClient provides the HTTP request handling logic used by all generated tools, including createAlert which POSTs to /v1/alerts.

  class AuthenticatedHTTPXClient:
      """An HTTPX client wrapper that handles Rootly API authentication and parameter transformation."""
  
      def __init__(self, base_url: str = "https://api.rootly.com", hosted: bool = False, parameter_mapping: Optional[Dict[str, str]] = None):
          self._base_url = base_url
          self.hosted = hosted
          self._api_token = None
          self.parameter_mapping = parameter_mapping or {}
  
          if not self.hosted:
              self._api_token = self._get_api_token()
  
          # Create the HTTPX client  
          headers = {
              "Content-Type": "application/vnd.api+json", 
              "Accept": "application/vnd.api+json"
              # Let httpx handle Accept-Encoding automatically with all supported formats
          }
          if self._api_token:
              headers["Authorization"] = f"Bearer {self._api_token}"
  
          self.client = httpx.AsyncClient(
              base_url=base_url,
              headers=headers,
              timeout=30.0,
              follow_redirects=True,
              # Ensure proper handling of compressed responses
              limits=httpx.Limits(max_keepalive_connections=5, max_connections=10)
          )
  
      def _get_api_token(self) -> Optional[str]:
          """Get the API token from environment variables."""
          api_token = os.getenv("ROOTLY_API_TOKEN")
          if not api_token:
              logger.warning("ROOTLY_API_TOKEN environment variable is not set")
              return None
          return api_token
  
      def _transform_params(self, params: Optional[Dict[str, Any]]) -> Optional[Dict[str, Any]]:
          """Transform sanitized parameter names back to original names."""
          if not params or not self.parameter_mapping:
              return params
  
          transformed = {}
          for key, value in params.items():
              # Use the original name if we have a mapping, otherwise keep the sanitized name
              original_key = self.parameter_mapping.get(key, key)
              transformed[original_key] = value
              if original_key != key:
                  logger.debug(f"Transformed parameter: '{key}' -> '{original_key}'")
          return transformed
  
      async def request(self, method: str, url: str, **kwargs):
          """Override request to transform parameters."""
          # Transform query parameters
          if 'params' in kwargs:
              kwargs['params'] = self._transform_params(kwargs['params'])
  
          # Call the underlying client's request method and let it handle everything
          return await self.client.request(method, url, **kwargs)
  
      async def get(self, url: str, **kwargs):
          """Proxy to request with GET method."""
          return await self.request('GET', url, **kwargs)
  
      async def post(self, url: str, **kwargs):
          """Proxy to request with POST method."""
          return await self.request('POST', url, **kwargs)
  
      async def put(self, url: str, **kwargs):
          """Proxy to request with PUT method."""
          return await self.request('PUT', url, **kwargs)
  
      async def patch(self, url: str, **kwargs):
          """Proxy to request with PATCH method."""
          return await self.request('PATCH', url, **kwargs)
  
      async def delete(self, url: str, **kwargs):
          """Proxy to request with DELETE method."""
          return await self.request('DELETE', url, **kwargs)
  
      async def __aenter__(self):
          return self
  
      async def __aexit__(self, exc_type, exc_val, exc_tb):
          pass
  
      def __getattr__(self, name):
          # Delegate all other attributes to the underlying client, except for request methods
          if name in ['request', 'get', 'post', 'put', 'patch', 'delete']:
              # Use our overridden methods instead
              return getattr(self, name)
          return getattr(self.client, name)
      
      @property 
      def base_url(self):
          return self._base_url
          
      @property
      def headers(self):
          return self.client.headers

• src/rootly_mcp_server/server.py:319-321 (schema)

  Calls sanitize_parameters_in_spec to process the OpenAPI spec, ensuring input schema for createAlert (and other tools) uses MCP-compliant parameter names.

  parameter_mapping = sanitize_parameters_in_spec(filtered_spec)
  logger.info(f"Sanitized parameter names for MCP compatibility (mapped {len(parameter_mapping)} parameters)")

• src/rootly_mcp_server/utils.py:45-105 (helper)

  Utility function sanitizes OpenAPI parameter names (e.g., page[size] -> page_size) for MCP compliance, used for createAlert input schema.

  def sanitize_parameters_in_spec(spec: Dict[str, Any]) -> Dict[str, str]:
      """
      Sanitize all parameter names in an OpenAPI specification.
      
      This function modifies the spec in-place and builds a mapping 
      of sanitized names to original names.
      
      Args:
          spec: OpenAPI specification dictionary
          
      Returns:
          Dictionary mapping sanitized names to original names
      """
      parameter_mapping = {}
      
      # Sanitize parameters in paths
      if "paths" in spec:
          for path, path_item in spec["paths"].items():
              if not isinstance(path_item, dict):
                  continue
                  
              # Sanitize path-level parameters
              if "parameters" in path_item:
                  for param in path_item["parameters"]:
                      if "name" in param:
                          original_name = param["name"]
                          sanitized_name = sanitize_parameter_name(original_name)
                          if sanitized_name != original_name:
                              logger.debug(f"Sanitized path-level parameter: '{original_name}' -> '{sanitized_name}'")
                              param["name"] = sanitized_name
                              parameter_mapping[sanitized_name] = original_name
              
              # Sanitize operation-level parameters
              for method, operation in path_item.items():
                  if method.lower() not in ["get", "post", "put", "delete", "patch", "options", "head", "trace"]:
                      continue
                  if not isinstance(operation, dict):
                      continue
                      
                  if "parameters" in operation:
                      for param in operation["parameters"]:
                          if "name" in param:
                              original_name = param["name"]
                              sanitized_name = sanitize_parameter_name(original_name)
                              if sanitized_name != original_name:
                                  logger.debug(f"Sanitized operation parameter: '{original_name}' -> '{sanitized_name}'")
                                  param["name"] = sanitized_name
                                  parameter_mapping[sanitized_name] = original_name
      
      # Sanitize parameters in components (OpenAPI 3.0)
      if "components" in spec and "parameters" in spec["components"]:
          for param_name, param_def in spec["components"]["parameters"].items():
              if isinstance(param_def, dict) and "name" in param_def:
                  original_name = param_def["name"]
                  sanitized_name = sanitize_parameter_name(original_name)
                  if sanitized_name != original_name:
                      logger.debug(f"Sanitized component parameter: '{original_name}' -> '{sanitized_name}'")
                      param_def["name"] = sanitized_name
                      parameter_mapping[sanitized_name] = original_name
      
      return parameter_mapping