🎬 DaVinci Director MCP

The Autonomous AI Video Director & Editor for DaVinci Resolve
Rhythm-synced cuts, algorithmic 3D LUT color grading, and hands-free Option C hybrid editing for Claude, Claude Code, Cursor, VS Code (Cline/Roo), OpenAI Codex, Antigravity, and any Model Context Protocol (MCP) client.

⚡ Why DaVinci Director? (Feature Matrix)

Most existing DaVinci Resolve MCP servers are simple 1:1 API wrappers around Blackmagic's official Python API (DaVinciResolveScript). They fail completely on DaVinci Resolve Free (which locks external socket scripting behind the Studio paywall) and have zero creative editing intelligence.

DaVinci Director introduces Option C (The Autonomous Hybrid): combining background API operations with Win32 ghost input, mathematical 3D LUT generation, and FCP 7 XML timeline synthesis.

Related MCP server: unofficial-davinci-mcp

🧠 Core Architecture (Option C: The Autonomous Hybrid)

┌────────────────────────────────────────────────────────────────────────────────────────┐
│               AI Clients (Claude Desktop, Claude Code, Cursor, VS Code, Antigravity)    │
└───────────────────────────────────────────┬────────────────────────────────────────────┘
                                            │ MCP Protocol (stdio / JSON-RPC)
                                            ▼
┌────────────────────────────────────────────────────────────────────────────────────────┐
│                               DaVinci Director MCP Server                              │
├───────────────────────┬────────────────────────┬───────────────────────────────────────┤
│  🎵 Audio Beat Finder │  🎨 3D Color Engine    │  💥 Dynamic Framing & Transitions     │
│  (BPM, Flux, Drops)   │  (.cube LUTs, ASC CDL) │  (Punch-in Zooms, Flash Transitions)  │
├───────────────────────┴────────────────────────┴───────────────────────────────────────┤
│                    ⚡ Smart Media Ingestion & Transcoder                                │
│                    (NVENC / VideoToolbox / CPU HEVC -> H.264 & HEIC -> JPG)            │
└───────────────────────────────────────────┬────────────────────────────────────────────┘
                                            │
                    ┌───────────────────────┴───────────────────────┐
                    ▼                                               ▼
┌───────────────────────────────────────┐       ┌───────────────────────────────────────┐
│   Native Support/LUT/Antigravity/     │       │   DaVinci Resolve 19 / 21 Engine      │
│   (Real-Time LUT System Directory)    │       │   (Timeline, Inspector, Color Page)   │
└───────────────────────────────────────┘       └───────────────────────────────────────┘

🚀 Key Superpowers

1. 🎵 Audio Beat & Rhythm Finder

• Evaluates spectral energy flux and autocorrelation across 65–175 BPM.

• Generates frame-accurate cut schedules:

  • rapid: 1-beat cuts for intense montage drops.

  • standard: 2-beat cuts (half-bars) for balanced pacing.

  • bars: 4-beat cuts for thematic scene transitions.

• Injects DaVinci timeline markers (cyan for downbeats, green for rhythm).

2. 🎨 Autonomous 3D LUT Color Engine

• Synthesizes mathematical $33 \times 33 \times 33$ .cube 3D LUT files and installs them directly into DaVinci Resolve's native directory:

  • Windows: %PROGRAMDATA%\Blackmagic Design\DaVinci Resolve\Support\LUT\Antigravity\

  • macOS: /Library/Application Support/Blackmagic Design/DaVinci Resolve/LUT/Antigravity/

  • Linux: /opt/resolve/LUT/Antigravity/

• Built-in Hollywood look profiles:

  • comic_noir: Spider-Man Comic Noir, deep crushed blacks, crimson/amber accents.

  • kodak_2383: Classic 2383 film print emulation, warm skin tones, teal shadows.

  • bleach_bypass: Gritty silver retention, 40% desaturation, crisp specular highlights.

  • cyberpunk_neon: Electric cyan & hot magenta split toning with deep navy shadows.

  • clean_commercial: Punchy vibrant commercial grade with neutral whites.

• Injects ASC CDL parameters (Slope, Offset, Power, Saturation) directly into timeline clips.

3. 💥 Dynamic Framing & Scene Effects

• Alternating sub-pixel camera punch-in scaling (100%, 118%, 108%, 125%, 130%) to eliminate static shots on vertical reels.

• Automatically schedules impact flash transitions (Dip to White) on major drops and Cross Dissolve on phrase boundaries.

4. ⚡ Hardware-Accelerated Ingest

• Automatically transcodes iPhone 10-bit HEVC (hvc1) footage (which shows as audio-only in DaVinci Free) into 8-bit Rec.709 H.264 using NVIDIA NVENC, Apple Silicon VideoToolbox, or CPU fallback.

• Converts Apple .heic photos to full-resolution JPEG.

📦 Installation

# Clone the repository
git clone https://github.com/kashyaprahul12659/davinci-director-mcp.git
cd davinci-director-mcp

# Install dependencies in editable mode
pip install -e .

Or run directly with uvx:

uvx --from . davinci-director

🛠️ Step-by-Step Setup Guide for Any AI Tool

1. 🤖 Claude Desktop (macOS & Windows)

Open your Claude Desktop configuration file:

• macOS: ~/Library/Application Support/Claude/claude_desktop_config.json

• Windows: %APPDATA%\Claude\claude_desktop_config.json

Add the davinci-director server:

{
  "mcpServers": {
    "davinci-director": {
      "command": "python",
      "args": ["-m", "davinci_director.server"]
    }
  }
}

(If using a virtual environment, replace "python" with the absolute path to your venv's python executable).

2. 💻 Claude Code (Anthropic Official CLI)

Add the server with a single terminal command:

claude mcp add davinci-director -- python -m davinci_director.server

To verify:

claude mcp list

3. ⚡ Cursor IDE

1. Open Cursor and go to Settings (Ctrl+, or Cmd+,).

2. Navigate to Features > MCP Servers.

3. Click Add New MCP Server.

4. Fill in:

   • Name: davinci-director

   • Type: command

   • Command: python -m davinci_director.server

Or add directly to .cursor/mcp.json:

{
  "mcpServers": {
    "davinci-director": {
      "command": "python",
      "args": ["-m", "davinci_director.server"]
    }
  }
}

4. 📝 VS Code (Cline / Roo Code / Continue.dev)

Using Cline or Roo Code extension:

1. Open VS Code and click the Cline / Roo Code robot icon in the sidebar.

2. Click the MCP Servers (network/plugs) icon at the top.

3. Click Configure MCP Servers (or open cline_mcp_settings.json).

4. Paste the configuration:

{
  "mcpServers": {
    "davinci-director": {
      "command": "python",
      "args": ["-m", "davinci_director.server"],
      "disabled": false,
      "autoApprove": []
    }
  }
}

Using Continue.dev extension:

In ~/.continue/config.json:

{
  "experimental": {
    "modelContextProtocolServers": [
      {
        "transport": {
          "type": "stdio",
          "command": "python",
          "args": ["-m", "davinci_director.server"]
        }
      }
    ]
  }
}

5. 🪐 Google Antigravity

In ~/.gemini/antigravity/mcp_config.json:

{
  "mcpServers": {
    "davinci-resolve": {
      "command": "python",
      "args": ["-m", "davinci_director.server"]
    }
  }
}

6. 🌊 Windsurf / Zed Editor

Windsurf (Cascade):

In ~/.codeium/windsurf/mcp_config.json:

{
  "mcpServers": {
    "davinci-director": {
      "command": "python",
      "args": ["-m", "davinci_director.server"]
    }
  }
}

Zed Editor:

In ~/.config/zed/settings.json:

{
  "experimental.mcp_servers": {
    "davinci-director": {
      "command": "python",
      "args": ["-m", "davinci_director.server"]
    }
  }
}

7. 🧠 OpenAI Codex / Custom Python AI Agents (LangChain, LlamaIndex, LiteLLM)

You can connect any custom Python LLM agent to davinci-director using the official mcp client library:

import asyncio
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client

server_params = StdioServerParameters(
    command="python",
    args=["-m", "davinci_director.server"]
)

async def main():
    async with stdio_client(server_params) as (read, write):
        async with ClientSession(read, write) as session:
            await session.initialize()
            
            # List all 21 available tools
            tools = await session.list_tools()
            print(f"Connected! Available tools: {len(tools.tools)}")
            
            # Autonomously build a beat-synced reel!
            result = await session.call_tool(
                "davinci_build_beat_synced_reel",
                arguments={
                    "timeline_name": "My_Epic_Reel",
                    "clip_paths": ["/path/to/shot1.mp4", "/path/to/shot2.mp4"],
                    "audio_path": "/path/to/music.wav",
                    "color_preset": "comic_noir",
                    "effects_style": "comic_dynamic"
                }
            )
            print(result)

asyncio.run(main())

🧰 Available MCP Tools (21 Tools)

💬 Prompts to Try with Your AI Assistant

Once connected, you can give high-level creative instructions to your AI:

• "Analyze the beat of music.wav and tell me the BPM and where the main drops happen."

• "Create a 15-second Spider-Man comic noir style vertical reel from the footage in my folder synced to song.wav."

• "Synthesize a Kodak 2383 3D LUT and apply it to my timeline."

• "Transcode all the raw iPhone footage in my downloads folder and import it into DaVinci Resolve."

• "Play the video in fullscreen and do a razor cut at the next drop."

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.