Skip to main content
Glama
OpenSTAAD MCP Server

OpenSTAAD MCP Server

Official

OpenSTAAD MCP Server

A Model Context Protocol (MCP) server for Bentley STAAD.Pro that enables AI agents like Claude Desktop, Gemini, or VSCode Copilot to interact with your STAAD.Pro models and perform various time-consuming tasks like load cases definition, data extraction, repetitive property setting and more.

This MCP server was introduced as part of Bentley's Infrastructure AI Co-Innovation Initiative to help our users and accounts discover opportunities and innovate faster, while connecting Bentley's unique engineering tool capabilities to their emerging agentic workflows.

Key Features

  • Fast and flexible: Enjoy minimal latency, interact with every STAAD.Pro features covered by the OpenSTAAD API.

  • AI-friendly: Provides documentation, guidance and feedback via dedicated tools to help your AI agent ramp up quickly on the STAAD.Pro API.

  • Multi-instance support: Connects to multiple running STAAD.Pro instances simultaneously to parallelize tasks across models.

  • Privacy-first: All processing happens locally on your machine. No data is sent to the cloud. No telemetry.

Related MCP server: Qiao-MCP

Prerequisites

  • OS: Windows 11 or newer

  • STAAD.Pro 2025 or newer installed and running

Quick Start with Claude Desktop (<2min)

  1. Download the latest openstaad-mcp.mcpb file from the GitHub Releases page.

  2. Open Claude Desktop.

  3. Click the ☰ menu (top-left) → File → Settings → Extensions.

  4. Click Advanced → Install Extensions.

  5. Select the downloaded .mcpb file.

  6. Click the ☰ menu (top-left) → File → Exit

  7. Restart Claude Desktop.

Claude Desktop will install the server automatically. Open a new conversation and ask Claude to interact with your STAAD.Pro model.

Tip: Make sure STAAD.Pro is running with a model open before you start chatting.


Other Clients & Configuration

TL;DR:

If not already installed, install uv with the command:

powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"

Configure your client to start the server in stdio mode with the command:

uvx --from git+https://github.com/BentleySystems/openstaad-mcp openstaad-mcp

VS Code with GitHub Copilot

  • For stdio: Open the Command Palette → MCP: Add Server... → Command (stdio) and enter the following command:

    uvx --from git+https://github.com/BentleySystems/openstaad-mcp openstaad-mcp
  • For http: First, start the server in a terminal:

    uvx --from git+https://github.com/BentleySystems/openstaad-mcp openstaad-mcp --transport http

    Look for the generated token and URL in the terminal output. It should look like this:

    WARNING: No --token provided. Auto-generated token: abc123def456ghi789jkl012mno345pq
    INFO:  Starting MCP server 'OpenSTAAD MCP' with transport 'http' (stateless) on http://127.0.0.1:18120/mcp

    Then, in VS Code, open the Command Palette → MCP: Add Server... → HTTP URL and enter the URL shown in the terminal (e.g. http://127.0.0.1:18120/mcp). 18120 is the default port, but yours may differ if you have multiple instances running or if you changed the default. Add the header Authorization: Bearer <token> with the token shown in the MCP server terminal.

GitHub Copilot CLI

Use the /mcp add command inside a Copilot CLI session to add the server. See the Copilot CLI documentation for more details.

  • For stdio transport, use the command:

    uvx --from git+https://github.com/BentleySystems/openstaad-mcp openstaad-mcp
  • For HTTP transport, first start the server in a terminal:

    uvx --from git+https://github.com/BentleySystems/openstaad-mcp openstaad-mcp --transport http

    Look for the generated token and URL in the terminal output. It should look like this:

    WARNING: No --token provided. Auto-generated token: abc123def456ghi789jkl012mno345pq
    INFO:  Starting MCP server 'OpenSTAAD MCP' with transport 'http' (stateless) on http://127.0.0.1:18120/mcp

    Then add the server in Copilot CLI using the URL shown in the terminal (e.g. http://127.0.0.1:18120/mcp). 18120 is the default port, but yours may differ if you have multiple instances running or if you changed the default. Add the header Authorization: Bearer <token> with the token shown in the MCP server terminal.

Claude Desktop (manual configuration)

If you prefer manual setup over the .mcpb bundle, edit the Claude Desktop config file directly:

  • Windows (MSIX): %LOCALAPPDATA%\Packages\Claude_<id>\LocalCache\Roaming\Claude\claude_desktop_config.json

  • Windows (classic): %APPDATA%\Claude\claude_desktop_config.json

  • macOS: ~/Library/Application Support/Claude/claude_desktop_config.json

{
  "mcpServers": {
    "openstaad": {
      "command": "uvx",
      "args": ["--from", "git+https://github.com/BentleySystems/openstaad-mcp", "openstaad-mcp"]
    }
  }
}

Claude Code (CLI)

  • For stdio transport, use the command:

    claude mcp add --transport stdio openstaad -- uvx --from git+https://github.com/BentleySystems/openstaad-mcp openstaad-mcp
  • For HTTP transport, first start the server in a terminal:

    uvx --from git+https://github.com/BentleySystems/openstaad-mcp openstaad-mcp --transport http

    Look for the generated token and URL in the terminal output. It should look like this:

    WARNING: No --token provided. Auto-generated token: abc123def456ghi789jkl012mno345pq
    INFO:  Starting MCP server 'OpenSTAAD MCP' with transport 'http' (stateless) on http://127.0.0.1:18120/mcp

    Then add the server in Claude Code with the command:

    claude mcp add --transport http openstaad http://127.0.0.1:18120/mcp --header "Authorization: Bearer <your-token>"

    18120 is the default port, but yours may differ if you have multiple instances running or if you changed the default.

Gemini CLI

  • For stdio transport, use the command:

    gemini mcp add openstaad uvx --from git+https://github.com/BentleySystems/openstaad-mcp openstaad-mcp
  • For HTTP transport, first start the server in a terminal:

    uvx --from git+https://github.com/BentleySystems/openstaad-mcp openstaad-mcp --transport http

    Look for the generated token and URL in the terminal output. It should look like this:

    WARNING: No --token provided. Auto-generated token: abc123def456ghi789jkl012mno345pq
    INFO:  Starting MCP server 'OpenSTAAD MCP' with transport 'http' (stateless) on http://127.0.0.1:18120/mcp

    Then add the server in Gemini CLI with the command:

    gemini mcp add --transport http --header "Authorization: Bearer <your-token>" openstaad http://127.0.0.1:18120/mcp

    18120 is the default port, but yours may differ if you have multiple instances running or if you changed the default.

Transport Modes

The server supports two transport modes:

Mode

When to use

stdio (default)

The MCP client launches the server process directly. Used by Claude Desktop, Claude Code, VS Code Copilot (stdio config).

HTTP

The server runs persistently and clients connect over the network.

CLI Options

Flag

Default

Description

--transport {stdio,http}

stdio

Transport mode

--log-level LEVEL

INFO

DEBUG, INFO, WARNING, or ERROR

--log-file PATH

OS default

Path to log file

--port PORT

18120

[http] TCP port to listen on

--token TOKEN

-

[http] Bearer token for authentication


Available MCP Tools

Tool

Description

discover_api

Lists available API skills and usage guidance

read_skills

Returns detailed guidance for requested skills

list_instances

Lists active STAAD.Pro instances with model paths and versions

execute_code

Runs validated Python code against the connected STAAD.Pro model

get_status

Returns connection state, STAAD version, model path, analysis status

File I/O

The execute_code tool supports optional server-side file I/O for bulk data workflows. Instead of passing large datasets through the agent's context window, the server reads/writes CSV and XLSX files directly and injects the data into the sandbox as the input_data variable.

Parameter

Description

input_data_path

Path to a .csv or .xlsx file. The server reads and parses it, then injects as the input_data variable in the sandbox.

output_data_path

Path where the sandbox return value will be written. The return value must be a list-of-lists (CSV) or a {sheet_name: {columns, rows}} dict (multi-sheet XLSX).

overwrite

Allow overwriting an existing output file (default false).

input_data has a stable, extension-specific shape:

  • CSV: a list of row lists. If a header is detected, it is input_data[0] and data rows start at input_data[1:].

  • XLSX: a dict: {sheet_name: {"columns": list, "rows": list_of_rows}}.

Path containment: File paths must resolve inside a configured allowed boundary before any read/write occurs. The server supports both client-configured MCP roots and server-configured allowed directories (via --allowed-dirs or user_config.allowed_directories in the manifest). The server validates paths against these boundaries before any file access.

Limits: Max file size 50 MB, max 100K rows, max 500 columns, max 50 input sheets.

Security Notes

  • Bearer token authentication. Pass --token MY_SECRET_TOKEN when running in HTTP mode and include Authorization: Bearer <token> in client requests.

  • DNS rebinding protection. Starlette Middlewares validate Host, Sec-Fetch-Site and Origin headers.

  • Code sandbox. The execute_code tool validates all Python code via AST analysis before execution. Imports, file access, and dangerous builtins are blocked.

Privacy Policy

Please find the Bentley Systems privacy policy here.

Contributing

See CONTRIBUTING.md for guidelines on setting up your development environment, branch naming, running tests, and submitting pull requests.

Available Tools

5 tools
discover_apiDiscover API and skillsA
Read-onlyIdempotent

Discover available API guidance and skills.

Call this FIRST before using other openstaad-mcp tools. Then use read_skills with one or more specific skill names to load full guidance.

Inputs: no named parameters. Returns: result

execute_codeExecute Python codeA
Destructive

Execute Python code in a sandbox against the OpenSTAAD API (don't forget to call discover_api and read_skills for API guidance).

The sandbox provides pre-connected staad (the OpenSTAAD root object) and input_data (if input_data_path is provided) variables (plus json and math modules). import statements, dir(), getattr(), ... are BLOCKED.

The last expression value or an explicit result = ... assignment is returned as the result. If output_data_path is provided, the sandbox will write the result to the specified file.

Paths must be on the user LOCAL filesystem and inside MCP roots or configured allowed_dirs. On Claude Desktop, users can configure allowed directories in the extension settings and Claude can use the filesystem copy_file_to_claude tool to move files to Claude's filesystem.

Inputs: code (required), instance, overwrite, input_data_path, +1 more. Returns: object

get_statusGet STAAD.Pro instance statusA
Read-only

Check the connection to a STAAD.Pro instance.

Pass instance (alias from list_instances) to target a specific instance. Omit it when only one instance is running.

Returns connection state, STAAD version, model path, and the directories execute_code may currently read/write (allowed_dirs) — call this again after the user reconfigures allowed directories, since the MCP server must be relaunched for that change to take effect and a stale in-context list will otherwise look correct.

Inputs: instance. Returns: object

list_instancesList running STAAD.Pro instancesA
Read-only

List all running STAAD.Pro instances.

Returns a list of instances with their alias, process ID, currently open file path, and STAAD version. Call this before execute_code when multiple STAAD instances may be running so you can pick the right one. The alias (e.g. staadPro1) is stable for the server session even if the model file changes.

If a version is below the minimum supported (25.0.1), a warning field is included with details about potential data inaccuracies.

Inputs: no named parameters. Returns: result

read_skillsRead OpenSTAAD skillsA
Read-onlyIdempotent

Read one or more skills by name.

Use discover_api first to list available skills. Each skill provides domain-specific guidance (e.g. analysis, geometry, loads).

Pass skill names like ["staad-analysis"] or sub-paths like ["staad-steel-design/assets/DESIGN_CODES"] to read reference files within a skill.

Inputs: skills (required). Returns: result

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A4.4/5.0

    Scored across 5 tools

    Disambiguation5/5

    Each tool has a clearly distinct role: discovery/guidance (discover_api, read_skills), instance/connection inspection (get_status, list_instances), and execution (execute_code). Although get_status and list_instances both report version/path details, their core purposes—checking a specific connection vs. enumerating running instances—are clearly differentiated by the descriptions.

    Naming Consistency5/5

    All tool names follow a consistent snake_case verb_noun pattern: discover_api, get_status, execute_code, list_instances, read_skills. There are no deviations in style or casing.

    Tool Count5/5

    Five tools are well-scoped for an MCP server that bridges to OpenSTAAD via code execution. Each tool serves a necessary part of the workflow: guidance discovery, connection/instance management, and code execution.

    Completeness5/5

    The surface covers the full lifecycle for this server's purpose: discovering API guidance, reading skills, checking connection/status, listing available STAAD.Pro instances, and executing Python against the OpenSTAAD API. No obvious operational gaps remain for the stated domain.

    Maintenance

    ActivityNo data
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      D
      maintenance
      Enables AI agents to interact with Bentley STAAD.Pro models for tasks like load case definition, data extraction, and property setting, running locally with multi-instance support and no cloud dependency.
      5
      MIT
    • A
      license
      A
      quality
      B
      maintenance
      Enables AI assistants to interact with bridge structural analysis software for modeling, construction stages, and code checking.
      15
      62 PyPI
      1
      Apache 2.0
    • A
      license
      Not graded
      quality
      B
      maintenance
      Enables AI coding assistants to directly control CSI ETABS for structural and seismic analysis, including model inspection, material/section definition, frame generation, solver execution, and result extraction through natural language.
      2
      MIT
    • A
      license
      Not graded
      quality
      C
      maintenance
      Enables AI agents to drive desktop CAD software through natural language with verified execution, failure recovery, and traceable results across modeling, assemblies, drawings, exports, motion, FEA, and related engineering workflows.
      1
      MIT