Skip to main content
Glama
Revit MCP Server

Revit MCP Server

by Demolinator

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 API

The 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.

  1. Go to https://github.com/pyrevitlabs/pyRevit/releases

  2. Download the latest .exe installer (e.g. pyRevit_CLI_x.x.x.x_admin_signed.exe)

  3. Run the installer — accept all defaults, click Next through each screen

  4. Open (or restart) Revit — you should see a pyRevit tab in the ribbon at the top

  5. In the pyRevit tab, click Settings (gear icon)

  6. In the Settings window, go to the Routes section on the left

  7. Check the box to Enable Routes Server

  8. 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 sync

2. 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.

  1. Pick a folder for your pyRevit extensions, e.g. C:\pyRevitExtensions.

  2. Link this repo into it under a name ending in .extension (a junction keeps it updated whenever you git 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.)

  3. In Revit: pyRevit tab → Settings → Custom Extension Directories → add C:\pyRevitExtensions.

  4. In the same Settings window, under Routes, turn on Routes Server (port 48884).

  5. 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/mcp

Start with

Protocol

Served at

uv run main.py

stdio (default)

the client's stdin/stdout

--http (alias --streamable-http)

Streamable HTTP

/mcp

--sse

Server-Sent Events (older clients)

/sse and /messages/

--combined

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

REVIT_HOST

localhost

Machine running Revit + pyRevit Routes

REVIT_PORT

48884

pyRevit Routes port

MCP_HOST

127.0.0.1

Bind address for --http / --sse / --combined

MCP_PORT

8000

Port for --http / --sse / --combined

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:6274

Supported Tools (48)

Create (15)

Tool

Description

create_level

Create new levels with elevations

create_line_based_element

Create walls, beams, and other line-based elements

create_surface_based_element

Create floors, roofs, and surface elements

place_family

Place a family instance at specified location

create_grid

Create column grid lines

create_structural_framing

Create structural beams and framing

create_sheet

Create new drawing sheets

create_schedule

Create schedules with custom fields

create_room

Create rooms at specified levels

create_room_separation

Create room separation boundary lines

create_duct

Create ducts between two points (MEP)

create_pipe

Create pipes between two points (MEP)

create_mep_system

Create mechanical or piping systems

create_detail_line

Create view-specific detail lines

create_view

Create floor plans, sections, elevations, 3D views

Query (12)

Tool

Description

get_revit_status

Check if the API is active and responding

get_revit_model_info

Get model information

list_levels

Get all levels with elevations

list_families

Get available family types

list_family_categories

Get all family categories

get_revit_view

Export a view as an image

list_revit_views

List all exportable views

get_current_view_info

Get active view details

get_current_view_elements

Get elements in current view

get_selected_elements

Get currently selected elements

list_category_parameters

List parameters for a category

get_element_properties

Get all parameters and properties of an element

Modify (9)

Tool

Description

delete_elements

Delete elements from the model

modify_element

Modify element parameter values

color_splash

Color elements by parameter values

clear_colors

Reset element colors

tag_walls

Tag all walls in current view

set_parameter

Set a single parameter value on an element

tag_elements

Tag specific elements with annotation symbols

transform_elements

Move, copy, rotate, or mirror elements

set_active_view

Switch the active view in Revit

Analyze (5)

Tool

Description

ai_element_filter

Filter elements by category and parameters

export_room_data

Export room areas, volumes, boundaries

get_material_quantities

Material takeoff data

check_clashes

Detect hard clashes (interferences) between disciplines, e.g. structure vs MEP

analyze_model_statistics

Element counts and model stats

Document (2)

Tool

Description

create_dimensions

Create dimension annotations

export_document

Export views to PDF or image

Interop & Persistence (4)

Tool

Description

export_ifc

Export model to IFC format (IFC2x3/IFC4)

link_file

Link or import DWG, DXF, DGN, SAT, SKP, 3DM, or RVT files

load_family

Load a Revit family (.rfa) from disk so its types can be placed

save_document

Save / Save-As the model to disk (persistence across sessions)

Advanced (1)

Tool

Description

execute_revit_code

Execute IronPython code in Revit context

Architecture

Two runtimes communicate over HTTP:

Component

Runtime

Location

Purpose

main.py + tools/

Python 3.11+ (CPython)

Your machine

MCP protocol, tool definitions

startup.py + revit_mcp/

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 .IntegerValue fallback

  • make_element_id() — Creates ElementIds using System.Int64 (2024+) with int fallback

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.Zone members, legacy rebar creation, or the dropped EnergyDataSettings properties).

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:

  1. Route handler in revit_mcp/new_module.py (IronPython 2.7)

  2. Tool definition in tools/new_tools.py (Python 3.11+)

  3. Register routes in startup.py

  4. Register 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.

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 tools
ai_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:

  1. 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'

  2. Always check if elements exist before accessing properties: element = doc.GetElement(element_id) if element: # Safe to access element properties

  3. Use hasattr() before accessing optional properties: if hasattr(element_type, 'FamilyName'): family_name = element_type.FamilyName

  4. 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.

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

    B3.1/5.0

    Scored across 45 tools

    Disambiguation4/5

    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.

    Naming Consistency3/5

    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.

    Tool Count2/5

    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.

    Completeness4/5

    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

    ActivityMaintained
    ResponsivenessLimited data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      A
      maintenance
      MCP 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.
      22
      MIT
    • A
      license
      Not graded
      quality
      D
      maintenance
      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.
      MIT
    • -
      license
      Not graded
      quality
      Not graded
      maintenance
      Connects 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.
      -

    Appeared in Searches