IDS MCP Server

Instructions

Implementation Reference

• src/ids_mcp_server/tools/restrictions.py:220-299 (handler)

  Implements the core logic for adding numeric bounds restrictions (min/max inclusive/exclusive) to a specified parameter in an IDS facet using IfcTester's Restriction API.

  async def add_bounds_restriction(
      spec_id: str,
      facet_index: int,
      parameter_name: str,
      base_type: str,
      ctx: Context,
      location: str = "requirements",
      min_inclusive: Optional[float] = None,
      max_inclusive: Optional[float] = None,
      min_exclusive: Optional[float] = None,
      max_exclusive: Optional[float] = None
  ) -> Dict[str, Any]:
      """
      Add numeric bounds restriction.
  
      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")
          base_type: XSD base type (e.g., "xs:double", "xs:integer")
          ctx: FastMCP Context (auto-injected)
          location: "applicability" or "requirements" (default: "requirements")
          min_inclusive: Minimum value (inclusive)
          max_inclusive: Maximum value (inclusive)
          min_exclusive: Minimum value (exclusive)
          max_exclusive: Maximum value (exclusive)
  
      Returns:
          {"status": "added", "restriction_type": "bounds", "spec_id": "S1"}
  
      Example:
          Add bounds to property value: Height must be between 2.4 and 3.0 meters
      """
      try:
          ids_obj = await get_or_create_session(ctx)
          spec = _find_specification(ids_obj, spec_id)
  
          await ctx.info(f"Adding bounds restriction to {spec_id}, facet {facet_index}")
  
          # Get the facet
          facet = _get_facet_from_spec(spec, location, facet_index)
  
          # Build bounds parameters
          bounds_params = {}
          if min_inclusive is not None:
              bounds_params["minInclusive"] = min_inclusive
          if max_inclusive is not None:
              bounds_params["maxInclusive"] = max_inclusive
          if min_exclusive is not None:
              bounds_params["minExclusive"] = min_exclusive
          if max_exclusive is not None:
              bounds_params["maxExclusive"] = max_exclusive
  
          # Create bounds 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=bounds_params
          )
  
          # Apply restriction to the parameter
          _apply_restriction_to_facet(facet, parameter_name, restriction)
  
          await ctx.info(f"Bounds restriction added: {bounds_params}")
  
          return {
              "status": "added",
              "restriction_type": "bounds",
              "spec_id": spec_id,
              "facet_index": facet_index,
              "parameter": parameter_name,
              "bounds": bounds_params
          }
  
      except ToolError:
          raise
      except Exception as e:
          await ctx.error(f"Failed to add bounds restriction: {str(e)}")
          raise ToolError(f"Failed to add bounds restriction: {str(e)}")

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

  Registers the add_bounds_restriction tool function with the FastMCP server instance.

  mcp_server.tool(restrictions.add_bounds_restriction)

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

  Helper function that applies a Restriction object to a specific parameter on a facet object, used by add_bounds_restriction and other restriction tools.

  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 an IDS specification by location ('applicability' or 'requirements') and index, used by all restriction tools.

  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 XSD base types by removing 'xs:' prefix, used when creating Restriction objects.

  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