revit-mcp-hardened
Provides tools for interacting with Autodesk Revit, enabling AI agents to read model information, list levels and views, place families, modify elements, and manage documents in a Revit project.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@revit-mcp-hardened List the levels in the current Revit model."
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
MCP server for Revit - Python
A pyRevit-oriented implementation of the Model Context Protocol (MCP) for Autodesk Revit
Hardened fork. Derived from mcp-server-for-revit-python by Juan D. Rodriguez and Jean-Marc Couffin (MIT) — see NOTICE.md for what is inherited and what was added here. This fork adds token authentication, capability profiles, gating for arbitrary code execution, a strict MCP error contract, the nine tools left pending on the upstream roadmap, and CI.
Read SECURITY.md before connecting this to a real model. Works with any MCP client — Claude Code, Claude Desktop, GitHub Copilot, OpenAI Codex, Cursor. Setup for each is in OFFICE-SETUP.md.
Related MCP server: mcp-server-for-revit
How?
This minimal implementation leverages the Routes module inside pyRevit to create a bridge between Revit and Large Language Models (LLMs).
It provides a straightforward template to get started quickly, letting you prototype and iterate tools to give LLMs access to your Revit models.
These tools are designed to be expanded for your specific use cases. You're very welcome to fork the repo and make your own contributions.
Note: The pyRevit Routes API is currently in draft form and subject to change. It has no built-in authentication, and it binds every network interface unless you set its host explicitly. This fork adds an optional shared-secret token, capability profiles, and gating for arbitrary code execution on top of it — see SECURITY.md, which you should read before deploying to more than one machine.
Batteries Included
This repo is aimed at:
Beginners to the Revit API
Python specialists who aren't versed in C#
Anyone wanting to prototype and iterate quickly with LLMs and Revit
It contains:
A complete Routes implementation for pyRevit
A minimal MCP server script to connect to any MCP-compatible client
Several test commands to get you started right away
Key Architecture Components
The system runs as two separate servers working together in a chain:
Claude / LLM Client
|
| MCP Protocol (stdio or HTTP)
v
main.py (MCP Server)
|
| HTTP requests (localhost:48884)
v
pyRevit Routes (REST API running inside Revit)
|
| Revit API calls
v
Revit Applicationmain.py is the MCP server. It speaks the MCP protocol so that Claude (or any MCP-compatible client) can call tools. When a tool is called, main.py translates it into an HTTP request and forwards it to Revit.
pyRevit Routes is a lightweight REST API that runs inside the Revit process. It receives those HTTP requests, executes Revit API code (since it has direct access to the running instance), and returns JSON responses.
They never conflict because they serve different roles, speak different protocols, and listen on different ports.
Note: The Launch & Document tools (
launch_revit,list_revit_installations) are the exception — they run entirely on the MCP side, usingsubprocessto start Revit and then polling the pyRevit Routes health endpoint until the bridge is ready.
MCP Server (
main.py):
Built with FastMCP
Handles HTTP communication with Revit Routes API
Registers tools from modular tool system
Provides helper functions for GET/POST/Image requests
pyRevit Extension (
revit-mcp-python.extension/):
Contains the Routes API that runs inside Revit
Modular route registration in
startup.pyIndividual route modules in
revit_mcp/directory
Tool Registration System (
tools/):
Modular tool organization by functionality
Central registration through
tools/__init__.pyEach module registers its own tools with the MCP server
Supported Tools
Current Implementation Status
Tool Name | Status | Category | Description |
| ✅ Implemented | Status & Connectivity | Check if the Revit-MCP API is active and responding |
| ✅ Implemented | Model Information | Get comprehensive information about the current Revit model |
| ✅ Implemented | Model Information | Get all levels with elevation information |
| ✅ Implemented | View & Image | Export a specific Revit view as an image |
| ✅ Implemented | View & Image | Get a list of all exportable views organized by type |
| ✅ Implemented | Family & Placement | Place a family instance at specified location with custom properties |
| ✅ Implemented | Family & Placement | Get a flat list of available family types (with filtering) |
| ✅ Implemented | Family & Placement | Get a list of all family categories in the model |
| ✅ Implemented | View Information | Get detailed information about the currently active view |
| ✅ Implemented | View Information | Get all elements visible in the current view |
| ✅ Implemented | Visualization | Color elements based on parameter values |
| ✅ Implemented | Visualization | Remove color overrides from a category |
| ✅ Implemented | Visualization | List parameters available on a category |
| ✅ Implemented | Code Execution | Execute IronPython code directly in Revit context |
| ✅ Implemented | Launch & Document | Discover all Revit versions installed on the system |
| ✅ Implemented | Launch & Document | Launch Revit, optionally with a file, and poll for readiness |
| ✅ Implemented | Launch & Document | Open a document in running Revit (supports detach and audit) |
| ✅ Implemented | Launch & Document | Close the active document |
| ✅ Implemented | Launch & Document | Save or Save As the active document |
| ✅ Implemented | Launch & Document | Synchronize a workshared document with central |
| ✅ Implemented | Selection Management | Read the elements currently selected in the Revit UI |
| ✅ Implemented | Element Creation | Create line-based elements (walls, beams, pipes) |
| ✅ Implemented | Element Creation | Create surface-based elements (floors, ceilings) |
| ✅ Implemented | Element Management | Delete elements by id, with a dry-run mode |
| ✅ Implemented | Element Management | Set instance parameters on one or more elements |
| ✅ Implemented | Element Management | Delete whole categories, dry-run by default and title-confirmed |
| ✅ Implemented | Annotation | Tag every element of a category in the active view |
| ✅ Implemented | Integration | Discover Revit commands and installed pyRevit extensions |
| ✅ Implemented | Integration | Post a built-in Revit command |
| ✅ Implemented | Security | Report the security posture of both halves of the bridge |
Capability profiles
REVIT_MCP_PROFILE decides which of these tools are registered. A tool that is
not registered is invisible to the client and cannot be called, so this is an
enforced boundary rather than a suggestion.
Profile | Tools | Contents |
| 12 | Inspection only. Nothing here can modify a model. |
| 26 |
|
| 29 |
|
| 30 | + |
execute_revit_code requires both the full profile and the explicit
opt-in flag, on the MCP server and on the Revit side. Neither knob alone
enables it.
Smaller profiles also select tools more reliably — routing accuracy degrades past roughly 18 tools on a single agent.
Units: every coordinate and length in the creation and modification tools is in decimal feet (the Revit API's internal unit), regardless of your project's display units. Divide millimetres by 304.8.
Set these in your MCP client's env block, not in your shell — the stdio
transport passes the server only a minimal default environment. Full setup
instructions are in OFFICE-SETUP.md.


Getting Started
Installing uv:
Refer to ./README_UV.md
Installing the Extension on Revit
Activate pyRevit Routes
In Revit, navigate to the pyRevit tab
Open Settings
Go to
Routes> activateRoutes ServerpyRevit will start listening on porthttp://localhost:48884/
Install from pyRevit:
In Revit, navigate to the pyRevit tab
Open Extensions
Select the MCP Server for Revit Python Extension > Install extension
Select location, default is
%APPDATA%\Roaming\pyRevit\ExtensionsEnable and wait for pyRevit to reload. Restart Revit if necessary.
Manual Installation on a custom directory:
Clone the repo in a custom location:
git clone https://github.com/mcp-servers-for-revit/mcp-server-for-revit-pythonAdd
.extensionto the root folder nameIn Revit, navigate to the pyRevit tab
Open Settings
Under "Custom Extensions", add the path to the
.extensionfolderSave settings and reload pyRevit (you might need to restart Revit entirely)
Testing Your Connection
Once installed, test that the Routes API is working:
Open your web browser and go to:
http://localhost:48884/revit_mcp/status/If successful, you should see a response like:
{"status": "active", "health": "healthy", "revit_available": true, "document_title": "your_revit_filename", "api_name": "revit_mcp"}
The Routes Service will now load automatically whenever you start Revit. To disable it, simply remove the extension path from the pyRevit settings.
Using the MCP Client
Testing with the MCP Inspector
The MCP SDK includes a handy inspector tool for debugging:
mcp dev main.pyThen access http://127.0.0.1:6274 in your browser to test your MCP server interactively.
Transport Modes
The MCP server supports multiple transport modes for different use cases:
Flag | Transport | Endpoints | Use Case |
(none) | stdio | stdin/stdout | Claude Desktop / Claude Code default |
| SSE only |
| Legacy clients |
| HTTP only |
| Modern HTTP clients |
| Both | All above | Maximum compatibility |
Running with combined transport (recommended for HTTP):
uv run --with "mcp[cli]" main.py --combinedThis starts the server on http://127.0.0.1:8000 with both SSE and streamable-HTTP endpoints available.
Testing the endpoints:
# Test streamable-http
curl -X POST http://localhost:8000/mcp
# Test SSE
curl http://localhost:8000/sseConnecting to Claude Desktop
The simplest way to install your MCP server in Claude Desktop:
mcp install main.pyOr for manual installation:
Open Claude Desktop → Settings → Developer → Edit Config
Add this to the
mcpServerssection:
{
"mcpServers": {
"Revit Connector": {
"command": "uv",
"args": [
"run",
"--with",
"mcp[cli]",
"mcp",
"run",
"/absolute/path/to/main.py"
]
}
}
}For HTTP transport mode, configure Claude Desktop with:
{
"mcpServers": {
"Revit Connector": {
"url": "http://localhost:8000/mcp"
}
}
}Connecting to Claude Code
claude mcp add -s user "Revit-Connector" -- uv run --with "mcp[cli]" mcp run /absolute/path/to/main.pyCreating Your Own Tools
The modular architecture of this project makes adding functionalities relatively simple. The provided LLM.txt file also gives your language model the necessary context to get started right away.
The process involves three main parts:
Part 1: Create the Route Module in Revit
Create a new Python file within the revit-mcp-python.extension/revit_mcp/ directory (e.g., revit_mcp/your_module.py). This module will contain all the related functions you want to expose.
# In revit-mcp-python.extension/revit_mcp/your_module.py
# -*- coding: UTF-8 -*-
"""
Your Module for Revit MCP
Handles your specific functionality.
"""
from pyrevit import routes, revit, DB
import json
import logging
from . import auth
# Standard logger setup
logger = logging.getLogger(__name__)
def register_your_routes(api):
"""Register all your routes with the API."""
# ---- Example 1: A GET request for reading data ----
@api.route('/your_endpoint/', methods=["GET"])
def get_project_title(doc, request):
"""Gets the project title from the Revit model."""
# Every route must authorize. Take `request` in the signature even on a
# GET - pyRevit binds it by name, and the token travels in the query
# string there because HTTP headers never reach route handlers.
denied = auth.check(request)
if denied:
return denied
try:
value = doc.Title
return routes.make_response(data={"status": "success", "data": value})
except Exception as e:
logger.error("Get project title failed: {}".format(str(e)))
return routes.make_response(
data={
"status": "error",
"error": str(e),
"error_type": type(e).__name__,
# Tell the caller whether retrying could ever help.
"retryable": False,
},
status=500,
)
# ---- Example 2: A POST request for modifying the model ----
@api.route('/modify_model/', methods=["POST"])
def modify_model(doc, request):
"""Handles POST requests for modifying the Revit model."""
# write=True so this route is refused in read-only mode.
denied = auth.check(request, write=True)
if denied:
return denied
try:
data = json.loads(request.data) if isinstance(request.data, str) else request.data
# Use a transaction for all model modifications
t = DB.Transaction(doc, "Modify Model via MCP")
t.Start()
try:
element_id = data.get("element_id")
new_value = data.get("new_value")
element = doc.GetElement(DB.ElementId(int(element_id)))
param = element.LookupParameter("Comments")
param.Set(new_value)
t.Commit()
return routes.make_response(data={"status": "success", "result": "Element modified."})
except Exception as tx_error:
if t.HasStarted() and not t.HasEnded():
t.RollBack()
raise tx_error
except Exception as e:
logger.error("Modify model failed: {}".format(str(e)))
return routes.make_response(
data={
"status": "error",
"error": str(e),
"error_type": type(e).__name__,
"retryable": False,
},
status=500,
)
logger.info("Your custom routes were registered successfully.")A route that omits
auth.checkfails CI:tests/unit/test_ironpython_compat.pycounts route decorators against auth calls. If a route genuinely must answer without a token, give it an explicit# auth-exempt: <reason>comment — that keeps the exemption a reviewable decision instead of an oversight.Remember this file runs on IronPython 2.7. No f-strings, no type annotations; use
.format(). CI enforces that too.
Part 2: Create the MCP Tool Module
Create the corresponding tools for the MCP server in the tools/ directory (e.g., tools/your_tools.py). This module will use the revit_get and revit_post helpers from main.py.
# In tools/your_tools.py
# -*- coding: utf-8 -*-
"""Your tools for the MCP server."""
from mcp.server.fastmcp import Context
from .utils import format_response
def register_your_tools(mcp, revit_get, revit_post, revit_image=None):
"""Register your tools with the MCP server."""
# ---- Tool for the GET request ----
@mcp.tool()
async def get_revit_project_title(ctx: Context) -> str:
"""Return the title of the currently open Revit project.
Use this to confirm which model is open before acting on it - the
title is also what reset_model requires as confirmation.
Does NOT return the file path or whether the model is workshared;
get_revit_model_info covers those.
"""
# No try/except: a bridge failure must raise so MCP reports isError.
response = await revit_get("/your_endpoint/", ctx)
return format_response(response)
# ---- Tool for the POST request ----
@mcp.tool()
async def modify_revit_element_comment(
element_id: int,
new_value: str,
ctx: Context = None
) -> str:
"""Set the 'Comments' parameter on one element.
Get element ids from get_selected_elements or
get_current_view_elements. Returns confirmation of what changed.
Does NOT create elements or edit type parameters.
Args:
element_id: The id of the element to modify.
new_value: The new comment to apply.
"""
payload = {"element_id": element_id, "new_value": new_value}
response = await revit_post("/modify_model/", payload, ctx)
return format_response(response)Two conventions worth copying from the examples above:
Do not wrap the bridge call in
try/except.format_responseand the transport layer raiseToolErroron failure, which is what setsisErroron the MCP result. Catching it and returning the message hands the model a successful result that merely describes a failure.Write the description for a reader who cannot see the code. State what the tool does, when to reach for it, what it returns, and — most usefully — what it does not do. That text is the only signal the model has when choosing between tools.
Then register it in tools/__init__.py under the right profile: read-only
tools in _register_read_tools, anything that can change a model in
_register_write_tools, destructive or administrative tools in
_register_full_tools.
Part 3: Register Your New Modules
1. Register the Route Module
Open revit-mcp-python.extension/startup.py and add your new route registration function.
# In revit-mcp-python.extension/startup.py
# ... (other imports)
# Import the registration function from your new module
from revit_mcp.your_module import register_your_routes
def register_routes():
"""Register all MCP route modules"""
api = routes.API('revit_mcp')
try:
# ... (existing route registrations)
# Register your new routes (this registers all functions inside)
register_your_routes(api)
logger.info("All MCP routes registered successfully")
except Exception as e:
logger.error("Failed to register MCP routes: {}".format(str(e)))
raise2. Register the Tool Module
Open tools/__init__.py and add your new tool registration function.
# In tools/__init__.py
# ... (other tool imports)
# Import the registration function from your new tool module
from .your_tools import register_your_tools
def register_tools(mcp_server, revit_get_func, revit_post_func, revit_image_func):
"""Register all tools with the MCP server"""
# ... (existing tool registrations)
# Register your new tools (this registers all tools inside)
register_your_tools(mcp_server, revit_get_func, revit_post_func, revit_image_func)
return mcp_serverRoadmap
Everything on the original roadmap table above is now implemented. Delivered in this fork:
✅ Authentication and security enhancements — shared-secret token on every route, capability profiles, read-only mode, code-execution gating with an audit log, and a
get_revit_security_statustool. See SECURITY.md.✅ More advanced Revit tools — selection, modification, deletion, line- and surface-based creation, tagging, command invocation, model reset.
✅ Better error handling — failures raise
ToolErrorso MCP reportsisError: true, each carrying a retry verdict; empty results stay successes.✅ CI — ruff and pytest on Python 3.11/3.12/3.13, plus static guards that fail the build if a route ships without an auth check or if Python-3-only syntax reaches the IronPython half.
Still open:
Creating a Client inside Revit
Benchmarking with local models
Openings, sloped floors, and curved geometry in the creation tools (currently straight lines and planar boundaries only — use
execute_revit_codefor the rest)MEP beyond pipes — ducts, cable trays, fittings
Integration test coverage for the newer routes (they need a live Revit)
Contributing
Contributions are welcome! Feel free to submit pull requests or open issues for any bugs or feature requests. Feel free to reach out to me if you have any questions, ideas
Available Tools
26 toolsclear_colorsA
Remove colour overrides from a category in the active view.
Reverses color_splash, returning elements to their normal appearance. Only affects the active view.
Args: category_name: Category to clear, e.g. "Walls".
Inputs: category_name (required).
close_documentA
Close the active Revit document.
Args: save: If True, save the document before closing. If False (default), close without saving.
Inputs: save.
color_splashA
Colour-code elements of a category by the value of one parameter.
Elements sharing a parameter value get the same colour, which makes this the fastest way to visually audit a model - phasing, fire rating, room department, wall type distribution.
Applies graphic overrides in the ACTIVE view only; other views are untouched. The overrides persist in the view until clear_colors is called. Returns the colour assigned to each distinct value, plus counts.
Use list_category_parameters first to get a valid parameter_name.
Args: category_name: Category to colour, e.g. "Walls". parameter_name: Parameter driving the colours, e.g. "Type Name". use_gradient: Use a continuous gradient instead of distinct colours. Suits numeric parameters; poor for text values. custom_colors: Optional hex colours to use in order, e.g. ["#FF0000", "#00FF00"].
Inputs: category_name (required), parameter_name (required), use_gradient, custom_colors.
create_line_based_elementA
Create a wall, structural beam, or pipe running between two points.
ALL LENGTHS ARE IN DECIMAL FEET - this is the Revit API's internal unit and is unaffected by the project's display units. To work in millimetres, divide by 304.8 before calling (3000mm -> 9.843).
Returns the new element's id, name and category.
Use list_levels to see valid level_name values, and list_families for beam types. When level_name is omitted the lowest level is used; when type_name is omitted the first available type is used. If a name does not match, the error lists what is available - read that rather than guessing again.
Does NOT create ducts, cable trays, curved walls, or anything that needs a non-straight curve. Use execute_revit_code for those.
Args: element_kind: One of "wall", "beam", "pipe". start_x, start_y, start_z: Start point, in feet. end_x, end_y, end_z: End point, in feet. level_name: Host level. Defaults to the lowest level. type_name: Wall/beam/pipe type name. Defaults to the first found. height: Wall height in feet. Walls only, ignored otherwise. offset: Base offset from the level, in feet. Walls only. structural: Mark the wall as structural. Walls only. diameter: Pipe diameter in feet. Pipes only.
Inputs: end_x (required), end_y (required), start_x (required), start_y (required), +9 more.
create_surface_based_elementA
Create a floor or ceiling from a closed boundary outline.
ALL COORDINATES ARE IN DECIMAL FEET (see create_line_based_element).
The boundary is an ordered list of at least three points that trace the outline. Do not repeat the first point at the end - the closing segment is added automatically. The outline must be planar and must not self-intersect.
Returns the new element's id, name and category.
Does NOT support openings, sloped floors, or boundaries built from arcs. Use execute_revit_code for those.
Ceiling creation requires Revit 2022 or newer.
Args: element_kind: Either "floor" or "ceiling". boundary: Ordered points, e.g. [{"x": 0, "y": 0, "z": 0}, {"x": 20, "y": 0, "z": 0}, {"x": 20, "y": 15, "z": 0}, {"x": 0, "y": 15, "z": 0}] level_name: Host level. Defaults to the lowest level. type_name: Floor/ceiling type name. Defaults to the first found. structural: Mark the floor as structural. Floors only.
Inputs: boundary (required), element_kind (required), type_name, level_name, +1 more.
delete_elementsA
Delete elements from the model, by element id.
Destructive. Prefer calling once with dry_run=True first: that returns exactly what would be removed without touching the model, which is worth doing whenever the ids came from a filter rather than from an explicit user selection.
Deleting one element can cascade - removing a wall also removes the doors and windows hosted in it - so deleted_count can exceed the number of ids supplied. The dry run cannot predict cascades.
Does NOT accept a category or a filter, only explicit ids: use reset_model for category-wide clearing, which has its own confirmation guards.
Elements that are pinned, owned by another user in a workshared model, or structurally required (such as the last level) cannot be deleted and are reported as failures.
Args: element_ids: Element ids to delete. Must be non-empty. dry_run: When True, report what would be deleted and change nothing.
Inputs: element_ids (required), dry_run.
get_current_view_elementsA
Get elements visible in the currently active view in Revit.
Returns per element: element_id, name, category, category_id. Also returns category_counts (always for ALL elements, even if truncated).
If the response contains truncated=true, not all elements were returned. Check total_elements vs returned_elements and increase limit if needed.
Args: limit: Maximum number of elements to return (default 5000). include_levels: Include level name and level_id per element. Default false. include_location: Include location geometry (point or curve). Default false.
Inputs: limit, include_levels, include_location.
get_current_view_infoA
Get detailed information about the currently active view in Revit.
Returns comprehensive information including:
View name, type, and ID
Scale and detail level
Crop box status
View family type
View discipline
Template status
Inputs: no named parameters.
get_revit_model_infoB
Get comprehensive information about the current Revit model
Inputs: no named parameters.
get_revit_security_statusA
Report the security posture of both halves of the bridge.
Answers: is a token required, is arbitrary code execution enabled, is the Revit Routes server reachable from other machines on the network, and is this server in read-only mode.
Use this when the user asks whether the setup is safe, when a call was refused as unauthorized, or before rolling this out to more people.
Never returns the token itself - only whether one is configured.
Reports both sides separately, because they are configured independently and disagreeing settings are the usual cause of confusing auth failures.
Inputs: no named parameters.
get_revit_statusA
Check if the Revit MCP API is active and responding
Inputs: no named parameters.
get_revit_viewB
Export a specific Revit view as an image
Inputs: view_name (required).
get_selected_elementsA
Read what the user currently has selected in the Revit UI.
Use this whenever the user says "these", "the selected ones", or "what I have highlighted" - it is the only way to find out. Returns element_id, name, category, type and level for each, plus category_counts covering the whole selection.
The element_ids returned here are what modify_elements and delete_elements take as input, so this is normally the first call in a select-then-act workflow.
Returns an empty list with total_selected 0 when nothing is selected; that is a successful answer, not an error.
Does NOT change the selection. There is no tool to set the selection - the user must do that in Revit.
Args: limit: Maximum elements described in full (default 500). category_counts stays accurate for the whole selection even when the detailed list is truncated. include_parameters: Also return every readable instance parameter per element. Verbose - leave off unless parameter values are actually needed.
Inputs: limit, include_parameters.
launch_revitA
Launch Revit on this machine, optionally opening a file.
Finds installed Revit versions automatically. After launching, polls the pyRevit Routes health endpoint until Revit is ready for MCP tools.
For workshared (central model) files, Revit will show its native worksharing dialog on open. Use the open_document tool after launch for more control over worksharing options like detach from central.
Args: file_path: Path to a .rvt, .rfa, or .rte file to open. Optional. version: Revit version year (e.g. "2025"). Uses latest if omitted. language: Language code (e.g. "ENU", "FRA"). Optional. timeout: Seconds to wait for Revit readiness (default 120).
Inputs: timeout, version, language, file_path.
list_category_parametersA
List the parameters available on elements of a category.
Returns each parameter with its type and a sample value. Use this to find a valid parameter_name for color_splash, and to check what modify_elements can set on a category.
Args: category_name: Revit category, e.g. "Walls", "Doors", "Rooms".
Inputs: category_name (required).
list_familiesA
List loadable family types available in the current model.
Returns family_name, type_name, category and whether the type is activated, for each match. Call this before place_family to get exact names - placement fails on a near-miss.
An empty list means nothing matched the filter, which is a successful answer rather than an error.
Does NOT list system types (walls, floors, ceilings, pipes). Those are reported by the error message of create_line_based_element or create_surface_based_element when a type name does not match.
Args: contains: Case-insensitive substring filter matched against both family and type name. Omit to list everything up to limit. limit: Maximum results (default 50).
Inputs: limit, contains.
list_family_categoriesA
List every family category in the model, with a count per category.
Useful for orienting in an unfamiliar model before drilling into list_families, and for finding the exact category spelling that tag_elements and color_splash expect.
Inputs: no named parameters.
list_levelsA
Get a list of all levels in the current Revit model
Inputs: no named parameters.
list_revit_installationsA
Discover all Revit versions installed on this system.
Returns a list of installed Revit versions with their executable paths. Use this to check what's available before calling launch_revit.
Inputs: no named parameters.
list_revit_viewsA
Get a list of all exportable views in the current Revit model
Inputs: no named parameters.
modify_elementsA
Set instance parameters on existing elements, by element id.
Applies the same parameter values to every element in element_ids, in one transaction. Returns which parameters were set and which failed, per element, so a partial success is visible rather than silent.
Get element ids from get_selected_elements or get_current_view_elements first. Use list_category_parameters to find out what parameter names a category actually has.
Lengths are in Revit internal units (decimal feet), not the units shown in the UI. Yes/No parameters accept true/false.
Does NOT: create elements, change an element's type, or edit type parameters (these are instance parameters only). Read-only and computed parameters are reported as failures rather than being forced.
Args: element_ids: Element ids to modify. Must be non-empty. parameters: Parameter name to value, e.g. {"Mark": "A1", "Comments": "checked"}. Must be non-empty.
Inputs: parameters (required), element_ids (required).
open_documentA
Open a Revit document file in the running Revit instance.
Supports workshared (central) files with options to detach from central or audit the file on open.
Args: file_path: Absolute path to a .rvt, .rfa, or .rte file. detach: If True, open detached from central (workshared files only). Preserves worksets but severs the link to the central model. audit: If True, audit the file on open to check for corruption.
Inputs: file_path (required), audit, detach.
place_familyA
Place one instance of a loadable family at a point.
This is the point-based placement tool: furniture, doors, windows, columns, equipment. For walls, beams, pipes, floors and ceilings use create_line_based_element or create_surface_based_element instead.
COORDINATES ARE IN DECIMAL FEET, and rotation is in DEGREES about the vertical axis. Get exact family_name and type_name from list_families first; if the name does not resolve, the error lists what is available.
Returns the new element's id, the location it actually ended up at (which can differ from the request when a level constrains it), and which properties were applied versus rejected.
Does NOT load families that are not already in the project.
Args: family_name: Exact family name, e.g. "Desk". type_name: Exact type name. Defaults to the first type found. x, y, z: Placement point, in feet. rotation: Rotation about the Z axis, in degrees. level_name: Host level. See list_levels. properties: Instance parameters to set on the new element, e.g. {"Mark": "D-01"}.
Inputs: family_name (required), x, y, z, +4 more.
save_documentA
Save the active Revit document.
If file_path is omitted, saves the document in place. If file_path is provided, performs a Save As to the new location.
Args: file_path: Optional path for Save As. If omitted, saves in place.
Inputs: file_path.
sync_with_centralA
Synchronize the active workshared document with central.
Only works with workshared (central model) documents. For non-workshared documents, use save_document instead.
Args: comment: Sync comment visible in the worksharing log. compact: If True, compact the central model during sync. relinquish_all: If True (default), relinquish all borrowed elements and worksets after sync.
Inputs: comment, compact, relinquish_all.
tag_elementsA
Place tags on all elements of one category in the ACTIVE view.
Tags land in whichever view is currently active in Revit - check with get_current_view_info first if that matters. Returns how many were tagged and, for anything skipped, why.
Tagging requires a tag family for that category to be loaded in the project. If none is loaded, nothing is tagged and the response says so; that is a loaded-content problem, not something to retry.
Does NOT: tag across multiple views, position tags intelligently (each one lands at its element's centre and they will overlap in dense areas), or choose between multiple loaded tag families.
Args: category_name: Revit category to tag, e.g. "Walls", "Doors", "Windows", "Rooms". Singular or plural both resolve. limit: Maximum tags to place in one call (default 1000). skip_tagged: Skip elements that already have a tag in this view. Leave True to make repeat calls idempotent. leader: Give each tag a leader line.
Inputs: category_name (required), limit, leader, skip_tagged.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 26 tools
Each tool targets a distinct resource or operation: views, model info, elements, families, parameters, selection, creation, modification, deletion, visualization, document lifecycle, and system management. Descriptions clearly delineate boundaries, and overlapping-sounding tools like get_revit_status vs. get_revit_model_info are unambiguous.
All tool names follow a consistent verb_noun pattern in snake_case (list_, get_, create_, modify_, delete_, save_, etc.). Even compound names like create_line_based_element are consistent, and there is no mixing of conventions or vague verbs.
With 26 tools, the server is slightly over the typical well-scoped range, but the broad scope of Revit functionality justifies the count. Each tool serves a distinct purpose and there are no redundant tools, making it feel slightly heavy but still appropriate.
Several significant gaps exist: the descriptions explicitly reference an execute_revit_code tool that is not actually available, and there is no tool to load missing families, edit type parameters, or create certain element types. These gaps create dead ends and will cause agent failures when attempting those operations.
Maintenance
Related MCP Connectors
Token-free MCP server for structured RevoGrid Core, Pro, and Enterprise knowledge retrieval.
Nifty's MCP server — exposes tasks, projects, messages, and files as tools for AI agents.
MCP server for AI dialogue using various LLM models via AceDataCloud
An MCP server that provides an API to LLMs to manage their JumpCloud resources.
Related MCP Servers
- AlicenseNot gradedqualityAmaintenanceMCP server for Autodesk Revit (BIM) with 705+ API endpoints. Enables AI agents to create walls, place doors/windows, generate sheets, manage views, and produce construction documents via the Model Context Protocol. Uses named pipes for zero-crash Revit integration.22MIT
- AlicenseNot gradedqualityDmaintenanceNode.js MCP server enabling AI assistants to interact with Autodesk Revit for model operations, data queries, and sketch-to-building generation via LLM.MIT
- AlicenseNot gradedqualityAmaintenanceAn MCP server that bridges AI agents to Autodesk Revit, enabling local tool-based interaction with Revit models, including query, create, and modify operations, with an optional personal tool baking system.140Apache 2.0
- -licenseNot gradedqualityNot gradedmaintenanceConnects MCP clients like Claude, Codex, and Cursor to a running Autodesk Revit session for typed BIM queries, verified model edits, family authoring, exports, and Power BI workflows. It is open-source, Apache-2.0, and designed for reliable, verified outcomes.-