Vivado MCP
Vivado MCP Server โ AI ้ฉฑๅจ็ FPGA ๅผๅๅฉๆ๏ผ่ชๅจ่ฏๆญ CRITICAL WARNING ๅนถ็ปๅบไฟฎๅคๅปบ่ฎฎ
Ask AI about Vivado MCP
Powered by Claude ยท Grounded in docs
I know everything about Vivado MCP. Ask me about installation, configuration, usage, or troubleshooting.
0/500
Reviews
Documentation
Vivado MCP Server
A Model Context Protocol (MCP) server that enables AI assistants like Claude to directly interact with AMD/Xilinx Vivado FPGA development tools.
Features
- Session Management: Start/stop persistent Vivado TCL sessions (avoids 30s startup per command)
- Project Management: Open/close Vivado projects (.xpr files)
- Design Flow: Run synthesis, implementation, and bitstream generation
- Reports & Analysis: Get timing summaries, utilization reports, and design analysis
- Design Queries: Explore hierarchy, ports, nets, and cells
- Simulation: Control Vivado's integrated simulator (xsim)
- Raw TCL: Execute arbitrary Vivado TCL commands for advanced operations
Requirements
- Python 3.10+
- AMD/Xilinx Vivado installed (tested with 2023.2+)
- Vivado must be in your PATH, or specify the full path when starting a session
Installation
From GitHub
git clone https://github.com/coreyhahn/vivado_mcp.git
cd vivado_mcp
pip install -e .
Configure Claude Code
Add to your Claude Code MCP configuration (~/.claude/claude_desktop_config.json or project-level .mcp.json):
{
"mcpServers": {
"vivado": {
"command": "vivado-mcp"
}
}
}
Or if you want to specify the Python interpreter:
{
"mcpServers": {
"vivado": {
"command": "python",
"args": ["-m", "vivado_mcp"]
}
}
}
Usage
Once configured, Claude can interact with Vivado through natural language. Example workflow:
- Start Vivado session: "Start a Vivado session"
- Open project: "Open my project at /path/to/project.xpr"
- Run synthesis: "Synthesize the design"
- Check timing: "What's the timing summary? Is timing met?"
- Check utilization: "Show me the resource utilization"
- Close session: "Stop the Vivado session"
Available Tools
Session Management
start_session- Start a persistent Vivado TCL sessionstop_session- Stop the Vivado sessionsession_status- Get session statistics
Project Management
open_project- Open a Vivado project (.xpr)close_project- Close the current projectget_project_info- Get project information (part, directory, etc.)
Design Flow
run_synthesis- Run synthesisrun_implementation- Run place and routegenerate_bitstream- Generate bitstream
Reports & Analysis
get_timing_summary- Get timing summary (WNS, TNS, WHS, THS)get_timing_paths- Get detailed timing paths for failing/critical pathsget_utilization- Get resource utilization (LUTs, FFs, BRAMs, DSPs)get_clocks- Get clock informationget_messages- Get synthesis/implementation messages
Design Queries
get_design_hierarchy- Get module/instance hierarchyget_ports- Get top-level portsget_nets- Search for netsget_cells- Search for cells/instances
Simulation
launch_simulation- Launch behavioral/post-synth/post-impl simulationrun_simulation- Run simulation for specified timerestart_simulation- Restart from time 0close_simulation- Close the simulatorget_simulation_time- Get current simulation timeget_signal_value- Get a signal's current valueget_signal_values- Get multiple signal values by patternadd_signals_to_wave- Add signals to waveform viewerset_simulation_top- Set the testbench moduleget_simulation_objects- List signals in a scopeget_scopes- List hierarchy scopesstep_simulation- Step simulationadd_breakpoint- Add signal breakpointremove_breakpoints- Remove all breakpoints
Advanced
run_tcl- Execute raw TCL commandsgenerate_full_report- Generate full reports to fileread_report_section- Read portions of large reportsrequest_feature- Request new featureslist_feature_requests- List submitted requests
Architecture
โโโโโโโโโโโโโโโโโโโ MCP Protocol โโโโโโโโโโโโโโโโโโโ
โ Claude Code โโโโโโ(JSON-RPC)โโโโโโโโโบโ Vivado MCP โ
โ (AI Client) โ over stdio โ Server โ
โโโโโโโโโโโโโโโโโโโ โโโโโโโโโโฌโโโโโโโโโ
โ
โ pexpect
โ (TCL commands)
โผ
โโโโโโโโโโโโโโโโโโโ
โ Vivado Process โ
โ (TCL mode) โ
โโโโโโโโโโโโโโโโโโโ
The server maintains a persistent Vivado process in TCL mode. Commands are sent via pexpect and output is captured by waiting for the Vivado prompt. This avoids the ~30 second startup overhead that would occur if Vivado were launched for each command.
Recreating This MCP Server with Claude
This MCP server was created entirely through conversation with Claude. Here's how you can create similar MCP servers:
1. Start with a Clear Goal
Tell Claude what you want to build:
"I want to create an MCP server that lets you control Vivado FPGA tools. You should be able to start Vivado, open projects, run synthesis, check timing, etc."
2. Describe the Architecture
Explain the key technical challenges:
"Vivado takes 30 seconds to start, so we need a persistent session. Vivado has a TCL interface we can use. We need to parse Vivado's text output into structured data."
3. Iterate on Tools
Start with basic tools and add more:
- Session management (start/stop)
- Project management
- Design flow commands
- Reports and queries
- Simulation control
4. Key Design Patterns Used
Singleton Session: Only one Vivado process runs at a time
_session: Optional[VivadoSession] = None
def get_session() -> VivadoSession:
global _session
if _session is None:
_session = VivadoSession()
return _session
pexpect for Process Management: Keeps Vivado alive between commands
self.child = pexpect.spawn(
f'{self.vivado_path} -mode tcl -nojournal -nolog',
encoding='utf-8',
timeout=self.timeout
)
self.child.expect('Vivado%', timeout=10) # Wait for prompt
Output Parsing: Convert text reports to structured JSON
def parse_timing_summary(output: str) -> dict:
wns_match = re.search(r"WNS\(ns\)\s*:\s*([-\d.]+)", output)
if wns_match:
result["wns"] = float(wns_match.group(1))
Response Truncation: Handle large outputs gracefully
def truncate_response(content: str, max_chars: int) -> dict:
if len(content) > max_chars:
return {"content": content[:max_chars], "truncated": True}
5. MCP Server Structure
Every MCP server needs:
from mcp.server import Server
from mcp.server.stdio import stdio_server
from mcp.types import Tool, TextContent
server = Server("your-server-name")
@server.list_tools()
async def list_tools() -> list[Tool]:
return [Tool(name="...", description="...", inputSchema={...})]
@server.call_tool()
async def call_tool(name: str, arguments: dict) -> list[TextContent]:
# Handle tool calls
return [TextContent(type="text", text=json.dumps(result))]
async def main():
async with stdio_server() as (read_stream, write_stream):
await server.run(read_stream, write_stream,
server.create_initialization_options())
6. Prompt for Creating Your Own MCP Server
Use this prompt template with Claude:
I want to create an MCP server for [YOUR TOOL].
Background:
- [Tool] is a [description] that [what it does]
- It has a [CLI/API/etc] interface that accepts [commands/requests]
- Key operations I want to support: [list operations]
Technical considerations:
- [Startup time, persistent state, output formats, etc.]
Please help me create an MCP server with:
1. Session/connection management
2. Core operations as tools
3. Proper error handling
4. Structured JSON responses
5. Comprehensive code comments
Start with the basic structure and we'll iterate from there.
Contributing
Contributions welcome! Please feel free to submit issues and pull requests.
License
MIT License - see LICENSE file for details.
Acknowledgments
- Created with Claude (Anthropic)
- Uses the Model Context Protocol specification
- Integrates with AMD/Xilinx Vivado
