Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://github.com/samuelgursky/davinci-resolve-mcp below:

samuelgursky/davinci-resolve-mcp: MCP server integration for DaVinci Resolve

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

For a comprehensive list of implemented and planned features, see docs/FEATURES.md.

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

For detailed installation instructions, please see INSTALL.md. This guide covers:

• Prerequisites and system requirements
• Step-by-step installation process
• Configuration details
• Common troubleshooting steps

The easiest way to get started is with our new unified installation script. This script does everything automatically:

• Clone the repository:

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

• Make sure DaVinci Resolve Studio is installed and running

• Run the installation script: macOS/Linux:

  Windows:

This will:

1. Automatically detect the correct paths on your system
2. Create a Python virtual environment
3. Install the MCP SDK from the official repository
4. Set up environment variables
5. Configure Cursor/Claude integration
6. Verify the installation is correct
7. Optionally start the MCP server

You can also use the original quick start scripts:

Windows Users:

macOS Users:

chmod +x run-now.sh
./run-now.sh

For configuration of DaVinci Resolve MCP with different AI assistant clients like Cursor or Claude, see the config-templates directory.

For detailed troubleshooting guidance, refer to the INSTALL.md file which contains solutions to common issues.

• The installation scripts now use more robust path resolution, fixing issues with run-now.sh looking for files in the wrong locations
• Always let the scripts determine the correct paths based on their location

• We've improved the process detection to reliably find DaVinci Resolve regardless of how it appears in the process list
• Make sure DaVinci Resolve is running before starting the MCP server

• Make sure all required environment variables are set correctly
• Review the log file at scripts/cursor_resolve_server.log for troubleshooting

• Make sure to use forward slashes (/) in configuration files
• Python must be installed and paths configured in configs
• DaVinci Resolve must be running before starting the server

• Make sure scripts have execute permissions
• Check Console.app for any Python-related errors
• Verify environment variables are set correctly
• DaVinci Resolve must be running before starting the server

For issues and feature requests, please use the GitHub issue tracker.

After installation, you have several ways to start the server:

The repository includes dedicated scripts for launching with specific clients:

# 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

These specialized scripts:

• Set up the proper environment for each client
• Verify DaVinci Resolve is running
• Configure client-specific settings
• Start the MCP server with appropriate parameters

Before connecting AI assistants, verify your environment is properly configured:

# On macOS
./scripts/check-resolve-ready.sh

# On Windows
./scripts/check-resolve-ready.bat

These scripts will:

• Verify DaVinci Resolve is running (and offer to start it)
• Check environment variables are properly set
• Ensure the Python environment is configured correctly
• Validate Cursor/Claude configuration
• Optionally launch Cursor

For advanced users, our unified launcher provides full control over both Cursor and Claude Desktop servers:

# Make the script executable (macOS only)
chmod +x scripts/mcp_resolve_launcher.sh

# Run in interactive mode
./scripts/mcp_resolve_launcher.sh

# Or use command line options
./scripts/mcp_resolve_launcher.sh --start-cursor    # Start Cursor server (uses mcp_resolve-cursor_start)
./scripts/mcp_resolve_launcher.sh --start-claude    # Start Claude Desktop server (uses mcp_resolve-claude_start)
./scripts/mcp_resolve_launcher.sh --start-both      # Start both servers
./scripts/mcp_resolve_launcher.sh --stop-all        # Stop all running servers
./scripts/mcp_resolve_launcher.sh --status          # Show server status

Additional options:

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

For a complete manual installation:

1. Clone this repository:

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

2. Create a Python virtual environment:

   # Create virtual environment
   python -m venv venv
   
   # Activate it
   # On macOS/Linux:
   source venv/bin/activate
   # On Windows:
   venv\Scripts\activate
   
   # Install dependencies from requirements.txt
   pip install -r requirements.txt
   
   # Alternatively, install MCP SDK directly
   pip install git+https://github.com/modelcontextprotocol/python-sdk.git

3. Set up DaVinci Resolve scripting environment variables:

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

   For 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 will set these for you:

   # On macOS
   ./scripts/check-resolve-ready.sh
   
   # On Windows
   ./scripts/check-resolve-ready.bat
   

4. Configure Cursor to use the server by creating a configuration file:

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

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

   For 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"]
       }
     }
   }

5. Start the server using one of the client-specific scripts:

   # For Cursor
   ./scripts/mcp_resolve-cursor_start
   
   # For Claude Desktop
   ./scripts/mcp_resolve-claude_start

1. Start the Cursor server using the dedicated script:

   ./scripts/mcp_resolve-cursor_start

   Or use the universal launcher:

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

2. Start Cursor and open a project.

3. In Cursor's AI chat, you can now interact with DaVinci Resolve. Try commands like:

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

1. Create a claude_desktop_config.json file in your Claude Desktop configuration directory using the template in the config-templates directory.

2. Run the Claude Desktop server using the dedicated script:

   ./scripts/mcp_resolve-claude_start

   Or use the universal launcher:

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

3. In Claude Desktop, you can now interact with DaVinci Resolve using the same commands as with Cursor.

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

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

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

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

Windows support is stable in v1.3.3 and should not require additional troubleshooting:

• Ensure DaVinci Resolve is installed in the default location
• Environment variables are properly set as described above
• Windows paths may require adjustment based on your installation
• For issues, please check the logs in the logs/ directory

Make sure DaVinci Resolve is running before starting the server. If the server can't connect to Resolve, check that:

1. Your environment variables are set correctly
2. You have the correct paths for your DaVinci Resolve installation
3. You have restarted your terminal after setting environment variables

davinci-resolve-mcp/
├── README.md               # This file
├── docs/                   # Documentation
│   ├── FEATURES.md         # Feature list and status
│   ├── CHANGELOG.md        # Version history
│   ├── VERSION.md          # Version information
│   ├── TOOLS_README.md     # Tools documentation
│   ├── PROJECT_MCP_SETUP.md # Project setup guide
│   └── COMMIT_MESSAGE.txt  # Latest commit information
├── config-templates/       # Configuration templates
│   ├── sample_config.json  # Example configuration
│   ├── cursor-mcp-example.json # Cursor config example
│   └── mcp-project-template.json # MCP project template
├── scripts/                # Utility scripts
│   ├── tests/              # Test scripts
│   │   ├── benchmark_server.py # Performance tests
│   │   ├── test_improvements.py # Test scripts
│   │   ├── test_custom_timeline.py # Timeline tests
│   │   ├── create_test_timeline.py # Create test timeline
│   │   ├── test-after-restart.sh # Test after restart (Unix)
│   │   └── test-after-restart.bat # Test after restart (Windows)
│   ├── batch_automation.py # Batch automation script
│   ├── restart-server.sh   # Server restart script (Unix)
│   ├── restart-server.bat  # Server restart script (Windows)
│   ├── run-now.sh          # Quick start script (Unix)
│   └── run-now.bat         # Quick start script (Windows)
├── resolve_mcp_server.py   # Main server implementation
├── src/                    # Source code
│   ├── api/                # API implementation
│   ├── features/           # Feature modules
│   └── utils/              # Utility functions
├── logs/                   # Log files
├── tools/                  # Development tools
├── assets/                 # Project assets
└── examples/               # Example code

MIT

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

Samuel Gursky (samgursky@gmail.com)

• GitHub: github.com/samuelgursky

• Windows and Linux support
• Additional DaVinci Resolve features
• Support for Claude Desktop

If you'd like to contribute, please check the feature checklist in the repo and pick an unimplemented feature to work on. The code is structured with clear sections for different areas of functionality.

MIT

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

After cleanup, the project has the following structure:

• resolve_mcp_server.py - The main MCP server implementation
• run-now.sh - Quick start script that handles setup and runs the server
• setup.sh - Complete setup script for installation
• check-resolve-ready.sh - Pre-launch check to verify DaVinci Resolve is ready
• start-server.sh - Script to start the server
• run-server.sh - Simplified script to run the server directly

Key Directories:

• src/ - Source code and modules
• assets/ - Project assets and resources
• logs/ - Log files directory
• scripts/ - Helper scripts

When developing, it's recommended to use ./run-now.sh which sets up the environment and launches the server in one step.

See docs/CHANGELOG.md for a detailed history of changes.

When integrating with Cursor, follow these specific steps:

1. Make sure DaVinci Resolve is running before starting Cursor

2. Install required dependencies:

   # From the davinci-resolve-mcp directory:
   pip install -r requirements.txt

   Note: This will install the MCP package and other dependencies automatically.

3. Set up the MCP server configuration in Cursor:

   Create or edit ~/.cursor/mcp.json on macOS (or %USERPROFILE%\.cursor\mcp.json on Windows):

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

   Important Notes:

   • Use main.py as the entry point (not resolve_mcp_server.py)
   • Use absolute paths in the configuration

4. Common issues:

   • "Client closed" error: Check that paths are correct in mcp.json and dependencies are installed
   • Connection problems: Make sure DaVinci Resolve is running before starting Cursor
   • Environment variables: The main.py script will handle setting environment variables

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4