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.

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.py
index 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 WorkspaceMonitor
from .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 Provider
job_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__.py
index 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 RhinoProvider
from .graph import SemanticGraphProvider
from .cloud import SpeckleProvider, AutodeskDataProvider
from .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.py
new file mode 100644
index 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:
+ pass
diff --git a/packages/mcp-server-revit/src/revit_mcp_server/providers/graph.py b/packages/mcp-server-revit/src/revit_mcp_server/providers/graph.py
index 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.py
index 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 Provider
self.job_manager = JobManager()
diff --git a/packages/mcp-server-revit/tests/test_exporter.py b/packages/mcp-server-revit/tests/test_exporter.py
new file mode 100644
index 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)}
+ ))