ZedMoster/revit-mcp

create_levels

在Revit中创建标高，支持批量创建，遵循JSON-RPC 2.0规范。 mcp_tool使用时params不要有任何注释信息

特性:

• 支持批量创建多个标高
• 自动处理单位转换（毫米转英尺）
• 自动处理标高名称冲突
• 完善的错误处理机制

参数: ctx (Context): FastMCP上下文对象 method (str): JSON-RPC方法名，默认为"CreateLevels" params (List[Dict]): 标高参数列表，每个字典包含: - elevation (float): 标高高度（毫米） - name (str, optional): 标高名称（可选，默认为"Level_{elevation}"）

返回: dict: JSON-RPC 2.0格式的响应，结构为: 成功时: { "jsonrpc": "2.0", "result": [ { "elementId": "创建的标高元素ID", "name": "标高名称", "familyName": "标高族名称" }, ... ], "id": request_id } 失败时: { "jsonrpc": "2.0", "error": { "code": int, "message": str, "data": any }, "id": request_id }

示例: # 创建多个标高 response = create_levels(ctx, params=[ {"elevation": 8000, "name": "Level_3"}, {"elevation": 12000} # 自动生成名称"Level_12000" ])

create_floor_plan_views

根据给定标高创建楼层平面视图，遵循JSON-RPC 2.0规范。 mcp_tool使用时params不要有任何注释信息

特性:

• 支持批量创建多个楼层平面视图
• 自动跳过已存在的视图，避免重复创建
• 完善的错误处理机制

参数: ctx (Context): FastMCP上下文对象 method (str): JSON-RPC方法名，默认为 CreateFloorPlanViews params (List[Dict]): 视图参数列表，每个字典包含: - levelId (str): 标高的ElementId - viewName (str): 要创建的视图名称

返回: dict: JSON-RPC 2.0格式的响应，结构为: 成功时: { "jsonrpc": "2.0", "result": [ { "elementId": "视图元素ID", "name": "视图名称", "familyName": "视图族名称" }, ... ], "id": request_id } 失败时: { "jsonrpc": "2.0", "error": { "code": int, "message": str, "data": any }, "id": request_id }

示例: response = create_floor_plan_views(ctx, params=[ {"levelId": "123456", "viewName": "Level 1 - Floor Plan"}, {"levelId": "789012", "viewName": "Level 2 - Floor Plan"} ])

# 返回示例
{
    "jsonrpc": "2.0",
    "result": [
        {
            "elementId": "123789",
            "name": "Level 1 - Floor Plan",
            "familyName": "Floor Plan"
        },
        {
            "elementId": "123790",
            "name": "Level 2 - Floor Plan",
            "familyName": "Floor Plan"
        }
    ],
    "id": 1
}

create_grids

在Revit中创建轴网，支持直线轴网和弧线轴网，遵循JSON-RPC 2.0规范。 mcp_tool使用时params不要有任何注释信息

特性:

• 支持批量创建多个轴网
• 支持直线轴网和弧线轴网创建
• 自动处理单位转换（毫米转英尺）
• 自动处理轴网名称冲突
• 完善的错误处理机制

参数: ctx (Context): FastMCP上下文对象 method (str): JSON-RPC方法名，默认为"CreateGrids" params (List[Dict]): 轴网参数列表，每个字典包含: - startX (float): 起点X坐标（毫米） - startY (float): 起点Y坐标（毫米） - endX (float): 终点X坐标（毫米） - endY (float): 终点Y坐标（毫米） - name (str, optional): 轴网名称（可选） - centerX (float, optional): 弧线轴网的圆心X坐标（毫米） - centerY (float, optional): 弧线轴网的圆心Y坐标（毫米）

返回: dict: JSON-RPC 2.0格式的响应，结构为: 成功时: { "jsonrpc": "2.0", "result": [ { "elementId": "轴网元素ID", "name": "轴网名称", "familyName": "轴网族名称" }, ... ], "id": request_id } 失败时: { "jsonrpc": "2.0", "error": { "code": int, "message": str, "data": any }, "id": request_id }

示例: # 创建直线轴网和弧线轴网 response = create_grids(ctx, params=[ { "name": "Grid_A", "startX": 0, "startY": 0, "endX": 10000, "endY": 0 }, { "name": "Grid_B", "startX": 5000, "startY": 0, "endX": 5000, "endY": 10000, "centerX": 5000, "centerY": 5000 } ])

# 输出示例
{
    "jsonrpc": "2.0",
    "result": [
        {
            "elementId": "212801",
            "name": "Grid_A",
            "familyName": "轴网"
        },
        {
            "elementId": "212802",
            "name": "Grid_B",
            "familyName": "轴网"
        }
    ],
    "id": 1
}

create_walls

在Revit中创建墙体，支持批量创建，遵循JSON-RPC 2.0规范。 mcp_tool使用时params不要有任何注释信息

特性:

• 支持批量创建多个墙体
• 自动处理单位转换（毫米转英尺）
• 自动创建或匹配符合厚度的墙类型
• 支持指定标高或使用默认标高
• 完善的错误处理机制

参数: ctx (Context): FastMCP上下文对象 method (str): JSON-RPC方法名，默认为"CreateWalls" params (List[Dict]): 墙体参数列表，每个字典包含: - startX (float): 起点X坐标（毫米） - startY (float): 起点Y坐标（毫米） - endX (float): 终点X坐标（毫米） - endY (float): 终点Y坐标（毫米） - height (float): 墙体高度（毫米） - width (float): 墙体厚度（毫米） - elevation (float, optional): 墙体底部标高（毫米，默认为0）

返回: dict: JSON-RPC 2.0格式的响应，结构为: 成功时: { "jsonrpc": "2.0", "result": [ { "elementId": "墙体元素ID", "name": "墙体名称", "familyName": "墙体族名称" }, ... ], "id": request_id } 失败时: { "jsonrpc": "2.0", "error": { "code": int, "message": str, "data": any }, "id": request_id }

示例: response = create_walls(ctx, params=[ {"startX": 0, "startY": 0, "endX": 5000, "endY": 0, "height": 3000, "width": 200}, {"startX": 5000, "startY": 0, "endX": 5000, "endY": 5000, "height": 3000, "width": 200, "elevation": 1000} ])

# 返回示例
{
    "jsonrpc": "2.0",
    "result": [
        {
            "elementId": "123456",
            "name": "基本墙",
            "familyName": "基本墙"
        },
        {
            "elementId": "123457",
            "name": "基本墙",
            "familyName": "基本墙"
        }
    ],
    "id": 1
}

create_floors

在Revit中创建楼板，支持批量创建，遵循JSON-RPC 2.0规范。 mcp_tool使用时params不要有任何注释信息

特性:

• 支持批量创建多个楼板
• 自动处理单位转换（毫米转英尺）
• 自动匹配楼板类型或使用默认类型
• 支持结构楼板和非结构楼板
• 自动根据z值标高确定楼层
• 完善的错误处理机制

参数: ctx (Context): FastMCP上下文对象 method (str): JSON-RPC方法名，默认为"CreateFloors" params (List[Dict]): 楼板参数列表，每个字典包含: - boundaryPoints (List[Dict]): 楼板边界点列表，每个点包含: - x (float): X坐标（毫米） - y (float): Y坐标（毫米） - z (float): Z坐标（毫米） - floorTypeName (str, optional): 楼板类型名称（可选） - structural (bool, optional): 是否为结构楼板（默认为False）

返回: dict: JSON-RPC 2.0格式的响应，结构为: 成功时: { "jsonrpc": "2.0", "result": [ { "elementId": "楼板元素ID", "name": "楼板名称", "familyName": "楼板族名称" }, ... ], "id": request_id } 失败时: { "jsonrpc": "2.0", "error": { "code": int, "message": str, "data": any }, "id": request_id }

示例: # 创建多个楼板 response = create_floors(ctx, params=[ { "boundaryPoints": [ {"x": 0, "y": 0, "z": 0}, {"x": 5000, "y": 0, "z": 0}, {"x": 5000, "y": 5000, "z": 0}, {"x": 0, "y": 5000, "z": 0}, {"x": 0, "y": 0, "z": 0} ], "floorTypeName": "常规 - 150mm", "structural": True }, { "boundaryPoints": [ {"x": 0, "y": 0, "z": 3000}, {"x": 5000, "y": 0, "z": 3000}, {"x": 5000, "y": 5000, "z": 3000}, {"x": 0, "y": 5000, "z": 3000}, {"x": 0, "y": 0, "z": 3000} ], "floorTypeName": "常规 - 200mm" } ])

# 输出示例
{
    "jsonrpc": "2.0",
    "result": [213001, 213002],
    "id": 1
}

create_door_windows

在Revit中创建门窗族实例，支持批量创建，遵循JSON-RPC 2.0规范。 mcp_tool使用时params不要有任何注释信息

特性:

• 支持批量创建多个门窗族实例
• 自动处理单位转换（毫米转英尺）
• 支持指定族类型和类别
• 支持指定主体墙ElementId
• 完善的错误处理机制

参数: ctx (Context): FastMCP上下文对象 method (str): JSON-RPC方法名，默认为"CreateDoorWindows" params (List[Dict]): 门窗参数列表，每个字典包含: - categoryName (str): 类别名称（门或窗） - familyName (str): 族名称 - name (str): 类型名称 - startX (float): 放置点X坐标（毫米） - startY (float): 放置点Y坐标（毫米） - startZ (float): 放置点Z坐标（毫米） - hostId (str): 主体墙的ElementId - offset (str, optional): 底高度偏移值

返回: dict: JSON-RPC 2.0格式的响应，结构为: 成功时: { "jsonrpc": "2.0", "result": [ { "elementId": "门窗元素ID", "name": "门窗名称", "familyName": "门窗族名称" }, ... ], "id": request_id } 失败时: { "jsonrpc": "2.0", "error": { "code": int, "message": str, "data": any }, "id": request_id }

示例: response = create_door_windows(ctx, params=[ { "categoryName": "门", "familyName": "单扇门", "name": "915 x 2134mm", "startX": 5000, "startY": 2500, "startZ": 0, "hostId": "123456", "offset": "0" }, { "categoryName": "窗", "familyName": "固定窗", "name": "0915 x 1220mm", "startX": 8000, "startY": 2500, "startZ": 1000, "hostId": "123456", "offset": "900" } ])

create_family_instances

在Revit中创建族实例，支持多种放置方式，遵循JSON-RPC 2.0规范。 mcp_tool使用时params不要有任何注释信息

特性:

• 支持批量创建多个族实例
• 自动处理单位转换（毫米转英尺）
• 支持多种放置类型：
  • 基于标高放置
  • 基于视图放置
  • 基于工作平面放置
  • 基于宿主放置
  • 基于曲线放置
• 支持旋转和偏移
• 自动匹配族类型和类别
• 完善的错误处理机制

参数: ctx (Context): FastMCP上下文对象 method (str): JSON-RPC方法名，默认为"CreateFamilyInstances" params (List[Dict]): 族实例参数列表，每个字典包含: - categoryName (str): 支持按类别BuiltInCategory或者Category.Name查找（如"OST_Walls","OST_Doors", "墙", "门", "结构框架"等） - name (str): 族类型名称 - startX (float): 起点X坐标（毫米） - startY (float): 起点Y坐标（毫米） - startZ (float): 起点Z坐标（毫米） - familyName (str, optional): 族名称（可选，用于更精确匹配） - endX (float, optional): 终点X坐标（毫米，默认等于startX） - endY (float, optional): 终点Y坐标（毫米，默认等于startY） - endZ (float, optional): 终点Z坐标（毫米，默认等于startZ） - hostId (str, optional): 宿主元素ID（可选） - viewName (str, optional): 视图名称（可选） - rotationAngle (float, optional): 旋转角度（度，默认0） - offset (float, optional): 偏移距离（毫米，默认0）

返回: dict: JSON-RPC 2.0格式的响应，结构为: 成功时: { "jsonrpc": "2.0", "result": [ { "elementId": "元素ID", "name": "名称", "familyName": "族名称" }, ... ], "id": request_id } 失败时: { "jsonrpc": "2.0", "error": { "code": int, "message": str, "data": any }, "id": request_id }

示例: # 创建多个族实例 response = create_family_instances(ctx, params=[ # 基于标高的门 { "categoryName": "窗", "name": "0406 x 0610mm", "startX": 1000, "startY": 2000, "startZ": 0, "hostId": 225535, "level": "标高 1", }, # 基于视图的家具 { "categoryName": "OST_Furniture", "name": "办公桌", "startX": 3000, "startY": 4000, "startZ": 0, "viewName": "标高 1", "rotationAngle": 90 }, # 基于曲线的梁 { "categoryName": "OST_StructuralFraming", "name": "H型钢梁", "startX": 0, "startY": 0, "startZ": 3000, "endX": 5000, "endY": 0, "endZ": 3000 } ])

# 输出示例
{
    "jsonrpc": "2.0",
    "result": [213101, 213102, 213103],
    "id": 1
}

create_rooms

在指定标高上创建房间，遵循JSON-RPC 2.0规范。 mcp_tool使用时params不要有任何注释信息

特性:

• 支持批量在多个标高上创建房间
• 自动验证标高元素有效性
• 事务化操作确保数据一致性
• 完善的错误处理机制

参数: ctx (Context): FastMCP上下文对象 method (str): JSON-RPC方法名，默认为"CreateRooms" params (List[Dict]): 标高参数列表，每个字典包含: - elementId (Union[int, str]): 元素ID

返回: dict: JSON-RPC 2.0格式的响应，结构为: 成功时: { "jsonrpc": "2.0", "result": [ { "elementId": "房间元素ID", "name": "房间名称", "familyName": "房间族名称" }, ... ], "id": request_id } 失败时: { "jsonrpc": "2.0", "error": { "code": int, "message": str, "data": any }, "id": request_id }

错误代码: -32600: 无效请求 -32602: 无效参数（元素不是标高或无效） -32603: 内部错误 -32700: 解析错误

示例: # 在多个标高上创建房间 response = create_rooms(ctx, params=[ {"elementId": 123456}, {"elementId": "789012"} ])

# 输出示例
{
    "jsonrpc": "2.0",
    "result": [
        {
            "elementId": "212801",
            "name": "房间 1",
            "familyName": "房间"
        },
        {
            "elementId": "212802",
            "name": "房间 2",
            "familyName": "房间"
        }
    ],
    "id": 1
}

注意: 1. 会在指定标高的所有封闭区域创建房间 2. 返回的房间信息列表顺序与创建顺序一致 3. 如果标高没有封闭区域，则不会创建房间但也不会报错

create_room_separation_lines

创建房间分割线，便于房间方案确定 方案更新时可使用call_func[清理房间方案]来清理重新设计方案

特性:

• 支持创建直线和弧线两种类型的分割线
• 自动过滤重复的线条
• 自动处理单位转换(毫米转英尺)
• 在当前活动视图中创建分割线

参数: ctx (Context): FastMCP上下文对象 method (str): JSON-RPC方法名，默认为"CreateRoomSeparationLines" params (List[dict]): 线条数据列表，每个字典应包含: - p0 (str/dict): 起点坐标，格式为 "X,Y,Z" - p1 (str/dict): 终点坐标，格式为 "X,Y,Z" - pointOnArc (str/dict, optional): 弧上点坐标，仅用于创建弧线，格式为 "X,Y,Z"

返回: dict: JSON-RPC 2.0格式的响应，成功时包含创建的元素信息

示例: # 创建一条直线分割线和一条弧线分割线 params = [ { "p0": "1000,2000,0", "p1": "2000,2000,0" }, { "p0": "0,0,0", "p1": "3000,0,0", "pointOnArc": "1500,1000,0" } ]

response = create_room_separation_lines(ctx, "CreateRoomSeparationLines", params)

# 创建简单直线
response = create_room_separation_lines(ctx,"CreateRoomSeparationLines", [
    {"p0": "0,0,0", "p1": "1000,0,0"},
    {"p0": "1000,0,0", "p1": "1000,1000,0"}
])

create_room_tags

给定平面视图ID，获取当前视图中所有房间，并为其创建房间标签，遵循JSON-RPC 2.0规范。 mcp_tool使用时params不要有任何注释信息

特性:

• 支持在指定平面视图中为所有房间创建标签
• 自动跳过已有标签的房间
• 返回已创建的房间标签信息
• 完善的错误处理机制

参数: ctx (Context): FastMCP上下文对象 method (str): JSON-RPC方法名，默认为"CreateRoomTags" params (List[Dict]): 视图参数列表，每个字典包含: - elementId (Union[int, str]): 平面视图元素ID

返回: dict: JSON-RPC 2.0格式的响应，结构为: 成功时: { "jsonrpc": "2.0", "result": [ { "elementId": "房间标签元素ID", "name": "房间标签名称", "familyName": "房间标签族名称" }, ... ], "id": request_id } 失败时: { "jsonrpc": "2.0", "error": { "code": int, "message": str, "data": any }, "id": request_id }

示例: # 为单个视图中的所有房间创建标签 response = create_room_tags(ctx, params=[{"elementId": 123456}])

# 为多个视图中的所有房间创建标签
response = create_room_tags(ctx, params=[
    {"elementId": 123456},
    {"elementId": "789012"}
])

# 输出示例
{
    "jsonrpc": "2.0",
    "result": [
        {
            "elementId": "212801",
            "name": "房间标签 1",
            "familyName": "房间标签"
        },
        {
            "elementId": "212802",
            "name": "房间标签 2",
            "familyName": "房间标签"
        }
    ],
    "id": 1
}

注意: 1. 如果视图不是平面视图，则会返回错误。 2. 如果一个房间已经有标签，则不会重复创建。 3. 返回的结果包含所有成功创建的房间标签信息。

create_sheets

批量创建Revit图纸并添加指定视图，遵循JSON-RPC 2.0规范。

特性:

• 支持批量创建带编号和名称的图纸
• 可指定标题块类型
• 支持在图纸上添加视图
• 完善的参数验证和错误处理

参数: ctx (Context): FastMCP上下文对象 method (str): JSON-RPC方法名，默认为"CreateSheets" params (List[Dict]): 参数列表，每个字典包含: - number (str): 图纸编号（必填） - name (str): 图纸名称（必填） - titleBlockType (str): 标题块类型名称（必填） - viewName (str, optional): 要添加到图纸的视图名称（可选） request_id (int, optional): 请求ID，默认自动生成

返回: dict: JSON-RPC 2.0格式的响应

示例: response = create_sheets(ctx, params=[ { "number": "A101", "name": "首层平面图", "titleBlockType": "A0 公制", "viewName": "标高 1" }, { "number": "A102", "name": "二层平面图", "titleBlockType": "A0 公制" } ])

create_ducts

在Revit中创建风管，支持批量创建，遵循JSON-RPC 2.0规范。 mcp_tool使用时params不要有任何注释信息

特性:

• 支持批量创建多个风管
• 自动处理单位转换（毫米转英尺）
• 自动匹配风管类型和系统类型
• 支持指定风管尺寸
• 完善的错误处理机制

参数: ctx (Context): FastMCP上下文对象 method (str): JSON-RPC方法名，默认为"CreateDucts" params (List[Dict]): 风管参数列表，每个字典包含: - ductTypeName (str): 风管类型名称 - systemTypeName (str): 风管系统类型名称 - startX (float): 起点X坐标（毫米） - startY (float): 起点Y坐标（毫米） - startZ (float): 起点Z坐标（毫米） - endX (float): 终点X坐标（毫米） - endY (float): 终点Y坐标（毫米） - endZ (float): 终点Z坐标（毫米） - width (float): 风管宽度（毫米） - height (float): 风管高度（毫米）

返回: dict: JSON-RPC 2.0格式的响应，结构为: 成功时: { "jsonrpc": "2.0", "result": [ { "elementId": "元素ID", "name": "名称", "familyName": "族名称" }, ... ], "id": request_id } 失败时: { "jsonrpc": "2.0", "error": { "code": int, "message": str, "data": any }, "id": request_id }

示例: response = create_ducts(ctx, params=[ { "ductTypeName": "默认", "systemTypeName": "送风", "startX": 0, "startY": 0, "startZ": 3000, "endX": 5000, "endY": 0, "endZ": 3000, "width": 300, "height": 200 }, { "ductTypeName": "矩形风管", "systemTypeName": "送风", "startX": 5000, "startY": 0, "startZ": 3000, "endX": 5000, "endY": 5000, "endZ": 3000, "width": 300, "height": 200 } ])

create_pipes

在Revit中创建管道，支持批量创建，遵循JSON-RPC 2.0规范。 mcp_tool使用时params不要有任何注释信息

特性:

• 支持批量创建多个管道
• 自动处理单位转换（毫米转英尺）
• 自动匹配管道类型和系统类型
• 支持指定管道直径
• 完善的错误处理机制

参数: ctx (Context): FastMCP上下文对象 method (str): JSON-RPC方法名，默认为"CreatePipes" params (List[Dict]): 管道参数列表，每个字典包含: - pipeTypeName (str): 管道类型名称 - systemTypeName (str): 管道系统类型名称 - startX (float): 起点X坐标（毫米） - startY (float): 起点Y坐标（毫米） - startZ (float): 起点Z坐标（毫米） - endX (float): 终点X坐标（毫米） - endY (float): 终点Y坐标（毫米） - endZ (float): 终点Z坐标（毫米） - diameter (float): 管道直径（毫米）

返回: dict: JSON-RPC 2.0格式的响应，结构为: 成功时: { "jsonrpc": "2.0", "result": [ { "elementId": "元素ID", "name": "名称", "familyName": "族名称" }, ... ], "id": request_id } 失败时: { "jsonrpc": "2.0", "error": { "code": int, "message": str, "data": any }, "id": request_id }

示例: response = create_pipes(ctx, params=[ { "pipeTypeName": "默认", "systemTypeName": "循环供水", "startX": 0, "startY": 0, "startZ": 3000, "endX": 5000, "endY": 0, "endZ": 3000, "diameter": 50 }, { "pipeTypeName": "标准", "systemTypeName": "生活热水", "startX": 5000, "startY": 0, "startZ": 3000, "endX": 5000, "endY": 5000, "endZ": 3000, "diameter": 40 } ])

create_cable_trays

在Revit中创建电缆桥架，支持批量创建，遵循JSON-RPC 2.0规范。 mcp_tool使用时params不要有任何注释信息

特性:

• 支持批量创建多个电缆桥架
• 自动处理单位转换（毫米转英尺）
• 自动匹配桥架类型
• 支持指定桥架宽度和高度
• 完善的错误处理机制

参数: ctx (Context): FastMCP上下文对象 method (str): JSON-RPC方法名，默认为"CreateCableTrays" params (List[Dict]): 桥架参数列表，每个字典包含: - cableTrayTypeName (str): 桥架类型名称 - startX (float): 起点X坐标（毫米） - startY (float): 起点Y坐标（毫米） - startZ (float): 起点Z坐标（毫米） - endX (float): 终点X坐标（毫米） - endY (float): 终点Y坐标（毫米） - endZ (float): 终点Z坐标（毫米） - width (float): 桥架宽度（毫米） - height (float): 桥架高度（毫米）

返回: dict: JSON-RPC 2.0格式的响应，结构为: 成功时: { "jsonrpc": "2.0", "result": [ { "elementId": "元素ID", "name": "名称", "familyName": "族名称" }, ... ], "id": request_id } 失败时: { "jsonrpc": "2.0", "error": { "code": int, "message": str, "data": any }, "id": request_id }

示例: response = create_cable_trays(ctx, params=[ { "cableTrayTypeName": "梯级式电缆桥架", "startX": 0, "startY": 0, "startZ": 3000, "endX": 5000, "endY": 0, "endZ": 3000, "width": 200, "height": 100 }, { "cableTrayTypeName": "标准", "startX": 5000, "startY": 0, "startZ": 3000, "endX": 5000, "endY": 5000, "endZ": 3000, "width": 200, "height": 100 } ])

get_commands

获取所有功能商店里的功能，每个功能包含名称、描述和提示信息，遵循JSON-RPC 2.0规范。 mcp_tool使用时params不要有任何注释信息

特性:

• 获取Revit插件中所有可用功能的完整列表
• 返回每个功能的名称、描述和提示信息
• 无需额外参数，直接获取所有功能
• 完善的错误处理机制

参数: ctx (Context): FastMCP上下文对象 method (str): JSON-RPC方法名，默认为"GetCommands"

返回: dict: JSON-RPC 2.0格式的响应，结构为: 成功时: { "jsonrpc": "2.0", "result": [ { "name": "功能名称", "description": "功能描述", "tooltip": "功能提示" }, ... ], "id": request_id } 失败时: { "jsonrpc": "2.0", "error": { "code": int, "message": str, "data": any }, "id": request_id }

示例: # 获取所有功能 response = get_commands(ctx)

# 输出示例
{
    "jsonrpc": "2.0",
    "result": [
        {
            "name": "创建墙",
            "description": "创建基本墙元素",
            "tooltip": "点击创建标准墙"
        },
        {
            "name": "创建门",
            "description": "在墙上创建门",
            "tooltip": "选择墙后点击创建门"
        },
        ...
    ],
    "id": 1
}

execute_commands

执行指定的功能命令，遵循JSON-RPC 2.0规范。 mcp_tool使用时params不要有任何注释信息

特性:

• 支持批量执行多个功能命令
• 可以指定是添加还是移除功能面板
• 自动查找并执行匹配名称的功能
• 完善的错误处理机制

参数: ctx (Context): FastMCP上下文对象 method (str): JSON-RPC方法名，默认为"ExecuteCommands" params (List[Dict]): 命令参数列表，每个字典包含: - name (str): 要执行的功能名称 - add (bool): True表示添加功能面板，False表示移除功能面板

返回: dict: JSON-RPC 2.0格式的响应，结构为: 成功时: { "jsonrpc": "2.0", "result": [ { "name": "AI助手", "description": "使用DeepSeek直接操作Revit,会员用户抢先体验", "tooltip": "关注公众号获取最新功能消息(F1获取帮助)" }, { "name": "AI代码转换", "description": "AI生成的代码功能尝试转换为Revit可用功能,会员用户抢先体验~", "tooltip": "关注公众号获取最新功能消息(F1获取帮助)" }, ... ], "id": request_id } 失败时: { "jsonrpc": "2.0", "error": { "code": int, "message": str, "data": any }, "id": request_id }

示例: # 添加功能面板 response = execute_command(ctx, params=[ {"name": "AI助手", "add": True}, {"name": "AI代码转换", "add": True} ])

# 移除功能面板
response = execute_command(ctx, params=[
    {"name": "AI助手", "add": False}
])

call_func

调用 Revit 函数服务，支持直接传递功能名称及其参数，遵循 JSON-RPC 2.0 规范。

特性:

• 支持批量调用多个功能
• 支持传递参数给每个功能
• 自动验证参数有效性
• 完善的错误处理机制
• 系统支持功能:清理重复实例,清理已删除房间,清理房间方案,轴网两道尺寸线,建筑尺寸标注,管道三维尺寸标注
• 其他都为本地MCP文件夹查询是否存在相应用户自定义功能

参数: ctx (Context): FastMCP上下文对象 method (str): JSON-RPC方法名，默认为"CallFunc" params (List[Dict]): 功能参数列表，必须提供至少一个函数名，每个字典包含: - name (str): 要调用的功能名称(清理重复实例,清理已删除房间,清理房间方案,轴网两道尺寸线,建筑尺寸标注,管道三维尺寸标注,及其他外部MCP文件夹调用的功能) - params (dict, optional): 功能对应的参数,可为空

返回: dict: JSON-RPC 2.0格式的响应

示例: # 调用不需要参数的函数 response = call_func(ctx, params=[ {"name": "清理重复实例"}, {"name": "清理已删除房间"}, {"name": "清理房间方案"}, {"name": "轴网两道尺寸线"}, {"name": "建筑尺寸标注"}, {"name": "管道三维尺寸标注"}, ])

# 外部MCP文件夹调用带参数的函数
response = call_func(ctx, params=[
    {"name": "新增标高", "params": {"offset": 3000}}
])

# 混合调用
response = call_func(ctx, params=[
    {"name": "清理重复实例"},
    {"name": "新增标高", "params": {"offset": 3000}}
])

find_elements

在Revit中按类别查找元素，返回匹配的元素信息列表，遵循JSON-RPC 2.0规范。 mcp_tool使用时params不要有任何注释信息

特性:

• 支持按类别BuiltInCategory或者Category.Name查找
• 和视图相关的请使用OST_Views类别作为categoryName参数,获取然后通过参数来过滤出如楼层平面,三维视图,剖面,图纸等
• 可指定查找实例或类型元素
• 支持批量多个查询条件
• 严格遵循JSON-RPC 2.0规范
• 详细的错误处理和日志记录

参数: ctx (Context): FastMCP上下文对象 method (str): JSON-RPC方法名，默认为"FindElements" params (List[Dict[str, Union[str, bool]]]): 查询条件列表，每个字典包含: - categoryName (str): BuiltInCategory或者Category.Name （如"OST_Views","OST_Walls","OST_Doors", "视图", "墙", "门"等） - isInstance (bool): True查找实例,False查找类型

返回: dict: JSON-RPC 2.0格式的响应，结构为: 成功时: { "jsonrpc": "2.0", "result": [ { "elementId": "元素ID", "name": "元素名称", "familyName": "族名称" }, ... ], "id": request_id } 失败时: { "jsonrpc": "2.0", "error": { "code": 错误代码, "message": 错误描述, "data": 错误详情 }, "id": request_id }

错误代码: -32600: 无效请求（参数验证失败） -32602: 类别未找到（无效的BuiltInCategory或Category.Name） -32603: 内部错误 -32700: 解析错误（参数格式错误）

示例: > response = find_elements(ctx, params=[ {"categoryName": "OST_Views", "isInstance": True}, {"categoryName": "OST_Doors", "isInstance": False}, {"categoryName": "门", "isInstance": True} ]) > print(response) { "jsonrpc": "2.0", "result": [ {"elementId": "123456", "name": "单扇门", "familyName": "M_单扇门"}, {"elementId": "789012", "name": "双扇门", "familyName": "M_双扇门"} ], "id": 1 }

update_elements

批量更新Revit元素参数值，遵循JSON-RPC 2.0规范，支持事务处理。 mcp_tool使用时params不要有任何注释信息

特性:

• 支持混合格式元素ID（整数/字符串）
• 自动参数值类型转换
• 详细的错误报告和元素级状态跟踪
• 严格遵循JSON-RPC 2.0规范

参数: ctx (Context): FastMCP上下文对象 method (str): JSON-RPC方法名，默认为"UpdateElements" params (List[Dict[str, Union[str, int]]]): 更新参数列表，每个字典必须包含: - elementId (Union[str, int]): 要更新的元素ID - parameterName (str): 参数名称（区分大小写） - parameterValue (str): 参数新值

返回: dict: JSON-RPC 2.0格式的响应，结构为: 成功时: { "jsonrpc": "2.0", "result": [ { "elementId": "元素ID", "name": "元素名称", "familyName": "族名称" }, ... ], "id": request_id } 失败时: { "jsonrpc": "2.0", "error": { "code": 错误代码, "message": 错误描述, "data": 错误详情 }, "id": request_id }

错误代码: -32600 (Invalid Request): 参数验证失败 -32602 (Invalid Params): 无效参数（元素不存在/参数不存在等） -32603 (Internal Error): 内部处理错误 -32700 (Parse Error): 参数解析错误

示例: > # 批量更新元素参数 > response = update_elements(ctx, params=[ ... {"elementId": 123456, "parameterName": "Comments", "parameterValue": "Test"}, ... {"elementId": "789012", "parameterName": "Height", "parameterValue": "3000"} ... ]) > print(response) { "jsonrpc": "2.0", "result": [ {"elementId": "123456", "name": "基本墙", "familyName": "基本墙"}, {"elementId": "789012", "name": "单扇门", "familyName": "M_单扇门"} ], "id": 1 }

# 错误情况示例
> response = update_elements(ctx, params=[
...     {"elementId":112,"parameterName":"InvalidParam","parameterValue":"X"} ])
> print(response)
> {"jsonrpc":"2.0","error":{"code":-32602,"message":"参数无效","data":"参数'InvalidParam'不存在"},"id":1}

事务说明: 所有更新操作在Revit事务组中执行，任一更新失败自动跳过。

delete_elements

批量删除Revit元素，支持字典格式参数，支持批量操作并遵循JSON-RPC 2.0规范。 mcp_tool使用时params不要有任何注释信息

特性:

• 完全匹配服务器参数处理逻辑
• 支持字典列表格式参数，每个字典包含elementId键
• 自动处理整数和字符串格式的elementId
• 事务化操作确保数据一致性
• 详细的错误处理和日志记录

参数: ctx (Context): FastMCP上下文对象 method (str): JSON-RPC方法名，默认为"DeleteElements" params (List[Dict[str, Union[int, str]]]): 删除参数列表，每个字典必须包含: - elementId (Union[int, str]): 要删除的元素ID

返回: dict: JSON-RPC 2.0格式的响应，结构为: 成功时: { "jsonrpc": "2.0", "result": [ { "elementId": "删除的元素ID", "name": "元素名称", "familyName": "族名称" }, ... ], "id": request_id } 失败时: { "jsonrpc": "2.0", "error": { "code": int, "message": str, "data": any }, "id": request_id }

示例: >>> # 删除多个元素（混合格式） >>> response = delete_elements(ctx, params=[ ... {"elementId": 5943}, ... {"elementId": "5913"}, ... {"elementId": 212831} ... ]) >>> print(response) { "jsonrpc": "2.0", "result": [ {"elementId": "5943", "name": "Wall 1", "familyName": "Basic Wall"}, {"elementId": "5913", "name": "Door 1", "familyName": "Single-Flush"}, {"elementId": "212831", "name": "Window 1", "familyName": "Fixed"} ], "id": 1 }

parameter_elements

获取Revit元素的参数信息，支持批量查询和特定参数查询，遵循JSON-RPC 2.0规范。 mcp_tool使用时params不要有任何注释信息

特性:

• 支持批量查询多个元素的参数
• 可查询特定参数或元素所有参数
• 返回参数哈希码、名称和值的完整信息
• 完善的错误处理机制

参数: ctx (Context): FastMCP上下文对象 method (str): JSON-RPC方法名，默认为"ParameterElements" params (List[Dict]): 查询参数列表，每个字典包含: - elementId (Union[int, str]): 要查询的元素ID - parameterName (str, optional): 要查询的特定参数名称

返回: dict: JSON-RPC 2.0格式的响应，结构为: 成功时: { "jsonrpc": "2.0", "result": { "elementId1": [ { "hashCode": int, "parameterName": str, "parameterValue": str, } ], ... }, "id": request_id } 失败时: { "jsonrpc": "2.0", "error": { "code": int, "message": str, "data": any }, "id": request_id }

示例: # 查询多个元素的参数 response = parameter_elements(ctx, params=[ {"elementId": 212792, "parameterName": "注释"}, # 获取特定参数 {"elementId": 212781} # 获取所有参数 ])

# 输出示例
{
    "jsonrpc": "2.0",
    "result": {
        "212792": [
            {
                "hashCode": 12345,
                "parameterName": "注释",
                "parameterValue": "示例注释",
            }
        ],
        "212781": [
            {
                "hashCode": 23456,
                "parameterName": "长度",
                "parameterValue": "5000",
            },
            ...
        ]
    },
    "id": 1
}

get_locations

获取Revit元素的位置信息，支持点和曲线元素，遵循JSON-RPC 2.0规范。 mcp_tool使用时params不要有任何注释信息

特性:

• 支持批量查询多个元素的位置
• 自动处理单位转换（英尺转毫米）
• 支持点位置和曲线位置（直线和圆弧）
• 完善的错误处理机制

参数: ctx (Context): FastMCP上下文对象 method (str): JSON-RPC方法名，默认为"GetLocations" params (List[Dict]): 查询参数列表，每个字典包含: - elementId (Union[str, int]): 要查询的元素ID,优先使用str类型Id

返回: dict: JSON-RPC 2.0格式的响应，结构为: 成功时: { "jsonrpc": "2.0", "result": { "elementId1": [ { "X": float, # X坐标（毫米） "Y": float, # Y坐标（毫米） "Z": float # Z坐标（毫米） }, ... ], ... }, "id": request_id } 失败时: { "jsonrpc": "2.0", "error": { "code": int, "message": str, "data": any }, "id": request_id }

错误代码: -32600: 无效请求 -32602: 无效参数（元素不存在等） -32603: 内部错误 -32700: 解析错误

示例: # 查询多个元素的位置 response = get_location(ctx, params=[ {"elementId": 123456}, {"elementId": "789012"} ])

# 输出示例（XYZ元素）
{
    "jsonrpc": "2.0",
    "result": {
        "123456": [
            {"X": 1000.0, "Y": 2000.0, "Z": 0.0}
        ]
    },
    "id": 1
}

# 输出示例（Line元素）
{
    "jsonrpc": "2.0",
    "result": {
        "789012": [
            {"X": 0.0, "Y": 0.0, "Z": 0.0},
            {"X": 5000.0, "Y": 0.0, "Z": 0.0}
        ]
    },
    "id": 1
}
# 输出示例（Arc元素）
{
    "jsonrpc": "2.0",
    "result": {
        "789012": [
            {"X": 0.0, "Y": 0.0, "Z": 0.0},
            {"X": 5000.0, "Y": 0.0, "Z": 0.0}
            {"X": 2500.0, "Y": 1200, "Z": 0.0}
        ]
    },
    "id": 1
}

用途:找到定位后可用于创建门窗这种带有主体的族,族插入点就可以通过这个计算出来

move_elements

移动Revit元素，支持批量操作，遵循JSON-RPC 2.0规范。 mcp_tool使用时params不要有任何注释信息

特性:

• 支持批量移动多个Revit元素
• 自动处理单位转换（毫米转英尺）
• 返回移动后的元素详细信息（使用ElementModelRequest格式）
• 完善的错误处理机制

参数: ctx (Context): FastMCP上下文对象 method (str): JSON-RPC方法名，默认为"MoveElements" params (List[Dict]): 移动参数列表，每个字典包含: - elementId (str): 要移动的元素ID - x (float): X方向移动距离（毫米） - y (float): Y方向移动距离（毫米） - z (float): Z方向移动距离（毫米）

返回: dict: JSON-RPC 2.0格式的响应，结构为: 成功时: { "jsonrpc": "2.0", "result": [ { "elementId": "移动后的元素ID", "name": "元素名称", "familyName": "族名称" }, ... ], "id": request_id } 失败时: { "jsonrpc": "2.0", "error": { "code": int, "message": str, "data": any }, "id": request_id }

示例: response = move_elements(ctx, params=[ {"elementId": "123456", "x": 100, "y": 200, "z": 0}, {"elementId": "789012", "x": -50, "y": 0, "z": 300} ])

show_elements

在Revit视图中高亮显示指定元素，支持批量操作并遵循JSON-RPC 2.0规范。 mcp_tool使用时params不要有任何注释信息

特性:

• 支持批量显示多个元素
• 自动处理整数和字符串格式的元素ID
• 元素自动缩放至视图中心并高亮显示
• 严格的参数验证和错误处理
• 完全匹配服务器端实现逻辑

参数: ctx (Context): FastMCP上下文对象 method (str): JSON-RPC方法名，默认为"ShowElements" params (List[Dict[str, Union[int, str]]]): 元素参数列表，每个字典必须包含: - elementId (Union[int, str]): 要显示的元素ID

返回: dict: JSON-RPC 2.0格式的响应，结构为: 成功时: { "jsonrpc": "2.0", "result": [成功显示的元素ID列表], "id": request_id } 失败时: { "jsonrpc": "2.0", "error": { "code": 错误代码, "message": 错误描述, "data": 错误详情 }, "id": request_id }

错误代码: -32600 (Invalid Request): 参数验证失败 -32602 (Invalid Params): 无效元素ID或元素不存在 -32603 (Internal Error): 内部处理错误 -32700 (Parse Error): 参数解析错误

示例: >>> # 显示多个元素 >>> response = show_elements(ctx, params=[ ... {"elementId": 212781}, ... {"elementId": "212792"} ... ]) >>> print(response) {"jsonrpc":"2.0","result":[212781,212792],"id":1}

视图操作: 成功调用后，元素将在当前视图中: 1. 自动缩放至视图中心 2. 高亮显示 3. 被添加到当前选择集

active_view

激活并打开Revit中的视图，遵循JSON-RPC 2.0规范。 mcp_tool使用时params不要有任何注释信息

特性:

• 支持打开单个或多个视图
• 自动验证视图元素有效性
• 过滤模板视图
• 完善的错误处理机制

参数: ctx (Context): FastMCP上下文对象 method (str): JSON-RPC方法名，默认为"ActiveView" params (List[Dict]): 视图参数列表，每个字典包含: - elementId (Union[int, str]): 视图元素ID

返回: dict: JSON-RPC 2.0格式的响应，结构为: 成功时: { "jsonrpc": "2.0", "result": [ { "elementId": "视图元素ID", "name": "视图名称", "familyName": "视图族名称" }, ... ], "id": request_id } 失败时: { "jsonrpc": "2.0", "error": { "code": int, "message": str, "data": any }, "id": request_id }

错误代码: -32600: 无效请求 -32602: 无效参数（元素不是视图/是模板视图/无效元素） -32603: 内部错误 -32700: 解析错误

示例: # 激活单个视图 response = active_view(ctx, params=[{"elementId": 123456}])

# 激活多个视图（最后一个成功激活的视图将成为当前视图）
response = active_view(ctx, params=[
    {"elementId": 123456},
    {"elementId": "789012"}
])

# 输出示例
{
    "jsonrpc": "2.0",
    "result": [123456, 789012],
    "id": 1
}

注意: 1. 无法激活模板视图（会返回错误） 2. 如果传入多个视图ID，会依次尝试激活，最后一个成功的视图将成为当前视图 3. 返回的列表包含所有成功激活的视图ID

get_selected_elements

获取当前Revit UI中选择的元素，遵循JSON-RPC 2.0规范。

特性:

• 获取当前用户在Revit界面中选择的所有元素
• 返回元素的完整信息，包括ID、类别和名称
• 无需额外参数，直接反映当前UI状态
• 完善的错误处理机制

参数: ctx (Context): FastMCP上下文对象 method (str): JSON-RPC方法名，默认为"GetSelectedElements"

返回: dict: JSON-RPC 2.0格式的响应，结构为: 成功时: { "jsonrpc": "2.0", "result": [ { "elementId": "元素ID", "name": "元素名称", "familyName": "类别名称" }, ... ], "id": request_id } 失败时: { "jsonrpc": "2.0", "error": { "code": int, "message": str, "data": any }, "id": request_id }

示例: # 获取当前选择的元素 response = get_selected_elements(ctx)

# 输出示例
{
    "jsonrpc":"2.0","id":"a39934f6-0ee9-4319-b820-1eba95a82c51",
    "result":
    [
        {"elementId":"355","familyName":"标高","name":"标高 1"},
        {"elementId":"2607","familyName":"标高","name":"标高 2"},
        {"elementId":"5855","familyName":"标高","name":"T.O. Fnd. 墙"}
    ],
    "error":[]
}

link_dwg_and_activate_view

链接本地 DWG 图纸并激活指定视图，遵循JSON-RPC 2.0规范。

特性:

• 支持链接本地 DWG 图纸到当前项目
• 支持激活指定视图
• 自动验证参数有效性
• 完善的错误处理机制

参数: ctx (Context): FastMCP上下文对象 method (str): JSON-RPC方法名，默认为"LinkDWGAndActivateView" params (List[Dict]): 参数列表，每个字典包含: - filePath (str): 本地 DWG 图纸路径 - viewName (str): 要激活的视图名称

返回: dict: JSON-RPC 2.0格式的响应，结构为: 成功时: { "jsonrpc": "2.0", "result": [ { "filePath": "链接的文件路径", "viewId": "视图ID", "viewName": "视图名称" }, ... ], "id": request_id } 失败时: { "jsonrpc": "2.0", "error": { "code": int, "message": str, "data": any }, "id": request_id }

示例: response = link_and_activate_view(ctx, params=[ {"filePath": "C:\Projects\SampleDrawing.dwg", "viewName": "Level 1"} ])

# 输出示例
{
    "jsonrpc": "2.0",
    "result": [
        {
            "filePath": "C:\Projects\SampleDrawing.dwg",
            "viewId": 123456,
            "viewName": "Level 1"
        }
    ],
    "id": 1
}

get_view_data

提取当前视图中所有信息，包括文本和图形实体数据，遵循JSON-RPC 2.0规范。

特性:

• 提取所有文本内容及其位置信息
• 提取所有图形对象（线、弧、圆等）的几何信息,图形坐标点的数据都是毫米单位
• 按图层组织返回的数据
• 完善的错误处理机制

参数: ctx (Context): FastMCP上下文对象 method (str): JSON-RPC方法名，默认为"GetViewData" params (List[dict], optional): 可选参数，默认为None

返回: dict: JSON-RPC 2.0格式的响应，结构为: 成功时: { "jsonrpc": "2.0", "result": [ { "name": "图层名称", "type": "Text", "text": "文本内容", "point": {"X": x值, "Y": y值, "Z": z值} }, { "name": "图层名称", "type": "Line", "startPoint": {"X": x1, "Y": y1, "Z": z1}, "endPoint": {"X": x2, "Y": y2, "Z": z2} }, { "name": "图层名称", "type": "Arc", "startAngle": 起始角度, "endAngle": 结束角度, "centerPoint": {"X": x, "Y": y, "Z": z}, "radius": 半径值 }, { "name": "图层名称", "type": "Circle", "centerPoint": {"X": x, "Y": y, "Z": z}, "radius": 半径值 }, ... ], "id": request_id } 失败时: { "jsonrpc": "2.0", "error": { "code": int, "message": str, "data": any }, "id": request_id }

错误代码: -32600: 无效请求 -32603: 内部错误（导出或解析时） -32700: 解析错误

示例: # 获取当前视图所有图形数据 response = get_view_data(ctx)

# 处理文本数据
texts = [item for item in response.get("result", []) if item.get("type") == "Text"]

# 处理线段数据
lines = [item for item in response.get("result", []) if item.get("type") == "Line"]

# 处理圆弧数据
arcs = [item for item in response.get("result", []) if item.get("type") == "Arc"]