IDS MCP Server

Instructions

Implementation Reference

• src/ids_mcp_server/tools/restrictions.py:302-377 (handler)

  The primary handler function implementing the 'add_length_restriction' tool. It adds length restrictions (exact, min, max) to a specified parameter on a facet in an IDS specification using IfcTester's Restriction API.

  async def add_length_restriction(
      spec_id: str,
      facet_index: int,
      parameter_name: str,
      base_type: str,
      ctx: Context,
      location: str = "requirements",
      length: Optional[int] = None,
      min_length: Optional[int] = None,
      max_length: Optional[int] = None
  ) -> Dict[str, Any]:
      """
      Add string length 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:string")
          ctx: FastMCP Context (auto-injected)
          location: "applicability" or "requirements" (default: "requirements")
          length: Exact length
          min_length: Minimum length
          max_length: Maximum length
  
      Returns:
          {"status": "added", "restriction_type": "length", "spec_id": "S1"}
  
      Example:
          Add length restriction to attribute value: Tag must be between 5 and 50 characters
      """
      try:
          ids_obj = await get_or_create_session(ctx)
          spec = _find_specification(ids_obj, spec_id)
  
          await ctx.info(f"Adding length restriction to {spec_id}, facet {facet_index}")
  
          # Get the facet
          facet = _get_facet_from_spec(spec, location, facet_index)
  
          # Build length parameters
          length_params = {}
          if length is not None:
              length_params["length"] = length
          if min_length is not None:
              length_params["minLength"] = min_length
          if max_length is not None:
              length_params["maxLength"] = max_length
  
          # Create length 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=length_params
          )
  
          # Apply restriction to the parameter
          _apply_restriction_to_facet(facet, parameter_name, restriction)
  
          await ctx.info(f"Length restriction added: {length_params}")
  
          return {
              "status": "added",
              "restriction_type": "length",
              "spec_id": spec_id,
              "facet_index": facet_index,
              "parameter": parameter_name,
              "constraints": length_params
          }
  
      except ToolError:
          raise
      except Exception as e:
          await ctx.error(f"Failed to add length restriction: {str(e)}")
          raise ToolError(f"Failed to add length restriction: {str(e)}")

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

  Tool registration in the FastMCP server using mcp_server.tool().

  mcp_server.tool(restrictions.add_length_restriction)

• src/ids_mcp_server/tools/restrictions.py:64-89 (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 based on location ('applicability' or 'requirements') and index.

  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 the '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