DaVinci Resolve Interaction Nexus (MCP Server)

This software implements the Model Context Protocol (MCP) standard to establish a comprehensive command-and-control layer for DaVinci Resolve Studio, empowering intelligent assistants to manipulate nearly every aspect of post-production workflows.

Core Capabilities Overview

The system functions as a sophisticated middleware, allowing AI directives to translate directly into Resolve actions, including:

• Project Administration: Instantiating new projects, retrieving/persisting existing datasets, and managing project metadata.
• Media Asset Orchestration: Ingesting source materials into the Media Pool, organizing bins, and establishing linkage between media elements.
• Timeline Construction & Manipulation: Authoring sequential edits, adjusting track visibility/muting, modifying clip parameters (e.g., speed, transforms), and temporal synchronization.
• Visual Effects & Compositing: Interfacing directly with Fusion compositions embedded within clips or timelines for node-level manipulation.
• Color Science Workflows: Accessing the Color Page, applying/storing look presets (Stills) in the Gallery, and managing primary/secondary correction nodes.
• Auditory Processing: Fine-tuning individual clip gains, adjusting track faders, and managing overall audio synchronization.
• Presentation Control: Executing dynamic playback commands (start, stop, jump to timecode) and managing the transport scrubber position.
• Script Execution Engine: Securely running embedded Python code or Fusion-specific Lua scripts for bespoke operations.
• Final Output Management: Initiating final delivery renders and monitoring their completion status.
• UI Navigation Proxy: Programmatically switching between Resolve's distinct workspace environments (Edit, Color, Fairlight, Deliver, etc.).

Prerequisites and Runtime Environment

Operation mandates the following dependencies:

• DaVinci Resolve Studio (Version 18.0 or later is prerequisite).
• A compliant Python runtime environment (version 3.10 or higher recommended).
• Accessibility to the native DaVinci Resolve Scripting SDK.

Deployment via uv Package Manager

We endorse the use of uv—a high-performance dependency resolution tool—for setting up the execution context.

Step 1: Installing uv Utility

If uv is absent from your system environment:

bash

Standard installation via pip

pip install uv

macOS using Homebrew package manager

brew install uv

Conda ecosystem installation

conda install -c conda-forge uv

Verification:

bash uv --version

Step 2: Environment Isolation

Establish a quarantined environment to manage required Python packages:

bash uv venv source .venv/bin/activate # For Unix-like shells .venv\Scripts\activate # For Windows Command Prompt/PowerShell

Step 3: Installing the Interaction Nexus

Install the server components within the active environment:

bash

Install the package in editable mode from local source

uv install -e .

Alternative: Direct installation from a remote repository

uv install git+https://github.com/yourusername/davinci-resolve-mcp.git

Step 4: Dependency Fulfillment

Ensure all required Python libraries listed in requirements.txt (e.g., mcp, pydantic) are present:

bash uv install -r requirements.txt

Environmental Configuration Details

Prior to initiation, confirm the Resolve application is active. The system attempts automated discovery of the scripting modules, but manual intervention may be needed depending on the operating system configuration.

Scripting API Path Configuration

macOS: The modules are typically discoverable in standard locations like /Library/Application Support/Blackmagic Design/DaVinci Resolve/Developer/Scripting/Modules.

Windows: If automatic detection fails, inject the path into the Python runtime:

python import sys

Adjust this path if necessary for your installation

sys.path.append("C:\ProgramData\Blackmagic Design\DaVinci Resolve\Support\Developer\Scripting\Modules")

Linux/Unix: Set the necessary environment variable:

bash export PYTHONPATH=$PYTHONPATH:/opt/resolve/Developer/Scripting/Modules

Or specify a user-defined location

export RESOLVE_SCRIPT_PATH="/custom/path/to/scripting/modules"

Launching the MCP Service

Invoke the server process using the Python interpreter:

bash

Standard execution

python -m resolve_mcp.server

Execution managed by uv

uv run resolve_mcp/server.py

The successful startup is indicated by a log message confirming the establishment of a connection to the running DaVinci Resolve instance.

AI Assistant Integration (e.g., Claude Desktop)

For seamless integration with desktop AI clients, modify the client's configuration file (e.g., claude_desktop_config.json). The entry should define how the client launches and manages this server process:

{ "mcpServers": { "davinci-resolve": { "command": "/path/to/uv", "args": [ "run", "--directory", "/path/to/davinci-resolve-mcp", "resolve_mcp/server.py" ] } } }

Crucially, substitute the placeholder paths for your actual uv executable location and the absolute path of the project directory.

Debugging Common Failures

Connectivity Interruptions

• Verify Resolve Studio is executing.
• Ensure scripting permissions are enabled within Resolve's global preferences.
• Confirm Python version adherence (>= 3.10).
• Inspect system logs for API path resolution errors (check Claude's log directory for MCP activity records).

Dependency Resolution Failures

If runtime module errors occur:

bash uv install mcp pydantic

Version Mismatch

If Python versioning causes issues, utilize pyenv or similar tools to switch context:

bash pyenv install 3.10.12 pyenv shell 3.10.12 uv install -r requirements.txt

Functionality Reference (ResolveAPI Methods)

This server exposes a rich vocabulary of operations via the underlying ResolveAPI object:

Domain	Key Operations
Project	Creation, loading, saving, versioning (export_project, load_project, set_project_setting).
Timeline	Track administration (naming, enabling), clip manipulation, marker insertion, current timeline selection.
Media Pool	Ingesting batches of media, hierarchical folder creation, metadata extraction.
Fusion	Creating/modifying nodes within the current composition, direct node graph traversal.
Color	Node tree inspection/modification, Gallery save/recall operations across defined albums.
Audio	Precise volume control at both clip and track bus levels.
Transport	Playback control, accurate timecode reading and seeking.
Rendering	Job queuing for final output and status polling.
Scripting	Remote execution hooks for both native Python context and Fusion’s Lua sandbox.

Contribution Guidelines

To participate in development: 1. Fork the source repository. 2. Establish a dedicated feature branch. 3. Install the environment (uv install -e .). 4. Implement and validate changes. 5. Submit a formal Pull Request against the main branch.

Licensing

This utility is distributed under the terms of the MIT License.

Summary of Enhancements

• Feature Parity: Comprehensive listing of all available ResolveAPI methods, categorized for clarity.
• Deployment Refinement: Elevated uv installation instructions, including verification steps and clearer environment activation.
• Configuration Detailing: Explicit guidance for configuring the server launch parameters within external AI clients.
• Troubleshooting Depth: Expanded sections addressing path discovery and version control conflicts.