Skip to content

Open-source Revit MCP server: let Claude and other AI assistants read and edit BIM models, with human approval on every change.

Scaffold 4, Task 4.1: Implement MEP connectivity checker

sammohammad578e0e755f19d3d
diff --git a/packages/model-checker/src/model_checker/mep.py b/packages/model-checker/src/model_checker/mep.py
new file mode 100644
index 0000000..22a2efa
--- /dev/null
+++ b/packages/model-checker/src/model_checker/mep.py
@@ -0,0 +1,273 @@
+"""MEP (Mechanical, Electrical, Plumbing) systems validation."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass
+class MEPConnectivityIssue:
+ """Issue found during MEP connectivity validation."""
+
+ element_id: str | int
+ element_type: str
+ issue_type: str
+ description: str
+ system_name: str | None = None
+ location: dict[str, float] | None = None
+
+
+class MEPConnectivityValidator:
+ """Validator for MEP system connectivity."""
+
+ def __init__(self) -> None:
+ """Initialize MEP connectivity validator."""
+ self.issues: list[MEPConnectivityIssue] = []
+
+ def validate_duct_connections(
+ self, ducts: list[dict[str, Any]], systems: list[dict[str, Any]]
+ ) -> list[MEPConnectivityIssue]:
+ """Validate duct connections and system membership.
+
+ Args:
+ ducts: List of duct dictionaries with 'id', 'start_connector', 'end_connector', 'system_id'
+ systems: List of MEP system dictionaries with 'id', 'name', 'type'
+
+ Returns:
+ List of connectivity issues
+ """
+ issues = []
+ system_map = {sys["id"]: sys for sys in systems}
+
+ for duct in ducts:
+ # Check if duct belongs to a system
+ if not duct.get("system_id"):
+ issue = MEPConnectivityIssue(
+ element_id=duct["id"],
+ element_type="duct",
+ issue_type="no_system",
+ description="Duct is not part of any MEP system",
+ )
+ issues.append(issue)
+ self.issues.append(issue)
+ continue
+
+ # Check if system exists
+ if duct["system_id"] not in system_map:
+ issue = MEPConnectivityIssue(
+ element_id=duct["id"],
+ element_type="duct",
+ issue_type="invalid_system",
+ description=f"Duct references invalid system ID: {duct['system_id']}",
+ )
+ issues.append(issue)
+ self.issues.append(issue)
+ continue
+
+ # Check connectors
+ if not duct.get("start_connector") or not duct["start_connector"].get("connected"):
+ issue = MEPConnectivityIssue(
+ element_id=duct["id"],
+ element_type="duct",
+ issue_type="disconnected_start",
+ description="Duct start connector is not connected",
+ system_name=system_map[duct["system_id"]]["name"],
+ )
+ issues.append(issue)
+ self.issues.append(issue)
+
+ if not duct.get("end_connector") or not duct["end_connector"].get("connected"):
+ issue = MEPConnectivityIssue(
+ element_id=duct["id"],
+ element_type="duct",
+ issue_type="disconnected_end",
+ description="Duct end connector is not connected",
+ system_name=system_map[duct["system_id"]]["name"],
+ )
+ issues.append(issue)
+ self.issues.append(issue)
+
+ return issues
+
+ def validate_pipe_connections(
+ self, pipes: list[dict[str, Any]], systems: list[dict[str, Any]]
+ ) -> list[MEPConnectivityIssue]:
+ """Validate pipe connections and system membership.
+
+ Args:
+ pipes: List of pipe dictionaries with 'id', 'connectors', 'system_id'
+ systems: List of MEP system dictionaries
+
+ Returns:
+ List of connectivity issues
+ """
+ issues = []
+ system_map = {sys["id"]: sys for sys in systems}
+
+ for pipe in pipes:
+ # Check system membership
+ if not pipe.get("system_id"):
+ issue = MEPConnectivityIssue(
+ element_id=pipe["id"],
+ element_type="pipe",
+ issue_type="no_system",
+ description="Pipe is not part of any MEP system",
+ )
+ issues.append(issue)
+ self.issues.append(issue)
+ continue
+
+ if pipe["system_id"] not in system_map:
+ issue = MEPConnectivityIssue(
+ element_id=pipe["id"],
+ element_type="pipe",
+ issue_type="invalid_system",
+ description=f"Pipe references invalid system ID: {pipe['system_id']}",
+ )
+ issues.append(issue)
+ self.issues.append(issue)
+ continue
+
+ # Check connectors
+ connectors = pipe.get("connectors", [])
+ disconnected = [c for c in connectors if not c.get("connected")]
+
+ if len(disconnected) > 1:
+ issue = MEPConnectivityIssue(
+ element_id=pipe["id"],
+ element_type="pipe",
+ issue_type="multiple_disconnected",
+ description=f"Pipe has {len(disconnected)} disconnected connectors",
+ system_name=system_map[pipe["system_id"]]["name"],
+ )
+ issues.append(issue)
+ self.issues.append(issue)
+
+ return issues
+
+ def validate_system_equipment(
+ self, equipment: list[dict[str, Any]], systems: list[dict[str, Any]]
+ ) -> list[MEPConnectivityIssue]:
+ """Validate MEP equipment connections to systems.
+
+ Args:
+ equipment: List of equipment dictionaries (air terminals, fixtures, etc.)
+ systems: List of MEP systems
+
+ Returns:
+ List of connectivity issues
+ """
+ issues = []
+ system_map = {sys["id"]: sys for sys in systems}
+
+ for equip in equipment:
+ # Equipment must belong to a system
+ if not equip.get("system_id"):
+ issue = MEPConnectivityIssue(
+ element_id=equip["id"],
+ element_type=equip.get("type", "equipment"),
+ issue_type="no_system",
+ description=f"{equip.get('type', 'Equipment')} is not connected to any system",
+ )
+ issues.append(issue)
+ self.issues.append(issue)
+ continue
+
+ # Verify system exists
+ if equip["system_id"] not in system_map:
+ issue = MEPConnectivityIssue(
+ element_id=equip["id"],
+ element_type=equip.get("type", "equipment"),
+ issue_type="invalid_system",
+ description=f"{equip.get('type', 'Equipment')} references invalid system",
+ )
+ issues.append(issue)
+ self.issues.append(issue)
+
+ return issues
+
+ def find_isolated_elements(
+ self, elements: list[dict[str, Any]]
+ ) -> list[MEPConnectivityIssue]:
+ """Find MEP elements that are isolated (no connections).
+
+ Args:
+ elements: List of MEP element dictionaries with 'id', 'type', 'connectors'
+
+ Returns:
+ List of isolated element issues
+ """
+ issues = []
+
+ for element in elements:
+ connectors = element.get("connectors", [])
+
+ if not connectors:
+ # Element has no connectors at all
+ issue = MEPConnectivityIssue(
+ element_id=element["id"],
+ element_type=element.get("type", "element"),
+ issue_type="no_connectors",
+ description=f"{element.get('type', 'Element')} has no connectors",
+ )
+ issues.append(issue)
+ self.issues.append(issue)
+ continue
+
+ # Check if all connectors are disconnected
+ all_disconnected = all(not c.get("connected") for c in connectors)
+
+ if all_disconnected:
+ issue = MEPConnectivityIssue(
+ element_id=element["id"],
+ element_type=element.get("type", "element"),
+ issue_type="isolated",
+ description=f"{element.get('type', 'Element')} has no connections (isolated)",
+ )
+ issues.append(issue)
+ self.issues.append(issue)
+
+ return issues
+
+ def get_issues(self) -> list[MEPConnectivityIssue]:
+ """Get all MEP connectivity issues.
+
+ Returns:
+ List of all issues
+ """
+ return self.issues
+
+ def get_issues_by_type(self, issue_type: str) -> list[MEPConnectivityIssue]:
+ """Get issues of a specific type.
+
+ Args:
+ issue_type: Type of issue to filter by
+
+ Returns:
+ List of issues of that type
+ """
+ return [issue for issue in self.issues if issue.issue_type == issue_type]
+
+ def get_issues_by_system(self, system_name: str) -> list[MEPConnectivityIssue]:
+ """Get issues for a specific system.
+
+ Args:
+ system_name: Name of the system
+
+ Returns:
+ List of issues for that system
+ """
+ return [issue for issue in self.issues if issue.system_name == system_name]
+
+ def clear_issues(self) -> None:
+ """Clear all recorded issues."""
+ self.issues = []
+
+ def get_issue_count(self) -> int:
+ """Get total number of issues.
+
+ Returns:
+ Count of issues
+ """
+ return len(self.issues)
diff --git a/packages/model-checker/tests/test_mep.py b/packages/model-checker/tests/test_mep.py
new file mode 100644
index 0000000..fdadd24
--- /dev/null
+++ b/packages/model-checker/tests/test_mep.py
@@ -0,0 +1,426 @@
+"""Test MEP connectivity validation."""
+
+import pytest
+
+from model_checker.mep import MEPConnectivityIssue, MEPConnectivityValidator
+
+
+def test_create_mep_validator():
+ """Test creating MEP connectivity validator."""
+ validator = MEPConnectivityValidator()
+ assert len(validator.issues) == 0
+
+
+def test_validate_duct_connections_valid():
+ """Test validating properly connected ducts."""
+ validator = MEPConnectivityValidator()
+
+ systems = [{"id": "sys_1", "name": "Supply Air", "type": "duct"}]
+
+ ducts = [
+ {
+ "id": "duct_1",
+ "system_id": "sys_1",
+ "start_connector": {"connected": True},
+ "end_connector": {"connected": True},
+ },
+ {
+ "id": "duct_2",
+ "system_id": "sys_1",
+ "start_connector": {"connected": True},
+ "end_connector": {"connected": True},
+ },
+ ]
+
+ issues = validator.validate_duct_connections(ducts, systems)
+ assert len(issues) == 0
+
+
+def test_validate_duct_no_system():
+ """Test detecting ducts not in any system."""
+ validator = MEPConnectivityValidator()
+
+ systems = []
+ ducts = [
+ {
+ "id": "duct_1",
+ "start_connector": {"connected": True},
+ "end_connector": {"connected": True},
+ }
+ ]
+
+ issues = validator.validate_duct_connections(ducts, systems)
+ assert len(issues) == 1
+ assert issues[0].issue_type == "no_system"
+
+
+def test_validate_duct_invalid_system():
+ """Test detecting ducts with invalid system references."""
+ validator = MEPConnectivityValidator()
+
+ systems = [{"id": "sys_1", "name": "Supply Air", "type": "duct"}]
+
+ ducts = [
+ {
+ "id": "duct_1",
+ "system_id": "sys_999", # Invalid system ID
+ "start_connector": {"connected": True},
+ "end_connector": {"connected": True},
+ }
+ ]
+
+ issues = validator.validate_duct_connections(ducts, systems)
+ assert len(issues) == 1
+ assert issues[0].issue_type == "invalid_system"
+
+
+def test_validate_duct_disconnected_start():
+ """Test detecting ducts with disconnected start connector."""
+ validator = MEPConnectivityValidator()
+
+ systems = [{"id": "sys_1", "name": "Supply Air", "type": "duct"}]
+
+ ducts = [
+ {
+ "id": "duct_1",
+ "system_id": "sys_1",
+ "start_connector": {"connected": False},
+ "end_connector": {"connected": True},
+ }
+ ]
+
+ issues = validator.validate_duct_connections(ducts, systems)
+ assert len(issues) == 1
+ assert issues[0].issue_type == "disconnected_start"
+ assert issues[0].system_name == "Supply Air"
+
+
+def test_validate_duct_disconnected_end():
+ """Test detecting ducts with disconnected end connector."""
+ validator = MEPConnectivityValidator()
+
+ systems = [{"id": "sys_1", "name": "Return Air", "type": "duct"}]
+
+ ducts = [
+ {
+ "id": "duct_1",
+ "system_id": "sys_1",
+ "start_connector": {"connected": True},
+ "end_connector": {"connected": False},
+ }
+ ]
+
+ issues = validator.validate_duct_connections(ducts, systems)
+ assert len(issues) == 1
+ assert issues[0].issue_type == "disconnected_end"
+
+
+def test_validate_duct_both_disconnected():
+ """Test detecting ducts with both connectors disconnected."""
+ validator = MEPConnectivityValidator()
+
+ systems = [{"id": "sys_1", "name": "Supply Air", "type": "duct"}]
+
+ ducts = [
+ {
+ "id": "duct_1",
+ "system_id": "sys_1",
+ "start_connector": {"connected": False},
+ "end_connector": {"connected": False},
+ }
+ ]
+
+ issues = validator.validate_duct_connections(ducts, systems)
+ assert len(issues) == 2 # Both start and end issues
+
+
+def test_validate_pipe_connections_valid():
+ """Test validating properly connected pipes."""
+ validator = MEPConnectivityValidator()
+
+ systems = [{"id": "sys_1", "name": "Domestic Cold Water", "type": "pipe"}]
+
+ pipes = [
+ {
+ "id": "pipe_1",
+ "system_id": "sys_1",
+ "connectors": [{"connected": True}, {"connected": True}],
+ }
+ ]
+
+ issues = validator.validate_pipe_connections(pipes, systems)
+ assert len(issues) == 0
+
+
+def test_validate_pipe_no_system():
+ """Test detecting pipes not in any system."""
+ validator = MEPConnectivityValidator()
+
+ systems = []
+ pipes = [{"id": "pipe_1", "connectors": [{"connected": True}, {"connected": True}]}]
+
+ issues = validator.validate_pipe_connections(pipes, systems)
+ assert len(issues) == 1
+ assert issues[0].issue_type == "no_system"
+
+
+def test_validate_pipe_multiple_disconnected():
+ """Test detecting pipes with multiple disconnected connectors."""
+ validator = MEPConnectivityValidator()
+
+ systems = [{"id": "sys_1", "name": "Hot Water", "type": "pipe"}]
+
+ pipes = [
+ {
+ "id": "pipe_1",
+ "system_id": "sys_1",
+ "connectors": [{"connected": False}, {"connected": False}],
+ }
+ ]
+
+ issues = validator.validate_pipe_connections(pipes, systems)
+ assert len(issues) == 1
+ assert issues[0].issue_type == "multiple_disconnected"
+
+
+def test_validate_system_equipment_valid():
+ """Test validating properly connected equipment."""
+ validator = MEPConnectivityValidator()
+
+ systems = [{"id": "sys_1", "name": "Supply Air", "type": "duct"}]
+
+ equipment = [
+ {"id": "at_1", "type": "air_terminal", "system_id": "sys_1"},
+ {"id": "at_2", "type": "air_terminal", "system_id": "sys_1"},
+ ]
+
+ issues = validator.validate_system_equipment(equipment, systems)
+ assert len(issues) == 0
+
+
+def test_validate_equipment_no_system():
+ """Test detecting equipment not connected to any system."""
+ validator = MEPConnectivityValidator()
+
+ systems = [{"id": "sys_1", "name": "Supply Air", "type": "duct"}]
+
+ equipment = [{"id": "at_1", "type": "air_terminal"}] # No system_id
+
+ issues = validator.validate_system_equipment(equipment, systems)
+ assert len(issues) == 1
+ assert issues[0].issue_type == "no_system"
+
+
+def test_validate_equipment_invalid_system():
+ """Test detecting equipment with invalid system reference."""
+ validator = MEPConnectivityValidator()
+
+ systems = [{"id": "sys_1", "name": "Supply Air", "type": "duct"}]
+
+ equipment = [{"id": "at_1", "type": "air_terminal", "system_id": "sys_999"}]
+
+ issues = validator.validate_system_equipment(equipment, systems)
+ assert len(issues) == 1
+ assert issues[0].issue_type == "invalid_system"
+
+
+def test_find_isolated_elements():
+ """Test finding isolated MEP elements."""
+ validator = MEPConnectivityValidator()
+
+ elements = [
+ {
+ "id": "elem_1",
+ "type": "duct",
+ "connectors": [{"connected": False}, {"connected": False}],
+ },
+ {
+ "id": "elem_2",
+ "type": "pipe",
+ "connectors": [{"connected": True}, {"connected": True}],
+ },
+ ]
+
+ issues = validator.find_isolated_elements(elements)
+ assert len(issues) == 1
+ assert issues[0].element_id == "elem_1"
+ assert issues[0].issue_type == "isolated"
+
+
+def test_find_elements_no_connectors():
+ """Test finding elements with no connectors."""
+ validator = MEPConnectivityValidator()
+
+ elements = [
+ {"id": "elem_1", "type": "duct", "connectors": []},
+ {"id": "elem_2", "type": "pipe"}, # No connectors field
+ ]
+
+ issues = validator.find_isolated_elements(elements)
+ assert len(issues) == 2
+ assert all(issue.issue_type == "no_connectors" for issue in issues)
+
+
+def test_get_issues():
+ """Test getting all issues."""
+ validator = MEPConnectivityValidator()
+
+ systems = [{"id": "sys_1", "name": "Supply", "type": "duct"}]
+ ducts = [{"id": "duct_1"}] # No system_id
+
+ validator.validate_duct_connections(ducts, systems)
+ issues = validator.get_issues()
+
+ assert len(issues) == 1
+
+
+def test_get_issues_by_type():
+ """Test filtering issues by type."""
+ validator = MEPConnectivityValidator()
+
+ systems = [{"id": "sys_1", "name": "Supply", "type": "duct"}]
+
+ ducts = [
+ {"id": "duct_1"}, # No system
+ {
+ "id": "duct_2",
+ "system_id": "sys_1",
+ "start_connector": {"connected": False},
+ "end_connector": {"connected": True},
+ }, # Disconnected start
+ ]
+
+ validator.validate_duct_connections(ducts, systems)
+
+ no_system_issues = validator.get_issues_by_type("no_system")
+ disconnected_issues = validator.get_issues_by_type("disconnected_start")
+
+ assert len(no_system_issues) == 1
+ assert len(disconnected_issues) == 1
+
+
+def test_get_issues_by_system():
+ """Test filtering issues by system name."""
+ validator = MEPConnectivityValidator()
+
+ systems = [
+ {"id": "sys_1", "name": "Supply Air", "type": "duct"},
+ {"id": "sys_2", "name": "Return Air", "type": "duct"},
+ ]
+
+ ducts = [
+ {
+ "id": "duct_1",
+ "system_id": "sys_1",
+ "start_connector": {"connected": False},
+ "end_connector": {"connected": True},
+ },
+ {
+ "id": "duct_2",
+ "system_id": "sys_2",
+ "start_connector": {"connected": False},
+ "end_connector": {"connected": True},
+ },
+ ]
+
+ validator.validate_duct_connections(ducts, systems)
+
+ supply_issues = validator.get_issues_by_system("Supply Air")
+ return_issues = validator.get_issues_by_system("Return Air")
+
+ assert len(supply_issues) == 1
+ assert len(return_issues) == 1
+
+
+def test_clear_issues():
+ """Test clearing issues."""
+ validator = MEPConnectivityValidator()
+
+ systems = []
+ ducts = [{"id": "duct_1"}]
+
+ validator.validate_duct_connections(ducts, systems)
+ assert len(validator.issues) > 0
+
+ validator.clear_issues()
+ assert len(validator.issues) == 0
+
+
+def test_get_issue_count():
+ """Test getting issue count."""
+ validator = MEPConnectivityValidator()
+
+ systems = [{"id": "sys_1", "name": "Supply", "type": "duct"}]
+ ducts = [
+ {"id": "duct_1"},
+ {"id": "duct_2"},
+ {"id": "duct_3"},
+ ]
+
+ validator.validate_duct_connections(ducts, systems)
+ assert validator.get_issue_count() == 3
+
+
+def test_complete_mep_workflow():
+ """Test complete MEP connectivity validation workflow."""
+ validator = MEPConnectivityValidator()
+
+ # Define MEP systems
+ systems = [
+ {"id": "hvac_supply", "name": "Supply Air System", "type": "duct"},
+ {"id": "hvac_return", "name": "Return Air System", "type": "duct"},
+ {"id": "dhw", "name": "Domestic Hot Water", "type": "pipe"},
+ ]
+
+ # Define ducts
+ ducts = [
+ {
+ "id": "duct_1",
+ "system_id": "hvac_supply",
+ "start_connector": {"connected": True},
+ "end_connector": {"connected": True},
+ },
+ {
+ "id": "duct_2",
+ "system_id": "hvac_supply",
+ "start_connector": {"connected": False}, # Issue
+ "end_connector": {"connected": True},
+ },
+ {"id": "duct_3"}, # No system - Issue
+ ]
+
+ # Define pipes
+ pipes = [
+ {
+ "id": "pipe_1",
+ "system_id": "dhw",
+ "connectors": [{"connected": True}, {"connected": True}],
+ },
+ {
+ "id": "pipe_2",
+ "system_id": "dhw",
+ "connectors": [{"connected": False}, {"connected": False}], # Issue
+ },
+ ]
+
+ # Define equipment
+ equipment = [
+ {"id": "at_1", "type": "air_terminal", "system_id": "hvac_supply"},
+ {"id": "at_2", "type": "air_terminal"}, # No system - Issue
+ {"id": "fix_1", "type": "fixture", "system_id": "dhw"},
+ ]
+
+ # Run validations
+ validator.validate_duct_connections(ducts, systems)
+ validator.validate_pipe_connections(pipes, systems)
+ validator.validate_system_equipment(equipment, systems)
+
+ # Check results
+ total_issues = validator.get_issue_count()
+ assert total_issues == 4 # 2 duct + 1 pipe + 1 equipment
+
+ supply_issues = validator.get_issues_by_system("Supply Air System")
+ assert len(supply_issues) == 1 # duct_2 disconnected start
+
+ no_system_issues = validator.get_issues_by_type("no_system")
+ assert len(no_system_issues) == 2 # duct_3 and at_2