mcp-servers-for-revit/mcp-servers-for-revit

mcp-servers-for-revit

Connect AI assistants to Autodesk Revit via the Model Context Protocol.

mcp-servers-for-revit enables AI clients like Claude, Cline, and other MCP-compatible tools to read, create, modify, and delete elements in Revit projects. It consists of three components: a TypeScript MCP server that exposes tools to AI, a C# Revit add-in that bridges commands into Revit, and a command set that implements the actual Revit API operations.

[!NOTE]

This is a fork of the original revit-mcp project with additional tools and functionality improvements.

Architecture

flowchart LR
    Client["MCP Client
(Claude, Cline, etc.)"]
    Server["MCP Server
server/"]
    Plugin["Revit Plugin
plugin/"]
    CommandSet["Command Set
commandset/"]
    Revit["Revit API"]
Client <-->|stdio| Server
    Server <-->|WebSocket| Plugin
    Plugin -->|loads| CommandSet
    CommandSet -->|executes| Revit

The MCP Server (TypeScript) translates tool calls from AI clients into WebSocket messages. The Revit Plugin (C#) runs inside Revit, listens for those messages, and dispatches them to the Command Set (C#), which executes the actual Revit API operations and returns results back up the chain.

Requirements

• Node.js 18+ (for the MCP server)
• Autodesk Revit 2020 - 2026 (any supported version)

Quick Start (Using a Release)

1. Download the ZIP for your Revit version from the Releases page (e.g., mcp-servers-for-revit-v1.0.0-Revit2025.zip)

2. Extract the ZIP and copy the contents to your Revit addins folder:

   %AppData%\Autodesk\Revit\Addins\\
   

After copying you should have:

   Addins/2025/
   ├── mcp-servers-for-revit.addin
   └── revit_mcp_plugin/
       ├── RevitMCPPlugin.dll
       ├── ...
       └── Commands/
           └── RevitMCPCommandSet/
               ├── command.json
               └── 2025/
                   ├── RevitMCPCommandSet.dll
                   └── ...
   

3. Configure the MCP server in your AI client (see MCP Server Setup)

4. Start Revit — if prompted about an unknown add-in, click Always Load

5. In Revit, click the Settings button on the mcp-servers-for-revit ribbon tab, enable the commands you want to use, and click Save

MCP Server Setup

The MCP server is published as an npm package and can be run directly with npx.

Claude Code

Run this in a terminal (not inside Claude Code):

claude mcp add mcp-server-for-revit -- cmd /c npx -y mcp-server-for-revit

Claude Desktop

Claude Desktop → Settings → Developer → Edit Config → claude_desktop_config.json:

{
    "mcpServers": {
        "mcp-server-for-revit": {
            "command": "cmd",
            "args": ["/c", "npx", "-y", "mcp-server-for-revit"]
        }
    }
}

Restart Claude Desktop. When you see the hammer icon, the MCP server is connected.

Revit Plugin Setup

If using a release ZIP, the plugin is already included. For manual installation:

1. Build the plugin from plugin/ (see Development) 2. Copy mcp-servers-for-revit.addin to %AppData%\Autodesk\Revit\Addins\\ 3. Copy the revit_mcp_plugin/ folder to the same addins directory

Command Set Setup

If using a release ZIP, the command set is pre-installed inside the plugin. For manual installation:

1. Build the command set from commandset/ (see Development) 2. Inside the plugin's installation directory, create Commands/RevitMCPCommandSet// 3. Copy the built DLLs into that folder 4. Copy command.json (from repo root) into Commands/RevitMCPCommandSet/

Supported Tools

| Tool | Description | | ---- | ----------- | | get_current_view_info | Get current active view info | | get_current_view_elements | Get elements from the current active view | | get_available_family_types | Get available family types in current project | | get_selected_elements | Get currently selected elements | | get_material_quantities | Calculate material quantities and takeoffs | | ai_element_filter | Intelligent element querying tool for AI assistants | | analyze_model_statistics | Analyze model complexity with element counts | | create_point_based_element | Create point-based elements (door, window, furniture) | | create_line_based_element | Create line-based elements (wall, beam, pipe) | | create_surface_based_element | Create surface-based elements (floor, ceiling, roof) | | create_grid | Create a grid system with smart spacing generation | | create_level | Create levels at specified elevations | | create_room | Create and place rooms at specified locations | | create_dimensions | Create dimension annotations in the current view | | create_structural_framing_system | Create a structural beam framing system | | delete_element | Delete elements by ID | | operate_element | Operate on elements (select, setColor, hide, etc.) | | color_elements | Color elements based on a parameter value | | tag_all_walls | Tag all walls in the current view | | tag_all_rooms | Tag all rooms in the current view | | export_room_data | Export all room data from the project | | store_project_data | Store project metadata in local database | | store_room_data | Store room metadata in local database | | query_stored_data | Query stored project and room data | | send_code_to_revit | Send C# code to Revit to execute | | say_hello | Display a greeting dialog in Revit (connection test) |

Testing

The test project uses Nice3point.TUnit.Revit to run integration tests against a live Revit instance. No separate addin installation is required — the framework injects into the running Revit process automatically.

Prerequisites

• .NET 10 SDK — required by Nice3point.Revit.Sdk 6.1.0. Install via winget install Microsoft.DotNet.SDK.10
• Autodesk Revit 2026 (or 2025) — must be installed and licensed on your machine

Running Tests

1. Open Revit 2026 (or 2025) and wait for it to fully load 2. Run the tests from the command line:

# For Revit 2026
dotnet test -c Debug.R26 -r win-x64 tests/commandset
For Revit 2025
dotnet test -c Debug.R25 -r win-x64 tests/commandset

Note: The -r win-x64 flag is required on ARM64 machines because the Revit API assemblies are x64-only.

Alternatively, you can use dotnet run:

cd tests/commandset
dotnet run -c Debug.R26

IDE Support

• JetBrains Rider — enable "Testing Platform support" in Settings > Build, Execution, Deployment > Unit Testing > Testing Platform
• Visual Studio — tests should be discoverable through the standard Test Explorer

Test Structure

| Directory | Purpose | |-----------|---------| | tests/commandset/AssemblyInfo.cs | Global [assembly: TestExecutor] registration | | tests/commandset/Architecture/ | Tests for level and room creation commands | | tests/commandset/DataExtraction/ | Tests for model statistics, room data export, and material quantities | | tests/commandset/ColorSplashTests.cs | Tests for color override functionality | | tests/commandset/TagRoomsTests.cs | Tests for room tagging functionality |

Writing New Tests

Test classes inherit from RevitApiTest and use TUnit's async assertion API:

public class MyTests : RevitApiTest
{
    private static Document _doc;
[Before(HookType.Class)]
    [HookExecutor]
    public static void Setup()
    {
        _doc = Application.NewProjectDocument(UnitSystem.Imperial);
    }
[After(HookType.Class)]
    [HookExecutor]
    public static void Cleanup()
    {
        _doc?.Close(false);
    }
[Test]
    public async Task MyTest_Condition_ExpectedResult()
    {
        var elements = new FilteredElementCollector(_doc)
            .WhereElementIsNotElementType()
            .ToElements();
await Assert.That(elements.Count).IsGreaterThan(0);
    }
}

Development

MCP Server

cd server
npm install
npm run build

The server compiles TypeScript to server/build/. During development you can run it directly with npx tsx server/src/index.ts.

Revit Plugin + Command Set

Open mcp-servers-for-revit.sln in Visual Studio. The solution contains both the plugin and command set projects. Build configurations target Revit 2020-2026:

• Revit 2020-2024: .NET Framework 4.8 (Release R20 through Release R24)
• Revit 2025-2026: .NET 8 (Release R25, Release R26)

Building the solution automatically assembles the complete deployable layout in plugin/bin/AddIn / - the command set is copied into the plugin's Commands/ folder as part of the build.

Project Structure

mcp-servers-for-revit/
├── mcp-servers-for-revit.sln    # Combined solution (plugin + commandset + tests)
├── command.json     # Command set manifest
├── server/          # MCP server (TypeScript) - tools exposed to AI clients
├── plugin/          # Revit add-in (C#) - WebSocket bridge inside Revit
├── commandset/      # Command implementations (C#) - Revit API operations
├── tests/           # Integration tests (C#) - TUnit tests against live Revit
├── assets/          # Images for documentation
├── .github/         # CI/CD workflows, contributing guide, code of conduct
├── LICENSE
└── README.md

Releasing

A single v* tag drives the entire release. The release workflow automatically:

• Builds the Revit plugin + command set for Revit 2020-2026
• Creates a GitHub release with mcp-servers-for-revit-vX.Y.Z-Revit.zip assets
• Publishes the MCP server to npm as mcp-server-for-revit

To create a release:

1. Run the bump script (updates server/package.json, server/package-lock.json, and plugin/Properties/AssemblyInfo.cs, then commits and tags):

   ./scripts/release.ps1 -Version X.Y.Z
   

2. Push to trigger the workflow:

   git push origin main --tags
   

[!NOTE]

npm publish uses trusted publishing via OIDC — no npm token is required. Provenance attestation is generated automatically.

Acknowledgements

This project is a fork of the work by the mcp-servers-for-revit team. The original repositories:

• revit-mcp - MCP server
• revit-mcp-plugin - Revit plugin
• revit-mcp-commandset - Command set

Thank you to the original authors for creating the foundation that this project builds upon.

License

MIT