Revit MCP Server
Revit MCP Server lets an MCP-compatible AI client inspect, create, modify, analyze, document, and interoperate with Autodesk Revit models through pyRevit Routes.
Create Revit elements: levels, walls/beams, floors/roofs/ceilings, family instances, grids, structural framing, sheets, schedules, rooms, room separations, ducts, pipes, MEP systems, detail lines, and views.
Query the model: Revit status, model info, levels, families/categories, views, current view details/elements, selected elements, category parameters, and full element properties.
Modify elements: delete, change parameters, set parameter values, color-splash/clear colors, tag walls/elements, transform (move/copy/rotate/mirror), and switch active view.
Analyze data: filter elements by category/type/visibility/bounds, export room data, get material quantities, detect clashes, and summarize model statistics.
Document and export: create dimensions, export views/sheets to PDF, PNG, JPG, or DWG, and export the model to IFC.
Interop and persist: link/import DWG, DXF, DGN, RVT; load families; save/save-as documents.
Advanced: execute IronPython code directly in Revit context for custom operations.
Operational: works over stdio/SSE/HTTP with MCP clients, supports Revit 2024–2027, and accepts millimeters.
Provides 45 tools for building design, editing, analysis, MEP, interop, and documentation via Autodesk Revit API, accessible through pyRevit.
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 Server create a new level at elevation 10 feet"
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.
Revit MCP Server
MCP server for Autodesk Revit 2024/2025/2026/2027 via pyRevit — 48 tools for building design, editing, analysis, clash detection, MEP, interop, documentation, and model persistence.
Works with any MCP client: Claude Desktop, Claude Code, Cursor, Windsurf, Copilot, or any other MCP-compatible application.
How It Works
AI Client ──stdio/SSE/HTTP──> MCP Server (Python/FastMCP) ──HTTP :48884──> pyRevit Routes ──> Revit APIThe MCP server runs on your machine and communicates with Revit through pyRevit's Routes API. Any MCP-compatible AI client can connect to it.
Related MCP server: RevitMCPBridge2026
Prerequisites
Requirement | Details |
Windows 10/11 | Revit is Windows-only |
Autodesk Revit | 2024, 2025, 2026, or 2027 |
pyRevit | Installed and loaded in Revit |
uv | Python package manager (install) |
A project open in Revit | Tools require an active document |
Install pyRevit (if not already installed)
pyRevit is a free add-in that lets scripts run inside Revit. This MCP server needs it to communicate with Revit.
Download the latest .exe installer (e.g.
pyRevit_CLI_x.x.x.x_admin_signed.exe)Run the installer — accept all defaults, click Next through each screen
Open (or restart) Revit — you should see a pyRevit tab in the ribbon at the top
In the pyRevit tab, click Settings (gear icon)
In the Settings window, go to the Routes section on the left
Check the box to Enable Routes Server
Click Save Settings and let pyRevit reload
To verify: open a browser and go to http://localhost:48884/ — you should see a response (not a "connection refused" error).
Quick Start
1. Get the code
git clone https://github.com/Demolinator/revit-mcp-server.git
cd revit-mcp-server
uv sync2. Load the extension into pyRevit
startup.py and revit_mcp/ run inside Revit, so pyRevit has to load this folder as an extension.
Don't install "MCP Server for Revit Python" from the pyRevit Extensions manager. That entry installs the original upstream project, which lacks most of the 48 routes this server calls.
Pick a folder for your pyRevit extensions, e.g.
C:\pyRevitExtensions.Link this repo into it under a name ending in
.extension(a junction keeps it updated whenever yougit pull):New-Item -ItemType Junction -Path C:\pyRevitExtensions\revit-mcp.extension -Target C:\path\to\revit-mcp-server(Copying the folder there with that name works too; you'll just need to copy it again after updates.)
In Revit: pyRevit tab → Settings → Custom Extension Directories → add
C:\pyRevitExtensions.In the same Settings window, under Routes, turn on Routes Server (port
48884).Save Settings and Reload.
3. Check Revit is answering
With a project open, browse to http://localhost:48884/revit_mcp/status/. A working setup answers with "status": "active" and your project's title. A 404 means the extension isn't loaded; "can't reach this page" means Routes is off or Revit is closed.
4. Connect your AI client
Most desktop clients start the server themselves over stdio. Add this to the client's MCP configuration (for Claude Desktop: claude_desktop_config.json):
{
"mcpServers": {
"revit": {
"command": "uv",
"args": ["run", "--directory", "C:\path\to\revit-mcp-server", "main.py"]
}
}
}For Claude Code: claude mcp add revit -- uv run --directory C:\path\to\revit-mcp-server main.py
Clients that connect over HTTP instead (some Cursor/Windsurf setups, remote clients) need the server started separately:
uv run main.py --http # then point the client at http://127.0.0.1:8000/mcpStart with | Protocol | Served at |
| stdio (default) | the client's stdin/stdout |
| Streamable HTTP |
|
| Server-Sent Events (older clients) |
|
| Streamable HTTP + SSE together | all of the above |
Configuration
Set these environment variables (or the env block of your MCP client config) to change the defaults:
Variable | Default | Purpose |
|
| Machine running Revit + pyRevit Routes |
|
| pyRevit Routes port |
|
| Bind address for |
|
| Port for |
Keep MCP_HOST on 127.0.0.1 unless you understand the risks in SECURITY.md.
Try tools without an AI client
uv run mcp dev main.py # opens the MCP Inspector at http://127.0.0.1:6274Supported Tools (48)
Create (15)
Tool | Description |
| Create new levels with elevations |
| Create walls, beams, and other line-based elements |
| Create floors, roofs, and surface elements |
| Place a family instance at specified location |
| Create column grid lines |
| Create structural beams and framing |
| Create new drawing sheets |
| Create schedules with custom fields |
| Create rooms at specified levels |
| Create room separation boundary lines |
| Create ducts between two points (MEP) |
| Create pipes between two points (MEP) |
| Create mechanical or piping systems |
| Create view-specific detail lines |
| Create floor plans, sections, elevations, 3D views |
Query (12)
Tool | Description |
| Check if the API is active and responding |
| Get model information |
| Get all levels with elevations |
| Get available family types |
| Get all family categories |
| Export a view as an image |
| List all exportable views |
| Get active view details |
| Get elements in current view |
| Get currently selected elements |
| List parameters for a category |
| Get all parameters and properties of an element |
Modify (9)
Tool | Description |
| Delete elements from the model |
| Modify element parameter values |
| Color elements by parameter values |
| Reset element colors |
| Tag all walls in current view |
| Set a single parameter value on an element |
| Tag specific elements with annotation symbols |
| Move, copy, rotate, or mirror elements |
| Switch the active view in Revit |
Analyze (5)
Tool | Description |
| Filter elements by category and parameters |
| Export room areas, volumes, boundaries |
| Material takeoff data |
| Detect hard clashes (interferences) between disciplines, e.g. structure vs MEP |
| Element counts and model stats |
Document (2)
Tool | Description |
| Create dimension annotations |
| Export views to PDF or image |
Interop & Persistence (4)
Tool | Description |
| Export model to IFC format (IFC2x3/IFC4) |
| Link or import DWG, DXF, DGN, SAT, SKP, 3DM, or RVT files |
| Load a Revit family ( |
| Save / Save-As the model to disk (persistence across sessions) |
Advanced (1)
Tool | Description |
| Execute IronPython code in Revit context |
Architecture
Two runtimes communicate over HTTP:
Component | Runtime | Location | Purpose |
| Python 3.11+ (CPython) | Your machine | MCP protocol, tool definitions |
| IronPython 2.7 (inside Revit) | Revit process | pyRevit route handlers, Revit API |
Multi-Version Revit Support
This server supports Revit 2024, 2025, 2026, and 2027 through centralized helper functions that handle the ElementId API differences across versions:
get_element_id_value()— Extracts integer IDs using.Value(2024+) with.IntegerValuefallbackmake_element_id()— Creates ElementIds usingSystem.Int64(2024+) withintfallback
No configuration needed — version detection is automatic via try/except at runtime.
Revit 2027 note: Revit 2027 runs on .NET 10 (vs .NET 8 in 2025/2026). This MCP server is pyRevit-based, so .NET compatibility is handled by pyRevit itself — ensure you run a pyRevit build with Revit 2027 support. None of the 48 tools use APIs removed in 2027 (AXM/FormIt import,
Mechanical.Zonemembers, legacy rebar creation, or the droppedEnergyDataSettingsproperties).
Unit Handling
All tools accept millimeters (mm). The server converts to Revit's internal feet.
From | To mm |
meters | x 1000 |
feet | x 304.8 |
inches | x 25.4 |
Creating Your Own Tools
Adding a new tool requires 2 files + 2 registration lines:
Route handler in
revit_mcp/new_module.py(IronPython 2.7)Tool definition in
tools/new_tools.py(Python 3.11+)Register routes in
startup.pyRegister tools in
tools/__init__.py
See CONTRIBUTING.md for a complete worked example, and LLM.txt for context that helps AI assistants understand the codebase.
Contributing
Contributions are welcome — from typo fixes to new tools! Read CONTRIBUTING.md for the dev setup, the edit–reload loop, a step-by-step "add a tool" walkthrough, and coding conventions.
Looking for a place to start? See issues labeled
good first issue.Found a bug or have an idea? Open an issue.
Please follow our Code of Conduct, and report security issues privately per SECURITY.md.
Contributors
Thanks to everyone who has built, fixed, tested, and reported issues in this repository. See CONTRIBUTORS.md for who did what.
Built on mcp-server-for-revit-python by Juan Rodriguez and its contributors.
Author
Talal Ahmed
License
MIT
Available Tools
45 toolsai_element_filterA
Filter and find Revit elements by category, type, visibility, and spatial bounds.
A powerful query tool for finding specific elements in the model. Combine filters for precise results — e.g., find all exterior walls on Level 1 visible in the current view.
Args: category: BuiltInCategory name, e.g. "OST_Walls", "OST_Doors" (optional) type_name: Filter by family type name or partial match (optional) visible_in_view: Only include elements visible in the active view (optional) bounding_box_min: Spatial filter min corner {"x", "y", "z"} in mm (optional) bounding_box_max: Spatial filter max corner {"x", "y", "z"} in mm (optional) max_elements: Maximum results to return (defaults to 50) ctx: MCP context for logging
Inputs: category, type_name, visible_in_view, bounding_box_min, +2 more.
analyze_model_statisticsB
Analyze the Revit model and return element counts grouped by category.
Provides a high-level overview of what's in the model — how many walls, doors, windows, floors, etc. Useful for progress tracking and model health checks.
Args: ctx: MCP context for logging
Inputs: no named parameters.
clear_colorsA
Clear color overrides for elements in a category
This tool removes all color overrides that have been applied to elements in the specified category, returning them to their default appearance.
Args: category_name: Name of the category to clear colors from (e.g., "Walls", "Doors") ctx: MCP context for logging
Returns: Results of the clear operation including count of elements processed
Inputs: category_name (required).
color_splashA
Color elements in a category based on parameter values
This tool applies color coding to Revit elements within a specified category based on their parameter values. Elements with the same parameter value will receive the same color.
Args: category_name: Name of the category to color (e.g., "Walls", "Doors", "Windows") parameter_name: Name of the parameter to use for coloring (e.g., "Mark", "Type Name") use_gradient: Whether to use gradient coloring instead of distinct colors (default: False) custom_colors: Optional list of custom colors in hex format (e.g., ["#FF0000", "#00FF00"]) ctx: MCP context for logging
Returns: Results of the coloring operation including statistics and color assignments
Inputs: category_name (required), parameter_name (required), use_gradient, custom_colors.
create_detail_lineA
Create a detail line in a Revit view for annotation purposes.
Detail lines are view-specific 2D annotation elements. They only appear in the view where they are created (unlike model lines). Must be created in a plan, section, or detail view.
Args: start_point: Start point {"x", "y", "z"} in mm end_point: End point {"x", "y", "z"} in mm view_name: Target view name (defaults to active view) line_style: Line style name (e.g., "Medium Lines"). Uses default if omitted ctx: MCP context for logging
Inputs: start_point (required), end_point (required), view_name, line_style.
create_dimensionsA
Create dimension annotations for elements in the current view.
Automatically dimensions the specified elements. Works in plan, section, and elevation views. The dimension line is placed at an offset from the elements for readability.
Args: element_ids: List of element IDs to dimension dimension_type: Type of dimension — "linear", "aligned", or "angular" (defaults to "linear") ctx: MCP context for logging
Inputs: element_ids (required), dimension_type.
create_ductA
Create a duct in the Revit model between two points.
Requires a project with mechanical families loaded (MEP template). Specify diameter for round ducts, or width+height for rectangular. All dimensions in millimeters.
Args: start_point: Start point {"x", "y", "z"} in mm end_point: End point {"x", "y", "z"} in mm system_type: System type name (e.g., "Supply Air"). Auto-detects if omitted duct_type: Duct type name (e.g., "Round Duct"). Auto-detects if omitted level_name: Level name. Defaults to nearest level diameter: Round duct diameter in mm width: Rectangular duct width in mm height: Rectangular duct height in mm ctx: MCP context for logging
Inputs: start_point (required), end_point (required), system_type, duct_type, +4 more.
create_gridA
Create grid lines for the structural layout of a building.
Grids define the column grid system. Each grid is a line from start to end point (in millimeters). Names auto-assign (A, B, C... or 1, 2, 3...) if not provided. Supports batch creation.
Args: grids: List of grid definitions, each with: - start_point (dict): {"x": float, "y": float, "z": float} in mm (required) - end_point (dict): {"x": float, "y": float, "z": float} in mm (required) - name (str): Grid line name (optional, auto-assigned) ctx: MCP context for logging
Inputs: grids (required).
create_levelA
Create building levels (floor elevations) in Revit.
Levels define the floor-to-floor heights of a building and must be created before placing walls, floors, or other level-dependent elements.
Args: levels: List of level definitions, each with: - elevation (float): Elevation in mm from project origin (required) - name (str): Level name, e.g. "Ground Floor" (optional, auto-assigned) ctx: MCP context for logging
Inputs: levels (required).
create_line_based_elementA
Create walls, beams, and other line-based building elements in Revit.
Each element needs start and end points (in millimeters), element type (wall/beam), and optionally a level name, height, and family type name. Supports batch creation — pass multiple elements in one call.
Args: elements: List of element definitions, each with: - element_type (str): "wall" or "beam" (required) - start_point (dict): {"x": float, "y": float, "z": float} in mm (required) - end_point (dict): {"x": float, "y": float, "z": float} in mm (required) - type_name (str): Family type name, e.g. "Generic - 200mm" (optional) - level_name (str): Target level name (optional, defaults to first level) - height (float): Element height in mm (optional, defaults to 3000) - offset (float): Offset from base level in mm (optional, defaults to 0) - structural (bool): Mark as structural (optional, defaults to false) - name (str): Description for reference (optional) ctx: MCP context for logging
Inputs: elements (required).
create_mep_systemA
Create a mechanical or piping system and optionally add elements to it.
Groups ducts or pipes into a named system for organization and analysis.
Args: system_type: "mechanical" or "piping" system_name: Display name for the system (e.g., "Level 1 Supply Air") element_ids: Optional list of duct/pipe element IDs to add to the system ctx: MCP context for logging
Inputs: system_type (required), system_name (required), element_ids.
create_pipeA
Create a pipe in the Revit model between two points.
Requires a project with plumbing families loaded (MEP template). All dimensions in millimeters.
Args: start_point: Start point {"x", "y", "z"} in mm end_point: End point {"x", "y", "z"} in mm system_type: System type name (e.g., "Domestic Hot Water"). Auto-detects if omitted pipe_type: Pipe type name (e.g., "Copper"). Auto-detects if omitted level_name: Level name. Defaults to nearest level diameter: Pipe diameter in mm ctx: MCP context for logging
Inputs: start_point (required), end_point (required), system_type, pipe_type, +2 more.
create_roomA
Create a room in the Revit model at a specified level.
Rooms must be placed inside enclosed areas (bounded by walls or room separation lines). If no location is given, Revit auto-places the room.
Args: level_name: Target level name (e.g., "Level 1") location: Optional placement point {"x": float, "y": float} in mm name: Room name (e.g., "Living Room") number: Room number (e.g., "101") ctx: MCP context for logging
Inputs: level_name (required), location, name, number.
create_room_separationA
Create room separation lines to define room boundaries.
Room separation lines act as invisible walls for room calculation. Use these when physical walls don't fully enclose a space (e.g., open-plan areas, corridors). All coordinates in millimeters.
Args: lines: List of line segments, each with: - start_point (dict): {"x": float, "y": float, "z": float} in mm - end_point (dict): {"x": float, "y": float, "z": float} in mm level_name: Target level name (defaults to active view's level) view_name: Plan view name (defaults to active view) ctx: MCP context for logging
Inputs: lines (required), level_name, view_name.
create_scheduleB
Create a schedule (quantity takeoff view) for a specific element category.
Schedules tabulate element data — e.g., a wall schedule showing all walls with their types, lengths, and areas. The schedule appears as a new view in the Revit project browser.
Args: category: BuiltInCategory name, e.g. "OST_Walls", "OST_Rooms" (required) fields: Parameter names to include as columns (optional, uses default set) e.g., ["Family and Type", "Length", "Area", "Mark"] schedule_name: Name for the schedule view (optional, auto-generated) ctx: MCP context for logging
Inputs: category (required), fields, schedule_name.
create_sheetA
Create a drawing sheet in Revit for construction documentation.
Sheets are the printable output of a Revit project. Each sheet has a title block, sheet number, and name. Views can be placed on sheets after creation.
Args: sheet_number: Sheet number, e.g. "A101" (optional, auto-assigned) sheet_name: Sheet title, e.g. "Ground Floor Plan" (defaults to "Unnamed Sheet") title_block_name: Title block family name (optional, uses first available) ctx: MCP context for logging
Inputs: sheet_number, sheet_name, title_block_name.
create_structural_framingA
Create structural beams and framing elements in Revit.
Beams are placed along a line between two points at a specified level. All dimensions in millimeters. Supports batch creation.
Args: elements: List of beam definitions, each with: - start_point (dict): {"x": float, "y": float, "z": float} in mm (required) - end_point (dict): {"x": float, "y": float, "z": float} in mm (required) - type_name (str): Beam family type name (optional) - level_name (str): Target level name (optional) - name (str): Description for reference (optional) ctx: MCP context for logging
Inputs: elements (required).
create_surface_based_elementA
Create floors, roofs, ceilings, and other surface-based building elements.
Each element needs a closed boundary polygon (list of line segments) where the last point connects back to the first. All dimensions in millimeters. Supports batch creation.
Args: elements: List of element definitions, each with: - element_type (str): "floor", "roof", or "ceiling" (required) - boundary (list[dict]): Array of {"p0": Point, "p1": Point} segments forming a closed polygon (required, minimum 3 segments) - type_name (str): Family type name (optional) - level_name (str): Target level name (optional) - offset (float): Offset from level in mm (optional, defaults to 0) - name (str): Description for reference (optional) ctx: MCP context for logging
Inputs: elements (required).
create_viewA
Create a new view in the Revit model.
Supports floor plans, ceiling plans, sections, elevations, and 3D views. Floor plans and ceiling plans require a level name. Sections require a section box definition with origin, direction, and dimensions.
Args: view_type: Type of view — "floor_plan", "ceiling_plan", "section", "elevation", or "3d" name: Display name for the new view level_name: Required for floor_plan and ceiling_plan — the level to show section_box: Required for section — defines the cut plane: - origin (dict): {"x", "y", "z"} center point in mm - direction (dict): {"x", "y", "z"} view direction vector - up (dict): {"x", "y", "z"} up direction vector - width (float): Section width in mm - height (float): Section height in mm - depth (float): Section depth in mm ctx: MCP context for logging
Inputs: view_type (required), name (required), level_name, section_box.
delete_elementsA
Delete one or more elements from the Revit model.
Removes elements by their IDs. If a deleted element hosts other elements (e.g., a wall with doors), the hosted elements are also deleted (cascade). All deletions happen in a single transaction — if any fails, none are deleted.
Args: element_ids: List of Revit element IDs to delete ctx: MCP context for logging
Inputs: element_ids (required).
execute_revit_codeA
Execute IronPython code directly in Revit context.
This tool allows you to send IronPython 2.7.12 code to be executed inside Revit. The code has access to:
doc: The active Revit document
DB: Revit API Database namespace
revit: pyRevit module
print: Function to output text (returned in response)
Use this when the existing MCP tools cannot accomplish what you need.
Args: code: The IronPython code to execute (as a string) description: Optional description of what the code does ctx: MCP context for logging
Returns: Execution results including any output or errors
Example: code = ''' # encoding: utf-8 # Hello World example print("Hello from Revit!") from pyrevit import revit, DB, forms, script output = script.get_output() output.close_others() doc = revit.doc print("Document title:", doc.Title) print("Number of walls:", len(list(DB.FilteredElementCollector(doc).OfCategory(DB.BuiltInCategory.OST_Walls).WhereElementIsNotElementType()))) collector = DB.FilteredElementCollector(doc).OfClass(DB.TextNoteType).ToElements() print("Number of text note types:", len(collector)) '''
Tips for writing IronPython code in Revit:
Accessing Element.Name property: Some Revit elements don't expose the 'Name' property directly in IronPython. Use defensive access patterns:
Option 1: Use getattr with a default value
name = getattr(element, 'Name', 'N/A')
Option 2: Use try-except
try: name = element.Name except AttributeError: name = 'Unable to retrieve name'
Option 3: Use BuiltInParameter for element types
param = element_type.get_Parameter(DB.BuiltInParameter.ALL_MODEL_TYPE_NAME) name = param.AsString() if param else 'N/A'
Always check if elements exist before accessing properties: element = doc.GetElement(element_id) if element: # Safe to access element properties
Use hasattr() before accessing optional properties: if hasattr(element_type, 'FamilyName'): family_name = element_type.FamilyName
The Tool already wraps the code around a transaction.
Inputs: code (required), description.
export_documentA
Export a Revit view or sheet to PDF or image format.
Exports the specified view (or the active view if none specified) to a file on disk. Supported formats: PDF, PNG, JPG, DWG.
Args: view_name: Name of the view or sheet to export (optional, uses active view) format: Output format — "pdf", "png", "jpg", or "dwg" (defaults to "pdf") resolution: DPI for image formats (defaults to 300, ignored for PDF/DWG) ctx: MCP context for logging
Inputs: view_name, format, resolution.
export_ifcA
Export the Revit model to IFC format.
Creates an IFC file at the specified path. Optionally filter by view to export only visible elements. Supports IFC2x3 and IFC4.
Args: file_path: Output file path (must end in .ifc) ifc_version: "IFC2x3" (default) or "IFC4" export_base_quantities: Include IFC base quantities (default: true) view_name: Export only elements visible in this view (optional) ctx: MCP context for logging
Inputs: file_path (required), ifc_version, export_base_quantities, view_name.
export_room_dataA
Export data for all rooms defined in the Revit model.
Returns room names, numbers, levels, areas, perimeters, and departments in a structured format suitable for analysis and reporting.
Args: ctx: MCP context for logging
Inputs: no named parameters.
get_current_view_elementsA
Get all elements visible in the currently active view in Revit.
Returns detailed information about each element including:
Element ID, name, and type
Category and category ID
Level information (if applicable)
Location information (point or curve)
Summary statistics grouped by category
This is useful for understanding what elements are currently visible and analyzing the content of the active view.
Inputs: no named parameters.
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_element_propertiesA
Get all properties and parameters of a Revit element.
Returns the element's category, family, type, and a complete list of both instance and type parameters with their values, storage types, and read-only status.
Args: element_id: Revit element ID to inspect include_type_params: Include type parameters in addition to instance parameters (default: true) ctx: MCP context for logging
Inputs: element_id (required), include_type_params.
get_material_quantitiesB
Get material quantities (areas and volumes) from the Revit model.
Returns aggregated material data across all elements, optionally filtered by category. Useful for quantity takeoffs and cost estimation.
Args: categories: List of categories to include, e.g. ["OST_Walls", "OST_Floors"] (optional, defaults to all categories) ctx: MCP context for logging
Inputs: categories.
get_revit_model_infoB
Get comprehensive information about the current Revit model
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
Get details of elements currently selected in the Revit UI.
Returns IDs, categories, types, and key parameters of all elements the user has selected in Revit. Returns an empty list if nothing is selected (not an error).
Args: ctx: MCP context for logging
Inputs: no named parameters.
link_fileA
Link or import an external file into the Revit model.
Supports DWG, DXF, DGN (CAD files) and RVT (Revit links). Linked files maintain a live connection; imported files are embedded.
Args: file_path: Path to the file (DWG, DXF, DGN, or RVT) mode: "link" (default, maintains connection) or "import" (embeds copy) position: Optional placement offset {"x", "y", "z"} in mm ctx: MCP context for logging
Inputs: file_path (required), mode, position.
list_category_parametersA
Get available parameters for elements in a category
This tool helps you discover what parameters are available for coloring by listing all parameters found on elements in the specified category.
Args: category_name: Name of the category to check parameters for (e.g., "Walls", "Doors") ctx: MCP context for logging
Returns: List of available parameters with their types and sample values
Inputs: category_name (required).
list_familiesB
Get a flat list of available family types in the current Revit model
Inputs: contains, limit.
list_family_categoriesA
Get a list of all family categories in the current Revit model
Inputs: no named parameters.
list_levelsA
Get a list of all levels in the current Revit model
Inputs: no named parameters.
list_revit_viewsA
Get a list of all exportable views in the current Revit model
Inputs: no named parameters.
modify_elementA
Modify parameter values on a Revit element.
Changes one or more instance parameters on the specified element. Returns old and new values for confirmation.
Args: element_id: Revit element ID to modify parameters: Dictionary of parameter name to new value pairs e.g., {"Mark": "EW-01", "Comments": "Updated via MCP"} ctx: MCP context for logging
Inputs: element_id (required), parameters (required).
place_familyC
Place a family instance at a specified location in the Revit model
Inputs: family_name (required), type_name, x, y, +4 more.
set_active_viewA
Switch the active view in Revit to the specified view.
Changes which view is displayed in the Revit UI. Use list_revit_views first to find available view names.
Args: view_name: Name of the view to activate ctx: MCP context for logging
Inputs: view_name (required).
set_parameterA
Set a single parameter value on a Revit element.
Automatically detects the parameter's storage type (String, Integer, Double, ElementId) and converts the value accordingly. Returns old and new values for confirmation.
Args: element_id: Target element ID parameter_name: Name of the parameter to set (e.g., "Comments", "Mark") value: New value as a string — automatically converted to the correct type ctx: MCP context for logging
Inputs: element_id (required), parameter_name (required), value (required).
tag_elementsA
Tag elements with annotation symbols in a view.
Places tags on the specified elements. Tags display element properties like type name, mark, or room name/number. Works with walls, doors, windows, rooms, and other taggable categories.
Args: element_ids: List of element IDs to tag view_name: View to place tags in (defaults to active view) tag_type_name: Tag family type name (auto-detects appropriate tag if omitted) add_leader: Show leader line from tag to element (default: false) orientation: Tag orientation — "horizontal" or "vertical" (default: "horizontal") offset: Tag offset from element center {"x": float, "y": float} in mm ctx: MCP context for logging
Inputs: element_ids (required), view_name, tag_type_name, add_leader, +2 more.
tag_wallsA
Tag all untagged walls in the current Revit view.
Places wall tags on every wall visible in the active view that doesn't already have a tag. Tags are centered on each wall segment.
Args: use_leader: Whether to show leader lines (defaults to False) tag_type_name: Specific wall tag family type name (optional, uses first available) ctx: MCP context for logging
Inputs: use_leader, tag_type_name.
transform_elementsA
Move, copy, rotate, or mirror elements in the Revit model.
Performs geometric transformations on one or more elements. All coordinates and distances are in millimeters, angles in degrees.
Args: element_ids: List of element IDs to transform operation: Transform type — "move", "copy", "rotate", or "mirror" vector: Translation vector {"x", "y", "z"} in mm (required for move/copy) axis_point: Rotation center {"x", "y", "z"} in mm (required for rotate) angle: Rotation angle in degrees (required for rotate) mirror_plane: Mirror definition (required for mirror): - origin (dict): {"x", "y", "z"} point on the mirror plane in mm - normal (dict): {"x", "y", "z"} plane normal direction ctx: MCP context for logging
Inputs: element_ids (required), operation (required), vector, axis_point, +2 more.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 45 tools
Most tools have distinct purposes, but a few overlap: `modify_element` and `set_parameter` both modify parameters with different interfaces, and `create_line_based_element` and `create_structural_framing` both create line-based elements (walls/beams vs. structural beams). Additionally, `get_current_view_elements` and `ai_element_filter` both retrieve elements, causing potential confusion.
The naming predominantly uses verb_noun in snake_case (e.g., `create_wall`, `delete_elements`), but there are inconsistencies: `ai_element_filter` is noun_noun, `color_splash` uses an informal verb, and `modify_element` vs. `set_parameter` have different verb choices for similar operations. The pattern is mostly consistent but has notable deviations.
With 45 tools, the server feels bloated. Many creation tools could be consolidated (e.g., `create_duct`, `create_pipe`, `create_line_based_element`, `create_structural_framing`, `create_surface_based_element` into a single tool with an element type parameter). Similarly, `modify_element` and `set_parameter` are redundant. The count is too high for the apparent scope.
The tool suite covers most Revit workflows: CRUD for elements, querying, filtering, tagging, exporting, view management, MEP, and documentation (schedules, sheets). Missing features include family editing, workset management, and advanced dimension styling, but these are minor gaps. Overall, the surface is comprehensive for typical modeling and documentation tasks.
Maintenance
Related MCP Connectors
Read and edit the Revit 2024–2027 model on your PC. Needs the free Revit MCP add-in.
MCP server for progressive tool usage at any scale (see https://klavis.ai)
Headless CAD engine & MCP server for 2D/3D drafting, solids, DXF/SVG export, and automation.
AI for Revit: 450+ tools, 1 undo step. Windows, Revit 2024–2027 (2021–2023 included). Free account.
Related MCP Servers
- AlicenseAqualityFmaintenanceAllows AI to interact with Autodesk Revit via the MCP protocol, enabling retrieval of project data and automation of tasks like creating, modifying, and deleting elements.1359 npm477MIT
- 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 gradedqualityDmaintenanceMCP server for Autodesk Revit 2024/2025/2026/2027 via pyRevit — 48 tools for building design, editing, analysis, clash detection, MEP, interop, documentation, and model persistence.MIT
- -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.-