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(hub): add local HTTP shim so the dockable panel can reach real MCP tools

A. Sam Mohammad8baebb55cf27
diff --git a/packages/mcp-server-revit/pyproject.toml b/packages/mcp-server-revit/pyproject.toml
index 3402163..6b2af4c 100644
--- a/packages/mcp-server-revit/pyproject.toml
+++ b/packages/mcp-server-revit/pyproject.toml
@@ -24,6 +24,7 @@ dependencies = [
[project.scripts]
aec-model-bridge = "revit_mcp_server.mcp_server:run_mcp_server"
revit-mcp-server = "revit_mcp_server.mcp_server:run_mcp_server"
+aec-model-bridge-panel-server = "revit_mcp_server.panel_server:run_panel_server"
[project.optional-dependencies]
dev = [
diff --git a/packages/mcp-server-revit/src/revit_mcp_server/__init__.py b/packages/mcp-server-revit/src/revit_mcp_server/__init__.py
index 32064bc..80b90a5 100644
--- a/packages/mcp-server-revit/src/revit_mcp_server/__init__.py
+++ b/packages/mcp-server-revit/src/revit_mcp_server/__init__.py
@@ -1,5 +1,16 @@
"""AEC Model Bridge server entrypoint."""
-from .mcp_server import run_mcp_server as run_server
-
__all__ = ["run_server"]
+
+
+def __getattr__(name: str):
+ # Lazy: importing this package (or any submodule, e.g. panel_server) must not
+ # have the side effect of building mcp_server's stdio-server registry — that
+ # registry does real work at construction (Speckle/APS OAuth setup, a Rhino
+ # bridge health probe, ModuleRegistry filesystem discovery), and paying for it
+ # on every import regardless of whether the stdio server is even wanted was a
+ # real, measurable cost once a second entry point (panel_server.py) existed.
+ if name == "run_server":
+ from .mcp_server import run_mcp_server
+ return run_mcp_server
+ raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
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 4fe5818..afe5f09 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
@@ -6,122 +6,21 @@ from __future__ import annotations
import asyncio
import json
import logging
-import os
from typing import Any
from mcp.server import Server
from mcp.server.stdio import stdio_server
from mcp.types import Tool, TextContent
-from .config import config
from .errors import BridgeError
-from .providers import (
- ProviderRegistry,
- RevitProvider,
- IfcProvider,
- AECMapperProvider,
- RhinoProvider,
- SemanticGraphProvider,
- SpeckleProvider,
- AutodeskDataProvider,
- JobProvider,
- SQLiteExporterProvider,
- McpProxyProvider,
- NavisworksProvider,
- ApprovalProvider,
- ModuleProvider,
- SemanticProvider,
-)
-from .module_registry import ModuleRegistry
-from .security.workspace import WorkspaceMonitor
+from .registry_factory import build_registry
from .security.audit import redact_data
-from .jobs import JobManager
logger = logging.getLogger(__name__)
# Initialize the MCP server
app = Server("aec-model-bridge")
-
-def build_registry() -> tuple[ProviderRegistry, ApprovalProvider, JobManager, ModuleRegistry, WorkspaceMonitor]:
- """Construct one fully-wired ProviderRegistry with every provider registered.
-
- Factored out so the stdio MCP server (below) and the panel's local HTTP shim
- (panel_server.py) build an identical registry without duplicating this ~60
- lines of provider wiring. Each caller gets its own independent instance —
- that's fine, since ApprovalGate persists plans to disk under the shared
- workspace directory, so plans created via one process are still visible to
- the other.
- """
- workspace = WorkspaceMonitor(config.allowed_directories)
-
- registry = ProviderRegistry()
- approval_provider = ApprovalProvider(workspace=workspace, registry=registry)
- registry.register(approval_provider)
- registry.register(RevitProvider(workspace=workspace))
- registry.register(IfcProvider(workspace=workspace))
- registry.register(AECMapperProvider(workspace=workspace))
- registry.register(SQLiteExporterProvider(workspace=workspace, registry=registry))
- registry.register(NavisworksProvider(workspace=workspace))
- registry.register(SemanticProvider(workspace=workspace, registry=registry))
-
- # Initialize and register Module registry and Module provider
- module_registry = ModuleRegistry(config_obj=config)
- module_registry.discover_and_load()
- registry.register(ModuleProvider(module_registry=module_registry, workspace=workspace, tool_registry=registry))
-
- # Initialize Job Manager and Job Provider
- job_manager = JobManager()
- registry.register(JobProvider(manager=job_manager))
-
- # Rhino Provider
- try:
- registry.register(RhinoProvider(workspace=workspace))
- except Exception as e:
- logger.warning("Could not initialize RhinoProvider: %s", e)
-
- # Semantic Graph Provider
- try:
- registry.register(SemanticGraphProvider())
- except Exception as e:
- logger.warning("Could not initialize SemanticGraphProvider: %s", e)
-
- # Speckle Provider
- try:
- registry.register(SpeckleProvider())
- except Exception as e:
- logger.warning("Could not initialize SpeckleProvider: %s. Please set SPECKLE_CLIENT_ID.", e)
-
- # Autodesk Data Provider
- try:
- registry.register(AutodeskDataProvider())
- except Exception as e:
- logger.warning("Could not initialize AutodeskDataProvider: %s. Please set APS_CLIENT_ID.", e)
-
- # Mcp Proxy Providers
- proxy_targets = os.getenv("MCP_PROXY_TARGETS")
- if proxy_targets:
- for target in proxy_targets.split(","):
- target = target.strip()
- if not target:
- continue
- if "=" in target:
- name, url = target.split("=", 1)
- name = name.strip()
- url = url.strip()
- identity = f"proxy_{name}"
- else:
- url = target
- identity = "proxy"
-
- try:
- registry.register(McpProxyProvider(target_url=url, identity=identity))
- except Exception as e:
- logger.warning("Could not initialize McpProxyProvider for %s: %s", target, e)
-
- return registry, approval_provider, job_manager, module_registry, workspace
-
-
# Build the registry used by the stdio MCP server below.
registry, approval_provider, job_manager, module_registry, workspace = build_registry()
diff --git a/packages/mcp-server-revit/src/revit_mcp_server/panel_server.py b/packages/mcp-server-revit/src/revit_mcp_server/panel_server.py
new file mode 100644
index 0000000..e046ad6
--- /dev/null
+++ b/packages/mcp-server-revit/src/revit_mcp_server/panel_server.py
@@ -0,0 +1,136 @@
+"""Loopback-only HTTP shim for the Revit dockable panel (WebView2 JS).
+
+The MCP hub (mcp_server.py) speaks stdio to AI clients (Claude Desktop/Code) —
+a browser page in WebView2 cannot launch or speak to a stdio subprocess. Per
+docs/product/PLUGIN_APP_ARCHITECTURE.md §2 ("panel UI is HTML/JS talking to
+the add-in over the WebView2 message bridge, and to the hub via localhost"),
+this module runs the *same* provider registry as the stdio server behind a
+minimal local-only HTTP server, so the C# add-in can forward panel button
+clicks to real MCP tools.
+
+This is not a general-purpose remote API: it binds 127.0.0.1 only, mirroring
+every other switch in this product (Revit/Rhino/Navisworks bridges), and
+exists purely so a WebView2 page in the same machine's Revit process can
+reach the hub.
+"""
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import os
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from typing import Any, Dict
+
+from .errors import RevitMCPError
+from .registry_factory import build_registry
+from .security.audit import redact_data
+
+logger = logging.getLogger(__name__)
+
+DEFAULT_PORT = 8787
+
+
+def _run_tool_sync(registry, approval_provider, name: str, arguments: Dict[str, Any]) -> Dict[str, Any]:
+ """Execute one tool call to completion in a fresh event loop.
+
+ Mirrors the approval-gate check and post-execution plan-state transition
+ that mcp_server.py's call_tool() applies, so a tool called through the
+ panel is gated identically to one called through MCP.
+ """
+ async def _run() -> Dict[str, Any]:
+ provider = registry.lookup_tool_provider(name)
+ if not provider:
+ raise ValueError(f"Unknown tool '{name}'")
+
+ tool_def = registry.lookup_tool(name)
+ if tool_def and tool_def.is_mutating:
+ approval_provider.gate.check_tool_execution(name, arguments)
+
+ result = await provider.execute_tool(name, arguments)
+
+ if tool_def and tool_def.is_mutating and isinstance(arguments, dict) and "plan_id" in arguments:
+ try:
+ approval_provider.gate.update_plan_state(arguments["plan_id"], "executed")
+ except Exception:
+ pass
+
+ return result
+
+ return asyncio.run(_run())
+
+
+class PanelRequestHandler(BaseHTTPRequestHandler):
+ registry = None
+ approval_provider = None
+
+ def log_message(self, format: str, *args: Any) -> None: # noqa: A002
+ logger.debug("panel_server: " + format, *args)
+
+ def _send_json(self, status: int, payload: Dict[str, Any]) -> None:
+ body = json.dumps(payload).encode("utf-8")
+ self.send_response(status)
+ self.send_header("Content-Type", "application/json")
+ self.send_header("Content-Length", str(len(body)))
+ self.end_headers()
+ self.wfile.write(body)
+
+ def do_GET(self) -> None: # noqa: N802
+ if self.path == "/health":
+ self._send_json(200, {"status": "healthy", "tools": len(self.registry.get_all_tools())})
+ return
+ self._send_json(404, {"ok": False, "error": f"Unknown path '{self.path}'"})
+
+ def do_POST(self) -> None: # noqa: N802
+ if self.path != "/execute":
+ self._send_json(404, {"ok": False, "error": f"Unknown path '{self.path}'"})
+ return
+
+ length = int(self.headers.get("Content-Length", "0") or "0")
+ raw = self.rfile.read(length) if length else b"{}"
+ try:
+ body = json.loads(raw or b"{}")
+ except json.JSONDecodeError:
+ self._send_json(400, {"ok": False, "error": "Request body must be valid JSON"})
+ return
+
+ tool = body.get("tool")
+ arguments = body.get("arguments", {})
+ if not tool or not isinstance(tool, str):
+ self._send_json(400, {"ok": False, "error": "Request body must include a string 'tool' field"})
+ return
+
+ try:
+ result = _run_tool_sync(self.registry, self.approval_provider, tool, arguments)
+ self._send_json(200, {"ok": True, "result": redact_data(result)})
+ except RevitMCPError as e:
+ self._send_json(409, {"ok": False, "error": redact_data(str(e))})
+ except Exception as e:
+ self._send_json(500, {"ok": False, "error": redact_data(str(e))})
+
+
+def build_server(port: int | None = None) -> ThreadingHTTPServer:
+ registry, approval_provider, _job_manager, _module_registry, _workspace = build_registry()
+
+ handler = type("BoundPanelRequestHandler", (PanelRequestHandler,), {
+ "registry": registry,
+ "approval_provider": approval_provider,
+ })
+
+ resolved_port = port if port is not None else int(os.getenv("MCP_PANEL_HTTP_PORT", str(DEFAULT_PORT)))
+ server = ThreadingHTTPServer(("127.0.0.1", resolved_port), handler)
+ return server
+
+
+def run_panel_server() -> None:
+ """Entry point for running the panel HTTP shim as a standalone process."""
+ server = build_server()
+ logger.info("Panel HTTP shim listening on http://127.0.0.1:%d", server.server_address[1])
+ try:
+ server.serve_forever()
+ finally:
+ server.shutdown()
+
+
+if __name__ == "__main__":
+ run_panel_server()
diff --git a/packages/mcp-server-revit/src/revit_mcp_server/registry_factory.py b/packages/mcp-server-revit/src/revit_mcp_server/registry_factory.py
new file mode 100644
index 0000000..4165ffa
--- /dev/null
+++ b/packages/mcp-server-revit/src/revit_mcp_server/registry_factory.py
@@ -0,0 +1,112 @@
+"""Builds one fully-wired ProviderRegistry with every provider registered.
+
+Shared by mcp_server.py (the stdio MCP server) and panel_server.py (the
+panel's local HTTP shim) so both entry points wire providers identically
+without duplicating ~60 lines of construction, and so importing one entry
+point's module never has the side effect of also constructing the other's
+registry.
+"""
+from __future__ import annotations
+
+import logging
+import os
+
+from .config import config
+from .providers import (
+ ProviderRegistry,
+ RevitProvider,
+ IfcProvider,
+ AECMapperProvider,
+ RhinoProvider,
+ SemanticGraphProvider,
+ SpeckleProvider,
+ AutodeskDataProvider,
+ JobProvider,
+ SQLiteExporterProvider,
+ McpProxyProvider,
+ NavisworksProvider,
+ ApprovalProvider,
+ ModuleProvider,
+ SemanticProvider,
+)
+from .module_registry import ModuleRegistry
+from .security.workspace import WorkspaceMonitor
+from .jobs import JobManager
+
+logger = logging.getLogger(__name__)
+
+
+def build_registry() -> tuple[ProviderRegistry, ApprovalProvider, JobManager, ModuleRegistry, WorkspaceMonitor]:
+ """Construct one fully-wired ProviderRegistry with every provider registered.
+
+ Each caller gets its own independent instance — that's fine, since
+ ApprovalGate persists plans to disk under the shared workspace directory,
+ so plans created via one process are still visible to the other.
+ """
+ workspace = WorkspaceMonitor(config.allowed_directories)
+
+ registry = ProviderRegistry()
+ approval_provider = ApprovalProvider(workspace=workspace, registry=registry)
+ registry.register(approval_provider)
+ registry.register(RevitProvider(workspace=workspace))
+ registry.register(IfcProvider(workspace=workspace))
+ registry.register(AECMapperProvider(workspace=workspace))
+ registry.register(SQLiteExporterProvider(workspace=workspace, registry=registry))
+ registry.register(NavisworksProvider(workspace=workspace))
+ registry.register(SemanticProvider(workspace=workspace, registry=registry))
+
+ # Initialize and register Module registry and Module provider
+ module_registry = ModuleRegistry(config_obj=config)
+ module_registry.discover_and_load()
+ registry.register(ModuleProvider(module_registry=module_registry, workspace=workspace, tool_registry=registry))
+
+ # Initialize Job Manager and Job Provider
+ job_manager = JobManager()
+ registry.register(JobProvider(manager=job_manager))
+
+ # Rhino Provider
+ try:
+ registry.register(RhinoProvider(workspace=workspace))
+ except Exception as e:
+ logger.warning("Could not initialize RhinoProvider: %s", e)
+
+ # Semantic Graph Provider
+ try:
+ registry.register(SemanticGraphProvider())
+ except Exception as e:
+ logger.warning("Could not initialize SemanticGraphProvider: %s", e)
+
+ # Speckle Provider
+ try:
+ registry.register(SpeckleProvider())
+ except Exception as e:
+ logger.warning("Could not initialize SpeckleProvider: %s. Please set SPECKLE_CLIENT_ID.", e)
+
+ # Autodesk Data Provider
+ try:
+ registry.register(AutodeskDataProvider())
+ except Exception as e:
+ logger.warning("Could not initialize AutodeskDataProvider: %s. Please set APS_CLIENT_ID.", e)
+
+ # Mcp Proxy Providers
+ proxy_targets = os.getenv("MCP_PROXY_TARGETS")
+ if proxy_targets:
+ for target in proxy_targets.split(","):
+ target = target.strip()
+ if not target:
+ continue
+ if "=" in target:
+ name, url = target.split("=", 1)
+ name = name.strip()
+ url = url.strip()
+ identity = f"proxy_{name}"
+ else:
+ url = target
+ identity = "proxy"
+
+ try:
+ registry.register(McpProxyProvider(target_url=url, identity=identity))
+ except Exception as e:
+ logger.warning("Could not initialize McpProxyProvider for %s: %s", target, e)
+
+ return registry, approval_provider, job_manager, module_registry, workspace