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.

Release v1.0.1 with Revit 2027 support

A. Sam Mohammad1eee2d7bebfd
diff --git a/.env.example b/.env.example
new file mode 100644
index 0000000..ee205f5
--- /dev/null
+++ b/.env.example
@@ -0,0 +1,20 @@
+# AEC Model Bridge Server Configuration
+# Copy this file to .env and adjust paths for your system
+
+# Required: Directory where your Revit projects are located
+MCP_REVIT_WORKSPACE_DIR=C:\RevitProjects
+
+# Required: Directories that the MCP server is allowed to access (semicolon-separated)
+MCP_REVIT_ALLOWED_DIRECTORIES=C:\RevitProjects;C:\Users\YourName\Documents
+
+# Bridge URL (default: http://127.0.0.1:3000)
+MCP_REVIT_BRIDGE_URL=http://127.0.0.1:3000
+
+# Server mode: "mock" for testing without Revit, "bridge" for real Revit connection
+MCP_REVIT_MODE=bridge
+
+# Log level: DEBUG, INFO, WARNING, ERROR
+MCP_REVIT_LOG_LEVEL=INFO
+
+# Audit log file path (optional)
+MCP_REVIT_AUDIT_LOG=audit.log
diff --git a/.github/workflows/publish-mcp.yml b/.github/workflows/publish-mcp.yml
index 052653a..5affaee 100644
--- a/.github/workflows/publish-mcp.yml
+++ b/.github/workflows/publish-mcp.yml
@@ -1,9 +1,9 @@
name: Publish MCP Server
on:
- push:
- tags:
- - "v*"
+ release:
+ types:
+ - published
workflow_dispatch:
jobs:
@@ -17,6 +17,35 @@ jobs:
- name: Checkout code
uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+ - name: Synchronize release artifact metadata
+ if: github.event_name == 'release'
+ shell: bash
+ env:
+ GH_TOKEN: ${{ github.token }}
+ run: |
+ version="${GITHUB_REF_NAME#v}"
+ asset="aec-model-bridge-${version}.mcpb"
+ gh release download "$GITHUB_REF_NAME" --pattern "$asset" --dir release
+ sha256="$(sha256sum "release/$asset" | cut -d' ' -f1)"
+ python - "$version" "$sha256" <<'PY'
+ import json
+ import sys
+ from pathlib import Path
+
+ version, sha256 = sys.argv[1:]
+ path = Path("server.json")
+ data = json.loads(path.read_text(encoding="utf-8"))
+ data["version"] = version
+ package = data["packages"][0]
+ package["version"] = version
+ package["identifier"] = (
+ "https://github.com/Sam-AEC/aec-model-bridge/"
+ f"releases/download/v{version}/aec-model-bridge-{version}.mcpb"
+ )
+ package["fileSha256"] = sha256
+ path.write_text(json.dumps(data, indent=2) + "\n", encoding="utf-8")
+ PY
+
- name: Install mcp-publisher
run: |
curl -L "https://github.com/modelcontextprotocol/registry/releases/latest/download/mcp-publisher_$(uname -s | tr '[:upper:]' '[:lower:]')_$(uname -m | sed 's/x86_64/amd64/;s/aarch64/arm64/').tar.gz" | tar xz mcp-publisher
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
new file mode 100644
index 0000000..e764431
--- /dev/null
+++ b/.github/workflows/release.yml
@@ -0,0 +1,61 @@
+name: Build GitHub Release
+
+on:
+ workflow_dispatch:
+ inputs:
+ version:
+ description: Release version without the v prefix
+ required: true
+ default: 1.0.1
+ revit_version:
+ description: Revit version to package
+ required: true
+ default: "2027"
+
+jobs:
+ release:
+ runs-on: windows-latest
+ permissions:
+ contents: write
+
+ steps:
+ - name: Checkout code
+ uses: actions/checkout@v5
+
+ - name: Set up Python
+ uses: actions/setup-python@v6
+ with:
+ python-version: "3.11"
+
+ - name: Set up .NET
+ uses: actions/setup-dotnet@v5
+ with:
+ dotnet-version: "10.0.x"
+
+ - name: Install Python build tools
+ shell: pwsh
+ run: |
+ python -m pip install --upgrade build pytest
+ python -m pip install -e packages/mcp-server-revit
+
+ - name: Run Python tests
+ shell: pwsh
+ run: python -m pytest packages/mcp-server-revit/tests
+
+ - name: Build release artifacts
+ shell: pwsh
+ run: >
+ ./scripts/build-release.ps1
+ -Version "${{ inputs.version }}"
+ -RevitVersion "${{ inputs.revit_version }}"
+
+ - name: Create GitHub release
+ shell: pwsh
+ env:
+ GH_TOKEN: ${{ github.token }}
+ run: >
+ gh release create "v${{ inputs.version }}"
+ dist/release/*
+ --title "AEC Model Bridge v${{ inputs.version }}"
+ --generate-notes
+ --verify-tag
diff --git a/.gitignore b/.gitignore
index 8ac4380..9318866 100644
--- a/.gitignore
+++ b/.gitignore
@@ -210,6 +210,7 @@ artifacts/
# Revit specific
*.addin.user
RevitBridge.dll
+AECModelBridge.dll
RevitBridge.pdb
Icons/
diff --git a/.vscode/mcp.json b/.vscode/mcp.json
index 009f72b..cc243f0 100644
--- a/.vscode/mcp.json
+++ b/.vscode/mcp.json
@@ -1,6 +1,6 @@
{
"servers": {
- "revit": {
+ "aec-model-bridge": {
"type": "stdio",
"command": "python",
"args": ["-m", "revit_mcp_server.mcp_server"],
diff --git a/CHANGELOG.md b/CHANGELOG.md
new file mode 100644
index 0000000..1ba96d5
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1,16 @@
+# Changelog
+
+## 1.0.1 - 2026-06-11
+
+- Add Autodesk Revit 2027 support targeting .NET 10.
+- Fix Revit startup failure when ribbon icon files are missing.
+- Package all runtime dependencies required by the Revit add-in.
+- Align MCP and bridge tool discovery with active implementations.
+- Add live download and repository-growth metrics to the README.
+- Add reproducible GitHub release packaging and publication automation.
+- Rename the public product to AEC Model Bridge and add trademark/API compliance notices.
+- Remove Autodesk product artwork and verify release packages exclude Autodesk API assemblies.
+
+## 1.0.0 - 2026-05-27
+
+- Initial 1.0 release.
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
new file mode 100644
index 0000000..905e310
--- /dev/null
+++ b/CONTRIBUTING.md
@@ -0,0 +1,27 @@
+# Contributing
+
+Thanks for improving AEC Model Bridge.
+
+## Focus Areas
+
+Contributions are most useful when they improve one of the following:
+- Revit command coverage
+- MCP tool reliability and error handling
+- installation and configuration documentation
+- developer ergonomics for local debugging and testing
+
+## Guidelines
+
+- Keep changes scoped to a single feature, fix, or documentation update.
+- Document any Revit version assumptions in the PR description.
+- Sanitize local paths, machine names, and credentials from config examples.
+- If a change affects UI or commands, include reproduction steps and expected behavior.
+- Update examples or docs when behavior changes.
+
+## Pull Request Checklist
+
+Before opening a PR, confirm that:
+- the change has clear reproduction and validation steps
+- config examples still work with placeholder values
+- README or docs are updated when setup or behavior changes
+- any limitations or known gaps are called out explicitly
diff --git a/LICENSE b/LICENSE
index ffd7586..60e3942 100644
--- a/LICENSE
+++ b/LICENSE
@@ -1,6 +1,6 @@
MIT License
-Copyright (c) 2025 MCP Revit Bridge Contributors
+Copyright (c) 2025-2026 AEC Model Bridge Contributors
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
diff --git a/README.md b/README.md
index 32d2e27..43347e8 100644
--- a/README.md
+++ b/README.md
@@ -1,60 +1,109 @@
<div align="center">
-<img src="https://cdn.simpleicons.org/autodeskrevit/0696D7" alt="Revit" height="80"/>
+<img src="assets/logo.svg" alt="AEC Model Bridge" height="120">
-# Autodesk Revit MCP Server
+# AEC Model Bridge
-**Model Context Protocol server for Autodesk Revit**
+Independent Model Context Protocol integration for Autodesk Revit® software.
-[![License: MIT](https://img.shields.io/badge/License-MIT-0078D4?style=flat-square)](LICENSE)
-[![Python](https://img.shields.io/badge/Python-3.11+-3776AB?style=flat-square&logo=python&logoColor=white)](https://python.org)
-[![.NET](https://img.shields.io/badge/.NET-4.8-512BD4?style=flat-square&logo=dotnet)](https://dotnet.microsoft.com)
-[![Revit](https://img.shields.io/badge/Revit-2024--2026-0696D7?style=flat-square)](https://autodesk.com/products/revit)
+[![Total downloads](https://img.shields.io/github/downloads/Sam-AEC/aec-model-bridge/total?style=flat-square&logo=github&label=total%20downloads&color=2563EB)](https://github.com/Sam-AEC/aec-model-bridge/releases)
+[![Latest release](https://img.shields.io/github/v/release/Sam-AEC/aec-model-bridge?style=flat-square)](https://github.com/Sam-AEC/aec-model-bridge/releases/latest)
+[![GitHub stars](https://img.shields.io/github/stars/Sam-AEC/aec-model-bridge?style=flat-square&logo=github)](https://github.com/Sam-AEC/aec-model-bridge/stargazers)
+[![GitHub forks](https://img.shields.io/github/forks/Sam-AEC/aec-model-bridge?style=flat-square&logo=github)](https://github.com/Sam-AEC/aec-model-bridge/forks)
+[![Commit activity](https://img.shields.io/github/commit-activity/m/Sam-AEC/aec-model-bridge?style=flat-square&logo=github)](https://github.com/Sam-AEC/aec-model-bridge/commits/main/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-0078D4?style=flat-square)](LICENSE)
+[![Python 3.11+](https://img.shields.io/badge/Python-3.11+-3776AB?style=flat-square&logo=python&logoColor=white)](https://www.python.org/)
+[![Revit 2024-2027](https://img.shields.io/badge/Revit-2024--2027-0696D7?style=flat-square)](https://www.autodesk.com/products/revit/)
-[Quick Start](#quick-start) | [API Reference](docs/tools.md)
+[Quick start](#quick-start) | [Tools](docs/tools.md) | [Architecture](docs/architecture.md) | [Security](docs/security.md)
</div>
----
+## What This Project Does
-## Overview
+This repository connects MCP clients such as Claude Desktop, VS Code, and custom agents to Autodesk Revit.
-Production-ready MCP server enabling AI agents to control Autodesk Revit through natural language. Integrates with Claude Desktop, Microsoft Copilot, and custom MCP clients.
+It has two runtime components:
-**Key Features:**
+- A Python MCP server that exposes tools to the AI client.
+- A C# Revit add-in that executes commands on Revit's main thread through `ExternalEvent`.
-- 100+ Revit API tools (geometry, views, sheets, families, MEP, structures)
-- Localhost HTTP bridge with sub-second response time
-- Thread-safe ExternalEvent architecture
-- Advanced reflection API for unlimited Revit access
-- Production-ready with comprehensive tool coverage
+The bridge currently implements 103 active command routes across model authoring, documentation, parameters, views, sheets, exports, worksharing, MEP, structure, geometry, and model inspection.
+
+## Repository Growth
+
+The download badge reports the cumulative number of GitHub release-asset downloads. GitHub does not include clones or automatically generated source archives in that total.
+
+<div align="center">
+ <a href="https://star-history.com/#Sam-AEC/aec-model-bridge&Date">
+ <picture>
+ <source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/svg?repos=Sam-AEC/aec-model-bridge&type=Date&theme=dark">
+ <source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/svg?repos=Sam-AEC/aec-model-bridge&type=Date">
+ <img alt="AEC Model Bridge star history" src="https://api.star-history.com/svg?repos=Sam-AEC/aec-model-bridge&type=Date">
+ </picture>
+ </a>
+</div>
+
+The chart is generated by the open-source [Star History](https://github.com/star-history/star-history) service and shows repository interest over time. GitHub does not provide a public historical time series for release downloads, so download growth cannot be reconstructed retroactively.
+
+## Why Use It
+
+- Direct Revit API execution without requiring pyRevit or Dynamo.
+- Localhost bridge with Revit-safe main-thread dispatch.
+- Typed tools for common BIM operations.
+- Reflection and in-process Python escape hatches for advanced workflows.
+- Mock mode for development and testing without Revit.
+- Version-specific builds for Revit 2024 through Revit 2027.
+
+## Compatibility
+
+| Revit | Add-in target | Status |
+|---|---|---|
+| 2024 | .NET Framework 4.8 | Supported |
+| 2025 | .NET 8 for Windows | Supported |
+| 2026 | .NET 8 for Windows | Supported |
+| 2027 | .NET 10 for Windows | Supported |
+
+Revit 2027 support is compiled against the installed Autodesk Revit 2027 API assemblies.
## Quick Start
### Prerequisites
-- Windows 10/11
-- Autodesk Revit 2024-2026
-- Python 3.11+
-- .NET Framework 4.8
+- Windows 10 or 11
+- Autodesk Revit 2024-2027
+- Python 3.11 or later
+- The .NET SDK required by the selected Revit version
-### Installation
+### 1. Clone and install the MCP server
```powershell
-# Clone repository
-git clone https://github.com/Sam-AEC/Autodesk-Revit-MCP-Server.git
-cd Autodesk-Revit-MCP-Server
+git clone https://github.com/Sam-AEC/aec-model-bridge.git
+cd aec-model-bridge
+pip install -e packages/mcp-server-revit
+```
-# Build Revit add-in
-.\scripts\build-addin.ps1 -RevitVersion 2024
+### 2. Build, package, and install the Revit add-in
-# Install Python package
-pip install -e packages/mcp-server-revit
+For Revit 2027:
+
+```powershell
+.\scripts\build-addin.ps1 -RevitVersion 2027
+.\scripts\package.ps1 -RevitVersion 2027
+.\scripts\install.ps1 -RevitVersion 2027
```
-### Configure Claude Desktop
+The installer places:
+
+- Binaries in `C:\ProgramData\AECModelBridge\bin`
+- The manifest in `%APPDATA%\Autodesk\Revit\Addins\2027`
+- Default configuration in `C:\ProgramData\AECModelBridge\config`
+
+Restart Revit after installing or replacing the add-in.
-Edit `%APPDATA%\Claude\claude_desktop_config.json`:
+### 3. Configure an MCP client
+
+Example Claude Desktop configuration:
```json
{
@@ -71,249 +120,118 @@ Edit `%APPDATA%\Claude\claude_desktop_config.json`:
}
```
-### Configure VS Code / GitHub Copilot
-
-This repository includes a workspace MCP config at `.vscode/mcp.json`. After installing the Python package and starting Revit with the bridge add-in loaded, open this repository in VS Code and run `MCP: List Servers` or use the MCP Servers view.
+The repository also includes [`.vscode/mcp.json`](.vscode/mcp.json) for VS Code and GitHub Copilot.
-### Verify Installation
+### 4. Verify the bridge
-Start Revit, then:
+Start Revit, then run:
```powershell
-curl http://localhost:3000/health
+Invoke-RestMethod http://127.0.0.1:3000/health
```
-Expected response:
+For Revit 2027, the response should include:
+
```json
{
"status": "healthy",
- "revit_version": "2024"
+ "revit_version": "2027"
}
```
----
-
## Architecture
-```
-┌─────────────────────────────────┐
-│ AI Client (Claude/Copilot) │
-└───────────────┬─────────────────┘
- │ MCP Protocol
-┌───────────────▼─────────────────┐
-│ MCP Server (Python) │
-│ - Tool Registry │
-│ - Security/Audit │
-└───────────────┬─────────────────┘
- │ HTTP :3000
-┌───────────────▼─────────────────┐
-│ Revit Bridge Add-in (C#) │
-│ - HTTP Server │
-│ - ExternalEvent Handler │
-└───────────────┬─────────────────┘
- │ Revit API
-┌───────────────▼─────────────────┐
-│ Autodesk Revit 2024-2026 │
-└─────────────────────────────────┘
+```text
+MCP client
+ |
+ | stdio / MCP
+ v
+Python MCP server
+ |
+ | HTTP on 127.0.0.1:3000
+ v
+C# Revit bridge add-in
+ |
+ | ExternalEvent on Revit main thread
+ v
+Autodesk Revit API
```
-**Threading Model:** HTTP requests are queued and executed on Revit's main thread via `ExternalEvent` for thread safety.
-
-**Bridge Status:** The bridge runs as a localhost HTTP server on port 3000, providing health checks and tool execution endpoints.
-
----
-
-## Available Tools
-
-### Document Management
-- `revit.create_new_document` - Create blank project
-- `revit.open_document` - Open RVT/RFA file
-- `revit.save_document` - Save active document
-- `revit.close_document` - Close document
-- `revit.get_document_info` - Get project metadata
-
-### Levels & Grids
-- `revit.create_level` - Create level at elevation
-- `revit.list_levels` - List all levels
-- `revit.create_grid` - Create grid line
-
-### Model Elements
-- `revit.create_wall` - Create wall from curve
-- `revit.create_floor` - Create floor from profile
-- `revit.create_roof` - Create roof from profile
-- `revit.create_column` - Create structural column
-- `revit.create_beam` - Create structural beam
-- `revit.create_foundation` - Create foundation element
-- `revit.create_room` - Create room boundary
-
-### MEP Systems
-- `revit.create_duct` - Create HVAC duct
-- `revit.create_pipe` - Create plumbing pipe
-- `revit.create_cable_tray` - Create cable tray
-- `revit.create_conduit` - Create electrical conduit
-- `revit.get_mep_systems` - List MEP systems
-
-### Families & Components
-- `revit.place_family_instance` - Place family instance
-- `revit.place_door` - Place door in wall
-- `revit.place_window` - Place window in wall
-- `revit.list_families` - List loaded families
-- `revit.edit_family` - Edit family document
-
-### Element Operations
-- `revit.delete_element` - Delete element
-- `revit.copy_element` - Copy element with translation
-- `revit.move_element` - Move element by vector
-- `revit.rotate_element` - Rotate element around axis
-- `revit.mirror_element` - Mirror element across plane
-- `revit.pin_element` - Pin element in place
-- `revit.unpin_element` - Unpin element
-
-### Parameters
-- `revit.get_element_parameters` - Read element parameters
-- `revit.set_parameter_value` - Write parameter value
-- `revit.get_parameter_value` - Read single parameter
-- `revit.batch_set_parameters` - Batch update parameters
-- `revit.get_type_parameters` - Get type parameters
-- `revit.set_type_parameter` - Set type parameter
-
-### Views
-- `revit.create_3d_view` - Create isometric 3D view
-- `revit.create_section_view` - Create section view
-- `revit.create_floor_plan_view` - Create floor plan
-- `revit.duplicate_view` - Duplicate view
-- `revit.apply_view_template` - Apply view template
-- `revit.get_view_templates` - List view templates
-- `revit.list_views` - List all views
-
-### Sheets & Documentation
-- `revit.create_sheet` - Create sheet with titleblock
-- `revit.place_viewport_on_sheet` - Place viewport on sheet
-- `revit.list_sheets` - List all sheets
-- `revit.delete_sheet` - Delete sheet
-- `revit.duplicate_sheet` - Duplicate sheet
-- `revit.get_sheet_info` - Get sheet information
-- `revit.list_titleblocks` - List titleblock types
-- `revit.populate_titleblock` - Fill titleblock parameters
-- `revit.renumber_sheets` - Renumber sheets
-- `revit.batch_create_sheets_from_csv` - Create sheets from CSV
-
-### Annotation
-- `revit.create_tag` - Create element tag
-- `revit.create_dimension` - Create dimension
-- `revit.create_text_note` - Create text annotation
-- `revit.create_text_type` - Create text type
-- `revit.tag_all_in_view` - Tag all elements in view
-- `revit.create_revision_cloud` - Create revision cloud
-
-### Selection & Query
-- `revit.get_selection` - Get current selection
-- `revit.set_selection` - Set element selection
-- `revit.list_elements_by_category` - Query by category
-- `revit.get_element_type` - Get element type
-- `revit.get_element_bounding_box` - Get element bounds
-- `revit.get_categories` - List all categories
-
-### Groups & Links
-- `revit.create_group` - Create model group
-- `revit.ungroup` - Ungroup elements
-- `revit.convert_to_group` - Convert to group
-- `revit.get_group_members` - Get group members
-- `revit.get_link_instances` - List link instances
-- `revit.get_rvt_links` - List Revit links
-
-### Schedules & Data
-- `revit.create_schedule` - Create schedule view
-- `revit.get_schedule_data` - Extract schedule data
-- `revit.export_schedules` - Export schedules to CSV
-- `revit.calculate_material_quantities` - Calculate quantities
-
-### Export Operations
-- `revit.export_pdf_by_sheet_set` - Export to PDF
-- `revit.export_dwg_by_view` - Export to DWG
-- `revit.export_ifc_with_settings` - Export to IFC
-- `revit.export_navisworks` - Export to Navisworks
-- `revit.export_image` - Export view as image
-- `revit.render_3d_view` - Render 3D view
-
-### Project Information
-- `revit.get_phases` - List project phases
-- `revit.get_phase_filters` - List phase filters
-- `revit.get_design_options` - List design options
-- `revit.get_worksets` - List worksets
-- `revit.get_warnings` - Get model warnings
-- `revit.get_project_location` - Get project location
-
-### Worksharing
-- `revit.sync_to_central` - Synchronize with central
-- `revit.relinquish_all` - Relinquish all elements
-
-### Materials & Rendering
-- `revit.create_material` - Create material
-- `revit.set_element_material` - Assign material
-- `revit.get_render_settings` - Get render settings
-
-### Analysis & Validation
-- `revit.check_clashes` - Run clash detection
-- `revit.get_room_boundary` - Get room boundary
-
-### Advanced Features
-- `revit.invoke_method` - Universal Revit API method invocation
-- `revit.reflect_get` - Get property via reflection
-- `revit.reflect_set` - Set property via reflection
-
-**Total: 100+ tools** • **Full API Reference:** [docs/tools.md](docs/tools.md)
-
----
-
-## Project Structure
+The HTTP listener receives requests off the Revit UI thread. Commands are queued and executed through `ExternalEvent`, which is required for safe Revit API access.
-```
-Autodesk-Revit-MCP-Server/
-├── packages/
-│ ├── revit-bridge-addin/ # C# Revit Add-in
-│ │ └── src/Bridge/
-│ │ ├── App.cs # IExternalApplication
-│ │ ├── BridgeServer.cs # HTTP server
-│ │ └── BridgeCommandFactory.cs
-│ └── mcp-server-revit/ # Python MCP Server
-│ ├── src/revit_mcp_server/
-│ │ ├── mcp_server.py # MCP protocol
-│ │ ├── bridge/client.py # HTTP client
-│ │ └── tools/ # Tool handlers
-│ └── tests/
-├── scripts/
-│ ├── build-addin.ps1 # Build C# DLL
-│ └── install.ps1 # Deploy to Revit
-├── docs/
-│ └── tools.md # API reference listing
-└── README.md
-```
+## Tool Coverage
----
+The active bridge command surface includes:
-## Documentation
+- Documents, levels, grids, walls, floors, roofs, rooms, and families
+- Parameters, project parameters, shared parameters, and batch updates
+- Views, view templates, sheets, title blocks, schedules, and annotations
+- Selection, transforms, groups, links, worksets, and synchronization
+- Structural columns, beams, foundations, ducts, pipes, and conduits
+- PDF, DWG, IFC, Navisworks, schedule, image, and rendering exports
+- Warnings, quantities, clashes, geometry, bounding boxes, and model queries
+- Reflection-based API calls and in-process Python execution
-- [API Reference (Revit MCP Tools List)](docs/tools.md)
+See [docs/tools.md](docs/tools.md) for the tool reference.
----
+## Security
-## License
+The bridge listens on `127.0.0.1` by default. Do not expose port `3000` to a network without authentication and transport security.
-[MIT License](LICENSE) - Copyright (c) 2025
+The `execute_python`, `invoke_method`, `reflect_get`, and `reflect_set` tools are privileged capabilities. They can modify the active model and execute broad API operations. Restrict them in shared or production environments and keep backups of important models.
----
+See [docs/security.md](docs/security.md) for the security model and [SECURITY.md](SECURITY.md) for vulnerability reporting.
-## Links
+## Current Limitations
-- [Issues](https://github.com/Sam-AEC/Autodesk-Revit-MCP-Server/issues)
-- [Discussions](https://github.com/Sam-AEC/Autodesk-Revit-MCP-Server/discussions)
-- [Model Context Protocol](https://modelcontextprotocol.io)
+- Some source directories are excluded from compilation while their APIs are stabilized.
+- Experimental command implementations are not advertised until they are active in the bridge.
+- Automated tests cover the Python server; full Revit integration testing still requires a licensed Windows/Revit environment.
+- Release download counts include GitHub release assets only. Git clones and GitHub-generated source archives are not counted.
----
+## Development
-<div align="center">
+Run the Python test suite:
+
+```powershell
+python -m pytest packages/mcp-server-revit/tests
+```
-**[⬆ Back to Top](#revit-mcp-server)**
+Build a specific Revit add-in:
-</div>
+```powershell
+.\scripts\build-addin.ps1 -RevitVersion 2027 -Configuration Release
+```
+
+Package all supported versions:
+
+```powershell
+.\scripts\package.ps1 -RevitVersion All
+```
+
+## Documentation
+
+- [Installation](docs/install.md)
+- [Tool reference](docs/tools.md)
+- [Architecture](docs/architecture.md)
+- [Configuration](docs/configuration-reference.md)
+- [Build and install scripts](docs/build-and-install-scripts.md)
+- [Target frameworks and dependencies](docs/target-frameworks-and-dependencies.md)
+- [MCP marketplaces](docs/marketplaces.md)
+- [Contributing](CONTRIBUTING.md)
+
+## License
+
+This repository is currently distributed under the [MIT License](LICENSE).
+
+## Trademark and Affiliation Notice
+
+AEC Model Bridge is an independent project. It is not sponsored, endorsed, or
+provided by Autodesk.
+
+Autodesk and Revit are trademarks of the Autodesk group of companies. Sam-AEC
+is not affiliated with Autodesk.
+
+The project uses the documented Revit desktop API and does not distribute
+Autodesk API assemblies, product icons, or other Autodesk software. Users must
+provide their own properly licensed installation. See [TRADEMARKS.md](TRADEMARKS.md).
diff --git a/SECURITY.md b/SECURITY.md
new file mode 100644
index 0000000..189f764
--- /dev/null
+++ b/SECURITY.md
@@ -0,0 +1,82 @@
+# Security Policy
+
+## Supported Versions
+
+We actively support and provide security updates for the following versions:
+
+| Version | Supported |
+| ------- | ------------------ |
+| 1.x | ✅ Active support |
+| < 1.0 | ❌ Not supported |
+
+## Reporting a Vulnerability
+
+**DO NOT** open public GitHub issues for security vulnerabilities.
+
+### Where to Report
+
+Use GitHub's private security advisory feature:
+
+1. Navigate to the repository's **Security** tab
+2. Click **"Report a vulnerability"**
+3. Provide detailed information
+
+### What to Include
+
+- **Description**: Clear description of the vulnerability
+- **Steps to Reproduce**: Detailed steps to demonstrate the issue
+- **Impact Assessment**: What an attacker could achieve
+- **Affected Versions**: Which versions are vulnerable
+- **Suggested Fix** (optional): Your recommendations
+
+### Response Timeline
+
+- **Acknowledgment**: Within 48 hours
+- **Initial Triage**: Within 7 days
+- **Fix Development**:
+ - **Critical**: Within 7 days
+ - **High**: Within 30 days
+ - **Medium**: Within 90 days
+
+### Disclosure Policy
+
+We follow **coordinated disclosure**:
+1. Private report received
+2. Fix developed and tested
+3. Patched version released
+4. Public disclosure after 30 days
+
+## Security Best Practices
+
+### For Users
+
+✅ **Keep localhost-only** - Never bind to `0.0.0.0` without enterprise hardening
+✅ **Update regularly** - Apply security patches within 30 days
+✅ **Enable audit logs** - Monitor `%APPDATA%\AECModelBridge\Logs\bridge.jsonl`
+✅ **Workspace sandboxing** - Only allow trusted project directories
+✅ **Enterprise mode** - Follow [docs/security.md](docs/security.md) for HTTPS/OAuth
+
+### For Developers
+
+✅ **Input validation** - All inputs validated against schemas
+✅ **No secrets in code** - Use environment variables
+✅ **Least privilege** - No privilege elevation
+✅ **Exception handling** - Sanitize before returning to client
+
+## Security Hardening Checklist
+
+Before production deployment:
+
+- [ ] Bridge binds to `127.0.0.1` only
+- [ ] Workspace directories limited
+- [ ] Audit logging enabled
+- [ ] HTTPS configured (if remote access)
+- [ ] OAuth2 enabled (if external clients)
+- [ ] Rate limiting configured
+- [ ] Security reviews scheduled
+
+Full guide: [docs/security.md](docs/security.md)
+
+---
+
+**Last Updated**: 2026-01-07
diff --git a/TRADEMARKS.md b/TRADEMARKS.md
new file mode 100644
index 0000000..1d05e98
--- /dev/null
+++ b/TRADEMARKS.md
@@ -0,0 +1,36 @@
+# Trademark and API Use
+
+AEC Model Bridge is an independent software project maintained by Sam-AEC. It
+is not affiliated with, sponsored by, endorsed by, or provided by Autodesk.
+
+Autodesk and Revit are trademarks of the Autodesk group of companies. Other
+product and company names may be trademarks of their respective owners.
+
+References to Autodesk Revit® software describe compatibility only. They are
+not part of the AEC Model Bridge product name.
+
+## Technical Boundary
+
+AEC Model Bridge:
+
+- uses the documented Revit desktop .NET API;
+- requires users to provide their own properly licensed Autodesk software;
+- does not distribute `RevitAPI.dll`, `RevitAPIUI.dll`, Autodesk product
+ icons, Autodesk logos, or Autodesk application binaries;
+- does not claim Autodesk certification, sponsorship, or endorsement; and
+- does not use undocumented API calls intentionally.
+
+The release build checks packaged files for known Autodesk API assemblies and
+fails if they are present.
+
+The MIT License applies only to this project's original code and assets. It
+does not grant rights to Autodesk trademarks, software, or other third-party
+intellectual property.
+
+Users are responsible for complying with the license terms that apply to their
+Autodesk installation. Autodesk Education licenses must not be used for
+commercial work.
+
+This notice describes the project's compliance approach and is not legal
+advice. Commercial distribution should receive independent trademark and
+software-licensing review.
diff --git a/assets/logo.svg b/assets/logo.svg
index b2be0a4..cd748da 100644
--- a/assets/logo.svg
+++ b/assets/logo.svg
@@ -20,11 +20,11 @@
<line x1="90" y1="100" x2="90" y2="105" stroke="#2563eb" stroke-width="2"/>
<line x1="110" y1="100" x2="110" y2="105" stroke="#2563eb" stroke-width="2"/>
- <!-- Revit Symbol (right) -->
+ <!-- Generic model symbol (right) -->
<rect x="125" y="85" width="25" height="30" rx="2" stroke="#2563eb" stroke-width="2" fill="none"/>
<line x1="130" y1="95" x2="145" y2="95" stroke="#1e40af" stroke-width="2"/>
<line x1="130" y1="105" x2="145" y2="105" stroke="#1e40af" stroke-width="2"/>
<!-- Text -->
- <text x="100" y="150" text-anchor="middle" class="logo-text logo-primary" font-size="18">MCP Revit Bridge</text>
+ <text x="100" y="150" text-anchor="middle" class="logo-text logo-primary" font-size="16">AEC Model Bridge</text>
</svg>
diff --git a/assets/revit-icon.svg b/assets/revit-icon.svg
deleted file mode 100644
index 8cf390f..0000000
--- a/assets/revit-icon.svg
+++ /dev/null
@@ -1 +0,0 @@
-<svg fill="#0696D7" role="img" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg"><title>Autodesk Revit</title><path d="M24 22.665H2.994c-.519 0-.838-.293-.835-.723.001.042.002-.148.003-.463.142-.083.283-.165.427-.247l.078-.045.07-.058.015-.013.127-.078 1.294-.804h1.134c3.35 0 11.817 0 16.548.007.159 0 .631 0 1.002-.371.371-.372.37-.853.37-1.011-.008-2.057-.001-4.109.005-6.16.008-2.39.016-4.86 0-7.298v-.063l.61-.007c.169-.003.143.197.143.296.014 5.68-.02 11.36.015 17.038zM14.326 8.982c.006-.281.006-.56.006-.859-.009-.5-.395-1.055-.916-1.055-.435 0-.919.006-1.432.006v3.01h1.432c.52 0 .9-.584.91-1.102zM3.887 19.234 3.853 1.363l.007-.025.026-.003h17.313c.51.232.943.56 1.033 1.16.023 1.052 0 1.896 0 2.854.001.023-.002.036 0 .059.03 4.489-.022 8.963-.005 13.453 0 .285-.072.38-.37.38-5.99-.008-17.97-.007-17.97-.007zm5.624-3.971h2.395l.057-.051v-3.5c.316.001.57-.005.787-.005.075 0 .348.075.449.286.36.757.692 1.531 1.125 2.25.583.967 1.704 1.204 2.469 1.204.528 0 .528-.024.528-.245 0-.423-.006-.935-.006-1.374-.403-.039-.734-.163-.929-.541-.362-.705-.74-1.401-1.119-2.114.248-.072.218-.057.302-.092.859-.357 1.139-.951 1.213-1.71.05-.503.059-1.144.025-1.395-.112-.833-.378-1.454-1.036-1.932-.773-.562-1.678-.657-2.582-.687a62.395 62.395 0 0 0-3.678.012v9.894zm-5.658-13.9C1.631 2.64.98 3.087.223 3.513.025 3.622 0 3.895 0 4.1l.02 17.45c.575-.357 3.293-1.96 3.867-2.316L3.853 1.363z"/></svg>
\ No newline at end of file
diff --git a/docs/architecture.md b/docs/architecture.md
new file mode 100644
index 0000000..19c093d
--- /dev/null
+++ b/docs/architecture.md
@@ -0,0 +1,436 @@
+# Architecture
+
+AEC Model Bridge is a two-tier system connecting MCP clients to Revit software through a Python server and .NET bridge add-in.
+
+## System Overview
+
+```
+┌──────────────────────────────────────────────────────────────────┐
+│ MCP Client (Claude Desktop, custom apps, automation scripts) │
+└────────────────────────────┬─────────────────────────────────────┘
+ │
+ │ MCP Protocol (stdio)
+ │ JSON-RPC messages
+ │
+┌────────────────────────────▼─────────────────────────────────────┐
+│ MCP Server (Python) │
+│ ┌────────────────┐ ┌──────────────┐ ┌────────────────────┐ │
+│ │ Schema │ │ Workspace │ │ Audit │ │
+│ │ Validation │ │ Sandbox │ │ Recorder │ │
+│ │ (Pydantic) │ │ (pathlib) │ │ (JSONL logs) │ │
+│ └────────────────┘ └──────────────┘ └────────────────────┘ │
+│ │
+│ ┌──────────────────────────────────────────────────────────┐ │
+│ │ Tool Handlers (25 tools) │ │
+│ │ - revit.health, revit.open_document, revit.export_* │ │
+│ └──────────────────────────────────────────────────────────┘ │
+│ │
+│ ┌──────────────────────────────────────────────────────────┐ │
+│ │ Bridge Client │ │
+│ │ ┌────────────────┐ ┌────────────────────────┐ │ │
+│ │ │ Mock Bridge │ OR │ HTTP Client (httpx) │ │ │
+│ │ │ (deterministic)│ │ -> localhost:3000 │ │ │
+│ │ └────────────────┘ └────────────────────────┘ │ │
+│ └──────────────────────────────────────────────────────────┘ │
+└────────────────────────────┬─────────────────────────────────────┘
+ │
+ │ HTTP POST (localhost only)
+ │ {"tool": "...", "payload": {...}}
+ │
+┌────────────────────────────▼─────────────────────────────────────┐
+│ Revit Bridge Add-in (.NET 4.8) │
+│ ┌──────────────────────────────────────────────────────────┐ │
+│ │ BridgeServer (HttpListener on 127.0.0.1:3000) │ │
+│ └────────────────────────────┬─────────────────────────────┘ │
+│ │ │
+│ ┌────────────────────────────▼─────────────────────────────┐ │
+│ │ BridgeCommandFactory (tool router) │ │
+│ │ - Routes tool requests to handlers │ │
+│ │ - Serializes/deserializes JSON │ │
+│ └────────────────────────────┬─────────────────────────────┘ │
+│ │ │
+│ ┌────────────────────────────▼─────────────────────────────┐ │
+│ │ ExternalEventHandler (Revit API queue) │ │
+│ │ - Queues operations on UI thread │ │
+│ │ - Executes Revit API calls safely │ │
+│ └────────────────────────────┬─────────────────────────────┘ │
+└────────────────────────────────┼─────────────────────────────────┘
+ │
+ │ Revit API
+ │
+┌────────────────────────────────▼─────────────────────────────────┐
+│ Autodesk Revit (2024-2027) │
+│ - Document operations │
+│ - Element queries and modifications │
+│ - Export operations (PDF, DWG, IFC, CSV) │
+│ - QA metric calculations │
+└──────────────────────────────────────────────────────────────────┘
+```
+
+## Components
+
+### MCP Server (Python)
+
+**Location**: [packages/mcp-server-revit/](../packages/mcp-server-revit/)
+
+**Responsibilities**:
+- Listen for MCP protocol messages on stdin/stdout
+- Validate tool inputs against JSON schemas (Pydantic)
+- Enforce workspace sandboxing (all file paths within allowed directories)
+- Route tool requests to appropriate handlers
+- Record audit logs for every invocation
+- Communicate with bridge (HTTP) or mock implementation
+
+**Key Modules**:
+- [server.py](../packages/mcp-server-revit/src/revit_mcp_server/server.py): Main MCP protocol handler
+- [config.py](../packages/mcp-server-revit/src/revit_mcp_server/config.py): Environment-based configuration
+- [schemas.py](../packages/mcp-server-revit/src/revit_mcp_server/schemas.py): Pydantic models for all 25 tools
+- [tools/handlers.py](../packages/mcp-server-revit/src/revit_mcp_server/tools/handlers.py): Tool implementation functions
+- [security/workspace.py](../packages/mcp-server-revit/src/revit_mcp_server/security/workspace.py): Path validation
+- [security/audit.py](../packages/mcp-server-revit/src/revit_mcp_server/security/audit.py): Audit log writing
+- [bridge/client.py](../packages/mcp-server-revit/src/revit_mcp_server/bridge/client.py): HTTP bridge client
+- [bridge/mock.py](../packages/mcp-server-revit/src/revit_mcp_server/bridge/mock.py): Deterministic mock responses
+
+**Configuration**:
+```bash
+MCP_REVIT_MODE=mock|bridge # Execution mode
+WORKSPACE_DIR=/path/to/workspace # Root directory for file operations
+MCP_REVIT_ALLOWED_DIRECTORIES=... # Colon/semicolon-separated paths
+MCP_REVIT_BRIDGE_URL=http://... # Bridge HTTP endpoint (bridge mode only)
+MCP_REVIT_AUDIT_LOG=/path/to/log # Audit log file
+```
+
+### Revit Bridge Add-in (.NET)
+
+**Location**: [packages/revit-bridge-addin/](../packages/revit-bridge-addin/)
+
+**Responsibilities**:
+- Start HTTP listener on Revit startup (IExternalApplication)
+- Accept JSON POST requests from MCP server
+- Queue operations on Revit UI thread via ExternalEvent
+- Execute Revit API operations
+- Return JSON responses to MCP server
+
+**Key Classes**:
+- [App.cs](../packages/revit-bridge-addin/src/Bridge/App.cs): Add-in entry point (IExternalApplication)
+- [BridgeServer.cs](../packages/revit-bridge-addin/src/Bridge/BridgeServer.cs): HTTP listener (HttpListener on port 3000)
+- [BridgeCommandFactory.cs](../packages/revit-bridge-addin/src/Bridge/BridgeCommandFactory.cs): Tool request router
+- [ExternalEventHandler.cs](../packages/revit-bridge-addin/src/Bridge/ExternalEventHandler.cs): Revit API execution queue
+
+**Deployment**:
+1. Build with MSBuild or Visual Studio
+2. Output DLL: `packages/revit-bridge-addin/bin/Release/{year}/{framework}/AECModelBridge.dll`
+3. Manifest file: [AECModelBridge.addin](../packages/revit-bridge-addin/AECModelBridge.addin)
+4. Install to: `%ProgramData%\Autodesk\Revit\Addins\{year}\AECModelBridge.addin`
+
+**Communication Protocol**:
+
+Request format:
+```json
+POST http://localhost:3000/
+Content-Type: application/json
+
+{
+ "tool": "revit.export_schedules",
+ "payload": {
+ "request_id": "req_001",
+ "output_path": "C:\\workspace\\schedules.csv"
+ }
+}
+```
+
+Response format:
+```json
+{
+ "schedules": ["Door Schedule", "Window Schedule"],
+ "output_path": "C:\\workspace\\schedules.csv"
+}
+```
+
+Error response:
+```json
+{
+ "error": "RevitAPIException",
+ "message": "Failed to export schedule: Document not open"
+}
+```
+
+## Execution Models
+
+### Mock Mode
+
+**Use case**: CI/CD, testing, development without Revit
+
+**Behavior**:
+- All tools return deterministic stub responses
+- No bridge HTTP communication
+- Workspace sandboxing still enforced
+- Audit logging still active
+
+**Advantages**:
+- No Windows/Revit dependency
+- Fast execution (no I/O delays)
+- Repeatable outputs for regression tests
+- Safe for automated pipelines
+
+**Configuration**:
+```bash
+export MCP_REVIT_MODE=mock
+```
+
+### Bridge Mode
+
+**Use case**: Production Revit automation
+
+**Behavior**:
+- MCP server sends HTTP requests to bridge
+- Bridge queues operations on Revit UI thread
+- Real Revit API operations execute
+- Actual files generated (CSV, PDF, DWG, IFC)
+
+**Requirements**:
+- Windows 10/11
+- Revit 2024-2027 running
+- Bridge add-in installed and loaded
+
+**Configuration**:
+```bash
+export MCP_REVIT_MODE=bridge
+export MCP_REVIT_BRIDGE_URL=http://localhost:3000
+```
+
+## Why the Bridge Exists
+
+### Revit API Constraints
+
+1. **UI Thread Requirement**: Most Revit API operations must run on the main UI thread
+2. **External Event Pattern**: Out-of-process calls must use `IExternalEventHandler`
+3. **.NET Framework Dependency**: Revit API requires .NET 4.8 (not .NET Core)
+4. **Windows-Only**: Revit runs exclusively on Windows
+
+### Design Decisions
+
+**Why not Python → Revit directly?**
+- Revit API is .NET only
+- pythonnet/.NET interop is complex and fragile
+- Process boundary provides cleaner separation
+
+**Why HTTP instead of named pipes/IPC?**
+- Simple debugging (curl/Postman can test bridge)
+- No Windows-specific IPC complexity
+- HTTP is language-agnostic for future clients
+- Localhost-only binding is secure
+
+**Why separate add-in instead of Revit macros?**
+- Add-ins start automatically with Revit
+- No manual macro execution required
+- Persistent HTTP listener across sessions
+- Better error handling and logging
+
+## Trust Boundaries
+
+### Boundary 1: MCP Client → MCP Server
+
+**Threat**: Malicious client sends path traversal attacks
+
+**Mitigation**:
+- Schema validation rejects malformed inputs
+- Workspace sandbox blocks paths outside allowed directories
+- All file paths resolved to absolute paths before validation
+
+### Boundary 2: MCP Server → Bridge
+
+**Threat**: Compromised bridge returns malicious data
+
+**Mitigation**:
+- Bridge runs on localhost only (127.0.0.1)
+- No authentication needed (same-machine trust)
+- Responses validated against output schemas
+- Audit log records all bridge communications
+
+### Boundary 3: Bridge → Revit
+
+**Threat**: Bridge exploits Revit API vulnerabilities
+
+**Mitigation**:
+- ExternalEvent enforces UI thread execution
+- Revit API's own security model applies
+- Document operations respect Revit's file permissions
+- Bridge cannot execute arbitrary code
+
+## Scaling and Performance
+
+### Current Limitations
+
+- Single-threaded bridge (one request at a time)
+- Synchronous HTTP requests (blocking)
+- No request queuing or batching
+- Each tool invocation is independent
+
+### Future Improvements
+
+- Async HTTP client in MCP server
+- Request queue in bridge with parallel execution
+- Batch operations (e.g., export 100 sheets in one call)
+- Persistent document cache (avoid repeated opening)
+
+## Testing Strategy
+
+### Unit Tests
+
+**Location**: [packages/mcp-server-revit/tests/](../packages/mcp-server-revit/tests/)
+
+**Coverage**:
+- Schema validation (valid/invalid inputs)
+- Workspace path enforcement
+- Tool handler registration
+- Mock bridge responses
+
+**Run**:
+```bash
+pytest packages/mcp-server-revit/tests
+```
+
+### Integration Tests
+
+**Approach**: Use mock mode to test end-to-end without Revit
+
+```python
+# Set mock mode
+os.environ["MCP_REVIT_MODE"] = "mock"
+
+# Run server and send MCP messages
+response = mcp_server.handle_tool_request({
+ "tool": "revit.export_schedules",
+ "payload": {"request_id": "test_001", "output_path": "/workspace/test.csv"}
+})
+
+# Validate response matches schema
+assert "schedules" in response
+assert response["output_path"] == "/workspace/test.csv"
+```
+
+### Manual Testing (Bridge Mode)
+
+1. Build and install bridge add-in
+2. Start Revit
+3. Verify HTTP listener: `curl http://localhost:3000/`
+4. Run demo client: `python packages/client-demo/demo.py`
+5. Check audit log for recorded requests
+
+## Security Considerations
+
+See [security.md](security.md) for comprehensive security model.
+
+**Key points**:
+- All file paths sandboxed to allowed directories
+- Bridge binds to localhost only (no external exposure)
+- Audit logs record every tool invocation
+- Schema validation prevents injection attacks
+- Mock mode safe for untrusted CI environments
+
+## Extending the System
+
+### Adding a New Tool
+
+1. Define input/output schemas in [schemas.py](../packages/mcp-server-revit/src/revit_mcp_server/schemas.py):
+```python
+class MyToolInput(RequestPayload):
+ document_id: str
+ parameter_name: str
+
+class MyToolOutput(BaseModel):
+ value: str
+```
+
+2. Implement handler in [handlers.py](../packages/mcp-server-revit/src/revit_mcp_server/tools/handlers.py):
+```python
+def my_tool(payload: dict, workspace: WorkspaceMonitor) -> dict:
+ input_model = MyToolInput(**payload)
+ # Mock implementation
+ return MyToolOutput(value="mock_result").model_dump()
+```
+
+3. Register in `TOOL_HANDLERS`:
+```python
+TOOL_HANDLERS["revit.my_tool"] = my_tool
+```
+
+4. Update bridge [BridgeCommandFactory.cs](../packages/revit-bridge-addin/src/Bridge/BridgeCommandFactory.cs):
+```csharp
+case "revit.my_tool":
+ // Revit API implementation
+ var doc = GetActiveDocument();
+ var param = GetParameter(doc, payload["parameter_name"]);
+ return new { value = param.AsString() };
+```
+
+5. Add tests in [test_tools.py](../packages/mcp-server-revit/tests/test_tools.py)
+
+6. Document in [tools.md](tools.md)
+
+## Deployment Topologies
+
+### Local Development
+
+```
+Developer Machine:
+ - Revit 2024
+ - Bridge add-in
+ - MCP server (Python venv)
+ - Demo client
+```
+
+### CI/CD Pipeline
+
+```
+GitHub Actions (Windows runner):
+ - MCP server (mock mode)
+ - Pytest
+ - No Revit dependency
+```
+
+### Production Automation
+
+```
+Dedicated Windows Server:
+ - Revit 2024 (licensed)
+ - Bridge add-in (installed)
+ - MCP server (systemd/Windows service)
+ - Cron/scheduled tasks invoke demo client
+ - Audit logs → monitoring system
+```
+
+## Troubleshooting
+
+### Bridge Not Responding
+
+**Symptoms**: MCP server reports "Connection refused"
+
+**Diagnosis**:
+1. Check Revit is running
+2. Verify add-in loaded: Check Revit Journal file
+3. Test bridge directly: `curl http://localhost:3000/`
+4. Review add-in manifest path in `AECModelBridge.addin`
+
+### Workspace Violations
+
+**Symptoms**: `WorkspaceViolation` errors
+
+**Diagnosis**:
+1. Print allowed directories: `echo $MCP_REVIT_ALLOWED_DIRECTORIES`
+2. Verify paths are absolute
+3. Check path separators (Windows: `\\` or `/`)
+4. Ensure directories exist and are readable
+
+### Schema Validation Failures
+
+**Symptoms**: `SchemaValidationError` on tool invocation
+
+**Diagnosis**:
+1. Review tool schema in [tools.md](tools.md)
+2. Check required vs optional fields
+3. Validate JSON syntax
+4. Review error message for specific field issues
+
+See [install.md](install.md) for additional troubleshooting.
diff --git a/docs/build-and-install-scripts.md b/docs/build-and-install-scripts.md
new file mode 100644
index 0000000..8643fab
--- /dev/null
+++ b/docs/build-and-install-scripts.md
@@ -0,0 +1,79 @@
+# Build And Install Scripts
+
+The `scripts/` directory is the operational entry surface for building, packaging, installing, and running the stack.
+
+## Script Roles
+
+### `scripts/build-addin.ps1`
+
+Builds the C# add-in for a selected Revit version.
+
+Key behavior:
+
+- blocks unsafe execution from `C:\Windows`
+- prefers MSBuild discovered through `vswhere`
+- falls back to `dotnet build`
+- passes `RevitVersion` into `RevitBridge.csproj`
+
+### `scripts/package.ps1`
+
+Creates a distribution package under `dist\AECModelBridge`.
+
+Key behavior:
+
+- builds add-in binaries for one or more Revit versions
+- copies versioned binaries into `dist\bin\{year}`
+- attempts PyInstaller packaging for the Python server
+- always builds a wheel as fallback
+- writes `default.json` and `README.txt` into the distribution payload
+
+### `scripts/install.ps1`
+
+Installs from a prepared distribution package.
+
+Key behavior:
+
+- auto-triggers packaging if `dist\AECModelBridge` is missing
+- copies bridge binaries into `C:\ProgramData\AECModelBridge\bin`
+- installs the add-in manifest into the selected Revit add-in directory
+- copies default configuration into `C:\ProgramData\AECModelBridge\config`
+
+### `scripts/install-addin.ps1`
+
+Performs the minimal manifest copy for a chosen Revit year.
+
+This is the narrowest install path and is useful when the binaries are already built.
+
+### `scripts/setup.ps1`
+
+Acts as the orchestration script.
+
+It runs:
+
+1. build
+2. package
+3. optional install
+
+### `scripts/start-server.ps1`
+
+Prepares and launches the Python MCP server.
+
+Key behavior:
+
+- creates `.env` from `.env.example` if needed
+- checks Python availability
+- installs the Python package in editable mode
+- optionally probes `http://127.0.0.1:3000/health` in bridge mode
+- launches `python -m revit_mcp_server`
+
+### `scripts/run-server.ps1`
+
+This is the thinnest launch path and only executes `python -m revit_mcp_server`.
+
+## Safety Pattern
+
+The more powerful scripts include a path guard that refuses execution from `C:\Windows`. That is an intentional operational safeguard, not decoration.
+
+## Working Rule
+
+Use `setup.ps1` when you want the full build-package-install path. Use `start-server.ps1` when the add-in is already in place and you only need to validate or run the Python side.
diff --git a/docs/install.md b/docs/install.md
new file mode 100644
index 0000000..ac7b2fd
--- /dev/null
+++ b/docs/install.md
@@ -0,0 +1,268 @@
+# Installation Guide
+
+This guide covers installation for both mock mode (no Revit required) and bridge mode (Windows with Revit).
+
+## Prerequisites
+
+### Mock Mode
+- Python 3.11 or later
+- pip package manager
+- Git
+
+### Bridge Mode (Additional)
+- Windows 10/11
+- Autodesk Revit 2024-2027
+- .NET Framework 4.8
+- Visual Studio 2019/2022 or MSBuild tools
+- Revit SDK (installed with Revit or available from Autodesk Developer Network)
+
+## Mock Mode Setup
+
+Mock mode runs the complete MCP server with deterministic responses, suitable for CI, testing, and development without Revit.
+
+### 1. Clone Repository
+
+```bash
+git clone https://github.com/YOUR_ORG/mcp-revit-bridge.git
+cd mcp-revit-bridge
+```
+
+### 2. Create Virtual Environment
+
+```bash
+python -m venv venv
+```
+
+Activate the environment:
+- Windows: `venv\Scripts\activate`
+- Linux/Mac: `source venv/bin/activate`
+
+### 3. Install Python Package
+
+```bash
+pip install -e packages/mcp-server-revit[dev]
+```
+
+This installs the MCP server with development dependencies (ruff, mypy, pytest).
+
+### 4. Configure Environment
+
+Set required environment variables:
+
+```powershell
+# PowerShell (Windows)
+$env:MCP_REVIT_MODE = "mock"
+$env:WORKSPACE_DIR = "C:\revit-workspace"
+$env:MCP_REVIT_ALLOWED_DIRECTORIES = "C:\revit-workspace;C:\temp"
+```
+
+```bash
+# Bash (Linux/Mac)
+export MCP_REVIT_MODE="mock"
+export WORKSPACE_DIR="/home/user/revit-workspace"
+export MCP_REVIT_ALLOWED_DIRECTORIES="/home/user/revit-workspace:/tmp"
+```
+
+Or use the provided script:
+
+```powershell
+.\scripts\dev.ps1
+```
+
+### 5. Verify Installation
+
+```bash
+python -m pytest packages/mcp-server-revit/tests
+```
+
+All tests should pass.
+
+### 6. Run Mock Server
+
+```bash
+python -m revit_mcp_server
+```
+
+The server listens on stdin/stdout for MCP protocol messages.
+
+### 7. Run Demo Client
+
+```bash
+python packages/client-demo/demo.py
+```
+
+Expected output:
+- Health check: `{"status": "healthy", "mode": "mock"}`
+- Document opened: Mock response with document path
+- Export quantities: Mock CSV file created in workspace
+- Audit log: JSON file with request tracking
+
+## Bridge Mode Setup
+
+Bridge mode connects the MCP server to a running Revit instance via the .NET add-in.
+
+### 1. Complete Mock Mode Setup
+
+Follow steps 1-3 from Mock Mode Setup.
+
+### 2. Set Environment Variable
+
+```powershell
+$env:REVIT_SDK = "C:\Program Files\Autodesk\Revit 2024\SDK"
+```
+
+Adjust path to your Revit version and SDK location.
+
+### 3. Build Bridge Add-in
+
+```powershell
+.\scripts\build-addin.ps1
+```
+
+This compiles [RevitBridge.csproj](../packages/revit-bridge-addin/RevitBridge.csproj) to a DLL.
+
+Expected output: `packages/revit-bridge-addin/bin/Release/{year}/{framework}/AECModelBridge.dll`
+
+### 4. Install Add-in Manifest
+
+```powershell
+.\scripts\install-addin.ps1 -RevitYear 2024
+```
+
+This copies [AECModelBridge.addin](../packages/revit-bridge-addin/AECModelBridge.addin) to `%ProgramData%\Autodesk\Revit\Addins\2024\`.
+
+### 5. Launch Revit
+
+Start Revit. The add-in loads automatically and starts the HTTP bridge on `http://localhost:3000/`.
+
+Verify in Revit:
+- Check the Add-Ins tab for "Revit Bridge" (if UI is implemented)
+- Bridge server runs silently in background
+
+### 6. Configure MCP Server for Bridge Mode
+
+Update environment:
+
+```powershell
+$env:MCP_REVIT_MODE = "bridge"
+$env:MCP_REVIT_BRIDGE_URL = "http://localhost:3000"
+```
+
+Or edit [examples/revit-mcp-config.json](../examples/revit-mcp-config.json):
+
+```json
+{
+ "mode": "bridge",
+ "bridge_url": "http://localhost:3000",
+ "workspace_dir": "C:\\revit-workspace",
+ "allowed_directories": ["C:\\revit-workspace"]
+}
+```
+
+### 7. Run Bridge Server
+
+```bash
+python -m revit_mcp_server
+```
+
+### 8. Run Demo Client
+
+```bash
+python packages/client-demo/demo.py
+```
+
+Expected output:
+- Health check: `{"status": "healthy", "mode": "bridge", "revit_version": "2024"}`
+- Real Revit operations execute via the bridge
+
+## Configuration Reference
+
+### Environment Variables
+
+| Variable | Required | Default | Description |
+|----------|----------|---------|-------------|
+| `MCP_REVIT_MODE` | Yes | - | `mock` or `bridge` |
+| `WORKSPACE_DIR` | Yes | - | Root directory for file operations |
+| `MCP_REVIT_ALLOWED_DIRECTORIES` | Yes | - | Semicolon-separated list of allowed paths |
+| `MCP_REVIT_BRIDGE_URL` | Bridge only | `http://localhost:3000` | Bridge HTTP endpoint |
+| `MCP_REVIT_AUDIT_LOG` | No | `workspace/audit.jsonl` | Audit log file path |
+| `REVIT_SDK` | Build only | - | Path to Revit SDK for building add-in |
+
+### Configuration File
+
+Alternative to environment variables: use a JSON config file.
+
+```json
+{
+ "mode": "mock",
+ "workspace_dir": "/path/to/workspace",
+ "allowed_directories": ["/path/to/workspace", "/path/to/data"],
+ "bridge_url": "http://localhost:3000",
+ "audit_log": "workspace/audit.jsonl"
+}
+```
+
+Load with:
+
+```bash
+python -m revit_mcp_server --config examples/revit-mcp-config.json
+```
+
+## Troubleshooting
+
+### Issue: Workspace Violation Error
+
+**Error**: `WorkspaceViolation: Path outside allowed directories`
+
+**Fix**:
+1. Verify `WORKSPACE_DIR` and `MCP_REVIT_ALLOWED_DIRECTORIES` are set
+2. Ensure paths use absolute paths (not relative)
+3. On Windows, use double backslashes or forward slashes: `C:\\workspace` or `C:/workspace`
+4. Check directory exists and has read/write permissions
+
+### Issue: Schema Validation Failed
+
+**Error**: `SchemaValidationError: Field 'document_path' is required`
+
+**Fix**:
+1. Check tool input matches schema in [docs/tools.md](tools.md)
+2. Review error message for missing/invalid fields
+3. Run tests to see valid examples: `pytest packages/mcp-server-revit/tests/test_tools.py -v`
+
+### Issue: Bridge Connection Refused
+
+**Error**: `BridgeError: Connection refused to http://localhost:3000`
+
+**Fix**:
+1. Verify Revit is running with the add-in loaded
+2. Check add-in manifest is installed: `%ProgramData%\Autodesk\Revit\Addins\2024\AECModelBridge.addin`
+3. Verify DLL path in manifest points to the built DLL
+4. Check Windows Firewall isn't blocking localhost:3000
+5. Review Revit Journal file for add-in load errors
+
+### Issue: Add-in Build Failed
+
+**Error**: `MSBuild error: RevitAPI reference not found`
+
+**Fix**:
+1. Set `REVIT_SDK` environment variable to correct SDK path
+2. Verify Revit SDK is installed (comes with Revit or download separately)
+3. Check [RevitBridge.csproj](../packages/revit-bridge-addin/RevitBridge.csproj) references match your Revit version
+4. Ensure Visual Studio or MSBuild tools are installed
+
+### Issue: Mock Mode Files Not Created
+
+**Error**: Export tools don't create output files in mock mode
+
+**Fix**:
+1. Verify `WORKSPACE_DIR` exists and is writable
+2. Check `MCP_REVIT_MODE=mock` is set
+3. Review audit log for errors: `cat workspace/audit.jsonl`
+4. Ensure no file permission issues in workspace directory
+
+## Next Steps
+
+- Review [tool catalog](tools.md) for available operations
+- Understand [architecture](architecture.md) and trust boundaries
+- Read [security model](security.md) for production deployments
+- Explore [examples](../examples/) for workflow configurations
diff --git a/docs/logging-and-audit.md b/docs/logging-and-audit.md
new file mode 100644
index 0000000..30f4457
--- /dev/null
+++ b/docs/logging-and-audit.md
@@ -0,0 +1,64 @@
+# Logging And Audit
+
+This repository records operational information in two different layers:
+
+- Python-side audit logging
+- C# bridge-side runtime logging
+
+## Python Audit Recorder
+
+The audit implementation lives in [packages/mcp-server-revit/src/revit_mcp_server/security/audit.py](../packages/mcp-server-revit/src/revit_mcp_server/security/audit.py).
+
+`AuditRecorder.record()` writes one JSON line per tool invocation with:
+
+- UTC timestamp
+- tool name
+- request ID
+- payload
+- response
+
+This is the structured trail for MCP-level actions.
+
+## Bridge Runtime Logs
+
+The Revit add-in initializes Serilog in [App.cs](../packages/revit-bridge-addin/src/Bridge/App.cs).
+
+Current behavior:
+
+- log file path is created under `%APPDATA%\AECModelBridge\Logs\bridge.jsonl`
+- logs roll daily
+- bridge startup, shutdown, request receipt, and execution errors are recorded
+
+This is the operational trail for the .NET side of the system.
+
+## Why Two Layers Exist
+
+The Python process and the Revit add-in do not share a runtime or process boundary.
+
+Because of that:
+
+- Python audit logs tell you what the MCP layer believed it asked for
+- bridge logs tell you what the Revit-hosted runtime actually received and executed
+
+When debugging production issues, both logs matter.
+
+## What To Expect In Incidents
+
+If the MCP server validates and sends a request successfully, but Revit fails to execute it:
+
+- Python audit may still look normal
+- bridge log will often hold the actionable failure
+
+If a path is rejected or payload shape is wrong before the bridge is contacted:
+
+- Python audit and validation behavior will matter more than the bridge log
+
+## Operational Rule
+
+Never treat one log as the whole story. For live bridge failures, correlate:
+
+1. Python audit entry
+2. bridge runtime log entry
+3. any client-visible error response
+
+That three-point check is the fastest way to separate schema problems, transport problems, and live Revit execution problems.
diff --git a/docs/marketplaces.md b/docs/marketplaces.md
new file mode 100644
index 0000000..de5afe1
--- /dev/null
+++ b/docs/marketplaces.md
@@ -0,0 +1,114 @@
+# MCP Marketplaces and Client Distribution
+
+This project is prepared for the major MCP discovery paths that can be handled from a public GitHub repository.
+
+Some marketplaces can index the repository automatically once the official MCP Registry entry exists. Others still require a maintainer-owned account, OAuth approval, or a manual web form. Those final publication clicks cannot be completed from the repository alone.
+
+## Primary Listing
+
+### Official MCP Registry
+
+Status: configured.
+
+Files and automation:
+
+- [server.json](../server.json) is valid for the official registry and points to the v1.0.1 MCPB release artifact.
+- [.github/workflows/publish-mcp.yml](../.github/workflows/publish-mcp.yml) publishes with GitHub OIDC on version tags or manual workflow dispatch.
+- [.github/workflows/publish-pypi.yml](../.github/workflows/publish-pypi.yml) publishes the optional Python package to PyPI when triggered manually after PyPI trusted publishing is configured.
+- [packages/mcp-server-revit/README.md](../packages/mcp-server-revit/README.md) contains the required `mcp-name` ownership marker for PyPI verification if the package is also published to PyPI.
+
+Manual publish from a maintainer machine after installing the official publisher:
+
+```powershell
+mcp-publisher login github
+mcp-publisher publish
+```
+
+Automated publish from GitHub:
+
+```powershell
+git tag v1.0.1
+git push origin v1.0.1
+```
+
+The official registry is the feed most downstream MCP galleries and aggregators are expected to scrape.
+
+### GitHub MCP Registry and VS Code MCP Gallery
+
+Status: covered by the official MCP Registry path.
+
+GitHub and VS Code surface MCP servers from registry metadata. After the official registry publish succeeds, this server should be discoverable through the MCP surfaces that consume that registry. No separate VS Code extension is required for a standard stdio MCP server.
+
+The repository also includes [.vscode/mcp.json](../.vscode/mcp.json) so users can install the server into a VS Code workspace directly.
+
+## Client Configurations
+
+### VS Code / GitHub Copilot
+
+The workspace config is already committed at `.vscode/mcp.json`.
+
+For user-level install:
+
+```powershell
+code --add-mcp "{`"name`":`"revit`",`"type`":`"stdio`",`"command`":`"python`",`"args`":[`"-m`",`"revit_mcp_server.mcp_server`"],`"env`":{`"MCP_REVIT_MODE`":`"bridge`",`"MCP_REVIT_BRIDGE_URL`":`"http://127.0.0.1:3000`",`"MCP_REVIT_WORKSPACE_DIR`":`"C:\\RevitProjects`",`"MCP_REVIT_ALLOWED_DIRECTORIES`":`"C:\\RevitProjects`"}}"
+```
+
+### Claude Desktop, Cursor, Windsurf, Cline, Roo Code, Continue, and Similar Clients
+
+Most desktop MCP clients accept this shape:
+
+```json
+{
+ "mcpServers": {
+ "revit": {
+ "command": "python",
+ "args": ["-m", "revit_mcp_server.mcp_server"],
+ "env": {
+ "MCP_REVIT_MODE": "bridge",
+ "MCP_REVIT_BRIDGE_URL": "http://127.0.0.1:3000",
+ "MCP_REVIT_WORKSPACE_DIR": "C:\\RevitProjects",
+ "MCP_REVIT_ALLOWED_DIRECTORIES": "C:\\RevitProjects"
+ }
+ }
+ }
+}
+```
+
+If the Python package was installed from PyPI, the console script can be used instead:
+
+```json
+{
+ "mcpServers": {
+ "revit": {
+ "command": "aec-model-bridge",
+ "env": {
+ "MCP_REVIT_MODE": "bridge",
+ "MCP_REVIT_BRIDGE_URL": "http://127.0.0.1:3000",
+ "MCP_REVIT_WORKSPACE_DIR": "C:\\RevitProjects",
+ "MCP_REVIT_ALLOWED_DIRECTORIES": "C:\\RevitProjects"
+ }
+ }
+ }
+}
+```
+
+## Third-Party Directories
+
+These directories usually need either an official registry entry, repository URL submission, or maintainer account verification.
+
+| Directory | Current best path |
+| --- | --- |
+| PulseMCP | Already mirrors this repo. After official registry publish, claim or ask them to replace the temporary mirror with the official registry entry. |
+| MCP.Directory | Submit the GitHub repository URL and optional PyPI package URL through their server submission form. |
+| Glama | Let Glama index the official registry entry, then claim/verify the maintainer page if needed. |
+| Smithery | This Revit server is local stdio and Windows/Revit-dependent, so use MCPB/local distribution or a manual listing rather than hosted HTTP unless a remote bridge is added. |
+| MCP.so / MCP Market / MCP Store / Conare / Aibase | Submit the GitHub repository URL and use the client config above. These sites generally crawl README, GitHub metadata, and registry data. |
+
+## Release Checklist
+
+1. Build and attach the `.mcpb` artifact to the GitHub release.
+2. Update `server.json` version, artifact URL, and SHA-256 if the artifact changes.
+3. Run `mcp-publisher validate`.
+4. Publish to the official MCP Registry.
+5. Verify discovery through the registry API.
+6. Submit or claim listings on third-party directories.
diff --git a/docs/revit-addin-lifecycle.md b/docs/revit-addin-lifecycle.md
new file mode 100644
index 0000000..56266ad
--- /dev/null
+++ b/docs/revit-addin-lifecycle.md
@@ -0,0 +1,75 @@
+# Revit Add-in Lifecycle
+
+The Revit-side runtime starts in [packages/revit-bridge-addin/src/Bridge/App.cs](../packages/revit-bridge-addin/src/Bridge/App.cs).
+
+## Startup Path
+
+`App` implements `IExternalApplication`, so Revit calls:
+
+- `OnStartup()`
+- `OnShutdown()`
+
+During `OnStartup()` the add-in:
+
+1. initializes Serilog file logging
+2. captures the running Revit version
+3. creates a shared `CommandQueue`
+4. creates `RevitCommandExecutor` and wraps it in `ExternalEvent`
+5. constructs and starts `BridgeServer`
+6. builds the ribbon UI
+7. hooks `DocumentChanged` to keep `ActiveDocumentName` updated
+
+This is the full bootstrap chain that makes the localhost bridge usable.
+
+## Queue And UI Thread Handoff
+
+The important separation is:
+
+- `BridgeServer` receives HTTP requests off the Revit UI thread
+- `CommandQueue` stores pending requests and completion handles
+- `ExternalEvent.Raise()` transfers execution to `RevitCommandExecutor`
+- `RevitCommandExecutor.Execute()` drains the queue on the Revit API thread
+
+That pattern is what makes live Revit automation safe inside Autodesk's threading model.
+
+## Ribbon Surface
+
+`CreateModernRibbonInterface()` creates:
+
+- an `AEC Bridge` tab
+- a `Connection` panel
+- a `Tools` panel
+
+It wires button commands for:
+
+- connect
+- disconnect
+- status
+- settings
+- help
+
+The ribbon is more than cosmetic: it exposes operational status and provides a manual control surface for the bridge lifecycle.
+
+## Runtime State
+
+`App` keeps a few static values available to the rest of the add-in:
+
+- `RevitVersion`
+- `ActiveDocumentName`
+- `Server`
+
+Those values are used indirectly by the health endpoint and operator diagnostics.
+
+## Shutdown Path
+
+`OnShutdown()`:
+
+- stops the bridge server
+- disposes the `ExternalEvent`
+- flushes logs
+
+If shutdown errors occur, they are logged and returned as `Result.Failed`.
+
+## Operational Rule
+
+If the bridge looks healthy from the Python side but tools still do nothing, inspect the add-in lifecycle first. Most hard failures in this repo start before tool routing, during startup, ribbon initialization, or `ExternalEvent` creation.
diff --git a/docs/security.md b/docs/security.md
new file mode 100644
index 0000000..c7f65e2
--- /dev/null
+++ b/docs/security.md
@@ -0,0 +1,273 @@
+# Security Model
+
+AEC Model Bridge implements defense-in-depth security with workspace sandboxing, schema validation, audit logging, and safe defaults.
+
+## Trust Boundaries
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│ External Client (untrusted) │
+└─────────────────────┬───────────────────────────────────────┘
+ │ MCP Protocol (stdio)
+ │ JSON messages
+┌─────────────────────▼───────────────────────────────────────┐
+│ MCP Server (Python) │
+│ - Schema validation (Pydantic) │
+│ - Workspace enforcement │
+│ - Audit logging │
+│ - Tool routing │
+└─────────────────────┬───────────────────────────────────────┘
+ │ HTTP POST (localhost only)
+ │ {"tool": "...", "payload": {...}}
+┌─────────────────────▼───────────────────────────────────────┐
+│ Bridge Add-in (.NET) │
+│ - HTTP listener (127.0.0.1:3000) │
+│ - ExternalEvent queue │
+│ - Revit API operations │
+└─────────────────────┬───────────────────────────────────────┘
+ │ Revit API
+┌─────────────────────▼───────────────────────────────────────┐
+│ Revit Process │
+│ - Document operations │
+│ - File I/O │
+│ - Export operations │
+└─────────────────────────────────────────────────────────────┘
+```
+
+## Workspace Sandboxing
+
+All file operations are restricted to allowed directories configured at server startup.
+
+### Configuration
+
+```python
+# Environment variables
+WORKSPACE_DIR = "C:\\revit-workspace"
+MCP_REVIT_ALLOWED_DIRECTORIES = "C:\\revit-workspace;C:\\exports;C:\\templates"
+```
+
+### Enforcement
+
+The `WorkspaceMonitor` class validates every file path:
+
+```python
+from revit_mcp_server.security import WorkspaceMonitor
+
+monitor = WorkspaceMonitor(allowed_dirs=[Path("C:\\workspace")])
+safe_path = monitor.validate_path("C:\\workspace\\output.csv") # OK
+unsafe_path = monitor.validate_path("C:\\system32\\file.txt") # Raises WorkspaceViolation
+```
+
+### Path Resolution Rules
+
+1. All paths are resolved to absolute paths
+2. Symbolic links are resolved to their targets
+3. Path traversal attempts (`..`, `.`) are blocked
+4. Paths must be children of allowed directories (using `Path.is_relative_to()`)
+
+### Bypass Prevention
+
+- Paths are validated before any I/O operation
+- Mock mode also enforces workspace constraints
+- Validation occurs in both Python server and (planned) C# bridge
+
+## Schema Validation
+
+All tool inputs are validated against Pydantic models before execution.
+
+### Input Validation
+
+```python
+from revit_mcp_server.schemas import ExportSchedulesInput
+
+# Valid input
+valid = ExportSchedulesInput(
+ document_path="C:\\workspace\\model.rvt",
+ schedule_names=["Door Schedule", "Window Schedule"],
+ output_dir="C:\\workspace\\exports"
+)
+
+# Invalid input - raises ValidationError
+invalid = ExportSchedulesInput(
+ document_path=123, # Wrong type
+ schedule_names="not a list", # Wrong type
+ output_dir=None # Missing required field
+)
+```
+
+### Schema Coverage
+
+All 25 tools have defined schemas in [schemas.py](../packages/mcp-server-revit/src/revit_mcp_server/schemas.py):
+
+- Input schemas: Define required/optional fields, types, constraints
+- Output schemas: Structure response data consistently
+- Validation errors: Return clear messages to client
+
+## Audit Logging
+
+Every tool invocation is logged with structured data.
+
+### Log Format
+
+```json
+{
+ "timestamp": "2025-01-07T10:30:45.123Z",
+ "request_id": "req_abc123",
+ "tool": "revit.export_schedules",
+ "payload": {
+ "document_path": "C:\\workspace\\model.rvt",
+ "schedule_names": ["Door Schedule"],
+ "output_dir": "C:\\workspace\\exports"
+ },
+ "response": {
+ "success": true,
+ "exports": ["C:\\workspace\\exports\\Door_Schedule.csv"]
+ },
+ "duration_ms": 1250,
+ "mode": "bridge"
+}
+```
+
+### Log Location
+
+Default: `{WORKSPACE_DIR}/audit.jsonl`
+
+Configure with:
+```bash
+export MCP_REVIT_AUDIT_LOG="/var/log/revit-mcp/audit.jsonl"
+```
+
+### Log Security
+
+- Append-only (no modification of past entries)
+- Includes all tool invocations (successful and failed)
+- Records file paths for output artifacts
+- Tamper-evident via chronological timestamps
+
+### Use Cases
+
+- Compliance auditing
+- Debugging failed operations
+- Usage analytics
+- Security incident investigation
+
+## Safe Defaults
+
+The server ships with secure defaults that must be explicitly relaxed.
+
+### Default Configuration
+
+- Mode: Not set (must be explicitly configured as `mock` or `bridge`)
+- Workspace: Not set (must be configured before first use)
+- Allowed directories: Empty (must be explicitly listed)
+- Bridge URL: `http://localhost:3000` (localhost only, not exposed externally)
+- Audit logging: Enabled (cannot be disabled)
+
+### Network Security
+
+The bridge HTTP listener:
+- Binds only to `127.0.0.1` (localhost)
+- Does not implement authentication (relies on localhost boundary)
+- Does not use HTTPS (localhost traffic is trusted)
+- Should never be exposed to external networks
+
+**Do not**:
+- Port forward bridge endpoint
+- Bind bridge to `0.0.0.0`
+- Proxy bridge through a reverse proxy accessible externally
+
+### Destructive Operations Policy
+
+Operations that modify models or delete data are disabled by default in mock mode and logged extensively in bridge mode.
+
+Destructive operations:
+- Model modification (element creation/deletion)
+- Document saves
+- File deletions
+- Batch operations on multiple documents
+
+Enable cautiously in production:
+```json
+{
+ "allow_destructive": true,
+ "destructive_confirm": true
+}
+```
+
+## Tool Allow-List
+
+While all 25 tools are exposed by default, you can restrict available tools for specific deployments.
+
+### Configuration
+
+```json
+{
+ "allowed_tools": [
+ "revit.health",
+ "revit.export_schedules",
+ "revit.export_quantities"
+ ]
+}
+```
+
+Tools not in the allow-list return an error when invoked.
+
+### Use Cases
+
+- Limit CI/CD pipelines to read-only export operations
+- Restrict automated workflows to specific QA tools
+- Create role-specific tool subsets
+
+## Mock Mode Security
+
+Mock mode provides the same security guarantees as bridge mode without requiring Revit.
+
+### Mock Mode Features
+
+- Workspace sandboxing: Enforced identically to bridge mode
+- Schema validation: Same Pydantic models
+- Audit logging: Full request/response logging
+- Deterministic outputs: Predictable mock data for testing
+
+### CI/CD Safety
+
+Mock mode is safe for CI environments:
+- No external network access
+- No Revit dependency
+- No system modifications outside workspace
+- Repeatable outputs for regression testing
+
+## Security Checklist
+
+Before deploying to production:
+
+- [ ] Configure `WORKSPACE_DIR` to a dedicated directory
+- [ ] Set `MCP_REVIT_ALLOWED_DIRECTORIES` to minimum required paths
+- [ ] Verify bridge binds to `127.0.0.1` only (default)
+- [ ] Review audit log location and retention policy
+- [ ] Test workspace violations raise errors (not silently fail)
+- [ ] Verify schema validation blocks malformed inputs
+- [ ] Confirm destructive operations are appropriately restricted
+- [ ] Run in mock mode first to validate configuration
+- [ ] Document incident response procedures
+- [ ] Set up log monitoring/alerting
+
+## Threat Model
+
+### In Scope
+
+- Malicious MCP client attempting path traversal
+- Untrusted input attempting to corrupt Revit models
+- Unauthorized file access outside workspace
+- Tool invocation without audit trail
+
+### Out of Scope
+
+- Physical access to machine running bridge
+- Compromised Revit process
+- Operating system vulnerabilities
+- Revit API bugs or security issues (vendor responsibility)
+
+## Reporting Security Issues
+
+See [SECURITY.md](../SECURITY.md) for vulnerability reporting procedures.
diff --git a/docs/target-frameworks-and-dependencies.md b/docs/target-frameworks-and-dependencies.md
new file mode 100644
index 0000000..d3abdda
--- /dev/null
+++ b/docs/target-frameworks-and-dependencies.md
@@ -0,0 +1,69 @@
+# Target Frameworks And Dependencies
+
+This repository is intentionally polyglot. The Python MCP server and the Revit add-in do not share the same runtime constraints.
+
+## Python Package
+
+The Python package metadata lives in [packages/mcp-server-revit/pyproject.toml](../packages/mcp-server-revit/pyproject.toml).
+
+Current characteristics:
+
+- package name: `aec-model-bridge`
+- Python requirement: `>=3.11`
+- validation and settings stack: `pydantic`, `pydantic-settings`
+- transport stack: `httpx`
+- environment loading: `python-dotenv`
+- development and test dependencies are defined inline rather than split into a separate requirements file
+
+## Revit Add-in Targets
+
+The add-in project file is [packages/revit-bridge-addin/RevitBridge.csproj](../packages/revit-bridge-addin/RevitBridge.csproj).
+
+It conditionally targets:
+
+- `net48` for Revit 2024
+- `net8.0-windows` for Revit 2025 and 2026
+- `net10.0-windows` for Revit 2027
+
+That dual-target behavior is one of the most important build facts in the repo.
+
+## Revit API Reference Strategy
+
+The add-in first tries to bind against locally installed Revit assemblies:
+
+- `RevitAPI.dll`
+- `RevitAPIUI.dll`
+
+If those are not present, it falls back to NuGet packages:
+
+- `Nice3point.Revit.Api.RevitAPI`
+- `Nice3point.Revit.Api.RevitAPIUI`
+
+This makes CI and local developer environments more forgiving, while still supporting direct machine installs with real Autodesk binaries.
+
+## Additional Add-in Dependencies
+
+The C# layer also references:
+
+- `Serilog`
+- `Serilog.Sinks.File`
+- `System.Text.Json`
+- `IronPython` 2.7 on `net48`
+- `IronPython` 3.4.1 on the modern .NET targets used by Revit 2025-2027
+
+The conditional IronPython dependency exists because the repo exposes an `execute_python` bridge command.
+
+## Temporary Compile Exclusions
+
+`RevitBridge.csproj` currently removes several command directories from compilation:
+
+- `src\Commands\Core\**\*.cs`
+- `src\Commands\Advanced\**\*.cs`
+- `src\Commands\Specialized\**\*.cs`
+- `src\Commands\Enhancements\**\*.cs`
+
+That means the source tree advertises a broader command surface than the compiled binary necessarily includes at the moment.
+
+## Operational Rule
+
+When a build succeeds locally but not in CI, check target framework and dependency resolution before debugging the business logic. In this repo, version-conditional framework selection is part of normal operation, not an edge case.
diff --git a/docs/tools.md b/docs/tools.md
index 94adbf0..2de9d3e 100644
--- a/docs/tools.md
+++ b/docs/tools.md
@@ -1,6 +1,6 @@
# Tool Catalog
-MCP Revit Bridge exposes 25 tools organized into five categories: health checks, document operations, QA audits, export operations, and automation workflows.
+AEC Model Bridge exposes tools for health checks, document operations, QA audits, export operations, and automation workflows.
All tools accept JSON inputs validated against Pydantic schemas and return structured JSON responses.
diff --git a/packages/mcp-server-revit/README.md b/packages/mcp-server-revit/README.md
index 9ffb6dc..2052887 100644
--- a/packages/mcp-server-revit/README.md
+++ b/packages/mcp-server-revit/README.md
@@ -1,10 +1,10 @@
-# Autodesk Revit MCP Server (Python Package)
+# AEC Model Bridge (Python Package)
-Python package for the Autodesk Revit MCP server used by AI clients over stdio.
+Independent MCP integration for Autodesk Revit® software, used by AI clients over stdio.
-- Repository: https://github.com/Sam-AEC/Autodesk-Revit-MCP-Server
+- Repository: https://github.com/Sam-AEC/aec-model-bridge
- MCP entrypoint: `python -m revit_mcp_server.mcp_server`
-- Console script: `revit-mcp-server`
+- Console scripts: `aec-model-bridge` and the compatibility alias `revit-mcp-server`
- Requires Python 3.11+
Environment variables (prefix `MCP_REVIT_`) include:
@@ -16,5 +16,8 @@ Environment variables (prefix `MCP_REVIT_`) include:
- `AUDIT_LOG`
- `LOG_LEVEL`
-<!-- mcp-name: io.github.Sam-AEC/autodesk-revit-mcp-server -->
+Autodesk and Revit are trademarks of the Autodesk group of companies. Sam-AEC
+is not affiliated with Autodesk.
+
+<!-- mcp-name: io.github.Sam-AEC/aec-model-bridge -->
diff --git a/packages/mcp-server-revit/manifest.json b/packages/mcp-server-revit/manifest.json
new file mode 100644
index 0000000..6334c97
--- /dev/null
+++ b/packages/mcp-server-revit/manifest.json
@@ -0,0 +1,35 @@
+{
+ "manifest_version": "0.2",
+ "name": "aec-model-bridge",
+ "display_name": "AEC Model Bridge",
+ "version": "1.0.1",
+ "description": "Independent MCP integration for Autodesk Revit software through a local bridge.",
+ "author": {
+ "name": "Sam-AEC"
+ },
+ "repository": {
+ "type": "git",
+ "url": "https://github.com/Sam-AEC/aec-model-bridge.git"
+ },
+ "server": {
+ "type": "python",
+ "entry_point": "src/revit_mcp_server/mcp_server.py",
+ "mcp_config": {
+ "command": "python",
+ "args": [
+ "-m",
+ "revit_mcp_server.mcp_server"
+ ],
+ "env": {
+ "PYTHONPATH": "${__dirname}/src"
+ }
+ }
+ },
+ "license": "MIT",
+ "keywords": [
+ "mcp",
+ "revit",
+ "autodesk",
+ "bim"
+ ]
+}
diff --git a/packages/mcp-server-revit/pyproject.toml b/packages/mcp-server-revit/pyproject.toml
index f5173dc..6d3916a 100644
--- a/packages/mcp-server-revit/pyproject.toml
+++ b/packages/mcp-server-revit/pyproject.toml
@@ -1,7 +1,7 @@
[project]
-name = "revit-mcp-server"
-version = "1.0.0"
-description = "Model Context Protocol server for Autodesk Revit via a local bridge"
+name = "aec-model-bridge"
+version = "1.0.1"
+description = "Independent Model Context Protocol integration for Autodesk Revit software"
readme = "README.md"
requires-python = ">=3.11"
license = "MIT"
@@ -18,6 +18,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"
[project.optional-dependencies]
@@ -28,9 +29,9 @@ dev = [
]
[project.urls]
-Homepage = "https://github.com/Sam-AEC/Autodesk-Revit-MCP-Server"
-Repository = "https://github.com/Sam-AEC/Autodesk-Revit-MCP-Server"
-Issues = "https://github.com/Sam-AEC/Autodesk-Revit-MCP-Server/issues"
+Homepage = "https://github.com/Sam-AEC/aec-model-bridge"
+Repository = "https://github.com/Sam-AEC/aec-model-bridge"
+Issues = "https://github.com/Sam-AEC/aec-model-bridge/issues"
[build-system]
requires = ["setuptools>=68", "wheel"]
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 86814c5..da1a1ac 100644
--- a/packages/mcp-server-revit/src/revit_mcp_server/__init__.py
+++ b/packages/mcp-server-revit/src/revit_mcp_server/__init__.py
@@ -1,4 +1,4 @@
-"""Revit MCP server entrypoint."""
+"""AEC Model Bridge server entrypoint."""
from .server import run_server
diff --git a/packages/mcp-server-revit/src/revit_mcp_server/bridge/client.py b/packages/mcp-server-revit/src/revit_mcp_server/bridge/client.py
index 6e0be1c..40893c2 100644
--- a/packages/mcp-server-revit/src/revit_mcp_server/bridge/client.py
+++ b/packages/mcp-server-revit/src/revit_mcp_server/bridge/client.py
@@ -27,7 +27,7 @@ class BridgeClient:
except httpx.RequestError as e:
raise BridgeError(
f"Bridge unreachable at {self.base_url}. "
- f"Ensure Revit is running with RevitMCP add-in loaded. Error: {e}"
+ f"Ensure Revit is running with the AEC Model Bridge add-in loaded. Error: {e}"
) from e
def call_tool(self, tool: str, payload: dict[str, Any]) -> dict[str, Any]:
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 784bfe6..02f4718 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
@@ -491,28 +491,21 @@ async def list_tools() -> list[Tool]:
Tool(name="revit_get_rvt_links", description="Get RVT links", inputSchema={"type": "object", "properties": {}}),
Tool(name="revit_get_link_instances", description="Get link instances", inputSchema={"type": "object", "properties": {}}),
# Batch 5: Advanced MEP & Engineering
- Tool(name="revit_create_cable_tray", description="Create cable tray run", inputSchema={"type": "object", "properties": {"level": {"type": "string"}, "start_x": {"type": "number"}, "start_y": {"type": "number"}, "start_z": {"type": "number", "default": 10}, "end_x": {"type": "number"}, "end_y": {"type": "number"}, "end_z": {"type": "number", "default": 10}, "width": {"type": "number", "default": 1.0}, "height": {"type": "number", "default": 0.33}}, "required": ["level", "start_x", "start_y", "end_x", "end_y"]}),
Tool(name="revit_create_conduit", description="Create electrical conduit", inputSchema={"type": "object", "properties": {"level": {"type": "string"}, "start_x": {"type": "number"}, "start_y": {"type": "number"}, "start_z": {"type": "number", "default": 10}, "end_x": {"type": "number"}, "end_y": {"type": "number"}, "end_z": {"type": "number", "default": 10}, "diameter": {"type": "number", "default": 0.0625}}, "required": ["level", "start_x", "start_y", "end_x", "end_y"]}),
- Tool(name="revit_get_mep_systems", description="Get MEP systems info", inputSchema={"type": "object", "properties": {"system_type": {"type": "string", "default": "all"}}}),
Tool(name="revit_check_clashes", description="Check clashes between categories", inputSchema={"type": "object", "properties": {"category1": {"type": "string"}, "category2": {"type": "string"}, "tolerance": {"type": "number", "default": 0.01}}, "required": ["category1", "category2"]}),
# Batch 6: Materials & Visuals
Tool(name="revit_create_material", description="Create a new material with color and properties", inputSchema={"type": "object", "properties": {"name": {"type": "string"}, "color": {"type": "object", "properties": {"r": {"type": "integer"}, "g": {"type": "integer"}, "b": {"type": "integer"}}}, "transparency": {"type": "integer", "default": 0}, "shininess": {"type": "integer", "default": 50}, "smoothness": {"type": "integer", "default": 50}}, "required": ["name"]}),
Tool(name="revit_set_element_material", description="Set material for an element or specific face", inputSchema={"type": "object", "properties": {"element_id": {"type": "integer"}, "material_name": {"type": "string"}, "face_index": {"type": "integer", "description": "Optional face index for face-specific material"}}, "required": ["element_id", "material_name"]}),
- Tool(name="revit_get_render_settings", description="Get rendering settings from document", inputSchema={"type": "object", "properties": {}}),
# Batch 7: Family Management
Tool(name="revit_convert_to_group", description="Convert elements into a group", inputSchema={"type": "object", "properties": {"element_ids": {"type": "array", "items": {"type": "integer"}}, "name": {"type": "string"}}, "required": ["element_ids"]}),
Tool(name="revit_edit_family", description="Open a family for editing", inputSchema={"type": "object", "properties": {"family_name": {"type": "string"}, "family_symbol_id": {"type": "integer"}, "family_instance_id": {"type": "integer"}}, "required": []}),
# Batch 8: High-Value Documentation & Analysis
Tool(name="revit_create_dimension", description="Create linear dimension between elements", inputSchema={"type": "object", "properties": {"start_point": {"type": "object", "properties": {"x": {"type": "number"}, "y": {"type": "number"}, "z": {"type": "number"}}}, "end_point": {"type": "object", "properties": {"x": {"type": "number"}, "y": {"type": "number"}, "z": {"type": "number"}}}, "element1_id": {"type": "integer"}, "element2_id": {"type": "integer"}}, "required": ["start_point", "end_point", "element1_id", "element2_id"]}),
- Tool(name="revit_create_revision_cloud", description="Create revision cloud defined by points", inputSchema={"type": "object", "properties": {"view_id": {"type": "integer"}, "points": {"type": "array", "items": {"type": "object", "properties": {"x": {"type": "number"}, "y": {"type": "number"}, "z": {"type": "number"}}}}, "revision_id": {"type": "integer"}}, "required": ["view_id", "points"]}),
Tool(name="revit_get_revision_sequences", description="Get list of revision sequences", inputSchema={"type": "object", "properties": {}}),
Tool(name="revit_tag_all_in_view", description="Tag all elements of a category in view", inputSchema={"type": "object", "properties": {"category": {"type": "string"}}, "required": ["category"]}),
- Tool(name="revit_create_text_type", description="Create or duplicate a text type", inputSchema={"type": "object", "properties": {"name": {"type": "string"}, "font": {"type": "string", "default": "Arial"}, "size_inches": {"type": "number", "default": 0.09375}}, "required": ["name"]}),
Tool(name="revit_get_view_templates", description="Get list of view templates", inputSchema={"type": "object", "properties": {}}),
Tool(name="revit_apply_view_template", description="Apply view template to a view", inputSchema={"type": "object", "properties": {"view_id": {"type": "integer"}, "template_id": {"type": "integer"}}, "required": ["view_id", "template_id"]}),
Tool(name="revit_calculate_material_quantities", description="Calculate material volumes for a category", inputSchema={"type": "object", "properties": {"category": {"type": "string"}}, "required": ["category"]}),
- Tool(name="revit_get_room_boundary", description="Get room geometric boundary loops", inputSchema={"type": "object", "properties": {"room_id": {"type": "integer"}}, "required": ["room_id"]}),
- Tool(name="revit_get_project_location", description="Get project base and survey points", inputSchema={"type": "object", "properties": {}}),
Tool(name="revit_get_warnings", description="Get current project warnings", inputSchema={"type": "object", "properties": {}}),
# Batch 9: Universal Reflection Bridge (10k+ Tools)
Tool(name="revit_invoke_method", description="Invoke any Revit API method dynamically using Reflection", inputSchema={"type": "object", "properties": {"class_name": {"type": "string"}, "method_name": {"type": "string"}, "arguments": {"type": "array", "items": {}}, "target_id": {"type": "string"}, "use_transaction": {"type": "boolean", "default": True}}, "required": ["class_name", "method_name", "arguments"]}),
@@ -879,14 +872,6 @@ async def call_tool(name: str, arguments: Any) -> list[TextContent]:
"revit_get_rvt_links": ("revit.get_rvt_links", {}),
"revit_get_link_instances": ("revit.get_link_instances", {}),
# Batch 5: Advanced MEP & Engineering
- "revit_create_cable_tray": ("revit.create_cable_tray", {
- "level": arguments.get("level"),
- "start_point": {"x": arguments.get("start_x"), "y": arguments.get("start_y"), "z": arguments.get("start_z", 10)},
- "end_point": {"x": arguments.get("end_x"), "y": arguments.get("end_y"), "z": arguments.get("end_z", 10)},
- "width": arguments.get("width", 1.0),
- "height": arguments.get("height", 0.33),
- "cable_tray_type": arguments.get("cable_tray_type")
- }),
"revit_create_conduit": ("revit.create_conduit", {
"level": arguments.get("level"),
"start_point": {"x": arguments.get("start_x"), "y": arguments.get("start_y"), "z": arguments.get("start_z", 10)},
@@ -894,9 +879,6 @@ async def call_tool(name: str, arguments: Any) -> list[TextContent]:
"diameter": arguments.get("diameter", 0.0625),
"conduit_type": arguments.get("conduit_type")
}),
- "revit_get_mep_systems": ("revit.get_mep_systems", {
- "system_type": arguments.get("system_type", "all")
- }),
"revit_check_clashes": ("revit.check_clashes", {
"category1": arguments.get("category1"),
"category2": arguments.get("category2"),
@@ -915,7 +897,6 @@ async def call_tool(name: str, arguments: Any) -> list[TextContent]:
"material_name": arguments.get("material_name"),
"face_index": arguments.get("face_index")
}),
- "revit_get_render_settings": ("revit.get_render_settings", {}),
# Batch 7: Family Management
"revit_convert_to_group": ("revit.convert_to_group", {
"element_ids": arguments.get("element_ids"),
@@ -933,26 +914,14 @@ async def call_tool(name: str, arguments: Any) -> list[TextContent]:
"element1_id": arguments.get("element1_id"),
"element2_id": arguments.get("element2_id")
}),
- "revit_create_revision_cloud": ("revit.create_revision_cloud", {
- "view_id": arguments.get("view_id"),
- "points": arguments.get("points"),
- "revision_id": arguments.get("revision_id")
- }),
"revit_get_revision_sequences": ("revit.get_revision_sequences", {}),
"revit_tag_all_in_view": ("revit.tag_all_in_view", {"category": arguments.get("category")}),
- "revit_create_text_type": ("revit.create_text_type", {
- "name": arguments.get("name"),
- "font": arguments.get("font"),
- "size_inches": arguments.get("size_inches")
- }),
"revit_get_view_templates": ("revit.get_view_templates", {}),
"revit_apply_view_template": ("revit.apply_view_template", {
"view_id": arguments.get("view_id"),
"template_id": arguments.get("template_id")
}),
"revit_calculate_material_quantities": ("revit.calculate_material_quantities", {"category": arguments.get("category")}),
- "revit_get_room_boundary": ("revit.get_room_boundary", {"room_id": arguments.get("room_id")}),
- "revit_get_project_location": ("revit.get_project_location", {}),
"revit_get_warnings": ("revit.get_warnings", {}),
# Batch 9: Universal Reflection Bridge
"revit_invoke_method": ("revit.invoke_method", {
@@ -1027,7 +996,7 @@ async def call_tool(name: str, arguments: Any) -> list[TextContent]:
error_msg += "Make sure:\n"
error_msg += "1. Revit is running\n"
error_msg += "2. A project is open in Revit\n"
- error_msg += "3. The RevitMCP Bridge add-in is loaded\n"
+ error_msg += "3. The AEC Model Bridge add-in is loaded\n"
error_msg += "4. The bridge is accessible at http://localhost:3000"
return [TextContent(type="text", text=error_msg)]
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 77c08f7..9673914 100644
--- a/packages/mcp-server-revit/src/revit_mcp_server/server.py
+++ b/packages/mcp-server-revit/src/revit_mcp_server/server.py
@@ -74,7 +74,7 @@ class MCPServer:
) -> None:
stdin = stdin or sys.stdin
stdout = stdout or sys.stdout
- stdout.write("Revit MCP server started. Awaiting JSON requests.\n")
+ stdout.write("AEC Model Bridge server started. Awaiting JSON requests.\n")
stdout.flush()
while line := stdin.readline():
diff --git a/packages/revit-bridge-addin/AECModelBridge.addin b/packages/revit-bridge-addin/AECModelBridge.addin
new file mode 100644
index 0000000..d73ee3b
--- /dev/null
+++ b/packages/revit-bridge-addin/AECModelBridge.addin
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="utf-8"?>
+<RevitAddIns>
+ <AddIn Type="Application">
+ <Name>AEC Model Bridge</Name>
+ <Assembly>C:\ProgramData\AECModelBridge\bin\AECModelBridge.dll</Assembly>
+ <AddInId>6721F048-9A81-4DE6-8543-B485A6329B92</AddInId>
+ <FullClassName>RevitBridge.Bridge.App</FullClassName>
+ <VendorId>SAMA</VendorId>
+ <VendorDescription>Independent MCP integration for Revit software</VendorDescription>
+ </AddIn>
+</RevitAddIns>
diff --git a/packages/revit-bridge-addin/RevitBridge.addin b/packages/revit-bridge-addin/RevitBridge.addin
deleted file mode 100644
index bc6b0fd..0000000
--- a/packages/revit-bridge-addin/RevitBridge.addin
+++ /dev/null
@@ -1,11 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<RevitAddIns>
- <AddIn Type="Application">
- <Name>RevitMCP Bridge</Name>
- <Assembly>C:\ProgramData\RevitMCP\bin\RevitBridge.dll</Assembly>
- <AddInId>6721F048-9A81-4DE6-8543-B485A6329B92</AddInId>
- <FullClassName>RevitBridge.Bridge.App</FullClassName>
- <VendorId>RevitMCP</VendorId>
- <VendorDescription>MCP server bridge for Autodesk Revit</VendorDescription>
- </AddIn>
-</RevitAddIns>
diff --git a/packages/revit-bridge-addin/RevitBridge.csproj b/packages/revit-bridge-addin/RevitBridge.csproj
index 2446bd7..6180083 100644
--- a/packages/revit-bridge-addin/RevitBridge.csproj
+++ b/packages/revit-bridge-addin/RevitBridge.csproj
@@ -3,19 +3,26 @@
<RevitVersion Condition="'$(RevitVersion)'==''">2024</RevitVersion>
<TargetFramework Condition="'$(RevitVersion)' == '2024'">net48</TargetFramework>
<TargetFramework Condition="'$(RevitVersion)' == '2025' OR '$(RevitVersion)' == '2026'">net8.0-windows</TargetFramework>
- <AssemblyName>RevitBridge</AssemblyName>
+ <TargetFramework Condition="'$(RevitVersion)' == '2027'">net10.0-windows</TargetFramework>
+ <AssemblyName>AECModelBridge</AssemblyName>
<RootNamespace>RevitBridge</RootNamespace>
+ <Version>1.0.1</Version>
+ <AssemblyVersion>1.0.1.0</AssemblyVersion>
+ <FileVersion>1.0.1.0</FileVersion>
+ <InformationalVersion>1.0.1</InformationalVersion>
<OutputType>Library</OutputType>
<OutputPath>bin\$(Configuration)\$(RevitVersion)\</OutputPath>
<LangVersion>latest</LangVersion>
<Nullable>enable</Nullable>
<UseWPF>true</UseWPF>
+ <CopyLocalLockFileAssemblies>true</CopyLocalLockFileAssemblies>
</PropertyGroup>
<PropertyGroup>
<RevitInstallPath Condition="'$(RevitVersion)'=='2024'">C:\Program Files\Autodesk\Revit 2024</RevitInstallPath>
<RevitInstallPath Condition="'$(RevitVersion)'=='2025'">C:\Program Files\Autodesk\Revit 2025</RevitInstallPath>
<RevitInstallPath Condition="'$(RevitVersion)'=='2026'">C:\Program Files\Autodesk\Revit 2026</RevitInstallPath>
+ <RevitInstallPath Condition="'$(RevitVersion)'=='2027'">C:\Program Files\Autodesk\Revit 2027</RevitInstallPath>
<!-- Check if local Revit API exists, otherwise default to NuGet -->
<UseLocalRevit Condition="Exists('$(RevitInstallPath)\RevitAPI.dll')">true</UseLocalRevit>
<UseLocalRevit Condition="'$(UseLocalRevit)'==''">false</UseLocalRevit>
@@ -42,14 +49,14 @@
<ItemGroup>
<PackageReference Include="Serilog" Version="3.1.1" />
<PackageReference Include="Serilog.Sinks.File" Version="5.0.0" />
- <PackageReference Include="System.Text.Json" Version="6.0.10" />
+ <PackageReference Include="System.Text.Json" Version="6.0.10" Condition="'$(TargetFramework)'=='net48'" />
<!-- IronPython: enables execute_python tool (in-process Python scripting with full Revit API access) -->
<PackageReference Include="IronPython" Version="2.7.12" Condition="'$(TargetFramework)'=='net48'" />
- <PackageReference Include="IronPython" Version="3.4.1" Condition="'$(TargetFramework)'=='net8.0-windows'" />
+ <PackageReference Include="IronPython" Version="3.4.1" Condition="'$(TargetFramework)'!='net48'" />
</ItemGroup>
- <!-- WPF References for Modern UI -->
- <ItemGroup>
+ <!-- .NET Framework requires explicit WPF references; modern SDK targets use UseWPF. -->
+ <ItemGroup Condition="'$(TargetFramework)'=='net48'">
<Reference Include="PresentationCore" />
<Reference Include="PresentationFramework" />
<Reference Include="WindowsBase" />
diff --git a/packages/revit-bridge-addin/src/Bridge/AdditionalCommands.cs b/packages/revit-bridge-addin/src/Bridge/AdditionalCommands.cs
index 9d348b6..0792da6 100644
--- a/packages/revit-bridge-addin/src/Bridge/AdditionalCommands.cs
+++ b/packages/revit-bridge-addin/src/Bridge/AdditionalCommands.cs
@@ -42,7 +42,7 @@ namespace RevitBridge.Bridge
dialog.AddInfoSection("Advanced",
"Note: Advanced settings can be configured in the config file.\n" +
- "Location: %AppData%\\RevitMCP\\config.json");
+ "Location: %AppData%\\AECModelBridge\\config.json");
dialog.SetActionButton("OK");
dialog.ShowDialog();
@@ -61,7 +61,7 @@ namespace RevitBridge.Bridge
private void ShowHelpDialog()
{
var dialog = new ModernDialog();
- dialog.SetTitle("RevitMCP Help", "Documentation & Support");
+ dialog.SetTitle("AEC Model Bridge Help", "Documentation & Support");
dialog.AddStatsGrid(
("📘", "Tools", "233"),
@@ -92,7 +92,7 @@ namespace RevitBridge.Bridge
dialog.AddSeparator();
dialog.AddInfoSection("Documentation",
- "GitHub: github.com/Sam-AEC/Autodesk-Revit-MCP-Server\n" +
+ "GitHub: github.com/Sam-AEC/aec-model-bridge\n" +
"Docs: See README.md for full documentation");
dialog.AddInfoSection("Support",
@@ -105,7 +105,7 @@ namespace RevitBridge.Bridge
{
Process.Start(new ProcessStartInfo
{
- FileName = "https://github.com/Sam-AEC/Autodesk-Revit-MCP-Server",
+ FileName = "https://github.com/Sam-AEC/aec-model-bridge",
UseShellExecute = true
});
}
@@ -129,22 +129,22 @@ namespace RevitBridge.Bridge
private void ShowAboutDialog()
{
var dialog = new ModernDialog();
- dialog.SetTitle("About RevitMCP Bridge", "Version 1.0.0");
+ dialog.SetTitle("About AEC Model Bridge", "Version 1.0.1");
dialog.AddStatusCard(
"🏆",
- "RevitMCP Bridge",
- "AI-Powered Revit Automation Platform",
+ "AEC Model Bridge",
+ "Independent MCP integration for Revit software",
new MediaBrush(MediaColor.FromRgb(33, 150, 243))
);
dialog.AddSeparator();
dialog.AddInfoSection("Version Information",
- "Version: 1.0.0\n" +
+ "Version: 1.0.1\n" +
$"Revit: {App.RevitVersion ?? "Unknown"}\n" +
- "Build: 2026.01.08\n" +
- "Platform: .NET Framework 4.8");
+ "Build: 2026.06.11\n" +
+ "Platform: Revit-version-specific .NET runtime");
dialog.AddSeparator();
@@ -161,9 +161,9 @@ namespace RevitBridge.Bridge
dialog.AddInfoSection("Credits",
"Built with Model Context Protocol (MCP)\n" +
- "Powered by Anthropic Claude\n" +
"Revit API Integration\n\n" +
- "© 2026 RevitMCP Project");
+ "Copyright 2026 AEC Model Bridge Contributors\n\n" +
+ "Not affiliated with or endorsed by Autodesk.");
dialog.SetActionButton("Close");
dialog.ShowDialog();
diff --git a/packages/revit-bridge-addin/src/Bridge/App.cs b/packages/revit-bridge-addin/src/Bridge/App.cs
index 1db300d..68f513f 100644
--- a/packages/revit-bridge-addin/src/Bridge/App.cs
+++ b/packages/revit-bridge-addin/src/Bridge/App.cs
@@ -1,5 +1,6 @@
using System;
using System.IO;
+using System.Windows.Media.Imaging;
using Autodesk.Revit.UI;
using RevitBridge.UI;
using Serilog;
@@ -32,27 +33,35 @@ namespace RevitBridge.Bridge
Server = _server; // Expose statically
_server.Start();
- // Create Modern Ribbon UI with Icons
- CreateModernRibbonInterface(application);
+ try
+ {
+ CreateModernRibbonInterface(application);
+ }
+ catch (Exception ex)
+ {
+ Log.Error(ex, "Bridge started, but the AEC Model Bridge ribbon could not be created");
+ }
application.ControlledApplication.DocumentChanged += (sender, args) =>
{
ActiveDocumentName = args.GetDocument()?.Title;
};
- Log.Information("RevitMCP Bridge started for Revit {Version}", RevitVersion);
+ Log.Information("AEC Model Bridge started for Revit {Version}", RevitVersion);
return Result.Succeeded;
}
catch (Exception ex)
{
- Log.Fatal(ex, "Failed to start RevitMCP Bridge");
+ Log.Fatal(ex, "Failed to start AEC Model Bridge");
+ _server?.Stop();
+ _externalEvent?.Dispose();
return Result.Failed;
}
}
private void CreateModernRibbonInterface(UIControlledApplication app)
{
- string tabName = "RevitMCP";
+ string tabName = "AEC Bridge";
try
{
app.CreateRibbonTab(tabName);
@@ -81,7 +90,7 @@ namespace RevitBridge.Bridge
string settingsIconPath = Path.Combine(iconPath, "settings.png");
string helpIconPath = Path.Combine(iconPath, "help.png");
- // Dynamically generate theme-adaptive icons on startup to guarantee they are never missing and adapt to Revit's Dark/Light theme!
+ // Generate theme-adaptive icons, then retain in-memory fallbacks if file I/O fails.
try
{
IconGenerator.GenerateAllIcons(iconPath);
@@ -91,13 +100,12 @@ namespace RevitBridge.Bridge
Log.Error(ex, "Failed to dynamically generate ribbon icons");
}
- // Log if icons are missing
- if (!File.Exists(connectIconPath))
- Log.Warning("Icon not found: {IconPath}", connectIconPath);
- if (!File.Exists(disconnectIconPath))
- Log.Warning("Icon not found: {IconPath}", disconnectIconPath);
- if (!File.Exists(statusIconPath))
- Log.Warning("Icon not found: {IconPath}", statusIconPath);
+ BitmapSource connectIcon = LoadIcon(connectIconPath, IconGenerator.CreateConnectIcon);
+ BitmapSource disconnectIcon = LoadIcon(disconnectIconPath, IconGenerator.CreateDisconnectIcon);
+ BitmapSource statusIcon = LoadIcon(statusIconPath, IconGenerator.CreateStatusIcon);
+ BitmapSource brandIcon = LoadIcon(brandIconPath, IconGenerator.CreateBrandIcon);
+ BitmapSource settingsIcon = LoadIcon(settingsIconPath, IconGenerator.CreateSettingsIcon);
+ BitmapSource helpIcon = LoadIcon(helpIconPath, IconGenerator.CreateHelpIcon);
// === CONNECTION PANEL ===
@@ -109,14 +117,10 @@ namespace RevitBridge.Bridge
"RevitBridge.Bridge.CommandConnect"
);
connectBtnData.ToolTip = "Start the MCP Bridge Server";
- connectBtnData.LongDescription = "Starts the RevitMCP Bridge Server to enable AI-powered automation and natural language control of Revit.";
- if (File.Exists(connectIconPath))
- {
- connectBtnData.Image = new System.Windows.Media.Imaging.BitmapImage(new Uri(connectIconPath));
- connectBtnData.LargeImage = new System.Windows.Media.Imaging.BitmapImage(new Uri(connectIconPath));
- }
- if (File.Exists(brandIconPath))
- connectBtnData.ToolTipImage = new System.Windows.Media.Imaging.BitmapImage(new Uri(brandIconPath));
+ connectBtnData.LongDescription = "Starts AEC Model Bridge to enable MCP automation for Revit software.";
+ connectBtnData.Image = connectIcon;
+ connectBtnData.LargeImage = connectIcon;
+ connectBtnData.ToolTipImage = brandIcon;
// Disconnect Button
PushButtonData disconnectBtnData = new PushButtonData(
@@ -126,12 +130,9 @@ namespace RevitBridge.Bridge
"RevitBridge.Bridge.CommandDisconnect"
);
disconnectBtnData.ToolTip = "Stop the MCP Bridge Server";
- disconnectBtnData.LongDescription = "Stops the RevitMCP Bridge Server and closes all active connections.";
- if (File.Exists(disconnectIconPath))
- {
- disconnectBtnData.Image = new System.Windows.Media.Imaging.BitmapImage(new Uri(disconnectIconPath));
- disconnectBtnData.LargeImage = new System.Windows.Media.Imaging.BitmapImage(new Uri(disconnectIconPath));
- }
+ disconnectBtnData.LongDescription = "Stops AEC Model Bridge and closes all active connections.";
+ disconnectBtnData.Image = disconnectIcon;
+ disconnectBtnData.LargeImage = disconnectIcon;
// Status Button
PushButtonData statusBtnData = new PushButtonData(
@@ -142,11 +143,8 @@ namespace RevitBridge.Bridge
);
statusBtnData.ToolTip = "View Server Status and Statistics";
statusBtnData.LongDescription = "Displays detailed information about the Bridge Server including connection status, statistics, and capabilities.";
- if (File.Exists(statusIconPath))
- {
- statusBtnData.Image = new System.Windows.Media.Imaging.BitmapImage(new Uri(statusIconPath));
- statusBtnData.LargeImage = new System.Windows.Media.Imaging.BitmapImage(new Uri(statusIconPath));
- }
+ statusBtnData.Image = statusIcon;
+ statusBtnData.LargeImage = statusIcon;
// Create stacked items for better layout
connectionPanel.AddItem(connectBtnData);
@@ -165,11 +163,8 @@ namespace RevitBridge.Bridge
);
settingsBtnData.ToolTip = "Configure Bridge Settings";
settingsBtnData.LongDescription = "Configure server settings, port, logging, and other options.";
- if (File.Exists(settingsIconPath))
- {
- settingsBtnData.Image = new System.Windows.Media.Imaging.BitmapImage(new Uri(settingsIconPath));
- settingsBtnData.LargeImage = new System.Windows.Media.Imaging.BitmapImage(new Uri(settingsIconPath));
- }
+ settingsBtnData.Image = settingsIcon;
+ settingsBtnData.LargeImage = settingsIcon;
settingsBtnData.AvailabilityClassName = "RevitBridge.Bridge.CommandAvailability";
// Help Button
@@ -180,12 +175,9 @@ namespace RevitBridge.Bridge
"RevitBridge.Bridge.CommandHelp"
);
helpBtnData.ToolTip = "View Documentation";
- helpBtnData.LongDescription = "Open the RevitMCP Bridge documentation and user guide.";
- if (File.Exists(helpIconPath))
- {
- helpBtnData.Image = new System.Windows.Media.Imaging.BitmapImage(new Uri(helpIconPath));
- helpBtnData.LargeImage = new System.Windows.Media.Imaging.BitmapImage(new Uri(helpIconPath));
- }
+ helpBtnData.LongDescription = "Open the AEC Model Bridge documentation and user guide.";
+ helpBtnData.Image = helpIcon;
+ helpBtnData.LargeImage = helpIcon;
toolsPanel.AddItem(settingsBtnData);
toolsPanel.AddItem(helpBtnData);
@@ -197,13 +189,30 @@ namespace RevitBridge.Bridge
Log.Information("Modern ribbon interface created with icons");
}
+ private static BitmapSource LoadIcon(string path, Func<int, BitmapSource> fallbackFactory)
+ {
+ if (!File.Exists(path))
+ {
+ Log.Debug("Icon not found at {IconPath}; using generated fallback", path);
+ return fallbackFactory(32);
+ }
+
+ var icon = new BitmapImage();
+ icon.BeginInit();
+ icon.CacheOption = BitmapCacheOption.OnLoad;
+ icon.UriSource = new Uri(path, UriKind.Absolute);
+ icon.EndInit();
+ icon.Freeze();
+ return icon;
+ }
+
public Result OnShutdown(UIControlledApplication application)
{
try
{
_server?.Stop();
_externalEvent?.Dispose();
- Log.Information("RevitMCP Bridge stopped");
+ Log.Information("AEC Model Bridge stopped");
Log.CloseAndFlush();
return Result.Succeeded;
}
@@ -218,7 +227,7 @@ namespace RevitBridge.Bridge
{
var logPath = Path.Combine(
Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData),
- "RevitMCP", "Logs", "bridge.jsonl"
+ "AECModelBridge", "Logs", "bridge.jsonl"
);
Directory.CreateDirectory(Path.GetDirectoryName(logPath)!);
diff --git a/packages/revit-bridge-addin/src/Bridge/BridgeCommandFactory.cs b/packages/revit-bridge-addin/src/Bridge/BridgeCommandFactory.cs
index ad338b7..4af5eec 100644
--- a/packages/revit-bridge-addin/src/Bridge/BridgeCommandFactory.cs
+++ b/packages/revit-bridge-addin/src/Bridge/BridgeCommandFactory.cs
@@ -313,31 +313,23 @@ public static class BridgeCommandFactory
"revit.get_link_instances",
// Batch 5: Advanced MEP & Engineering
- "revit.create_cable_tray",
"revit.create_conduit",
- "revit.get_mep_systems",
"revit.check_clashes",
// Batch 6: Materials & Visuals
"revit.create_material",
"revit.set_element_material",
- "revit.get_render_settings",
// Batch 7: Family Management
"revit.convert_to_group",
"revit.edit_family",
// Batch 8: High-Value Documentation
- "revit.create_dimension",
- "revit.create_revision_cloud",
"revit.get_revision_sequences",
"revit.tag_all_in_view",
- "revit.create_text_type",
"revit.get_view_templates",
"revit.apply_view_template",
"revit.calculate_material_quantities",
- "revit.get_room_boundary",
- "revit.get_project_location",
"revit.get_warnings",
// Batch 9: Universal Reflection
@@ -3748,7 +3740,7 @@ public static class BridgeCommandFactory
family_name = family.Name,
family_document_title = familyDoc.Title,
is_family_document = familyDoc.IsFamilyDocument,
- categories = new FilteredElementCollector(familyDoc).OfClass(typeof(Category)).Cast<Category>().Select(c => c.Name).Take(10).ToList()
+ categories = familyDoc.Settings.Categories.Cast<Category>().Select(c => c.Name).Take(10).ToList()
};
}
diff --git a/packages/revit-bridge-addin/src/Bridge/BridgeCommands.cs b/packages/revit-bridge-addin/src/Bridge/BridgeCommands.cs
index 6edecb5..a365df4 100644
--- a/packages/revit-bridge-addin/src/Bridge/BridgeCommands.cs
+++ b/packages/revit-bridge-addin/src/Bridge/BridgeCommands.cs
@@ -139,7 +139,7 @@ namespace RevitBridge.Bridge
var dialog = new ModernDialog();
dialog.SetTitle(
- "RevitMCP Bridge Status",
+ "AEC Model Bridge Status",
App.Server!.IsRunning ? "Server is Active" : "Server is Stopped"
);
diff --git a/packages/revit-bridge-addin/src/Bridge/ExternalEventHandler.cs b/packages/revit-bridge-addin/src/Bridge/ExternalEventHandler.cs
index 84b96f0..4c1f008 100644
--- a/packages/revit-bridge-addin/src/Bridge/ExternalEventHandler.cs
+++ b/packages/revit-bridge-addin/src/Bridge/ExternalEventHandler.cs
@@ -52,5 +52,5 @@ public class RevitCommandExecutor : IExternalEventHandler
}
}
- public string GetName() => "RevitMCP Command Executor";
+ public string GetName() => "AEC Model Bridge Command Executor";
}
diff --git a/packages/revit-bridge-addin/src/UI/IconGenerator.cs b/packages/revit-bridge-addin/src/UI/IconGenerator.cs
index d5ba282..0577bcf 100644
--- a/packages/revit-bridge-addin/src/UI/IconGenerator.cs
+++ b/packages/revit-bridge-addin/src/UI/IconGenerator.cs
@@ -210,7 +210,7 @@ namespace RevitBridge.UI
}
/// <summary>
- /// Creates a branded RevitMCP icon (gorgeous isometric cyan/teal/blue 3D BIM cube)
+ /// Creates the generic AEC Model Bridge icon.
/// </summary>
public static BitmapSource CreateBrandIcon(int size = 32)
{
@@ -219,7 +219,7 @@ namespace RevitBridge.UI
{
double cX = size / 2.0;
- // High-end Gradient Brushes
+ // Gradient faces for a generic building-model cube.
var topBrush = new LinearGradientBrush(Color.FromRgb(0, 188, 212), Color.FromRgb(0, 150, 136), 45); // Cyan to Teal
var leftBrush = new LinearGradientBrush(Color.FromRgb(33, 150, 243), Color.FromRgb(21, 101, 192), 90); // Blue to Dark Blue
var rightBrush = new LinearGradientBrush(Color.FromRgb(0, 150, 136), Color.FromRgb(0, 105, 92), 90); // Dark Teal
diff --git a/packages/revit-bridge-addin/src/UI/ModernDialog.xaml b/packages/revit-bridge-addin/src/UI/ModernDialog.xaml
index ac21255..c281140 100644
--- a/packages/revit-bridge-addin/src/UI/ModernDialog.xaml
+++ b/packages/revit-bridge-addin/src/UI/ModernDialog.xaml
@@ -1,7 +1,7 @@
<Window x:Class="RevitBridge.UI.ModernDialog"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
- Title="RevitMCP Bridge"
+ Title="AEC Model Bridge"
Height="450"
Width="600"
WindowStartupLocation="CenterScreen"
@@ -126,12 +126,12 @@
<!-- Title -->
<StackPanel Grid.Column="1" VerticalAlignment="Center">
<TextBlock x:Name="DialogTitle"
- Text="RevitMCP Bridge Status"
+ Text="AEC Model Bridge Status"
FontSize="16"
FontWeight="SemiBold"
Foreground="White"/>
<TextBlock x:Name="DialogSubtitle"
- Text="AI-Powered Revit Automation"
+ Text="MCP automation for Revit software"
FontSize="11"
Foreground="White"
Opacity="0.85"/>
diff --git a/scripts/build-addin.ps1 b/scripts/build-addin.ps1
index d7b688a..fcf07ed 100644
--- a/scripts/build-addin.ps1
+++ b/scripts/build-addin.ps1
@@ -4,6 +4,12 @@ param(
)
$ErrorActionPreference = "Stop"
+$supportedVersions = @("2024", "2025", "2026", "2027")
+
+if ($supportedVersions -notcontains $RevitVersion) {
+ Write-Error "Unsupported Revit version: $RevitVersion. Supported: $($supportedVersions -join ', ')"
+ exit 1
+}
# Path Guard: Prevent Execution in System32 or Windows
if ($PSScriptRoot -like "*C:\Windows*") {
@@ -37,7 +43,7 @@ if (-not $msbuild) {
exit 1
}
-Write-Host "Building RevitBridge for Revit $RevitVersion ($Configuration)..." -ForegroundColor Cyan
+Write-Host "Building AEC Model Bridge for Revit $RevitVersion ($Configuration)..." -ForegroundColor Cyan
if ($msbuild -like "*dotnet*") {
& $msbuild build $projectPath `
@@ -57,5 +63,10 @@ if ($LASTEXITCODE -ne 0) {
exit $LASTEXITCODE
}
-$outputPath = "packages\revit-bridge-addin\bin\$Configuration\$RevitVersion\RevitBridge.dll"
-Write-Host "Build succeeded: $outputPath" -ForegroundColor Green
+$targetFramework = switch ($RevitVersion) {
+ "2024" { "net48" }
+ { $_ -in @("2025", "2026") } { "net8.0-windows" }
+ "2027" { "net10.0-windows" }
+}
+$outputPath = Join-Path $PSScriptRoot "..\packages\revit-bridge-addin\bin\$Configuration\$RevitVersion\$targetFramework\AECModelBridge.dll"
+Write-Host "Build succeeded: $([System.IO.Path]::GetFullPath($outputPath))" -ForegroundColor Green
diff --git a/scripts/build-release.ps1 b/scripts/build-release.ps1
new file mode 100644
index 0000000..fb6ba19
--- /dev/null
+++ b/scripts/build-release.ps1
@@ -0,0 +1,111 @@
+param(
+ [string]$Version = "1.0.1",
+ [string]$RevitVersion = "2027",
+ [switch]$UpdateServerMetadata
+)
+
+$ErrorActionPreference = "Stop"
+
+$repoRoot = [System.IO.Path]::GetFullPath((Join-Path $PSScriptRoot ".."))
+$distRoot = Join-Path $repoRoot "dist"
+$packageDir = Join-Path $distRoot "AECModelBridge"
+$releaseDir = Join-Path $distRoot "release"
+$mcpbStage = Join-Path $distRoot "mcpb-stage"
+
+function Remove-WorkspaceDirectory {
+ param([string]$Path)
+
+ $resolved = [System.IO.Path]::GetFullPath($Path)
+ if (-not $resolved.StartsWith($repoRoot, [System.StringComparison]::OrdinalIgnoreCase)) {
+ throw "Refusing to remove path outside repository: $resolved"
+ }
+
+ if (Test-Path -LiteralPath $resolved) {
+ Remove-Item -LiteralPath $resolved -Recurse -Force
+ }
+}
+
+Remove-WorkspaceDirectory $packageDir
+Remove-WorkspaceDirectory $releaseDir
+Remove-WorkspaceDirectory $mcpbStage
+New-Item -ItemType Directory -Path $releaseDir -Force | Out-Null
+
+& (Join-Path $PSScriptRoot "package.ps1") -Version $Version -RevitVersion $RevitVersion
+if ($LASTEXITCODE -ne 0) {
+ throw "Distribution packaging failed with exit code $LASTEXITCODE"
+}
+
+$bridgeDll = Join-Path $packageDir "bin\$RevitVersion\AECModelBridge.dll"
+if (-not (Test-Path -LiteralPath $bridgeDll)) {
+ throw "Expected bridge assembly was not produced: $bridgeDll"
+}
+
+$prohibitedNames = @(
+ "RevitAPI.dll",
+ "RevitAPIUI.dll",
+ "AdWindows.dll",
+ "AdskLicensingSDK_*.dll"
+)
+$prohibitedFiles = foreach ($pattern in $prohibitedNames) {
+ Get-ChildItem -Path $packageDir -Recurse -File -Filter $pattern -ErrorAction SilentlyContinue
+}
+if ($prohibitedFiles) {
+ $paths = ($prohibitedFiles.FullName | Sort-Object -Unique) -join [Environment]::NewLine
+ throw "Release contains Autodesk assemblies and cannot be published:$([Environment]::NewLine)$paths"
+}
+
+$distributionZip = Join-Path $releaseDir "aec-model-bridge-revit-$RevitVersion-$Version.zip"
+Compress-Archive -Path (Join-Path $packageDir "*") -DestinationPath $distributionZip -CompressionLevel Optimal
+
+New-Item -ItemType Directory -Path $mcpbStage -Force | Out-Null
+$pythonPackage = Join-Path $repoRoot "packages\mcp-server-revit"
+Copy-Item (Join-Path $pythonPackage "manifest.json") $mcpbStage -Force
+Copy-Item (Join-Path $pythonPackage "pyproject.toml") $mcpbStage -Force
+Copy-Item (Join-Path $pythonPackage "README.md") $mcpbStage -Force
+Copy-Item (Join-Path $pythonPackage "src") $mcpbStage -Recurse -Force
+
+Get-ChildItem -Path $mcpbStage -Recurse -Directory -Filter "__pycache__" |
+ Sort-Object FullName -Descending |
+ Remove-Item -Recurse -Force
+Get-ChildItem -Path $mcpbStage -Recurse -Directory -Filter "*.egg-info" |
+ Sort-Object FullName -Descending |
+ Remove-Item -Recurse -Force
+Get-ChildItem -Path $mcpbStage -Recurse -File -Include "*.pyc", "*.pyo" |
+ Remove-Item -Force
+
+$mcpbZip = Join-Path $releaseDir "aec-model-bridge-$Version.zip"
+$mcpbPath = Join-Path $releaseDir "aec-model-bridge-$Version.mcpb"
+Compress-Archive -Path (Join-Path $mcpbStage "*") -DestinationPath $mcpbZip -CompressionLevel Optimal
+Move-Item -LiteralPath $mcpbZip -Destination $mcpbPath
+
+$wheel = Get-ChildItem -Path (Join-Path $packageDir "server") -Filter "aec_model_bridge-$Version-*.whl" |
+ Select-Object -First 1
+if (-not $wheel) {
+ throw "Python wheel for version $Version was not produced."
+}
+Copy-Item -LiteralPath $wheel.FullName -Destination $releaseDir -Force
+
+$mcpbSha = (Get-FileHash -LiteralPath $mcpbPath -Algorithm SHA256).Hash.ToLowerInvariant()
+if ($UpdateServerMetadata) {
+ $serverPath = Join-Path $repoRoot "server.json"
+ $server = Get-Content -LiteralPath $serverPath -Raw | ConvertFrom-Json
+ $server.version = $Version
+ $server.packages[0].version = $Version
+ $server.packages[0].identifier = "https://github.com/Sam-AEC/aec-model-bridge/releases/download/v$Version/aec-model-bridge-$Version.mcpb"
+ $server.packages[0].fileSha256 = $mcpbSha
+ $server | ConvertTo-Json -Depth 20 | Set-Content -LiteralPath $serverPath -Encoding utf8
+}
+
+$checksums = Get-ChildItem -Path $releaseDir -File |
+ Where-Object Name -ne "SHA256SUMS.txt" |
+ Sort-Object Name |
+ ForEach-Object {
+ $hash = (Get-FileHash -LiteralPath $_.FullName -Algorithm SHA256).Hash.ToLowerInvariant()
+ "$hash $($_.Name)"
+ }
+$checksums | Set-Content -LiteralPath (Join-Path $releaseDir "SHA256SUMS.txt") -Encoding ascii
+
+Remove-WorkspaceDirectory $mcpbStage
+
+Write-Host "Release artifacts created in $releaseDir" -ForegroundColor Green
+Get-ChildItem -Path $releaseDir -File | Select-Object Name, Length
diff --git a/scripts/install-addin.ps1 b/scripts/install-addin.ps1
index e3bb6cc..9424b19 100644
--- a/scripts/install-addin.ps1
+++ b/scripts/install-addin.ps1
@@ -7,5 +7,9 @@ $target = Join-Path $AddinDir $RevitYear
if (-not (Test-Path $target)) {
New-Item -ItemType Directory -Path $target | Out-Null
}
-Copy-Item packages/revit-bridge-addin/RevitBridge.addin -Destination $target -Force
+Copy-Item packages/revit-bridge-addin/AECModelBridge.addin -Destination $target -Force
+$legacyManifest = Join-Path $target "RevitBridge.addin"
+if (Test-Path $legacyManifest) {
+ Remove-Item -LiteralPath $legacyManifest -Force
+}
Write-Host "Installed add-in manifest to $target"
diff --git a/scripts/install.ps1 b/scripts/install.ps1
index aa977ea..ec1d5f1 100644
--- a/scripts/install.ps1
+++ b/scripts/install.ps1
@@ -1,12 +1,12 @@
param(
[string]$RevitVersion = "2024",
[switch]$AllUsers,
- [string]$DistPath = "$PSScriptRoot\..\dist\RevitMCP"
+ [string]$DistPath = "$PSScriptRoot\..\dist\AECModelBridge"
)
$ErrorActionPreference = "Stop"
-Write-Host "RevitMCP Installer" -ForegroundColor Cyan
+Write-Host "AEC Model Bridge Installer" -ForegroundColor Cyan
Write-Host "==================`n" -ForegroundColor Cyan
# Path Guard: Prevent Execution in System32 or Windows
@@ -20,7 +20,7 @@ if ($PSScriptRoot -like "*C:\Windows*") {
if (-not (Test-Path $DistPath)) {
Write-Host "Distribution package not found at: $DistPath" -ForegroundColor Yellow
Write-Host "Auto-triggering packaging for Revit $RevitVersion..." -ForegroundColor Cyan
- & "$PSScriptRoot\package.ps1" -RevitVersion $RevitVersion -Version "1.0.0"
+ & "$PSScriptRoot\package.ps1" -RevitVersion $RevitVersion -Version "1.0.1"
if (-not (Test-Path $DistPath)) {
Write-Error "Packaging failed. Please run .\scripts\package.ps1 manually to diagnose."
@@ -30,7 +30,7 @@ if (-not (Test-Path $DistPath)) {
# Install binaries to ProgramData
Write-Host "Installing binaries..." -ForegroundColor Yellow
-$targetBin = "C:\ProgramData\RevitMCP\bin"
+$targetBin = "C:\ProgramData\AECModelBridge\bin"
New-Item -ItemType Directory -Path $targetBin -Force | Out-Null
$sourceBin = "$DistPath\bin\$RevitVersion"
@@ -52,12 +52,17 @@ else {
}
New-Item -ItemType Directory -Path $addinDir -Force | Out-Null
-Copy-Item "$DistPath\addin\RevitBridge.addin" $addinDir -Force
+Copy-Item "$DistPath\addin\AECModelBridge.addin" $addinDir -Force
+$legacyManifest = Join-Path $addinDir "RevitBridge.addin"
+if (Test-Path $legacyManifest) {
+ Remove-Item -LiteralPath $legacyManifest -Force
+ Write-Host " Removed legacy manifest: $legacyManifest" -ForegroundColor Gray
+}
Write-Host " Installed to: $addinDir" -ForegroundColor Green
# Copy config (optional)
Write-Host "`nCopying default configuration..." -ForegroundColor Yellow
-$configTarget = "C:\ProgramData\RevitMCP\config"
+$configTarget = "C:\ProgramData\AECModelBridge\config"
New-Item -ItemType Directory -Path $configTarget -Force | Out-Null
Copy-Item "$DistPath\config\default.json" $configTarget -Force
Write-Host " Installed to: $configTarget\default.json" -ForegroundColor Green
@@ -68,8 +73,8 @@ Write-Host "Installation Complete!" -ForegroundColor Green
Write-Host "========================================" -ForegroundColor Cyan
Write-Host "`nInstalled components:" -ForegroundColor Yellow
-Write-Host " Bridge DLL: $targetBin\RevitBridge.dll"
-Write-Host " Add-in: $addinDir\RevitBridge.addin"
+Write-Host " Bridge DLL: $targetBin\AECModelBridge.dll"
+Write-Host " Add-in: $addinDir\AECModelBridge.addin"
Write-Host " Config: $configTarget\default.json"
Write-Host "`nNext steps:" -ForegroundColor Yellow
@@ -92,5 +97,5 @@ else {
Write-Host "`nTroubleshooting:" -ForegroundColor Yellow
Write-Host " - Check Revit journal: %LOCALAPPDATA%\Autodesk\Revit\Autodesk Revit $RevitVersion\Journals\" -ForegroundColor Gray
-Write-Host " - Check bridge logs: %APPDATA%\RevitMCP\Logs\bridge.jsonl" -ForegroundColor Gray
+Write-Host " - Check bridge logs: %APPDATA%\AECModelBridge\Logs\bridge.jsonl" -ForegroundColor Gray
Write-Host " - Uninstall: Remove files from paths above" -ForegroundColor Gray
diff --git a/scripts/package.ps1 b/scripts/package.ps1
index 242bc78..705a630 100644
--- a/scripts/package.ps1
+++ b/scripts/package.ps1
@@ -1,5 +1,5 @@
param(
- [string]$Version = "1.0.0",
+ [string]$Version = "1.0.1",
[string]$RevitVersion = "All"
)
@@ -12,7 +12,7 @@ if ($PSScriptRoot -like "*C:\Windows*") {
exit 1
}
-$distDir = "$PSScriptRoot\..\dist\RevitMCP"
+$distDir = "$PSScriptRoot\..\dist\AECModelBridge"
Write-Host "Creating distribution package: $distDir" -ForegroundColor Cyan
# Clean dist directory only if building everything or if it doesn't exist
@@ -21,7 +21,13 @@ if (-not (Test-Path $distDir)) {
}
# Define versions to build
-$versionsToBuild = @("2024", "2025", "2026")
+$targetFrameworks = @{
+ "2024" = "net48"
+ "2025" = "net8.0-windows"
+ "2026" = "net8.0-windows"
+ "2027" = "net10.0-windows"
+}
+$versionsToBuild = @("2024", "2025", "2026", "2027")
if ($RevitVersion -ne "All") {
if ($versionsToBuild -notcontains $RevitVersion) {
Write-Error "Unsupported Revit version: $RevitVersion. Supported: $($versionsToBuild -join ', ')"
@@ -46,16 +52,14 @@ foreach ($year in $versionsToBuild) {
New-Item -ItemType Directory -Path $binDir -Force | Out-Null
$sourcePath = "$PSScriptRoot\..\packages\revit-bridge-addin\bin\Release\$year"
- # Adjust source path for the selected target framework
- if ($year -ge "2025" -and (Test-Path "$sourcePath\net8.0-windows")) {
- $sourcePath = "$sourcePath\net8.0-windows"
- }
- elseif (Test-Path "$sourcePath\net48") {
- $sourcePath = "$sourcePath\net48"
- }
+ $sourcePath = Join-Path $sourcePath $targetFrameworks[$year]
if (Test-Path $sourcePath) {
Copy-Item "$sourcePath\*" $binDir -Recurse -Force
+ $nonWindowsRuntimes = Join-Path $binDir "runtimes"
+ if (Test-Path $nonWindowsRuntimes) {
+ Remove-Item -LiteralPath $nonWindowsRuntimes -Recurse -Force
+ }
Write-Host " Copied binaries for Revit $year" -ForegroundColor Green
}
else {
@@ -99,8 +103,12 @@ finally {
Write-Host "`nCopying add-in manifests..." -ForegroundColor Yellow
$addinDir = "$distDir\addin"
New-Item -ItemType Directory -Path $addinDir -Force | Out-Null
-Copy-Item "$PSScriptRoot\..\packages\revit-bridge-addin\RevitBridge.addin" $addinDir -Force
-Write-Host " Copied RevitBridge.addin" -ForegroundColor Green
+Copy-Item "$PSScriptRoot\..\packages\revit-bridge-addin\AECModelBridge.addin" $addinDir -Force
+Write-Host " Copied AECModelBridge.addin" -ForegroundColor Green
+
+# Copy installer entrypoint into the distribution package
+Copy-Item "$PSScriptRoot\install.ps1" "$distDir\install.ps1" -Force
+Write-Host " Copied install.ps1" -ForegroundColor Green
# Create default config
Write-Host "`nCreating default configuration..." -ForegroundColor Yellow
@@ -125,26 +133,26 @@ Write-Host " Created default.json" -ForegroundColor Green
# Create README for distribution
$distReadme = @"
-# RevitMCP Distribution Package v$Version
+# AEC Model Bridge Distribution Package v$Version
-This package contains the RevitMCP Bridge add-in and MCP server.
+This package contains AEC Model Bridge for Revit software and its MCP server.
## Installation
-### Quick Install (Revit 2024)
+### Quick Install (Revit 2027)
``````powershell
-.\install.ps1 -RevitVersion 2024
+.\install.ps1 -RevitVersion 2027
``````
### Manual Install
-1. Copy bin\{year}\* to C:\ProgramData\RevitMCP\bin\
-2. Copy addin\RevitBridge.addin to C:\ProgramData\Autodesk\Revit\Addins\{year}\
+1. Copy bin\{year}\* to C:\ProgramData\AECModelBridge\bin\
+2. Copy addin\AECModelBridge.addin to C:\ProgramData\Autodesk\Revit\Addins\{year}\
3. Restart Revit
## Verify Installation
1. Start Revit
2. In PowerShell: ``curl http://localhost:3000/health``
-3. Should return: ``{"status":"healthy","revit_version":"2024",...}``
+3. Should return: ``{"status":"healthy","revit_version":"2027",...}``
## Run MCP Server
``````powershell
@@ -162,7 +170,11 @@ python -m revit_mcp_server
- Copilot Integration: ../docs/copilot-integration.md
## Support
-https://github.com/Sam-AEC/Autodesk-Revit-MCP-Server/issues
+https://github.com/Sam-AEC/aec-model-bridge/issues
+
+## Trademark Notice
+AEC Model Bridge is independent and is not affiliated with Autodesk.
+Autodesk and Revit are trademarks of the Autodesk group of companies.
"@
$distReadme | Set-Content "$distDir\README.txt"
@@ -176,7 +188,7 @@ Get-ChildItem $distDir -Recurse -File | ForEach-Object {
}
Write-Host "`nNext steps:" -ForegroundColor Yellow
-Write-Host " 1. Test installation: .\scripts\install.ps1 -RevitVersion 2024" -ForegroundColor White
+Write-Host " 1. Test installation: .\scripts\install.ps1 -RevitVersion 2027" -ForegroundColor White
Write-Host " 2. Create MSI: Build WiX installer from dist\ folder" -ForegroundColor White
-Write-Host " 3. Create release: Compress to RevitMCP-$Version.zip" -ForegroundColor White
+Write-Host " 3. Create release: Compress to aec-model-bridge-$Version.zip" -ForegroundColor White
exit 0
diff --git a/scripts/setup.ps1 b/scripts/setup.ps1
index ff371ff..836b897 100644
--- a/scripts/setup.ps1
+++ b/scripts/setup.ps1
@@ -14,7 +14,7 @@ if ($PSScriptRoot -like "*C:\Windows*") {
exit 1
}
-Write-Host "== RevitMCP Setup Master Script ==" -ForegroundColor Cyan
+Write-Host "== AEC Model Bridge Setup ==" -ForegroundColor Cyan
Write-Host "Target Revit Version: $RevitVersion" -ForegroundColor Gray
# == Config Loader ==
diff --git a/scripts/start-server.ps1 b/scripts/start-server.ps1
index 8777677..371c630 100644
--- a/scripts/start-server.ps1
+++ b/scripts/start-server.ps1
@@ -4,7 +4,7 @@ param(
$ErrorActionPreference = "Stop"
-Write-Host "RevitMCP Server Startup" -ForegroundColor Cyan
+Write-Host "AEC Model Bridge Server Startup" -ForegroundColor Cyan
Write-Host "=====================`n" -ForegroundColor Cyan
# Check if .env exists
diff --git a/server.json b/server.json
index aa4dddc..027f7ab 100644
--- a/server.json
+++ b/server.json
@@ -1,76 +1,76 @@
-{
- "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
- "name": "io.github.Sam-AEC/autodesk-revit-mcp-server",
- "title": "Autodesk Revit MCP Server",
- "description": "MCP server connecting AI assistants to Autodesk Revit through a local bridge.",
- "icons": [
- {
- "src": "https://raw.githubusercontent.com/Sam-AEC/Autodesk-Revit-MCP-Server/main/assets/revit-icon.svg",
- "mimeType": "image/svg+xml",
- "sizes": [
- "any"
- ]
- }
- ],
- "repository": {
- "url": "https://github.com/Sam-AEC/Autodesk-Revit-MCP-Server",
- "source": "github",
- "subfolder": "packages/mcp-server-revit"
- },
- "version": "1.0.0",
- "packages": [
- {
- "registryType": "mcpb",
- "identifier": "https://github.com/Sam-AEC/Autodesk-Revit-MCP-Server/releases/download/v1.0.0/revit-mcp-server-1.0.0.mcpb",
- "fileSha256": "feb1f736e892a079715d08f17a1fdc3643013b27febc2d373899c60636d9bcb8",
- "version": "1.0.0",
- "transport": {
- "type": "stdio"
- },
- "environmentVariables": [
- {
- "name": "MCP_REVIT_WORKSPACE_DIR",
- "description": "Workspace root directory for server file operations.",
- "isSecret": false,
- "isRequired": true,
- "format": "string"
- },
- {
- "name": "MCP_REVIT_ALLOWED_DIRECTORIES",
- "description": "Semicolon-delimited allow-list of directories the server can access.",
- "isSecret": false,
- "isRequired": true,
- "format": "string"
- },
- {
- "name": "MCP_REVIT_MODE",
- "description": "Server mode: mock or bridge.",
- "isSecret": false,
- "isRequired": false,
- "format": "string"
- },
- {
- "name": "MCP_REVIT_BRIDGE_URL",
- "description": "Bridge URL, for example http://127.0.0.1:3000 (required when MCP_REVIT_MODE=bridge).",
- "isSecret": false,
- "isRequired": false,
- "format": "string"
- },
- {
- "name": "MCP_REVIT_AUDIT_LOG",
- "description": "Path to the audit log file.",
- "isSecret": false,
- "isRequired": false,
- "format": "string"
- },
- {
- "name": "MCP_REVIT_LOG_LEVEL",
- "description": "Python log level, for example INFO or DEBUG.",
- "isSecret": false,
- "isRequired": false,
- "format": "string"
- }
- ]
- }
- ]
+{
+ "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
+ "name": "io.github.Sam-AEC/aec-model-bridge",
+ "title": "AEC Model Bridge",
+ "description": "Independent MCP integration for Autodesk Revit software through a local bridge.",
+ "icons": [
+ {
+ "src": "https://raw.githubusercontent.com/Sam-AEC/aec-model-bridge/main/assets/logo.svg",
+ "mimeType": "image/svg+xml",
+ "sizes": [
+ "any"
+ ]
+ }
+ ],
+ "repository": {
+ "url": "https://github.com/Sam-AEC/aec-model-bridge",
+ "source": "github",
+ "subfolder": "packages/mcp-server-revit"
+ },
+ "version": "1.0.1",
+ "packages": [
+ {
+ "registryType": "mcpb",
+ "identifier": "https://github.com/Sam-AEC/aec-model-bridge/releases/download/v1.0.1/aec-model-bridge-1.0.1.mcpb",
+ "fileSha256": "74181224be8399c0c2e4368c9ad7bd9881fc83aa519b7fdee358d9f1e63cb0da",
+ "version": "1.0.1",
+ "transport": {
+ "type": "stdio"
+ },
+ "environmentVariables": [
+ {
+ "name": "MCP_REVIT_WORKSPACE_DIR",
+ "description": "Workspace root directory for server file operations.",
+ "isSecret": false,
+ "isRequired": true,
+ "format": "string"
+ },
+ {
+ "name": "MCP_REVIT_ALLOWED_DIRECTORIES",
+ "description": "Semicolon-delimited allow-list of directories the server can access.",
+ "isSecret": false,
+ "isRequired": true,
+ "format": "string"
+ },
+ {
+ "name": "MCP_REVIT_MODE",
+ "description": "Server mode: mock or bridge.",
+ "isSecret": false,
+ "isRequired": false,
+ "format": "string"
+ },
+ {
+ "name": "MCP_REVIT_BRIDGE_URL",
+ "description": "Bridge URL, for example http://127.0.0.1:3000 (required when MCP_REVIT_MODE=bridge).",
+ "isSecret": false,
+ "isRequired": false,
+ "format": "string"
+ },
+ {
+ "name": "MCP_REVIT_AUDIT_LOG",
+ "description": "Path to the audit log file.",
+ "isSecret": false,
+ "isRequired": false,
+ "format": "string"
+ },
+ {
+ "name": "MCP_REVIT_LOG_LEVEL",
+ "description": "Python log level, for example INFO or DEBUG.",
+ "isSecret": false,
+ "isRequired": false,
+ "format": "string"
+ }
+ ]
+ }
+ ]
}