What can you do with this server?

The OpenROAD MCP server enables interaction with OpenROAD and OpenROAD Flow Scripts (ORFS) for chip design workflows. Here's what you can do: * Execute read-only commands — Run query/report commands like report_*, get_*, check_*, timing analysis, and help lookups without modifying design state. * Execute state-modifying commands — Run commands that change design state, such as loading designs, running placement/routing, applying constraints, and writing output files. * Session Management — Create persistent sessions (with optional custom working directories and environment variables), list active sessions, inspect session metadata/status, and terminate sessions gracefully or forcefully. * Command History — Access full or filtered command history for any session. * Performance Metrics — Retrieve comprehensive metrics across all active sessions. * ORFS Report Images — List available report images from ORFS runs (organized by platform, design, and stage) and retrieve specific images as base64-encoded data with metadata for visualization.

Which integrations are available for this server?

Allows Amazon Q Developer CLI to leverage OpenROAD for chip design tasks. Provides OpenROAD tools within the Amp MCP client for chip design automation. Provides OpenROAD tools within GitHub Copilot for chip design workflow, including session management and command execution. Integrates OpenROAD chip design capabilities into Hermes Agent for automated design workflows. Integrates OpenROAD chip design capabilities into JetBrains AI Assistant, allowing session management and command execution. Allows OpenAI Codex CLI to interact with OpenROAD for chip design, including running commands and viewing reports. Enables Warp AI to execute OpenROAD commands and manage sessions for chip design automation.

openroad-mcp

by The-OpenROAD-Project

Overview Schema Related Servers Score Discussions

Python

Local

OpenROAD MCP Server

A Model Context Protocol (MCP) server that provides tools for interacting with OpenROAD and ORFS (OpenROAD Flow Scripts).

Demo

OpenROAD MCP Demo

Watch full demo video

Related MCP server: MCP Server

Features

Interactive OpenROAD sessions - Execute commands in persistent OpenROAD sessions with PTY support
Session management - Create, list, inspect, and terminate multiple sessions
Command history - Access full command history for any session
Performance metrics - Get comprehensive metrics across all sessions
Report visualization - List and read report images from ORFS runs

Requirements

OpenROAD installed and available in your PATH
- Installation guide
OpenROAD-flow-scripts (ORFS) for complete RTL-to-GDS flows (optional but recommended)
- ORFS installation guide
A runtime for one of the two distributions:
- Node.js 22+ for the npx distribution (recommended — no extra install if you already have Node)
- or Python 3.13+ and the uv package manager for the uvx distribution (deprecated — final release, see below)
  - Install uv: curl -LsSf https://astral.sh/uv/install.sh | sh

Support Matrix

MCP Client	Supported	Transport Mode(s)	Config file
Claude Code	✅	STDIO	`.claude/settings.json`
Claude Desktop	✅	STDIO	`~/Library/Application Support/Claude/claude_desktop_config.json` (macOS)
Cursor	✅	STDIO	`.cursor/mcp.json`
GitHub Copilot (VS Code)	✅	STDIO	`.vscode/mcp.json`
Gemini CLI	✅	STDIO	`~/.gemini/settings.json`
Windsurf	✅	STDIO	`~/.codeium/windsurf/mcp_config.json`
Cline	✅	STDIO	VS Code globalStorage (see below)
Roo Code	✅	STDIO	`.roo/mcp.json`
Continue	✅	STDIO	`~/.continue/config.json`
Zed	✅	STDIO	`~/.config/zed/settings.json`
JetBrains AI Assistant	✅	STDIO	Settings UI
Amazon Q Developer CLI	✅	STDIO	`~/.aws/amazonq/mcp.json`
Augment Code	✅	STDIO	VS Code `settings.json`
Warp	✅	STDIO	Settings UI
Amp	✅	STDIO	CLI-managed
Trae	✅	STDIO	User config
Opencode	✅	STDIO	`opencode.json`
Kiro	✅	STDIO	Settings UI
Kilo Code	✅	STDIO	`.kilocode/mcp.json`
Goose	✅	STDIO	`~/.config/goose/config.yaml`
Sourcegraph Cody	✅	STDIO	VS Code `settings.json`
OpenAI Codex CLI	✅	STDIO	`~/.codex/config.toml`
PearAI	✅	STDIO	`~/pearai/config.json`
CodeBuddy	✅	STDIO	`~/.codebuddy/config.jsonc`
Hermes Agent	✅	STDIO	`~/.hermes/config.yaml`
GitHub Copilot CLI	✅	STDIO	`~/.copilot/mcp-config.json`
Oh My Pi	✅	STDIO	`.omp/mcp.json`
OpenClaw	✅	STDIO	`~/.openclaw/openclaw.json`
AstrBot	✅	STDIO	WebUI
DeepCode	✅	STDIO	`deepcode_config.json`
nanobot	✅	STDIO	`nanobot.yaml`
Crush	✅	STDIO	`.crush.json`
Reasonix	✅	STDIO	`reasonix.toml`
Other MCP clients	⚠️	STDIO	Should work with standard STDIO transport

Getting Started

New to OpenROAD MCP? Check out our Quick Start guide.

For platform-specific setup instructions, see the Cross-Platform Guide.

Standard Configuration

The server ships as two interchangeable distributions with identical tools and behavior. Pick the one that matches your installed runtime.

npx (Node.js 22+) — recommended:

{
  "mcpServers": {
    "openroad-mcp": {
      "command": "npx",
      "args": ["-y", "openroad-mcp"]
    }
  }
}

uvx (Python 3.13+ and uv) — deprecated, final release:

{
  "mcpServers": {
    "openroad-mcp": {
      "command": "uvx",
      "args": [
        "--from",
        "git+https://github.com/The-OpenROAD-Project/openroad-mcp@v0.6.1#subdirectory=python",
        "openroad-mcp"
      ]
    }
  }
}

Note: The uvx URL above is pinned to a specific release for supply chain safety. To always track the latest version instead, drop the @v0.5.5 suffix: "git+https://github.com/The-OpenROAD-Project/openroad-mcp@v0.6.1#subdirectory=python".

The uvx distribution above is deprecated (final release — no further PyPI publishes). Every client example below still uses uvx for now; swap the "command"/"args" for the npx block above to use the actively maintained npm distribution instead — the server name, tools, and behavior are identical.

For local development, use:

{
  "mcpServers": {
    "openroad-mcp": {
      "command": "uv",
      "args": [
        "--directory",
        "/path/to/openroad-mcp/python",
        "run",
        "openroad-mcp"
      ]
    }
  }
}

Installation

claude mcp add --transport stdio openroad-mcp -- uvx --from git+https://github.com/The-OpenROAD-Project/openroad-mcp#subdirectory=python openroad-mcp

Or add the standard configuration to .claude/settings.json.

Add the standard configuration to:

macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Windows: %APPDATA%\Claude\claude_desktop_config.json

Add the standard configuration to .cursor/mcp.json.

Add to .vscode/mcp.json (VS Code 1.99+). Note the different schema — servers key and "type": "stdio" required:

{
  "servers": {
    "openroad-mcp": {
      "type": "stdio",
      "command": "uvx",
      "args": [
        "--from",
        "git+https://github.com/The-OpenROAD-Project/openroad-mcp@v0.6.1#subdirectory=python",
        "openroad-mcp"
      ]
    }
  }
}

Follow the Gemini MCP install guide, using the standard configuration above.

Add the standard configuration to ~/.codeium/windsurf/mcp_config.json.

Add to the Cline MCP settings file:

macOS: ~/Library/Application Support/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json
Windows: %APPDATA%\Code\User\globalStorage\saoudrizwan.claude-dev\settings\cline_mcp_settings.json
Linux: ~/.config/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json

{
  "mcpServers": {
    "openroad-mcp": {
      "command": "uvx",
      "args": [
        "--from",
        "git+https://github.com/The-OpenROAD-Project/openroad-mcp@v0.6.1#subdirectory=python",
        "openroad-mcp"
      ],
      "disabled": false,
      "autoApprove": []
    }
  }
}

Add to .roo/mcp.json in your project root (or the equivalent user-level settings file via the Roo Code UI):

{
  "mcpServers": {
    "openroad-mcp": {
      "command": "uvx",
      "args": [
        "--from",
        "git+https://github.com/The-OpenROAD-Project/openroad-mcp@v0.6.1#subdirectory=python",
        "openroad-mcp"
      ],
      "disabled": false,
      "autoApprove": []
    }
  }
}

Add to ~/.continue/config.json:

{
  "experimental": {
    "modelContextProtocolServers": [
      {
        "transport": {
          "type": "stdio",
          "command": "uvx",
          "args": [
            "--from",
            "git+https://github.com/The-OpenROAD-Project/openroad-mcp@v0.6.1#subdirectory=python",
            "openroad-mcp"
          ]
        }
      }
    ]
  }
}

Add to ~/.config/zed/settings.json:

{
  "context_servers": {
    "openroad-mcp": {
      "command": {
        "path": "uvx",
        "args": [
          "--from",
          "git+https://github.com/The-OpenROAD-Project/openroad-mcp@v0.6.1#subdirectory=python",
          "openroad-mcp"
        ]
      },
      "settings": {}
    }
  }
}

Open Settings → Tools → AI Assistant → Model Context Protocol (MCP) and add a new server entry using the standard configuration.

Add the standard configuration to ~/.aws/amazonq/mcp.json.

Add to your VS Code settings.json (User or Workspace scope):

{
  "augment.advanced": {
    "mcpServers": [
      {
        "name": "openroad-mcp",
        "command": "uvx",
        "args": [
          "--from",
          "git+https://github.com/The-OpenROAD-Project/openroad-mcp@v0.6.1#subdirectory=python",
          "openroad-mcp"
        ]
      }
    ]
  }
}

Open Settings → AI → MCP Servers → Add New MCP Server and enter:

Name: openroad-mcp
Command: uvx
Args: --from git+https://github.com/The-OpenROAD-Project/openroad-mcp#subdirectory=python openroad-mcp

amp mcp add openroad-mcp uvx --from git+https://github.com/The-OpenROAD-Project/openroad-mcp#subdirectory=python openroad-mcp

Add the standard configuration to the MCP section of Trae's user settings (accessible via Settings → MCP).

Add to opencode.json in your project root:

{
  "mcp": {
    "openroad-mcp": {
      "type": "local",
      "command": [
        "uvx",
        "--from",
        "git+https://github.com/The-OpenROAD-Project/openroad-mcp@v0.6.1#subdirectory=python",
        "openroad-mcp"
      ],
      "enabled": true
    }
  }
}

Open the MCP configuration panel in Kiro and add a new server entry using the standard configuration.

Add to .kilocode/mcp.json in your project root:

{
  "mcpServers": {
    "openroad-mcp": {
      "command": "uvx",
      "args": [
        "--from",
        "git+https://github.com/The-OpenROAD-Project/openroad-mcp@v0.6.1#subdirectory=python",
        "openroad-mcp"
      ],
      "alwaysAllow": [],
      "disabled": false
    }
  }
}

Add to ~/.config/goose/config.yaml:

extensions:
  openroad-mcp:
    name: openroad-mcp
    type: stdio
    cmd: uvx
    args:
      - --from
      - git+https://github.com/The-OpenROAD-Project/openroad-mcp@v0.6.1#subdirectory=python
      - openroad-mcp
    enabled: true

Add to your VS Code settings.json:

{
  "openctx.providers": {
    "https://openctx.org/npm/@openctx/provider-mcp": {
      "transports": [
        {
          "type": "stdio",
          "command": "uvx",
          "args": [
            "--from",
            "git+https://github.com/The-OpenROAD-Project/openroad-mcp@v0.6.1#subdirectory=python",
            "openroad-mcp"
          ]
        }
      ]
    }
  }
}

Add to ~/.codex/config.toml (global) or .codex/config.toml (project-scoped):

[[mcp_servers]]
name = "openroad-mcp"
command = "uvx"
args = ["--from", "git+https://github.com/The-OpenROAD-Project/openroad-mcp@v0.6.1#subdirectory=python", "openroad-mcp"]

PearAI uses the same config format as Continue. Add to ~/pearai/config.json:

{
  "experimental": {
    "modelContextProtocolServers": [
      {
        "transport": {
          "type": "stdio",
          "command": "uvx",
          "args": [
            "--from",
            "git+https://github.com/The-OpenROAD-Project/openroad-mcp@v0.6.1#subdirectory=python",
            "openroad-mcp"
          ]
        }
      }
    ]
  }
}

Add to ~/.codebuddy/config.jsonc (global) or .codebuddy/mcp.jsonc (project-scoped):

{
  "mcpServers": {
    "openroad-mcp": {
      "command": "uvx",
      "args": [
        "--from",
        "git+https://github.com/The-OpenROAD-Project/openroad-mcp@v0.6.1#subdirectory=python",
        "openroad-mcp"
      ]
    }
  }
}

Add to ~/.hermes/config.yaml:

mcp_servers:
  - name: openroad-mcp
    transport: stdio
    command: uvx
    args:
      - --from
      - git+https://github.com/The-OpenROAD-Project/openroad-mcp@v0.6.1#subdirectory=python
      - openroad-mcp

Add to ~/.copilot/mcp-config.json:

{
  "mcpServers": {
    "openroad-mcp": {
      "type": "stdio",
      "command": "uvx",
      "args": [
        "--from",
        "git+https://github.com/The-OpenROAD-Project/openroad-mcp@v0.6.1#subdirectory=python",
        "openroad-mcp"
      ]
    }
  }
}

Or run /mcp add inside a Copilot CLI session for guided setup.

Add to .omp/mcp.json (project-level) or ~/.omp/agent/mcp.json (global):

{
  "mcpServers": {
    "openroad-mcp": {
      "type": "stdio",
      "command": "uvx",
      "args": [
        "--from",
        "git+https://github.com/The-OpenROAD-Project/openroad-mcp@v0.6.1#subdirectory=python",
        "openroad-mcp"
      ]
    }
  }
}

Add to ~/.openclaw/openclaw.json:

{
  "mcp": {
    "servers": {
      "openroad-mcp": {
        "command": "uvx",
        "args": [
          "--from",
          "git+https://github.com/The-OpenROAD-Project/openroad-mcp@v0.6.1#subdirectory=python",
          "openroad-mcp"
        ],
        "enabled": true
      }
    }
  }
}

Or run openclaw mcp add for guided setup.

Navigate to the AstrBot WebUI → MCP section → Add Server, and enter:

{
  "command": "uvx",
  "args": ["--from", "git+https://github.com/The-OpenROAD-Project/openroad-mcp@v0.6.1#subdirectory=python", "openroad-mcp"]
}

Requires uv installed on the host running AstrBot.

Add to deepcode_config.json in your project root:

{
  "tools": {
    "mcpServers": {
      "openroad-mcp": {
        "type": "stdio",
        "command": "uvx",
        "args": [
          "--from",
          "git+https://github.com/The-OpenROAD-Project/openroad-mcp@v0.6.1#subdirectory=python",
          "openroad-mcp"
        ]
      }
    }
  }
}

Add to nanobot.yaml in your project root:

mcpServers:
  openroad-mcp:
    command: uvx
    args:
      - --from
      - git+https://github.com/The-OpenROAD-Project/openroad-mcp@v0.6.1#subdirectory=python
      - openroad-mcp

Add to .crush.json (project-local) or ~/.config/crush/crush.json (global):

{
  "mcp": {
    "openroad-mcp": {
      "type": "stdio",
      "command": "uvx",
      "args": [
        "--from",
        "git+https://github.com/The-OpenROAD-Project/openroad-mcp@v0.6.1#subdirectory=python",
        "openroad-mcp"
      ]
    }
  }
}

Add to reasonix.toml (project root) or ~/.config/reasonix/config.toml (global):

[[plugins]]
name    = "openroad-mcp"
command = "uvx"
args    = ["--from", "git+https://github.com/The-OpenROAD-Project/openroad-mcp@v0.6.1#subdirectory=python", "openroad-mcp"]

Alternatively, use the standard .mcp.json format — Reasonix auto-discovers it.

🚧 Work in Progress: Docker deployment via GitHub Container Registry (GHCR) is coming soon.

Once published to the MCP Registry, clients can discover and install directly using either distribution:

npx -y openroad-mcp   # Node.js 22+
uvx openroad-mcp      # Python 3.13+ and uv

Verification

After configuration, restart your MCP client and verify the MCP server is running:

The server should automatically start when your MCP client launches
You can use OpenROAD tools through the MCP interface
Check logs for any startup errors if tools are not available

Available Tools

Once configured, the following tools are available:

interactive_openroad - Execute commands in an interactive OpenROAD session
create_interactive_session - Create a new OpenROAD session
list_interactive_sessions - List all active sessions
terminate_interactive_session - Terminate a session
inspect_interactive_session - Get detailed session information
get_session_history - View command history
get_session_metrics - Get performance metrics
list_report_images - List ORFS report directory images
read_report_image - Read a ORFS report image

Troubleshooting

If the MCP server fails to start:

Ensure uv is installed and available in your PATH
Verify the path to openroad-mcp is correct
Check that all dependencies are installed: make sync
Review your MCP client logs for specific error messages

Development

Setup

# Install environment
uv venv
make sync

Testing

# Run core tests (recommended - excludes PTY tests that may fail in some environments)
make test

# Run interactive PTY tests separately (may have file descriptor issues in CI)
make test-interactive

# Run all tests including potentially problematic PTY tests
make test-all

# Format and check code
make format
make check

Note: Interactive PTY tests are separated because they may experience file descriptor issues in certain environments (containers, CI systems). The core functionality tests (make test) provide comprehensive coverage of the MCP integration without these environment-specific issues.

MCP Inspector

# Launch MCP inspector for debugging
# For STDIO transport: Set Command as "uv", Arguments as "run openroad-mcp"
make inspect

Contributing

We welcome contributions to OpenROAD MCP! Please see CONTRIBUTING.md for detailed instructions on how to get started, our development workflow, and code standards.

Support

If you encounter any issues or have questions, please open an issue on our GitHub issue tracker.

License

BSD 3-Clause License. See LICENSE file.

Built with ❤️ by Precision Innovations

Install Server

license - permissive license

quality

maintenance

How are these scores calculated?

Maintenance

–Maintainers

2dResponse time

2wRelease cycle

14Releases (12mo)

Commit activity

Issues opened vs closed

Resources

GitHub Repository

Need Help?

Related Servers

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Tools

View all tools

Related MCP Servers

openrpc-mpc-server
Developer Tools API Testing
shanejonas
A
license
B
quality
F
maintenance
A Model Context Protocol (MCP) server that provides JSON-RPC functionality through OpenRPC.
Last updated 2026-03-02
2
67
43
Apache 2.0
MCP Server
Autonomous Agents Developer Tools
la-rebelion
A
license
-
quality
D
maintenance
MCP Server simplifies the implementation of the Model Context Protocol by providing a user-friendly API to create custom tools and manage server workflows efficiently.
Last updated 2025-01-13
31
4
MIT
MCP REST API Server
Developer Tools Code Execution
vinaykp
F
license
-
quality
D
maintenance
A server implementation of the Model Context Protocol (MCP) that provides REST API endpoints for managing and interacting with MCP resources.
Last updated 2025-06-01
JSON-RPC
Entertainment & Media
xiaobenyang-com
A
license
B
quality
D
maintenance
A Model Context Protocol (MCP) server based on OpenRPC, providing JSON-RPC function invocation and method discovery services.
Last updated 2026-01-09
2
1
Apache 2.0

View all related MCP servers

Related MCP Connectors

Fcc Ecfs
MCP server for fcc-ecfs
hithereiamaliff-mcp-nextcloud
A comprehensive Model Context Protocol (MCP) server that enables AI assistants to interact with yo…
mcp
MCP (Model Context Protocol) server for Appwrite

View all MCP Connectors

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/The-OpenROAD-Project/OpenROAD-MCP'

If you have feedback or need assistance with the MCP directory API, please join our Discord server