DaVinci Resolve

Permite que assistentes de IA interajam com o DaVinci Resolve Studio para controle avançado sobre edição de vídeo, correção de cores e áudio.

GitHub

Documentação

DaVinci Resolve MCP Server

Controle o DaVinci Resolve Studio a partir de clientes MCP, como o Claude Desktop.

Este projeto expõe projetos, linhas do tempo, mídia, Fusion, cor, áudio, reprodução e operações de renderização do Resolve por meio de um servidor local de Model Context Protocol.

O que ele faz

O servidor fornece:

32 ferramentas MCP para edição e controle do Resolve;
6 recursos MCP somente leitura que descrevem o estado atual do Resolve;
descoberta automática da API de script do DaVinci Resolve no Windows, macOS e Linux;
uma sonda de módulo nativo protegida, para que uma importação quebrada de fusionscript não derrube o servidor MCP;
isolamento de runtime do Windows para impedir que o Resolve carregue uma DLL Python incompatível.

Exemplos de solicitações de um cliente MCP:

Crie um projeto chamado “Product Launch”.

Importe esses três clipes e crie uma linha do tempo chamada “Rough Cut”.

Adicione um marcador azul no quadro 240 com a nota “Review transition”.

Salve a classificação atual como um still no álbum “Approved Looks”.

Requisitos

DaVinci Resolve Studio 18 ou mais recente. O script externo deve estar habilitado.
CPython 3.10 ou 3.11 de 64 bits. O módulo de script do Resolve ainda importa imp, que foi removido do Python 3.12.
A API de script do DaVinci Resolve instalada com o Resolve.
Um cliente MCP, como o Claude Desktop.

Antes de iniciar o servidor, abra o Resolve e defina:

Preferences → System → General → External scripting using → Local

A edição gratuita do Resolve não expõe a conexão de script externo usada por este servidor. O processo MCP pode iniciar, mas permanecerá desconectado.

Instalação

Clone o repositório primeiro:

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

Windows

Use um Python 64 bits comum do python.org. Não use um Python autônomo gerenciado por uv no Windows: sabe-se que o fusionscript.dll do Resolve falha com essas versões.

Instale o Python 3.10:

winget install --id Python.Python.3.10 -e

Crie o ambiente e instale as dependências:

& "$env:LOCALAPPDATA\Programs\Python\Python310\python.exe" -m venv .venv310
.\.venv310\Scripts\python.exe -m pip install --upgrade pip
.\.venv310\Scripts\python.exe -m pip install -e .

Inicie o servidor por meio do launcher do Windows:

.\run_server.ps1

Sempre use run_server.ps1 no Windows. Ele fixa o Resolve no runtime Python correto, isola PATH e configura os caminhos da API de script antes de iniciar o servidor.

macOS

Crie um ambiente virtual com CPython 3.10 ou 3.11:

python3.11 -m venv .venv
./.venv/bin/python -m pip install --upgrade pip
./.venv/bin/python -m pip install -e .

Inicie o servidor:

./.venv/bin/davinci-resolve-mcp

Os locais padrão da API do Resolve são detectados automaticamente:

/Library/Application Support/Blackmagic Design/DaVinci Resolve/Developer/Scripting/Modules
~/Library/Application Support/Blackmagic Design/DaVinci Resolve/Developer/Scripting/Modules

Tanto Macs Intel quanto Apple Silicon usam os mesmos caminhos de aplicativo e script do Resolve.

Linux

Crie o ambiente e instale as dependências:

python3.11 -m venv .venv
./.venv/bin/python -m pip install --upgrade pip
./.venv/bin/python -m pip install -e .
./.venv/bin/davinci-resolve-mcp

O caminho padrão de script no Linux é /opt/resolve/Developer/Scripting/Modules.

Se você usar uv como instalador, aponte explicitamente para um ambiente CPython compatível existente:

uv pip install --python .venv/bin/python -e .

No Windows, continue usando o ambiente python.org comum e run_server.ps1; não deixe o uv provisionar um runtime Python autônomo.

Configuração do cliente MCP

O servidor usa o transporte padrão de E/S do MCP. Configure seu cliente para iniciar o servidor como um processo local.

Claude Desktop no Windows

Edite %APPDATA%\Claude\claude_desktop_config.json:

{
  "mcpServers": {
    "davinci-resolve": {
      "command": "powershell",
      "args": [
        "-NoProfile",
        "-ExecutionPolicy",
        "Bypass",
        "-File",
        "C:\\absolute\\path\\to\\davinci-resolve-mcp\\run_server.ps1"
      ]
    }
  }
}

Claude Desktop no macOS

Edite ~/Library/Application Support/Claude/claude_desktop_config.json:

{
  "mcpServers": {
    "davinci-resolve": {
      "command": "/absolute/path/to/davinci-resolve-mcp/.venv/bin/davinci-resolve-mcp",
      "args": []
    }
  }
}

Outros clientes MCP

Use os mesmos pares de comando e argumento mostrados acima:

Windows: powershell -NoProfile -ExecutionPolicy Bypass -File <run_server.ps1>
macOS/Linux: <venv>/bin/davinci-resolve-mcp

Use caminhos absolutos. Mantenha o Resolve em execução, reinicie o cliente MCP após alterar a configuração e verifique se as ferramentas davinci-resolve estão disponíveis.

Recursos MCP disponíveis

URI	Descrição
`system://status`	Status da conexão, do projeto e da linha do tempo
`project://current`	Nome do projeto atual e contagem de linhas do tempo
`timeline://current`	Nome, duração e contagem de trilhas de vídeo da linha do tempo atual
`timeline://items`	Itens na primeira trilha de vídeo
`mediapool://current`	Pasta atual do pool de mídia e contagem de clipes
`gallery://albums`	Nomes dos álbuns da galeria

Ferramentas MCP disponíveis

Projetos e navegação

Ferramenta	Operação
`refresh`	Atualizar objetos em cache do Resolve
`create_project`	Criar um projeto
`load_project`	Abrir um projeto existente
`save_project`	Salvar o projeto atual
`export_project`	Exportar um projeto para um arquivo
`import_project`	Importar um arquivo de projeto
`set_project_setting`	Alterar uma configuração do projeto
`open_page`	Abrir Media, Edit, Fusion, Color, Fairlight ou Deliver

Mídia e linhas do tempo

Ferramenta	Operação
`import_media`	Importar arquivos para o pool de mídia
`add_sub_folder`	Adicionar uma subpasta ao pool de mídia
`create_timeline`	Criar uma linha do tempo vazia
`set_current_timeline`	Selecionar uma linha do tempo pelo índice baseado em 1
`append_to_timeline`	Anexar clipes nomeados
`create_timeline_from_clips`	Construir uma linha do tempo a partir de clipes nomeados
`import_timeline_from_file`	Importar uma linha do tempo, como XML ou EDL
`set_clip_property`	Alterar uma propriedade de clipe da linha do tempo
`add_timeline_marker`	Adicionar um marcador em um quadro
`add_track`	Adicionar uma trilha de vídeo, áudio ou legenda
`set_track_name`	Renomear uma trilha
`enable_track`	Habilitar ou desabilitar uma trilha
`set_current_version`	Selecionar uma versão de clipe de cor ou Fusion

Fusion e cor

Ferramenta	Operação
`execute_lua`	Executar Lua no ambiente Fusion do Resolve
`create_fusion_node`	Adicionar um nó à composição Fusion atual
`add_color_node`	Adicionar um nó de cor ao clipe atual
`save_still`	Salvar a classificação atual em um álbum da galeria
`apply_still`	Aplicar um still nomeado a um clipe

execute_lua executa código dentro do Resolve. Execute apenas scripts de fontes confiáveis.

Áudio, reprodução e renderização

Ferramenta	Operação
`set_audio_volume`	Definir o volume de áudio de um clipe nomeado
`set_track_volume`	Definir o volume de uma trilha de áudio
`play_timeline`	Iniciar reprodução
`stop_timeline`	Parar reprodução
`set_playhead_position`	Mover o cursor de reprodução para um quadro
`start_project_render`	Iniciar uma renderização com um preset e caminho de saída opcionais

Como funciona a inicialização da conexão

server.py importa resolve_env.py antes de criar ResolveAPI.

Em todas as plataformas, a inicialização:

seleciona os caminhos da API de script do Resolve e da biblioteca nativa;
propaga o diretório Modules selecionado para processos filhos;
testa DaVinciResolveScript em um subprocesso descartável;
importa a biblioteca nativa no processo MCP somente quando a sonda sai com segurança.

No Windows, o Resolve pode, de outra forma, selecionar um runtime Python do registro do Windows e carregar um python3xx.dll estranho no processo atual. FUSION_PYTHON3_HOME, o pré-carregamento de DLL e o launcher isolado evitam essa falha nativa.

Substituições de ambiente

Os padrões funcionam para instalações padrão do Resolve. Para uma instalação personalizada, defina estas variáveis antes de iniciar o servidor:

Variável	Finalidade
`RESOLVE_SCRIPT_PATH`	Diretório que contém `DaVinciResolveScript.py`
`RESOLVE_SCRIPT_API`	Raiz do diretório `Developer/Scripting` do Resolve
`RESOLVE_SCRIPT_LIB`	Caminho absoluto para `fusionscript.dll` ou `fusionscript.so`
`FUSION_PYTHON3_HOME`	Runtime Python do Windows que o Resolve deve carregar

Exemplo:

export RESOLVE_SCRIPT_PATH="/custom/Developer/Scripting/Modules"
export RESOLVE_SCRIPT_API="/custom/Developer/Scripting"
export RESOLVE_SCRIPT_LIB="/custom/Fusion/fusionscript.so"
./.venv/bin/davinci-resolve-mcp

Solução de problemas

O servidor inicia, mas não está conectado

Confirme que o DaVinci Resolve Studio está em execução.
Defina External scripting using como Local e reinicie o Resolve.
Confirme que o Python configurado é a versão 3.10 ou 3.11.
Verifique se o diretório Modules de script do Resolve existe.

O servidor permanece intencionalmente disponível em um estado desconectado quando não consegue inicializar o Resolve.

`scriptapp('Resolve') returned None`

O módulo nativo foi carregado, mas não foi possível obter um objeto Resolve em execução. O Resolve está fechado, o script externo está desabilitado ou a edição instalada não suporta script externo.

`ModuleNotFoundError: No module named 'imp'`

Está sendo usado Python 3.12 ou mais recente. Recrie o ambiente virtual com Python 3.10 ou 3.11.

Violação de acesso no Windows `0xC0000005`

Inicie o projeto por meio de run_server.ps1, não com python server.py.

A falha ocorre quando fusionscript.dll carrega um runtime Python incompatível, geralmente de outra instalação python.org ou Anaconda registrada na máquina. O launcher define FUSION_PYTHON3_HOME e isola a resolução de DLL.

`No valid Resolve scripting module path found`

Defina RESOLVE_SCRIPT_PATH para o diretório que contém DaVinciResolveScript.py. Se a biblioteca nativa também estiver em um local não padrão, defina RESOLVE_SCRIPT_LIB.

Dependências MCP ausentes

Instale o projeto no mesmo interpretador configurado no cliente MCP:

python -m pip install -e .

Desenvolvimento

Instale o projeto em modo editável:

python -m pip install -e .

Execute os testes unitários:

python -m unittest discover -s tests -v

Execute verificações de sintaxe:

python -m py_compile server.py resolve_api.py resolve_env.py

O fluxo de trabalho do GitHub Actions executa os testes unitários em Python 3.10 e 3.11 no Windows, macOS e Linux.

As contribuições devem manter o comportamento de inicialização específico da plataforma coberto por testes.