📌Overview

Purpose: To connect AI coding assistants to DaVinci Resolve, enabling control and querying through natural language.

Overview: DaVinci Resolve MCP Server functions as a Model Context Protocol server that interfaces with AI coding assistants, facilitating voice-driven commands and control over DaVinci Resolve’s various functionalities.

Key Features:

Connect to DaVinci Resolve: Integrate AI assistants to directly query and manage DaVinci Resolve's operations using natural language commands.
Project Management: Efficiently handle projects by listing, opening, and creating projects within DaVinci Resolve.
Timeline Operations: Perform actions like creating timelines, switching between them, and adding markers directly from the AI assistant.
Media Management: Import media files, create bins, and list clips, enhancing workflow and media organization.
Multi-Client Support: Compatibility with multiple AI assistants, such as Cursor and Claude Desktop.
Cross-Platform Compatibility: Fully operational on macOS with experimental support for Windows, allowing for versatility across different operating systems.

DaVinci Resolve MCP Server

A Model Context Protocol (MCP) server that connects AI coding assistants (Cursor, Claude Desktop) to DaVinci Resolve, enabling natural language querying and control of DaVinci Resolve.

Features

For a comprehensive list of implemented and planned features, see the FEATURES documentation.

Requirements

macOS or Windows with DaVinci Resolve installed
Python 3.6+
DaVinci Resolve running in the background
(Optional) Node.js/npm for some features

Installation Guide

Quick Start (Recommended)

The easiest way to get started is with the new unified installation script:

git clone https://github.com/samuelgursky/davinci-resolve-mcp.git
cd davinci-resolve-mcp

Make sure DaVinci Resolve Studio is installed and running, then run:

macOS/Linux:
```
./install.sh
```
Windows:
```
install.bat
```

This script will:

Detect correct paths
Create a Python virtual environment
Install the MCP SDK
Set environment variables
Configure Cursor/Claude integration
Verify installation
Optionally start the MCP server

Alternative Quick Start

Windows:
```
run-now.bat
```
macOS:
```
chmod +x run-now.sh
./run-now.sh
```

Platform Support

Platform	Status	One-Step Install	Quick Start
macOS	Stable	`./install.sh`	`./run-now.sh`
Windows	Stable	`install.bat`	`run-now.bat`
Linux	Not supported	N/A	N/A

Configuration

Configuration templates for Cursor or Claude clients are available in the config-templates directory.

Troubleshooting

Key troubleshooting tips:

Path Resolution: Always let the scripts determine correct paths.
DaVinci Resolve Detection: Ensure DaVinci Resolve is running before starting the MCP server.
Environment Variables: Verify all required environment variables; check logs in scripts/cursor_resolve_server.log.

Platform-specific notes:

Windows: Use forward slashes / in configuration files; Python and paths must be correctly configured.
macOS: Ensure scripts have execute permissions; check Console.app for Python errors.

For more guidance, consult the INSTALL documentation.

Launch Options

Client-Specific Launch Scripts

For Cursor integration (macOS):

chmod +x scripts/mcp_resolve-cursor_start
./scripts/mcp_resolve-cursor_start

For Claude Desktop integration (macOS):

chmod +x scripts/mcp_resolve-claude_start
./scripts/mcp_resolve-claude_start

Pre-Launch Check

Verify readiness before connecting AI assistants:

macOS:
```
./scripts/check-resolve-ready.sh
```
Windows:
```
./scripts/check-resolve-ready.bat
```

Universal Launcher

Use the unified launcher for managing Cursor and Claude servers:

chmod +x scripts/mcp_resolve_launcher.sh

# Run interactively
./scripts/mcp_resolve_launcher.sh

# Command-line options
./scripts/mcp_resolve_launcher.sh --start-cursor
./scripts/mcp_resolve_launcher.sh --start-claude
./scripts/mcp_resolve_launcher.sh --start-both
./scripts/mcp_resolve_launcher.sh --stop-all
./scripts/mcp_resolve_launcher.sh --status

Options:

Force mode (skip Resolve running check): --force
Project selection: --project "Project Name"

Full Manual Installation

Clone the repository:

git clone https://github.com/samuelgursky/davinci-resolve-mcp.git
cd davinci-resolve-mcp

Create and activate a Python virtual environment:

python -m venv venv
# macOS/Linux:
source venv/bin/activate
# Windows:
venv\Scripts\activate

Install dependencies:

pip install -r requirements.txt
# Or install MCP SDK directly
pip install git+https://github.com/modelcontextprotocol/python-sdk.git

Set up scripting environment variables for DaVinci Resolve:

macOS:

export RESOLVE_SCRIPT_API="/Library/Application Support/Blackmagic Design/DaVinci Resolve/Developer/Scripting"
export RESOLVE_SCRIPT_LIB="/Applications/DaVinci Resolve/DaVinci Resolve.app/Contents/Libraries/Fusion/fusionscript.so"
export PYTHONPATH="$PYTHONPATH:$RESOLVE_SCRIPT_API/Modules/"

Windows:

set RESOLVE_SCRIPT_API=C:\ProgramData\Blackmagic Design\DaVinci Resolve\Support\Developer\Scripting
set RESOLVE_SCRIPT_LIB=C:\Program Files\Blackmagic Design\DaVinci Resolve\fusionscript.dll
set PYTHONPATH=%PYTHONPATH%;%RESOLVE_SCRIPT_API%\Modules

Alternatively, run the pre-launch check script which sets these automatically.

Configure Cursor to use the server by creating mcp.json:

macOS (~/.cursor/mcp.json):

{
  "mcpServers": {
    "davinci-resolve": {
      "name": "DaVinci Resolve MCP",
      "command": "/path/to/venv/bin/python",
      "args": ["/path/to/davinci-resolve-mcp/src/main.py"]
    }
  }
}

Windows (%APPDATA%\Cursor\mcp.json):

{
  "mcpServers": {
    "davinci-resolve": {
      "name": "DaVinci Resolve MCP",
      "command": "C:\\path\\to\\venv\\Scripts\\python.exe",
      "args": ["C:\\path\\to\\davinci-resolve-mcp\\src\\main.py"]
    }
  }
}

Start the server using client-specific scripts:

# Cursor
./scripts/mcp_resolve-cursor_start

# Claude Desktop
./scripts/mcp_resolve-claude_start

Usage with AI Assistants

Cursor

Start the Cursor server:

./scripts/mcp_resolve-cursor_start

Or with universal launcher:

./scripts/mcp_resolve_launcher.sh --start-cursor

Open Cursor and a project; interact with DaVinci Resolve via AI chat using commands such as:

"What version of DaVinci Resolve is running?"
"List all projects in DaVinci Resolve"
"Create a new timeline called 'My Sequence'"
"Add a marker at the current position"

Claude Desktop

Create a claude_desktop_config.json based on the template in config-templates.

Run the Claude server:

./scripts/mcp_resolve-claude_start

Or via universal launcher:

./scripts/mcp_resolve_launcher.sh --start-claude

Use Claude Desktop to interact with DaVinci Resolve similarly to Cursor.

Available Features

General

Get DaVinci Resolve version
Get or switch current page (Edit, Color, Fusion, etc.)

Project Management

List available projects
Get current project name
Open project by name
Create new project
Save current project

Timeline Operations

List all timelines
Get current timeline info
Create new timeline
Switch to timeline by name
Add marker to timeline

Media Pool Operations

List media pool clips
Import media file
Create media bin
Add clip to timeline

Windows Support Notes

Windows support is stable since v1.3.3:

Ensure DaVinci Resolve is installed in default location
Environment variables are set correctly
Paths adjusted for Windows installations
Check logs in the logs/ directory for issues

Troubleshooting

Ensure DaVinci Resolve is running before starting the server
Confirm all environment variables are correctly set
Verify correct DaVinci Resolve installation paths
Restart terminal after setting environment variables if necessary

Project Structure

davinci-resolve-mcp/
├── README.md
├── docs/                   # Documentation
├── config-templates/       # Configuration templates
├── scripts/                # Utility and launch scripts
├── resolve_mcp_server.py   # Main server implementation
├── src/                    # Source code modules
├── logs/                   # Log files
├── tools/                  # Development tools
├── assets/                 # Project assets
└── examples/               # Example code

License

MIT

Acknowledgments

Blackmagic Design for DaVinci Resolve and its API
The MCP protocol team for enabling AI assistant integration

Author

Samuel Gursky (samgursky@gmail.com)
GitHub: https://github.com/samuelgursky

Future Plans

Enhanced Windows and Linux support
Additional DaVinci Resolve features
Further support for Claude Desktop

Development

Contributions are welcome. Please check the feature checklist and work on unimplemented features. The codebase is modular for easy navigation.

Cursor-Specific Setup

Ensure DaVinci Resolve is running before starting Cursor.
Install dependencies:
```
pip install -r requirements.txt
```

Configure Cursor’s MCP server:

Create or edit ~/.cursor/mcp.json (macOS) or %USERPROFILE%\.cursor\mcp.json (Windows). Use absolute paths and set the command to use main.py:

{
  "mcpServers": {
    "davinci-resolve": {
      "name": "DaVinci Resolve MCP",
      "command": "/path/to/venv/bin/python",
      "args": ["/path/to/davinci-resolve-mcp/src/main.py"]
    }
  }
}

Common issues:

"Client closed" error — check paths and dependencies
Connection problems — verify DaVinci Resolve is running
Environment variables — handled by main.py

davinci-resolve-mcp

📌Overview

DaVinci Resolve MCP Server

Features

Requirements

Installation Guide

Quick Start (Recommended)

Alternative Quick Start

Platform Support

Configuration

Troubleshooting

Launch Options

Client-Specific Launch Scripts

Pre-Launch Check

Universal Launcher

Full Manual Installation

Usage with AI Assistants

Cursor

Claude Desktop

Available Features

General

Project Management

Timeline Operations

Media Pool Operations

Windows Support Notes

Troubleshooting

Project Structure

License

Acknowledgments

Author

Future Plans

Development

Cursor-Specific Setup

End of Document