Open-source Revit MCP server: let Claude and other AI assistants read and edit BIM models, with human approval on every change.
Python aecai-agentsautodeskautomationbimclaudeifcmcpmcp-servermodel-context-protocolnavisworksrevitrevit-addinrevit-apirhino
feat: implement SQLiteExporterProvider for local database exports and graph mapping
A. Sam Mohammad030e2ab66f41
diff --git a/packages/mcp-server-revit/src/revit_mcp_server/mcp_server.py b/packages/mcp-server-revit/src/revit_mcp_server/mcp_server.pyindex 6714a00..c71ee3d 100644--- a/packages/mcp-server-revit/src/revit_mcp_server/mcp_server.py+++ b/packages/mcp-server-revit/src/revit_mcp_server/mcp_server.py@@ -24,6 +24,7 @@ from .providers import (SpeckleProvider,AutodeskDataProvider,JobProvider,+ SQLiteExporterProvider,)from .security.workspace import WorkspaceMonitorfrom .security.audit import redact_data@@ -42,6 +43,7 @@ registry = ProviderRegistry()registry.register(RevitProvider(workspace=workspace))registry.register(IfcProvider(workspace=workspace))registry.register(AECMapperProvider(workspace=workspace))+registry.register(SQLiteExporterProvider(workspace=workspace, registry=registry))# Initialize Job Manager and Job Providerjob_manager = JobManager()diff --git a/packages/mcp-server-revit/src/revit_mcp_server/providers/__init__.py b/packages/mcp-server-revit/src/revit_mcp_server/providers/__init__.pyindex 9c040b7..04699f7 100644--- a/packages/mcp-server-revit/src/revit_mcp_server/providers/__init__.py+++ b/packages/mcp-server-revit/src/revit_mcp_server/providers/__init__.py@@ -8,6 +8,7 @@ from .rhino import RhinoProviderfrom .graph import SemanticGraphProviderfrom .cloud import SpeckleProvider, AutodeskDataProviderfrom .job_provider import JobProvider+from .exporter import SQLiteExporterProvider__all__ = ["AECProvider",@@ -22,4 +23,5 @@ __all__ = ["SpeckleProvider","AutodeskDataProvider","JobProvider",+ "SQLiteExporterProvider",]diff --git a/packages/mcp-server-revit/src/revit_mcp_server/providers/exporter.py b/packages/mcp-server-revit/src/revit_mcp_server/providers/exporter.pynew file mode 100644index 0000000..ceecda5--- /dev/null+++ b/packages/mcp-server-revit/src/revit_mcp_server/providers/exporter.py@@ -0,0 +1,279 @@+from __future__ import annotations++import json+import logging+import sqlite3+from pathlib import Path+from typing import Any, Dict, List++from ..errors import WorkspaceViolation+from ..security.workspace import WorkspaceMonitor+from .base import AECProvider, ProviderTool+from .registry import ProviderRegistry++logger = logging.getLogger(__name__)+++class SQLiteExporterProvider(AECProvider):+ def __init__(self, workspace: WorkspaceMonitor, registry: ProviderRegistry) -> None:+ self.workspace = workspace+ self.registry = registry+ self._init_capabilities()++ def get_identity(self) -> str:+ return "exporter"++ def get_capabilities(self) -> List[ProviderTool]:+ return self._capabilities++ async def check_health(self) -> Dict[str, Any]:+ return {"status": "healthy", "provider": "exporter"}++ async def execute_tool(self, name: str, arguments: Dict[str, Any]) -> Dict[str, Any]:+ normalized = name.replace(".", "_")+ if normalized == "exporter_db_health":+ return await self.check_health()+ elif normalized == "exporter_to_sqlite":+ return self._export_to_sqlite(arguments)+ elif normalized == "exporter_graph_to_sqlite":+ return self._export_graph_to_sqlite(arguments)+ raise ValueError(f"Unknown exporter tool '{name}'")++ def _init_capabilities(self) -> None:+ self._capabilities = [+ ProviderTool(+ name="exporter_db_health",+ description="Check health and readiness of the local database exporter.",+ inputSchema={"type": "object", "properties": {}},+ ),+ ProviderTool(+ name="exporter_to_sqlite",+ description="Export a structured payload of BIM elements, parameters, and relationships to a local SQLite database in the workspace.",+ inputSchema={+ "type": "object",+ "properties": {+ "db_path": {+ "type": "string",+ "description": "Workspace-relative or absolute path to the output .db file.",+ },+ "elements": {+ "type": "array",+ "description": "List of elements and their parameters.",+ "items": {+ "type": "object",+ "properties": {+ "id": {"type": "string", "description": "The unique identifier (GUID / element ID) of the element."},+ "name": {"type": "string", "description": "Human-readable name of the element."},+ "category": {"type": "string", "description": "The category classification (e.g. Walls, Windows)."},+ "type_name": {"type": "string", "description": "The type or family name of the element."},+ "parameters": {+ "type": "object",+ "description": "Flat dictionary of parameter name/value attributes.",+ },+ },+ "required": ["id"],+ },+ },+ "relations": {+ "type": "array",+ "description": "Optional relationships between elements.",+ "items": {+ "type": "object",+ "properties": {+ "source_id": {"type": "string", "description": "Source element identifier."},+ "target_id": {"type": "string", "description": "Target element identifier."},+ "relation_type": {"type": "string", "description": "Type of relation (e.g. SUPPORTED_BY)."},+ "attributes": {+ "type": "object",+ "description": "Optional attributes associated with the relationship.",+ },+ },+ "required": ["source_id", "target_id", "relation_type"],+ },+ },+ },+ "required": ["db_path", "elements"],+ "additionalProperties": False,+ },+ ),+ ProviderTool(+ name="exporter_graph_to_sqlite",+ description="Extract the active semantic network graph and dump its nodes, properties, and typed edges to a local SQLite database in the workspace.",+ inputSchema={+ "type": "object",+ "properties": {+ "db_path": {+ "type": "string",+ "description": "Workspace-relative or absolute path to the output .db file.",+ }+ },+ "required": ["db_path"],+ "additionalProperties": False,+ },+ ),+ ]++ def _export_to_sqlite(self, arguments: Dict[str, Any]) -> Dict[str, Any]:+ db_path_str = arguments["db_path"]+ elements = arguments["elements"]+ relations = arguments.get("relations", [])++ try:+ db_file = self.workspace.assert_in_workspace(Path(db_path_str))+ except WorkspaceViolation as exc:+ raise ValueError("Database path is outside the allowed workspace.") from exc++ return self._write_database(db_file, elements, relations)++ def _export_graph_to_sqlite(self, arguments: Dict[str, Any]) -> Dict[str, Any]:+ db_path_str = arguments["db_path"]++ try:+ db_file = self.workspace.assert_in_workspace(Path(db_path_str))+ except WorkspaceViolation as exc:+ raise ValueError("Database path is outside the allowed workspace.") from exc++ graph_provider = self.registry.get_provider("graph")+ if not graph_provider:+ raise ValueError("SemanticGraphProvider is not registered on the server.")++ g = getattr(graph_provider, "graph", None)+ if g is None:+ raise ValueError("Could not access graph on SemanticGraphProvider.")++ elements: List[Dict[str, Any]] = []+ relations: List[Dict[str, Any]] = []++ for node_id, data in g.nodes(data=True):+ el = {+ "id": str(node_id),+ "name": str(data.get("name", node_id)),+ "category": str(data.get("type", "unknown")),+ "placeholder": bool(data.get("placeholder", False)),+ "parameters": {+ k: v for k, v in data.items() if k not in {"name", "type", "placeholder"}+ }+ }+ elements.append(el)++ for u, v, key, data in g.edges(keys=True, data=True):+ rel = {+ "source_id": str(u),+ "target_id": str(v),+ "relation_type": str(data.get("relation", "CONNECTED_TO")),+ "attributes": {+ k: v for k, v in data.items() if k != "relation"+ }+ }+ relations.append(rel)++ return self._write_database(db_file, elements, relations)++ def _write_database(+ self,+ db_file: Path,+ elements: List[Dict[str, Any]],+ relations: List[Dict[str, Any]]+ ) -> Dict[str, Any]:+ db_file.parent.mkdir(parents=True, exist_ok=True)++ conn = sqlite3.connect(str(db_file))+ cursor = conn.cursor()++ try:+ cursor.execute("""+ CREATE TABLE IF NOT EXISTS elements (+ id TEXT PRIMARY KEY,+ name TEXT,+ category TEXT,+ type_name TEXT,+ placeholder INTEGER DEFAULT 0+ )+ """)++ cursor.execute("""+ CREATE TABLE IF NOT EXISTS parameters (+ id INTEGER PRIMARY KEY AUTOINCREMENT,+ element_id TEXT,+ name TEXT,+ value TEXT,+ value_type TEXT,+ FOREIGN KEY(element_id) REFERENCES elements(id)+ )+ """)++ cursor.execute("""+ CREATE TABLE IF NOT EXISTS relations (+ id INTEGER PRIMARY KEY AUTOINCREMENT,+ source_id TEXT,+ target_id TEXT,+ relation_type TEXT,+ attributes_json TEXT,+ FOREIGN KEY(source_id) REFERENCES elements(id),+ FOREIGN KEY(target_id) REFERENCES elements(id)+ )+ """)++ cursor.execute("DELETE FROM relations")+ cursor.execute("DELETE FROM parameters")+ cursor.execute("DELETE FROM elements")++ element_count = 0+ parameter_count = 0+ relation_count = 0++ for el in elements:+ el_id = str(el["id"])+ name = el.get("name")+ category = el.get("category")+ type_name = el.get("type_name")+ placeholder = 1 if el.get("placeholder") else 0++ cursor.execute(+ "INSERT INTO elements (id, name, category, type_name, placeholder) VALUES (?, ?, ?, ?, ?)",+ (el_id, name, category, type_name, placeholder)+ )+ element_count += 1++ params = el.get("parameters", {})+ if isinstance(params, dict):+ for k, v in params.items():+ val_str = str(v) if v is not None else ""+ val_type = type(v).__name__ if v is not None else "NoneType"+ cursor.execute(+ "INSERT INTO parameters (element_id, name, value, value_type) VALUES (?, ?, ?, ?)",+ (el_id, k, val_str, val_type)+ )+ parameter_count += 1++ for rel in relations:+ src = str(rel["source_id"])+ tgt = str(rel["target_id"])+ rel_type = str(rel["relation_type"])+ attrs = rel.get("attributes", {})+ attrs_str = json.dumps(attrs) if attrs else None++ cursor.execute(+ "INSERT INTO relations (source_id, target_id, relation_type, attributes_json) VALUES (?, ?, ?, ?)",+ (src, tgt, rel_type, attrs_str)+ )+ relation_count += 1++ conn.commit()+ return {+ "status": "success",+ "db_path": str(db_file),+ "exported": {+ "elements": element_count,+ "parameters": parameter_count,+ "relations": relation_count,+ }+ }+ except Exception as e:+ conn.rollback()+ raise e+ finally:+ conn.close()++ async def shutdown(self) -> None:+ passdiff --git a/packages/mcp-server-revit/src/revit_mcp_server/providers/graph.py b/packages/mcp-server-revit/src/revit_mcp_server/providers/graph.pyindex 8a258cd..737de5c 100644--- a/packages/mcp-server-revit/src/revit_mcp_server/providers/graph.py+++ b/packages/mcp-server-revit/src/revit_mcp_server/providers/graph.py@@ -26,6 +26,11 @@ class SemanticGraphProvider(AECProvider):self._graph = nx.MultiDiGraph()self._init_capabilities()+ @property+ def graph(self) -> nx.MultiDiGraph:+ """Access the underlying NetworkX MultiDiGraph instance."""+ return self._graph+def get_identity(self) -> str:return "graph"diff --git a/packages/mcp-server-revit/src/revit_mcp_server/server.py b/packages/mcp-server-revit/src/revit_mcp_server/server.pyindex 7cb9382..cb91af0 100644--- a/packages/mcp-server-revit/src/revit_mcp_server/server.py+++ b/packages/mcp-server-revit/src/revit_mcp_server/server.py@@ -21,6 +21,7 @@ from .providers import (SpeckleProvider,AutodeskDataProvider,JobProvider,+ SQLiteExporterProvider,)from .jobs import JobManager@@ -66,6 +67,7 @@ class MCPServer:self.registry.register(self.revit_provider)self.registry.register(IfcProvider(workspace=self.workspace))self.registry.register(AECMapperProvider(workspace=self.workspace))+ self.registry.register(SQLiteExporterProvider(workspace=self.workspace, registry=self.registry))# Register Job Providerself.job_manager = JobManager()diff --git a/packages/mcp-server-revit/tests/test_exporter.py b/packages/mcp-server-revit/tests/test_exporter.pynew file mode 100644index 0000000..15cedaa--- /dev/null+++ b/packages/mcp-server-revit/tests/test_exporter.py@@ -0,0 +1,211 @@+from __future__ import annotations++import sqlite3+import json+import sys+from pathlib import Path++import pytest++sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src"))++from revit_mcp_server.providers.exporter import SQLiteExporterProvider+from revit_mcp_server.providers.graph import SemanticGraphProvider+from revit_mcp_server.providers.registry import ProviderRegistry+from revit_mcp_server.security.workspace import WorkspaceMonitor+++def test_exporter_health(tmp_path: Path):+ workspace = WorkspaceMonitor([tmp_path])+ registry = ProviderRegistry()+ provider = SQLiteExporterProvider(workspace=workspace, registry=registry)++ # Run sync health check+ import asyncio+ health = asyncio.run(provider.check_health())+ assert health["status"] == "healthy"+ assert health["provider"] == "exporter"+++def test_exporter_to_sqlite(tmp_path: Path):+ workspace = WorkspaceMonitor([tmp_path])+ registry = ProviderRegistry()+ provider = SQLiteExporterProvider(workspace=workspace, registry=registry)++ db_file = tmp_path / "model.db"++ elements = [+ {+ "id": "wall-1",+ "name": "Generic Wall 1",+ "category": "Walls",+ "type_name": "Wall-Type-A",+ "parameters": {+ "Unconnected Height": 3000,+ "Structural": True,+ "Comments": "Audit ready"+ }+ },+ {+ "id": "door-1",+ "name": "Timber Door",+ "category": "Doors",+ "type_name": "Door-Type-B",+ "parameters": {+ "Width": 900,+ "Height": 2100+ }+ }+ ]++ relations = [+ {+ "source_id": "door-1",+ "target_id": "wall-1",+ "relation_type": "CONTAINED_IN",+ "attributes": {"offset": 120}+ }+ ]++ import asyncio+ res = asyncio.run(provider.execute_tool(+ "exporter_to_sqlite",+ {+ "db_path": str(db_file),+ "elements": elements,+ "relations": relations+ }+ ))++ assert res["status"] == "success"+ assert Path(res["db_path"]).exists()++ # Query database and assert correctness+ conn = sqlite3.connect(res["db_path"])+ cursor = conn.cursor()++ # Check elements table+ cursor.execute("SELECT id, name, category, type_name, placeholder FROM elements ORDER BY id")+ rows = cursor.fetchall()+ assert len(rows) == 2+ assert rows[0] == ("door-1", "Timber Door", "Doors", "Door-Type-B", 0)+ assert rows[1] == ("wall-1", "Generic Wall 1", "Walls", "Wall-Type-A", 0)++ # Check parameters table+ cursor.execute("SELECT element_id, name, value, value_type FROM parameters ORDER BY element_id, name")+ param_rows = cursor.fetchall()+ assert len(param_rows) == 5+ assert param_rows[0] == ("door-1", "Height", "2100", "int")+ assert param_rows[4] == ("wall-1", "Unconnected Height", "3000", "int")++ # Check relations table+ cursor.execute("SELECT source_id, target_id, relation_type, attributes_json FROM relations")+ rel_rows = cursor.fetchall()+ assert len(rel_rows) == 1+ assert rel_rows[0][0] == "door-1"+ assert rel_rows[0][1] == "wall-1"+ assert rel_rows[0][2] == "CONTAINED_IN"+ assert json.loads(rel_rows[0][3]) == {"offset": 120}++ conn.close()+++def test_exporter_graph_to_sqlite(tmp_path: Path):+ workspace = WorkspaceMonitor([tmp_path])+ registry = ProviderRegistry()++ # Register semantic graph provider and compile a graph+ graph_provider = SemanticGraphProvider()+ registry.register(graph_provider)++ nodes = [+ {+ "id": "column-1",+ "type": "Columns",+ "attributes": {"load_bearing": True, "requires_support": False}+ },+ {+ "id": "beam-1",+ "type": "Structural Framing",+ "attributes": {"load_bearing": True, "requires_support": True}+ }+ ]+ edges = [+ {+ "source": "beam-1",+ "target": "column-1",+ "type": "SUPPORTED_BY",+ "attributes": {"span": 6000.0}+ }+ ]++ import asyncio+ compile_res = asyncio.run(graph_provider.execute_tool(+ "graph_compile",+ {"nodes": nodes, "edges": edges, "allow_dangling_edges": False}+ ))+ assert compile_res["status"] == "success"++ # Register exporter provider+ exporter_provider = SQLiteExporterProvider(workspace=workspace, registry=registry)+ registry.register(exporter_provider)++ db_file = tmp_path / "graph_export.db"+ res = asyncio.run(exporter_provider.execute_tool(+ "exporter_graph_to_sqlite",+ {"db_path": str(db_file)}+ ))+ assert res["status"] == "success"++ # Query database and verify schema contents+ conn = sqlite3.connect(res["db_path"])+ cursor = conn.cursor()++ cursor.execute("SELECT id, category, placeholder FROM elements ORDER BY id")+ elements = cursor.fetchall()+ assert len(elements) == 2+ assert elements[0] == ("beam-1", "Structural Framing", 0)+ assert elements[1] == ("column-1", "Columns", 0)++ cursor.execute("SELECT element_id, name, value FROM parameters ORDER BY element_id, name")+ params = cursor.fetchall()+ assert len(params) == 4+ assert params[0] == ("beam-1", "load_bearing", "True")+ assert params[1] == ("beam-1", "requires_support", "True")+ assert params[2] == ("column-1", "load_bearing", "True")+ assert params[3] == ("column-1", "requires_support", "False")++ cursor.execute("SELECT source_id, target_id, relation_type, attributes_json FROM relations")+ relations = cursor.fetchall()+ assert len(relations) == 1+ assert relations[0][0] == "beam-1"+ assert relations[0][1] == "column-1"+ assert relations[0][2] == "SUPPORTED_BY"+ assert json.loads(relations[0][3]) == {"span": 6000.0}++ conn.close()+++def test_exporter_workspace_bounds(tmp_path: Path):+ workspace = WorkspaceMonitor([tmp_path])+ registry = ProviderRegistry()+ provider = SQLiteExporterProvider(workspace=workspace, registry=registry)++ # Outside allowed directory+ bad_db_path = tmp_path.parent / "unsafe.db"++ import asyncio+ with pytest.raises(ValueError, match="Database path is outside"):+ asyncio.run(provider.execute_tool(+ "exporter_to_sqlite",+ {+ "db_path": str(bad_db_path),+ "elements": []+ }+ ))++ with pytest.raises(ValueError, match="Database path is outside"):+ asyncio.run(provider.execute_tool(+ "exporter_graph_to_sqlite",+ {"db_path": str(bad_db_path)}+ ))