Resolve Claude MCP
Provides tools for controlling DaVinci Resolve Studio through its scripting API, enabling project and media pool management, timeline editing, color grading, Fusion compositing, AI-assisted features, rendering, and arbitrary Resolve Python API execution.
This server does not currently have a deployable release on Glama. Follow the repository's setup instructions to install and configure it for your MCP client, including any required credentials and local dependencies.
Resolve Claude MCP
Connect DaVinci Resolve Studio to Claude AI through the Model Context Protocol (MCP), enabling AI-assisted video editing, color grading, Fusion compositing, and more — all through natural language.
Note: This is a third-party integration and is not created by or affiliated with Blackmagic Design.
⚠️ Use at your own risk. This project is intended for testing and experimentation. Do not use in production. AI-assisted tools can modify or delete your project data — always work on backups.
Platform support: Tested only on macOS (Apple Silicon). The Blackmagic scripting API is cross-platform, so the core 48 Resolve-control tools may work on Windows and Linux as well, but this is unverified. The local transcription tools and the
screenshottool are macOS-only (they rely onmlx-whisperand macOS-specific screen-capture APIs).
Demo
Color Grading with Claude

Local Transcription & Subtitles

Related MCP server: DaVinci Resolve MCP Server
Features
Core
Direct connection to DaVinci Resolve Studio's scripting API — no addon or plugin needed inside Resolve
Project inspection and navigation across all pages (Media, Cut, Edit, Fusion, Color, Fairlight, Deliver)
Media pool management (import, organize, browse)
Timeline creation and editing
Arbitrary Python code execution with the full Resolve API
Color Grading
Node graph inspection and manipulation
LUT application
CDL (Color Decision List) adjustments
Fusion (Compositing / VFX)
Create, import, export, and manage Fusion compositions
Insert Fusion generators, titles, and blank compositions
Merge timeline items into Fusion clips
AI / DaVinci Neural Engine
Magic Mask — AI-powered subject isolation
Smart Reframe — automatic reframing for different aspect ratios
Stabilization — AI-powered clip stabilization
Scene Cut Detection — auto-detect and cut at scene boundaries
Subtitle Generation — AI speech-to-text with multi-language support
Voice Isolation — separate speech from background noise
Local Transcription (macOS / Apple Silicon only)
mlx-whisper transcription running locally on your Mac's Neural Engine / GPU
Auto-chunks long files with ffmpeg (5-min pieces) — no timeouts on hour-long clips
Returns compact timestamped transcript inline for immediate use
Saves SRT file next to source for Resolve subtitle import
Multiple model sizes: tiny (fastest) to large (most accurate), default: turbo
Windows/Linux users: these tools are unavailable (MLX is Apple-only). The other 48 tools work fine.
Screenshot (macOS only)
screenshot— captures the Resolve window so Claude can visually inspect what's on screenUses macOS
screencapture+ Quartz to target the Resolve window directlyNeeds Screen Recording permission for Claude Desktop in System Settings
Windows/Linux users: this tool is unavailable
Rendering
Browse available formats and codecs
Configure render settings
Queue and start render jobs
Monitor render progress
Code Execution
execute_resolve_code— run any Python code with the Resolve API available (resolve,project,mediaPool,timeline,mediaStoragepre-loaded)This is the power tool: anything the Resolve Python API can do, Claude can do
Architecture
Unlike BlenderMCP which requires a socket-based addon, Resolve Claude MCP connects directly to DaVinci Resolve via its native scripting API. This means a simpler, single-process architecture:
Claude AI (MCP Client)
|
v
Resolve Claude MCP Server (FastMCP)
|
v
DaVinciResolveScript (fusionscript.so)
|
v
DaVinci Resolve Studio (running)No addon to install inside Resolve. No socket server. Just one MCP server that talks directly to Resolve.
Prerequisites
DaVinci Resolve Studio 18.0+ — the free edition blocks external scripting, but it can still be driven; see Free Edition
Python 3.10+
uv package manager
Install uv:
# macOS
brew install uv
# Windows
powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"
# Linux
curl -LsSf https://astral.sh/uv/install.sh | shInstallation
Step 1: Clone this repo
git clone https://github.com/SirIdontCare/resolve-claude-mcp.git
cd resolve-claude-mcp
uv syncOriginally written by Ivo Vacca (barckley75/resolve-claude-mcp).
Note the absolute path to the folder you just cloned — you'll need it in Step 2.
Step 2: Tell Claude Desktop about this server
Claude Desktop has a settings file called claude_desktop_config.json that lists every MCP server it should launch on startup. You need to add an entry to that file so Claude Desktop knows about Resolve Claude MCP.
The file lives in your user folder (not inside the Claude app):
macOS:
~/Library/Application Support/Claude/claude_desktop_config.jsonWindows:
%APPDATA%\Claude\claude_desktop_config.json, or%LOCALAPPDATA%\Claude-Data\<package>\claude_desktop_config.jsonon the Store build of the app. If%APPDATA%\Claudeis empty, yours is the second layout — the app keeps its own settings in that file, so edit the one that is already there instead of creating the other.
Open it (or create it if it doesn't exist — these commands will create a blank file you can fill in):
# macOS — opens in TextEdit
open -e "$HOME/Library/Application Support/Claude/claude_desktop_config.json"
# Windows (PowerShell) — opens in Notepad
notepad "$env:APPDATA\Claude\claude_desktop_config.json"When the editor opens, paste in the JSON below. Replace /absolute/path/to/resolve-claude-mcp with the path to the folder you cloned in Step 1. If the file already has other MCP servers in it, just add the "resolve" block inside the existing "mcpServers" object — don't create a second "mcpServers".
{
"mcpServers": {
"resolve": {
"command": "uv",
"args": [
"--directory",
"/absolute/path/to/resolve-claude-mcp",
"run",
"resolve-claude-mcp"
],
"env": {
"RESOLVE_SCRIPT_LIB": "/Applications/DaVinci Resolve/DaVinci Resolve.app/Contents/Libraries/Fusion/fusionscript.so",
"RESOLVE_SCRIPT_API": "/Library/Application Support/Blackmagic Design/DaVinci Resolve/Developer/Scripting",
"PYTHONPATH": "/Library/Application Support/Blackmagic Design/DaVinci Resolve/Developer/Scripting/Modules/"
}
}
}
}If
uvisn't on Claude Desktop'sPATH, use the full path — find it withwhich uv(macOS/Linux) orwhere.exe uv(Windows). On macOS via Homebrew it's typically/opt/homebrew/bin/uv.
{
"mcpServers": {
"resolve": {
"command": "uv",
"args": [
"--directory",
"C:\\absolute\\path\\to\\resolve-claude-mcp",
"run",
"resolve-claude-mcp"
],
"env": {
"RESOLVE_SCRIPT_LIB": "C:\\Program Files\\Blackmagic Design\\DaVinci Resolve\\fusionscript.dll",
"RESOLVE_SCRIPT_API": "C:\\ProgramData\\Blackmagic Design\\DaVinci Resolve\\Support\\Developer\\Scripting",
"PYTHONPATH": "C:\\ProgramData\\Blackmagic Design\\DaVinci Resolve\\Support\\Developer\\Scripting\\Modules\\"
}
}
}
}If you installed Resolve on a non-default drive (e.g. D:\), update RESOLVE_SCRIPT_LIB to point at the actual location of fusionscript.dll. The RESOLVE_SCRIPT_API / PYTHONPATH paths stay under C:\ProgramData\ regardless of where Resolve itself was installed.
{
"mcpServers": {
"resolve": {
"command": "uv",
"args": [
"--directory",
"/absolute/path/to/resolve-claude-mcp",
"run",
"resolve-claude-mcp"
],
"env": {
"RESOLVE_SCRIPT_LIB": "/opt/resolve/libs/Fusion/fusionscript.so",
"RESOLVE_SCRIPT_API": "/opt/resolve/Developer/Scripting",
"PYTHONPATH": "/opt/resolve/Developer/Scripting/Modules/"
}
}
}
}Step 3: Enable Scripting in Resolve
Open DaVinci Resolve Studio
Go to Preferences > General
Under External scripting using, select Local (or Network if running remotely)
Step 4: Restart Claude Desktop
Quit and reopen the Claude Desktop app. You should see the Resolve Claude MCP tools available (hammer icon).
Free Edition
The free edition of DaVinci Resolve refuses scriptapp("Resolve") to any process
other than its own, so the stdio server above connects to nothing — the tools load
and every call fails. Scripting itself is not disabled, though: a script launched
from Resolve's own Scripts menu is handed a live resolve object.
So on the free edition the server runs inside Resolve, and your MCP client connects to it over HTTP.
Setup
Open
resolve-scripts/MCP Server.pyand setPROJECTto your clone of this repository (or set theRESOLVE_CLAUDE_MCP_HOMEenvironment variable).Copy it into Resolve's Utility scripts folder:
Platform
Folder
Windows
%APPDATA%\Blackmagic Design\DaVinci Resolve\Support\Fusion\Scripts\UtilitymacOS
~/Library/Application Support/Blackmagic Design/DaVinci Resolve/Fusion/Scripts/UtilityLinux
~/.local/share/DaVinciResolve/Fusion/Scripts/UtilityRegister the HTTP endpoint with your MCP client instead of the stdio command:
{ "mcpServers": { "resolve": { "type": "http", "url": "http://127.0.0.1:8765/mcp" } } }
Each session
Open a project, then run Workspace > Scripts > MCP Server. The script does not
return — it serves until you stop it, and it writes mcp_server.log next to itself
recording the pid, the detected product and version, and the endpoint.
Trade-offs against the Studio route:
One launch per Resolve session; the server dies with Resolve.
Resolve must stay open, as it already must for Studio.
RESOLVE_SCRIPT_API/RESOLVE_SCRIPT_LIBare irrelevant here — nothing is imported from Blackmagic's scripting module.
Every tool works unchanged. Only the way ResolveConnection acquires the resolve
object is swapped, and that is the one thing the free edition denies.
Using it from Claude chat
The HTTP endpoint serves Claude Code sessions as soon as it is registered, but a
Code session is not the chat side of the desktop app. The chat side ignores
~/.claude.json; it does read claude_desktop_config.json, and a stdio server
listed there is announced to the whole app, chat included.
chat-extension/ holds the piece that bridges the gap: a
stdlib-only stdio-to-HTTP proxy, so it carries no dependencies.
Add it to the same config file as Step 2 and restart the app:
"mcpServers": {
"davinci-resolve": {
"command": "C:\\path\\to\\python.exe",
"args": ["C:\\path\\to\\resolve-claude-mcp\\chat-extension\\server\\bridge.py"]
}
}Give the interpreter by its full path — the app does not inherit your shell's
PATH. The config file is read at startup, so quit the app completely, tray icon
included, rather than opening a new chat. Verified with desktop app 4.4212 on
Windows: the log then says [localMcpBridge] announcing davinci-resolve: 53 tool(s) beside the installed extensions.
The same bridge also packages as a .mcpb extension, if you would rather see it
listed under Extensions:
python chat-extension/build.pyThen Settings → Extensions → Advanced settings → Install extension, and pick
chat-extension/dist/davinci-resolve.mcpb.
Either way the bridge inherits the same requirement as everything else here:
launch Workspace → Scripts → MCP Server in Resolve first. With the server
down, the bridge fails to start and says so in its log rather than loading with
no tools. Point it elsewhere with RESOLVE_MCP_URL if you changed the port.
Why there is no click-free version
Resolve's internal script server is not running between script launches. Resolve
passes the connection to its child as fuscript.exe -q -l Py3 -a <handle> <script>,
where -a is an inherited handle rather than a port, so the invocation cannot be
reproduced from outside. fuscript -p finds no script app to attach to either.
Usage
Make sure DaVinci Resolve Studio is running with a project open, then talk to Claude:
Project & Navigation
"What project do I have open?"
"Switch to the Color page"
"How many timelines are in this project?"
Media & Timeline
"Import all the .mp4 files from ~/Videos/project/ into the media pool"
"Create a new timeline called 'Rough Cut'"
"What clips are on video track 1?"
"Add a red marker at frame 200 called 'Fix audio here'"
Color Grading
"Show me the node graph for the first clip"
"Apply this LUT to node 1: /path/to/my.cube"
"Set CDL values: increase slope to 1.2 and reduce saturation to 0.8"
AI Features
"Run scene cut detection on the timeline"
"Apply Smart Reframe to the first clip"
"Create a Magic Mask on clip 3 to isolate the subject"
"Generate subtitles from the audio in English"
"Enable Voice Isolation on audio track 1"
"Stabilize the second clip on video track 1"
Transcription
"Transcribe ~/Videos/interview.mp4"
"Transcribe this clip in French using the large model"
"Export an SRT file from ~/Videos/podcast.wav to ~/Desktop/podcast.srt"
"Transcribe the audio and add subtitle markers to the timeline"
Fusion
"List all Fusion compositions on the first clip"
"Add a Fusion composition to clip 2"
"Insert a Fusion title into the timeline"
Rendering
"What render formats are available?"
"Set up a render to ProRes 422 HQ, output to ~/Desktop/exports"
"Add a render job and start rendering"
"What's the render progress?"
Power Tool
"Run this code: print(project.GetSetting('timelineFrameRate'))"
Keeping grades across a timeline rebuild
If you cut outside Resolve and bring the edit in as FCPXML, EDL or AAF, every
re-import hands you fresh timeline items with no grade on them. tools/grades.py
lifts the grades out beforehand and puts them back afterwards:
python tools/grades.py save --out grades # before re-importing
# ... rebuild the timeline ...
python tools/grades.py apply --from grades # aftersave writes one .drx per clip plus a grades.json manifest. apply matches
each clip on the rebuilt timeline against that manifest by source file — not by
position — so clips may move, be retrimmed or be reordered. Clips that are new
get no grade and are listed by name; clips whose source is ambiguous are
reported rather than guessed at.
It needs the Free Edition server from the section above to be running, and
--url if it is not on the default port. On a 64-clip timeline, save takes
about 30 seconds (it parks the playhead on each clip in turn and checks it
landed there before grabbing) and apply about 3 seconds.
Two things worth knowing:
Resolve has no
GetCDL, so a grade cannot be read back as numbers. This goes through gallery stills instead, which carry the whole node tree, so it preserves more than lift/gamma/gain. The stills it grabs are deleted again, leaving the gallery as it was.Drop-frame timecode is not supported;
savesays so and stops rather than grabbing the wrong frames.
Available Tools (52)
Category | Tools |
Project & Navigation |
|
Media Pool |
|
Timeline |
|
Item Properties |
|
Color Grading |
|
Rendering |
|
AI / Neural Engine |
|
Audio |
|
Fusion |
|
Export |
|
Thumbnail |
|
Local Transcription (macOS only) |
|
Screenshot (macOS only) |
|
Code Execution |
|
Troubleshooting
"Could not connect to DaVinci Resolve"
Make sure DaVinci Resolve Studio is running
Check that scripting is enabled in Preferences > General > External scripting using
Verify the
RESOLVE_SCRIPT_LIBpath matches your installationOn the free edition this always fails for the stdio server — use the Free Edition route instead
Free-edition server won't start
Launch it from Workspace > Scripts, not a terminal: outside Resolve there is no
resolveobject to borrow, and the script exits saying soRead
mcp_server.lognext to the script — it records the exact failureIf it reports no virtualenv, fix
PROJECTat the top of the script, thenuv sync
"Failed to import DaVinciResolveScript"
Check that
PYTHONPATHin the config points to the correct Modules directoryOn macOS, the default path is
/Library/Application Support/Blackmagic Design/DaVinci Resolve/Developer/Scripting/Modules/
"No active timeline"
Open a project and make sure a timeline is loaded before using timeline tools
Tools not appearing in Claude Desktop
Make sure
uvis installed:uv --versionRestart Claude Desktop after editing
claude_desktop_config.jsonCheck the Claude Desktop logs for MCP server errors
Important Notes
DaVinci Resolve Studio is required for the stdio server. The free edition blocks external scripting, so it needs the Free Edition route, which trades a per-session launch for the same tool set.
execute_resolve_coderuns arbitrary Python — review code before executing.Some tools require being on a specific page (e.g., thumbnails require the Color page).
The server connects to whichever project is currently open — switching projects in Resolve is reflected immediately.
Disclaimer
USE AT YOUR OWN RISK. This software is provided "as is", without warranty of any kind, express or implied. By using Resolve Claude MCP you acknowledge and accept that:
This is an unofficial, third-party project — not created by, affiliated with, endorsed by, or supported by Blackmagic Design or Anthropic.
It is designed to control DaVinci Resolve Studio through an AI assistant. AI agents can make mistakes: they may modify, overwrite, or delete your projects, timelines, clips, render queues, or files on disk.
The
execute_resolve_codetool executes arbitrary Python code with full access to the Resolve API and your filesystem. Inspect code before allowing execution.The
screenshottool captures the DaVinci Resolve window (or the full screen as a fallback). These images are sent to the AI provider (Anthropic) for analysis. Anything visible in the screenshot — client footage, unreleased material, personal content, notifications, passwords, other apps in the background — may be transmitted. Only use it when you're comfortable with what's on screen, and be aware of your NDAs and privacy obligations.Always work on a backup of your project. Save often. Use Resolve's built-in project backups (Project Manager → right-click → Backups). Keep media outside the project folder if it matters to you.
The authors and contributors accept no liability for lost work, corrupted projects, missed deadlines, wasted render time, accidental uploads/exports, API charges, or any other damages arising from use of this software.
You are responsible for reviewing what the AI is about to do before approving tool calls in your MCP client.
If this is production work on a client project, don't let the AI drive unsupervised. Watch the tool calls, keep backups, render proofs.
License
MIT — see LICENSE. The MIT license specifically disclaims all warranties and liability; the Disclaimer section above restates that in plain English.
Acknowledgments
Inspired by BlenderMCP by Siddharth Ahuja.
Built with the Model Context Protocol by Anthropic.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
This server cannot be deployed
Maintenance
Related MCP Connectors
The agentic video editor for ChatGPT and Claude. Ask in your chat and it cuts, captions, adds music, titles and motion graphics on a real timeline you can open and adjust.
Use AI models for chat, image, and video generation from Claude Code and other MCP hosts.
A film studio inside your own Claude: your Claude plans, writes, makes, checks and finishes films, pictures, voices and music with you, on your own provider keys.
Connect ChatGPT and Claude to your Mac, Windows or Linux with secure MCP remote access.
Related MCP Servers
- FlicenseCqualityDmaintenanceA Model Context Protocol server that enables AI assistants like Claude to interact with DaVinci Resolve Studio, providing advanced control over editing, color grading, audio, and other video production tasks.3222-
- AlicenseAqualityDmaintenanceAllows AI assistants like Claude to directly interact with and control DaVinci Resolve through the Model Context Protocol, providing capabilities for project management, timeline manipulation, media management, and Fusion integration.1481MIT
- AlicenseNot gradedqualityDmaintenanceConnects AI coding assistants (Cursor, Claude Desktop) to DaVinci Resolve, enabling control of video editing workflows through natural language commands for project management, timeline operations, and media pool tasks.MIT
- AlicenseBqualityDmaintenanceConnects DaVinci Resolve Studio to Claude AI via the Model Context Protocol, enabling natural language control over video editing, color grading, Fusion compositing, AI features, and more.53399MIT