Skip to content

Latest commit

 

History

History
217 lines (155 loc) · 6.46 KB

INSTALL.md

File metadata and controls

217 lines (155 loc) · 6.46 KB

DaVinci Resolve MCP Integration - Installation Guide

This guide provides step-by-step instructions for installing and configuring the DaVinci Resolve MCP integration for use with Cursor AI. The integration allows Cursor AI to control DaVinci Resolve through its API.

Prerequisites

  • DaVinci Resolve installed (Free or Studio version)
  • Python 3.9+ installed
  • Cursor AI installed

Installation Steps

1. New One-Step Installation (Recommended)

We now provide a unified installation script that handles everything automatically, with robust error detection and configuration:

macOS/Linux:

# Make sure DaVinci Resolve is running, then:
./install.sh

Windows:

# Make sure DaVinci Resolve is running, then:
install.bat

This new installation script will:

  • Detect the correct installation path automatically
  • Create the Python virtual environment
  • Install all required dependencies
  • Set up environment variables
  • Generate the correct Cursor MCP configuration
  • Verify the installation
  • Optionally start the server if everything is correct

2. Quick Start (Alternative)

The earlier quick start scripts are still available:

macOS/Linux:

# Make sure DaVinci Resolve is already running before executing this script
./run-now.sh

Windows:

# Make sure DaVinci Resolve is already running before executing this script
run-now.bat

3. Manual Setup (Advanced)

If you prefer to set up the integration manually or if you encounter issues with the automatic methods:

Step 3.1: Create a Python Virtual Environment

python3 -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate

Step 3.2: Install Dependencies

# Install all required dependencies from requirements.txt
pip install -r requirements.txt

Alternatively, you can install just the MCP SDK:

pip install "mcp[cli]"

Step 3.3: Set Environment Variables

On macOS/Linux, add the following to your ~/.zshrc or ~/.bashrc:

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/"

On Windows, set these environment variables in PowerShell or through System Properties:

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

Step 3.4: Configure Cursor

The installation creates two MCP configuration files:

System-level configuration:

  • macOS/Linux: ~/.cursor/mcp/config.json
  • Windows: %APPDATA%\Cursor\mcp\config.json

Project-level configuration:

  • In the project root: .cursor/mcp.json

Both configurations use absolute paths to the Python interpreter and script. This ensures Cursor can find the correct files regardless of how the project is opened.

Sample configuration:

{
  "mcpServers": {
    "davinci-resolve": {
      "name": "DaVinci Resolve MCP",
      "command": "/Users/username/davinci-resolve-mcp/venv/bin/python",
      "args": ["/Users/username/davinci-resolve-mcp/resolve_mcp_server.py"]
    }
  }
}

The installation scripts automatically create both configuration files with the correct absolute paths for your system. If you need to move the project to a new location, you'll need to run the installation script again to update the paths.

4. Start the Integration

For a more controlled setup with additional options:

macOS/Linux:

# From the scripts directory
cd scripts
./mcp_resolve-cursor_start

5. Verify Your Installation

After completing the installation steps, you can verify that everything is set up correctly by running:

macOS/Linux:

./scripts/verify-installation.sh

Windows:

scripts\verify-installation.bat

This verification script checks:

  • Python virtual environment setup
  • MCP SDK installation
  • DaVinci Resolve running status
  • Cursor configuration
  • Environment variables
  • Server script presence

If all checks pass, you're ready to use the integration. If any checks fail, the script will provide guidance on how to fix the issues.

Troubleshooting

DaVinci Resolve Detection Issues

If the script cannot detect that DaVinci Resolve is running:

  1. Make sure DaVinci Resolve is actually running before executing scripts
  2. The detection method has been updated to use ps -ef | grep -i "[D]aVinci Resolve" instead of pgrep, which provides more reliable detection

Path Resolution Issues

If you see errors related to file paths:

  1. The scripts now use the directory where they're located as the reference point
  2. Check that the resolve_mcp_server.py file exists in the expected location
  3. Verify that your Cursor MCP configuration points to the correct paths
  4. If you move the project to a new location, you'll need to run the installation script again to update the paths

Environment Variables

If you encounter Python import errors:

  1. Verify that the environment variables are correctly set
  2. The paths may differ depending on your DaVinci Resolve installation location
  3. You can check the log file at scripts/cursor_resolve_server.log for details

Cursor Configuration Issues

If Cursor isn't connecting to the MCP server:

  1. Check both the system-level and project-level configuration files
  2. Ensure the paths in the configurations match your actual installation
  3. The absolute paths must be correct - verify they point to your actual installation location
  4. After moving the project, run ./install.sh or install.bat again to update the paths

Configuration Reference

The integration creates two configuration files:

  1. System-level config (for global use): ~/.cursor/mcp/config.json (macOS/Linux) or %APPDATA%\Cursor\mcp\config.json (Windows)
  2. Project-level config (for specific project use): .cursor/mcp.json in the project root

Both configurations have the same structure:

{
  "mcpServers": {
    "davinci-resolve": {
      "name": "DaVinci Resolve MCP",
      "command": "<absolute-path-to-python-interpreter>",
      "args": ["<absolute-path-to-resolve_mcp_server.py>"]
    }
  }
}

Support

If you encounter any issues not covered in this guide, please file an issue on the GitHub repository.