Un servidor de Protocolo de Contexto de Modelo (MCP) de nivel empresarial que expone la API de scripting completa de DaVinci Resolve a asistentes de IA. Este proyecto es un fork directo de davinci-resolve-mcp de @samuelgursky, reescrito y mantenido de forma independiente.
Clientes MCP compatibles: Claude Desktop (principal), Gemini CLI, ChatGPT.
DaVinci Resolve Studio instalado y con licencia (la edición gratuita no admite scripting externo)
Python 3.10 o posterior, instalado a nivel de sistema (el instalador de python.org con "Add to PATH" e "Install for all users" seleccionados). En Windows, DaVinci Resolve localiza Python a través del registro de Windows; una instalación de Python gestionada por uv o solo para el usuario no será encontrada y provocará un error.
uv — gestor rápido de paquetes y entornos virtuales de Python
Related MCP server: DaVinci Resolve MCP Server
git clone https://github.com/Positronikal/davinci-mcp-professional.git
cd davinci-mcp-professional
uv venv
uv syncDescargue los binarios de Windows precompilados desde Releases. No requiere instalación de Python.
La versión incluye dos ejecutables:
Ejecutable | Propósito |
| Servidor MCP — iniciado automáticamente por Claude Desktop (u otro cliente MCP). Se comunica a través de stdio sin salida de consola. Úselo en su |
| CLI interactiva — para ejecutar el servidor manualmente en una terminal. Muestra un banner de inicio, comprueba que DaVinci Resolve se esté ejecutando y admite las banderas |
La mayoría de los usuarios solo necesitan davinci-mcp-server.exe configurado en su cliente MCP. davinci-mcp.exe es útil para solucionar problemas o verificar que el servidor pueda conectarse a Resolve antes de configurar un cliente.
Localice o cree su archivo claude_desktop_config.json:
Windows: %APPDATA%\Claude\claude_desktop_config.json
macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Añada la entrada del servidor:
Ejecución desde el código fuente (Windows):
{
"mcpServers": {
"davinci-resolve": {
"name": "DaVinci MCP Professional",
"command": "C:\\path\\to\\davinci-mcp-professional\\.venv\\Scripts\\python.exe",
"args": ["C:\\path\\to\\davinci-mcp-professional\\mcp_server.py"]
}
}
}Ejecución desde el código fuente (macOS):
{
"mcpServers": {
"davinci-resolve": {
"name": "DaVinci MCP Professional",
"command": "/path/to/davinci-mcp-professional/.venv/bin/python",
"args": ["/path/to/davinci-mcp-professional/mcp_server.py"]
}
}
}Uso del ejecutable independiente para Windows:
{
"mcpServers": {
"davinci-resolve": {
"name": "DaVinci MCP Professional",
"command": "C:\\path\\to\\davinci-mcp-server\\davinci-mcp-server.exe",
"args": []
}
}
}Reinicie Claude Desktop después de guardar la configuración.
Gemini CLI y ChatGPT admiten el estándar MCP y pueden conectarse a este servidor utilizando el mismo punto de entrada mcp_server.py. Su integración con MCP aún está madurando; consulte la documentación de cada cliente para conocer el método de configuración actual.
Inicie DaVinci Resolve y espere a que se cargue por completo.
Inicie el servidor MCP (Claude Desktop lo hace automáticamente cuando está configurado).
Pida a su asistente de IA que interactúe con Resolve:
What version of DaVinci Resolve is running?
List all projects in the database.
Create a new timeline called "Act 1".
Switch to the Color page.
Import /path/to/clip.mp4 into the media pool.Documento | Propósito |
Configuración para desarrolladores, instrucciones de compilación, contribución | |
Solución de problemas e informe de errores | |
Directrices de contribución | |
Licencia GPL-3.0 |
Para obtener información sobre la configuración para desarrolladores, instrucciones de compilación y directrices de contribución, consulte USING.md.
Activate a domain to make its tools available. Available domains: ai_studio, clip_properties, color_grading, media_pool, project_management, render_delivery, system_fairlight_storage, timeline_item_editing, timeline_operations. Call list_domains to see current activation status.
| Name | Required | Description | Default |
|---|---|---|---|
| domain | Yes | Domain name to activate |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure. It states the primary effect—'make its tools available'—but does not explain side effects, idempotency, whether activating one domain deactivates another, persistence, or error behavior. This is a thin disclosure for a state-changing tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and front-loaded with action and purpose, followed by a list of valid domains and a pointer to list_domains. The domain list repeats the schema enum, but it serves as a convenient inline reference without being overly verbose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is simple with a single parameter and no output schema, so the description covers the basics: what to activate, the valid domains, and how to check status. However, it leaves the activation model under-specified—particularly whether domains are mutually exclusive or cumulative—and does not mention deactivate_domain as the reverse operation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% and the schema already describes the domain parameter with an enum and 'Domain name to activate.' The description adds no meaningful semantics beyond listing the same enum values, so it does not exceed the baseline.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb and resource: 'Activate a domain to make its tools available.' It lists all valid domain values, making the tool's scope explicit, and its purpose is clearly distinct from siblings like deactivate_domain and list_domains.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit guidance to 'Call list_domains to see current activation status,' directing the agent to the appropriate sibling for checking state. It does not explicitly contrast with deactivate_domain or describe when activation is unnecessary, but the core usage context is clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Deactivate a domain to remove its tools from the active tool list.
| Name | Required | Description | Default |
|---|---|---|---|
| domain | Yes | Domain name to deactivate |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the behavioral disclosure burden. It clearly reveals the primary side effect—removing tools from the active tool list—but does not mention reversibility, whether the domain itself is deleted, or any side effects for already-active tools. This is adequate but minimally transparent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence that leads with the action and object, then provides the meaningful consequence. Every word earns its place and there is no redundant restating of schema information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
This is a simple one-parameter tool with no output schema, and the description explains what it does and what effect to expect. It is functionally sufficient for an agent to select and invoke the tool correctly, though it would be more complete if it explicitly confirmed that deactivation does not delete the domain.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the meaning of 'domain' is already fully captured in the schema. The description adds no additional meaning beyond restating that the domain name is being deactivated, so the baseline score of 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb and resource: 'Deactivate a domain' and clearly describes the intended outcome: 'remove its tools from the active tool list.' This differentiates it from sibling tools like list_domains, get_version, and switch_page, and makes activate_domain the obvious inverse.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives clear context: use this when a domain's tools should no longer appear in the active tool list. It does not explicitly name alternatives or give when-not-to-use conditions, so it stops short of full guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get the current page open in DaVinci Resolve (Edit, Color, Fusion, etc.)
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description must bear the burden. It simply states 'Get', implying a read-only operation. No mention of side effects or edge cases (e.g., if no page is open). Adequate but minimal.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence of 11 words, front-loaded with verb and resource. No unnecessary information. Highly efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple getter with no parameters or output schema, the description provides sufficient context. It could mention the return format (e.g., a string) but is adequate.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
No parameters, so schema coverage is 100%. Description adds no extra parameter info, but this is acceptable for a parameterless tool. Baseline of 4 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states the verb 'Get' and resource 'current page' with specific examples of pages (Edit, Color, Fusion). It distinguishes from sibling tools like 'switch_page'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit when-to-use or when-not-to-use guidance. The description implies its use for querying the current page, but does not mention alternatives like 'switch_page' or contexts where it might not be applicable.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get DaVinci Resolve version information
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description does not disclose any behavioral traits such as side effects, authentication needs, or limitations. It simply restates the name, adding no extra insight beyond what the tool name provides.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence with no extraneous words. It is front-loaded and efficient, earning its place without any waste.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is simple with no parameters, but the description fails to mention the return format or any error conditions. Since there is no output schema, this information would be helpful. However, the description still provides the core purpose adequately, earning a mid-range score.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has zero parameters and 100% description coverage (trivially). The description does not need to elaborate on parameters, and the baseline score of 4 is appropriate for a parameterless tool.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Get' and the resource 'DaVinci Resolve version information', making the tool's purpose immediately obvious. It effectively distinguishes itself from sibling tools which deal with projects, timelines, media, etc.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives or any context about prerequisites. While the tool is straightforward, the lack of any usage hints is a missed opportunity.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List all registered domains and their activation status. Use this to discover available domains before calling activate_domain.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden, but 'List' clearly signals a non-mutating read operation and the description tells what is returned: all registered domains with their activation status. It does not cover pagination or exact output shape, but for a zero-parameter listing tool the core behavioral surface is well disclosed.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two compact sentences: the first states the core function, the second gives practical usage guidance. There is no redundant or filler content.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple zero-parameter list operation with no output schema, the description provides the essential context: what is returned and when to invoke it. It could add detail on how activation status is represented, but nothing critical is missing for the agent to select and call this tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has no parameters and schema coverage is 100%, so there is nothing missing to explain in the description. The rubric baseline for zero parameters applies, and no parameter-specific description is necessary.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb and resource: 'List all registered domains and their activation status.' It clearly distinguishes itself from the sibling activation/deactivation tools by focusing on discovery and status rather than mutation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly says 'Use this to discover available domains before calling activate_domain,' giving a specific when-to-use instruction and referencing a dependent sibling. This tells the agent exactly when this tool is the correct choice.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Switch to a specific page in DaVinci Resolve
| Name | Required | Description | Default |
|---|---|---|---|
| page | Yes | The page to switch to |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden but only states the action without disclosing side effects (e.g., if already on the page), error conditions, or behavior beyond the basic switch.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence of 10 words with no redundant information, perfectly concise.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (one required enum parameter, no output schema), the description fully covers the necessary context for an agent to understand its purpose and usage.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema has 100% coverage with enum descriptions. The description adds no extra meaning about the page parameter beyond what schema provides, so baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'switch' and resource 'page', and specifies the context 'in DaVinci Resolve'. It distinguishes from sibling tools like 'get_current_page' which reads the current page.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives such as 'switch_timeline' or 'get_current_page'. No prerequisites or context of use are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
v4.0.0activate_domain1 field changedInput schema / properties / domain / enumPrevious value: -[
- "media_pool",
- "project_management",
- "timeline_operations"
-]New value: +[
+ "ai_studio",
+ "clip_properties",
+ "color_grading",
+ "media_pool",
+ "project_management",
+ "render_delivery",
+ "system_fairlight_storage",
+ "timeline_item_editing",
+ "timeline_operations"
+]v3.1.0activate_domaincreate_projectcreate_timelinedeactivate_domainget_current_projectget_current_timelineimport_medialist_domainslist_media_clipslist_projectslist_timelinesopen_projectswitch_timelinev0.1.0create_projectcreate_timelineget_current_pageget_current_projectget_current_timelineget_versionimport_medialist_media_clipslist_projectslist_timelinesopen_projectswitch_pageswitch_timelineScored across 6 tools
Each tool has a clearly distinct purpose: domain activation/deactivation/listing, version retrieval, and page navigation. There is no overlap or ambiguity between them.
All tools follow the snake_case verb_noun pattern consistently, making the API predictable and easy to navigate.
Six tools is well-scoped for a domain management and basic Resolve control server. Each tool serves a necessary function without bloat.
The domain lifecycle is fully covered with list, activate, and deactivate, and page navigation is complete with get and switch. Version info adds essential context. No obvious gaps.
A comprehensive Model Context Protocol (MCP) server that enables AI assistants to interact with yo…
MCP server for Clipkit — gives AI agents a video toolbox via the Clipkit schema.
A Model Context Protocol server for Wix AI tools
A comprehensive Model Context Protocol (MCP) server that enables AI assistants to control Unreal E…
