# Rvt Mcp

> BIMwright — AI-native Revit MCP server (Revit 2022–2027)

- **Type:** MCP server
- **Install:** `agentstack add mcp-bimwright-rvt-mcp`
- **Verified:** Yes — security-reviewed for prompt injection and unsafe behavior
- **Seller:** [bimwright](https://agentstack.voostack.com/s/bimwright)
- **Installs:** 0
- **Category:** [Integrations](https://agentstack.voostack.com/c/integrations)
- **Latest version:** 0.1.0
- **License:** Apache-2.0
- **Upstream author:** [bimwright](https://github.com/bimwright)
- **Source:** https://github.com/bimwright/rvt-mcp
- **Website:** https://github.com/bimwright/rvt-mcp

## Install

```sh
agentstack add mcp-bimwright-rvt-mcp
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

rvt-mcp

  
  
  
  

  English · Tiếng Việt · 简体中文 · 日本語

---

## Client Quick Install (Recommended)

For a Revit user machine, use the setup ZIP from GitHub Releases. It includes the self-contained MCP server and Revit plugins, so the client machine does **not** need the .NET SDK, NuGet global tools, this source repo, or a local build.

**AI agents:** if a user asks you to install Bimwright on a client machine, download the latest `RvtMcp.Setup-*-win-x64.zip` release asset and run the installer below. Do **not** clone this repo, build source, install the .NET SDK, or use `dotnet tool install` unless the user explicitly asks for a developer install. See [AGENTS.md](AGENTS.md) for the full agent install protocol.

```powershell
$tag = (Invoke-RestMethod https://api.github.com/repos/bimwright/rvt-mcp/releases/latest).tag_name
$zip = "$env:TEMP\RvtMcp.Setup-$tag-win-x64.zip"
$dir = "$env:TEMP\RvtMcp.Setup-$tag-win-x64"
Invoke-WebRequest "https://github.com/bimwright/rvt-mcp/releases/download/$tag/RvtMcp.Setup-$tag-win-x64.zip" -OutFile $zip
Expand-Archive $zip -DestinationPath $dir -Force

powershell -ExecutionPolicy Bypass -File "$dir\install.ps1" -WhatIf
powershell -ExecutionPolicy Bypass -File "$dir\install.ps1"
```

The installer detects Revit 2022-2027, installs only the matching plugin(s), copies the server under `%LOCALAPPDATA%\RvtMcp\rvt\server\\`, and wires installed MCP clients with absolute paths. Use `-Client codex`, `-Client opencode`, `-Client claude`, or `-Client none` to override auto-detection.

`dwg-mcp` is a separate gateway for AutoCAD; install it independently from its own repo.

---

## Revit Automation Should Not Stop At "I Don't Code"

Before AI agents, many BIM users already wanted the same thing: make Revit faster, remove repetitive clicks, and shape the software around the way they actually work.

The hard part was never the idea. The hard part was turning the idea into a tool.

To build even a small Revit add-in, a practitioner usually has to:

- Define the input and output clearly enough for software.
- Think through the algorithm, edge cases, parameters, categories, filters, units, and Revit API constraints.
- Prototype in Dynamo, maybe move to Python, then eventually rewrite in C# when the workflow needs to become stable.
- Package the result as an add-in, handle dependencies, install paths, `.addin` manifests, Revit version drift, and ribbon buttons.

That is a lot of work for someone who studied architecture, structure, MEP, quantity takeoff, or BIM coordination - not software engineering.

The usual options are expensive in different ways:

- Spend months learning enough coding to maintain your own tools.
- Pay someone to build custom add-ins.
- Buy fixed add-ins and adapt your workflow to the vendor's assumptions.
- Stay with manual work because the automation path is too much friction.

`rvt-mcp` exists to compress that loop.

It gives AI agents a safe local bridge into Revit, then lets repeated workflows evolve into personal tools through ToolBaker. The goal is not one universal add-in for everyone. Revit serves too many disciplines, offices, standards, and habits for that. The goal is a system where each practitioner can grow a toolkit that matches their own work.

Personal automation should be personal.

---

## What rvt-mcp Is

`rvt-mcp` is a local MCP gateway for Autodesk Revit 2022-2027.

It has two parts:

- `RvtMcp.Server`: a .NET 8 MCP server launched by Claude, Cursor, Codex, OpenCode, Cline, VS Code Copilot, or another stdio MCP client.
- `RvtMcp.Plugin`: a Revit add-in shell for each supported Revit year, running inside Revit and executing commands on the Revit UI thread.

The agent talks MCP. The server talks to the plugin over localhost TCP or Named Pipe. The plugin talks to the Revit API.

Your model stays on your machine.

---

## Why It Matters

AI agents make it possible for BIM users to describe intent instead of writing code by hand. But intent alone is not enough. Revit automation still needs a runtime that understands transactions, parameters, units, selection, model state, version drift, safety, and rollback.

`rvt-mcp` is that runtime.

It is designed around four ideas:

- **Local first.** No cloud bridge is required. Revit, the plugin, MCP server, logs, and ToolBaker storage all live on the user's machine.
- **Reversible by default.** Mutating workflows can run through `batch_execute`, wrapping multiple commands in one Revit `TransactionGroup` so one undo step rolls the batch back.
- **Progressively exposed.** Toolsets and `--read-only` mode control what the agent can see and do. Weak or narrow agents do not need destructive tools.
- **Personal over generic.** Adaptive ToolBaker can observe repeated local workflows, propose a personal tool, and make accepted tools available through MCP and the Revit ribbon.

This is not a black-box demo and not courseware. It is public Apache-2.0 code. Claims should be checked by building, testing, running, and reading the source.

---

## The ToolBaker Loop

Most Revit automation dies between "good idea" and "usable add-in".

ToolBaker is the path from agent-assisted workflow to personal tool:

1. Use the existing MCP tools to query, create, lint, inspect, or batch operations in Revit.
2. When advanced automation is needed, call `send_code_to_revit` directly from the default tool surface.
3. If adaptive bake is enabled, repeated local usage is recorded locally under `%LOCALAPPDATA%\RvtMcp\`.
4. Repeated patterns become suggestions, visible through `list_bake_suggestions`.
5. You explicitly accept a suggestion with `accept_bake_suggestion`, including the tool name, schema, and output choice.
6. Accepted tools become callable through `list_baked_tools` / `run_baked_tool` and available from the Revit ribbon runtime cache.

Adaptive bake is off by default. It is for users who want their own local usage data to shape their own tools.

---

## Architecture

```text
+---------------------------+
| AI Client                 |
| Claude / Cursor / Codex   |
+---------------------------+
              |
              | stdio MCP
              v
+---------------------------+
| RvtMcp.Server      |
| .NET 8 / C#               |
+---------------------------+
              |
               | TCP (2022–2024)
               | Named Pipe (2025–2027)
              v
+---------------------------+
| Plugin Shell              |
| thin add-in per Revit yr  |
+---------------------------+
              |
              | shared command core
              | from `src/shared/`
              v
+---------------------------+
| ExternalEvent Marshal     |
| execution -> Revit UI     |
+---------------------------+
              |
              v
+---------------------------+
| Revit API                 |
+---------------------------+
              |
              v
+---------------------------+
| Model / Transaction /     |
| Undo                      |
+---------------------------+
```

`rvt-mcp` is a full C# MCP stack. The MCP server, per-version Revit plugin shells, transport bridge, command handlers, DTO mapping, and ToolBaker pipeline are all written in C# using the official MCP C# SDK.

There is no Node.js sidecar on the Revit machine.

The version split is explicit at the edge: one thin plugin shell per Revit year, all compiling the same `src/shared/` source glob. See [ARCHITECTURE.md](ARCHITECTURE.md) for the threading, transport, DTO, and ToolBaker details.

---

## Current State

`rvt-mcp` is usable but still young.

- Compile gate covers Revit 2022–2027 plugin shells.
- Unit tests cover pure .NET logic, tool-surface snapshots, ToolBaker storage/policy paths, config, logging, privacy, and batching behavior.
- Core runtime coverage exists for 2023–2026.
- Accepted ToolBaker list/run/ribbon path has smoke evidence on 2022, 2026, and 2027.
- Fresh-machine install testing is tracked in [docs/testing/fresh-install-checklist.md](docs/testing/fresh-install-checklist.md).

Treat it like serious open-source infrastructure: test it on your own environment before trusting it on production models.

---

## Project Structure

```text
rvt-mcp/
├── src/
│   ├── RvtMcp.sln         # Solution (server + 6 plugin shells)
│   ├── server/                   # RvtMcp.Server - stdio MCP server
│   ├── shared/                   # Source glob shared by every plugin shell
│   │   ├── Handlers/             # One file per Revit command handler
│   │   ├── Commands/             # Revit ribbon commands
│   │   ├── ToolBaker/            # Baked-tool registry/runtime/policy
│   │   ├── Transport/            # TCP + Named Pipe abstraction
│   │   ├── Infrastructure/       # Dispatcher, schema validation, ExternalEvent marshal
│   │   └── Security/             # Auth token, redaction, secret masking
│   ├── plugin-2022/              # Revit 2022 shell - .NET 4.8, TCP
│   ├── plugin-2023/              # Revit 2023 shell - .NET 4.8, TCP
│   ├── plugin-2024/              # Revit 2024 shell - .NET 4.8, TCP
│   ├── plugin-2025/              # Revit 2025 shell - .NET 8, Named Pipe
│   ├── plugin-2026/              # Revit 2026 shell - .NET 8, Named Pipe
│   └── plugin-2027/              # Revit 2027 shell - .NET 10, Named Pipe
├── tests/                        # xUnit, tool snapshots, policy/privacy tests
├── benchmarks/                   # Weak-model accuracy harness
├── scripts/                      # install, uninstall, plugin ZIP staging
├── docs/                         # Architecture, roadmap, ToolBaker, testing notes
├── server.json                   # MCP registry manifest
├── smithery.yaml                 # Smithery directory manifest
├── AGENTS.md                     # Agent-led install guide for MCP clients
└── ARCHITECTURE.md               # Deep dive on runtime architecture
```

Six plugin shells compile from the same `src/shared/` glob. Year-specific `#if` fences handle Revit API drift such as `ElementId.IntegerValue` moving to `.Value` in newer versions.

---

## Install

## Migration from `Bimwright.Rvt.*` (v0.3.0 and earlier)

v0.4.0 renames the codebase from `Bimwright.Rvt.*` to `RvtMcp.*`. The GitHub repo (`bimwright/rvt-mcp`) and brand are unchanged; only file names, package IDs, and folder paths change.

If you have v0.3.0 or earlier installed:

1. **Close all running Revit instances.**
2. **Run the migration script:**
   ```powershell
   pwsh scripts/uninstall-old.ps1
   ```
   This removes:
   - `%APPDATA%\Autodesk\Revit\Addins\\Bimwright\` (plugin DLLs)
   - `%APPDATA%\Autodesk\Revit\Addins\\Bimwright.R.addin` (manifests)
   - `%LOCALAPPDATA%\Bimwright\rvt\server\` (server install root)

   It **preserves** `%LOCALAPPDATA%\Bimwright\baked\`, `journal\`, `firm-profiles\`, and `*.log` files — these contain user data and are migrated to `%LOCALAPPDATA%\RvtMcp\` on first launch of v0.4.0.

3. **Install v0.5.0:**
   ```powershell
   dotnet tool update -g Bimwright.Rvt.Server --version 0.3.0   # ensure clean uninstall first
   dotnet tool uninstall -g Bimwright.Rvt.Server
   dotnet tool install -g RvtMcp.Server --version 0.5.0
   ```

4. **Re-wire your MCP client.** Old MCP entries `bimwright-rvt-r22`..`bimwright-rvt-r27` are auto-removed by `install.ps1`. The new entry is `rvt-mcp` (single, auto-detects Revit version).

The old NuGet package `Bimwright.Rvt.Server` is deprecated at 0.3.0 with a redirect note pointing to `RvtMcp.Server`.

### Client setup ZIP

Download `RvtMcp.Setup-v-win-x64.zip` from [GitHub Releases](https://github.com/bimwright/rvt-mcp/releases/latest), extract it, then run:

```powershell
powershell -ExecutionPolicy Bypass -File .\install.ps1 -WhatIf   # preview files and config edits
powershell -ExecutionPolicy Bypass -File .\install.ps1           # install server, plugins, and detected client config entries
```

Useful installer options:

```powershell
powershell -ExecutionPolicy Bypass -File .\install.ps1 -Client codex      # wire only Codex
powershell -ExecutionPolicy Bypass -File .\install.ps1 -Client opencode   # wire only OpenCode
powershell -ExecutionPolicy Bypass -File .\install.ps1 -Client claude     # wire Claude Code/Desktop configs if present
powershell -ExecutionPolicy Bypass -File .\install.ps1 -Client none       # install files without MCP client config edits
powershell -ExecutionPolicy Bypass -File .\install.ps1 -Years 2024        # force a Revit year if registry detection is unavailable
```

The setup ZIP contains a self-contained `rvt-mcp.exe`, so the client machine does not need `.NET 8 SDK`, `dotnet tool install`, or this repository. Config entries use the absolute installed path, so `%USERPROFILE%\.dotnet\tools` and PATH are not involved. The installer deploys plugins for every detected Revit year, then writes one auto-detect MCP entry named `rvt-mcp`.

### Verify

1. Open Revit 2022-2027 and a model.
2. Use the BIMwright ribbon panel to start/toggle the MCP plugin.
3. In the MCP client, run `tools/list`.
4. Call `get_current_view_info`.

Expected response shape:

```json
{ "viewName": "Level 1", "viewType": "FloorPlan", "levelName": "Level 1", "scale": 100 }
```

Do not claim an install is complete until the MCP client can list tools and call Revit successfully.

### Uninstall

To remove plugin, self-contained server, legacy .NET global tool if present, host-config entries, discovery files, logs, and ToolBaker cache in one pass:

```powershell
powershell -ExecutionPolicy Bypass -File .\uninstall.ps1 -WhatIf
powershell -ExecutionPolicy Bypass -File .\uninstall.ps1 -Yes
```

The setup ZIP also includes `uninstall-all.ps1` as an alias for the same full sweep.

### Developer / legacy install

Developers can still install the server as a NuGet .NET tool and use the plugin-only bundle:

```powershell
dotnet tool install -g RvtMcp.Server
powershell -ExecutionPolicy Bypass -File .\install.ps1 -SourceDir . -Client none
```

This path is for development and backward compatibility. Client machines should use the setup ZIP instead.

---

## Supported MCP Clients

| Client | Status | Notes |
|--------|--------|-------|
| Claude Code CLI | documented | project `.mcp.json` or global `~/.claude.json` |
| Claude Desktop | documented | `%APPDATA%\Claude\claude_desktop_config.json` |
| OpenCode | scripted | `install.ps1 -Client opencode` |
| Codex | scripted | `install.ps1 -Client codex` |
| Cursor | documented | project or user `mcp.json` |
| Cline (VS Code) | documented | Cline MCP settings JSON |
| VS Code Copilot | documented | native `servers` schema with `type: stdio` |
| Gemini CLI | documented | `gemini mcp add ...` or settings JSON |
| Antigravity | documented | Gemini/Antigravity MCP config JSON |

---

## Toolsets

The full surface is **226 tools across 23 toolsets** (`--toolsets all`). By default every toolset is on except `modify` and `delete`. Adaptive bake, when enabled, adds accepted baked tools on top; `--read-only` strips every write-capable toolset.

Default-on toolsets: `query`, `create`, `view`, `schedule`, `families`, `mep`, `graphics`, `export`, `toolbaker`, `meta`, `lint`, `sheets`, `materials`, `geometry`, `annotation`, `rooms`, `links`, `parameters`, `organization`, `workflows`, `structural`.

Opt-in toolsets (off by default): `modify`, `delete`. Enable explicitly or via `--toolsets all`.

Enable specific sets with `--toolsets query,create,modify,meta`, or `--toolsets all` for everything. Add `--read-only` to strip write-capable toolsets regardless of what was requested.

| Toolset | Tools | Default |
|---------|-------|---------|
| `query` | get current view, selected elements, available family types, material quantities, model stats, AI element filter | on |
| `create` | grid, level, room, line-based, point-based, surface-based element, group from elements | on |
| `view` | create view, sheet layout, place view on sheet, capture image, set crop/scale, activate view, show element | on |
| `meta` | `show_message`, `switch_target`, `batch_execute`, usage stats, set project info, purge unused f

…

## Source & license

This open-source MCP server is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [bimwright](https://github.com/bimwright)
- **Source:** [bimwright/rvt-mcp](https://github.com/bimwright/rvt-mcp)
- **License:** Apache-2.0
- **Homepage:** https://github.com/bimwright/rvt-mcp

Install and usage instructions live in the source repository linked above.

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v0.1.0 — what this tool can access:

- **Network access:** no
- **Filesystem access:** no
- **Shell / process execution:** no
- **Environment & secrets:** no
- **Dynamic code execution:** no

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **0.1.0** — security scan: passed — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/mcp-bimwright-rvt-mcp
- Seller: https://agentstack.voostack.com/s/bimwright
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.
