IDS MCP Server

Instructions

Implementation Reference

• src/ids_mcp_server/tools/restrictions.py:90-153 (handler)

  The core handler function for the 'add_enumeration_restriction' tool. It retrieves a specification, locates the target facet, creates an enumeration Restriction using the IfcTester IDS library, applies it to the specified parameter, and returns success details.

  async def add_enumeration_restriction(
      spec_id: str,
      facet_index: int,
      parameter_name: str,
      base_type: str,
      values: List[str],
      ctx: Context,
      location: str = "requirements"
  ) -> Dict[str, Any]:
      """
      Add enumeration restriction (list of allowed values).
  
      Args:
          spec_id: Specification identifier or name
          facet_index: Index of facet in location (0-based)
          parameter_name: Which parameter to restrict (e.g., "value", "propertySet")
          base_type: XSD base type (e.g., "xs:string", "xs:integer")
          values: List of allowed values
          ctx: FastMCP Context (auto-injected)
          location: "applicability" or "requirements" (default: "requirements")
  
      Returns:
          {"status": "added", "restriction_type": "enumeration", "spec_id": "S1"}
  
      Example:
          Add enumeration to property value: FireRating must be "REI30", "REI60", or "REI90"
      """
      try:
          ids_obj = await get_or_create_session(ctx)
          spec = _find_specification(ids_obj, spec_id)
  
          await ctx.info(f"Adding enumeration restriction to {spec_id}, facet {facet_index}")
  
          # Get the facet
          facet = _get_facet_from_spec(spec, location, facet_index)
  
          # Create enumeration restriction using IfcTester
          # Normalize base type (remove 'xs:' prefix if present)
          normalized_base = _normalize_base_type(base_type)
          restriction = ids.Restriction(
              base=normalized_base,
              options={"enumeration": values}
          )
  
          # Apply restriction to the parameter
          _apply_restriction_to_facet(facet, parameter_name, restriction)
  
          await ctx.info(f"Enumeration restriction added with {len(values)} values")
  
          return {
              "status": "added",
              "restriction_type": "enumeration",
              "spec_id": spec_id,
              "facet_index": facet_index,
              "parameter": parameter_name,
              "value_count": len(values)
          }
  
      except ToolError:
          raise
      except Exception as e:
          await ctx.error(f"Failed to add enumeration restriction: {str(e)}")
          raise ToolError(f"Failed to add enumeration restriction: {str(e)}")

• src/ids_mcp_server/server.py:45-45 (registration)

  Registers the 'add_enumeration_restriction' tool function with the FastMCP server instance.

  mcp_server.tool(restrictions.add_enumeration_restriction)

• src/ids_mcp_server/tools/restrictions.py:64-88 (helper)

  Helper function that applies the Restriction object to the specified parameter on the facet object.

  def _apply_restriction_to_facet(
      facet: Any,
      parameter_name: str,
      restriction: ids.Restriction
  ) -> None:
      """
      Apply restriction to a facet parameter.
  
      Args:
          facet: Facet object (Entity, Property, Attribute, etc.)
          parameter_name: Parameter to restrict (e.g., "value", "propertySet", "baseName")
          restriction: Restriction object to apply
  
      Raises:
          ToolError: If parameter doesn't exist on facet
      """
      # Check if parameter exists
      if not hasattr(facet, parameter_name):
          raise ToolError(
              f"Parameter '{parameter_name}' not found on facet type {type(facet).__name__}"
          )
  
      # Set the restriction on the parameter
      setattr(facet, parameter_name, restriction)

• src/ids_mcp_server/tools/restrictions.py:29-62 (helper)

  Helper function to retrieve a specific facet from the specification's applicability or requirements list.

  def _get_facet_from_spec(
      spec: ids.Specification,
      location: str,
      facet_index: int
  ) -> Any:
      """
      Get facet from specification by location and index.
  
      Args:
          spec: Specification object
          location: "applicability" or "requirements"
          facet_index: Index of facet in location (0-based)
  
      Returns:
          Facet object
  
      Raises:
          ToolError: If location invalid or index out of range
      """
      if location == "applicability":
          facets = spec.applicability
      elif location == "requirements":
          facets = spec.requirements
      else:
          raise ToolError(f"Invalid location: {location}. Must be 'applicability' or 'requirements'")
  
      if facet_index < 0 or facet_index >= len(facets):
          raise ToolError(
              f"Facet index {facet_index} out of range. "
              f"Location '{location}' has {len(facets)} facet(s)"
          )
  
      return facets[facet_index]

• src/ids_mcp_server/tools/restrictions.py:12-26 (helper)

  Helper function to normalize the base_type by removing 'xs:' prefix if present, as required by IfcTester.

  def _normalize_base_type(base_type: str) -> str:
      """
      Normalize XML Schema base type for IfcTester.
  
      IfcTester adds 'xs:' prefix automatically, so we need to remove it if present.
  
      Args:
          base_type: Base type (e.g., "xs:string" or "string")
  
      Returns:
          Normalized base type without 'xs:' prefix (e.g., "string")
      """
      if base_type.startswith("xs:"):
          return base_type[3:]  # Remove 'xs:' prefix
      return base_type