Rootly MCP server

Instructions

{
  "key": "value"
}

Implementation Reference

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

  Registers the listEnvironments tool (among others) by creating FastMCP server from filtered OpenAPI spec containing the /environments endpoint.

  # Create the MCP server using OpenAPI integration
  # 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:146-149 (registration)

  DEFAULT_ALLOWED_PATHS includes /environments endpoint, which generates the listEnvironments tool.

  # Environments
  "/environments",
  "/environments/{environment_id}",
  # Users

• src/rootly_mcp_server/server.py:227-235 (handler)

  AuthenticatedHTTPXClient.request method executes the HTTP requests for generated OpenAPI tools, including GET /v1/environments for listEnvironments.

  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)

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

  Sanitizes parameter names in the OpenAPI spec used to generate input schema for listEnvironments tool.

  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:44-105 (helper)

  Helper function that sanitizes parameter names in OpenAPI spec to MCP-compliant format, affecting input schema for listEnvironments.

  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