de en es ja ko ru zh

io.github.Airta-Admin/davinc-resolve-local-bridge-mcp

Name: io.github.Airta-Admin/davinc-resolve-local-bridge-mcp
Author: Airta-Admin

by Airta-Admin

Overview Schema Source Related Servers Discussions Admin

Python

Local

Davinc-Resolve-Local-Bridge-MCP

Was ist das?

Davinc-Resolve-Local-Bridge-MCP ist ein Model Context Protocol (MCP)-Server, der KI-Assistenten die volle Kontrolle über DaVinci Resolve gibt. Er stellt 215 Tools bereit, die die gesamte Resolve-Scripting-API abdecken — Projekte, Timelines, Medien, Fusion, Farbkorrektur, Rendering und mehr.

So funktioniert es

Your AI Assistant (Claude, Cursor, Devin, etc.)
       │
       │  talks MCP (stdio)
       ▼
  mcp_server/server.py        ← runs on your machine
       │
       │  talks HTTP (localhost:8787)
       ▼
  Bridge-Connection-Script.py ← runs INSIDE DaVinci Resolve
       │                        (Workspace > Scripts menu)
       ▼
  DaVinci Resolve API         ← full read + write access

Das Bridge-Skript läuft innerhalb des DaVinci-Resolve-Prozesses und erhält dadurch vollen Zugriff auf die Resolve-Scripting-API — sogar in der Free-Edition (die externes Scripting blockiert). Der MCP-Server läuft als separater Prozess und leitet Tool-Aufrufe über localhost-HTTP an die Bridge weiter.

Related MCP server: davinci-resolve-mcp

Schnellstart

Voraussetzungen

DaVinci Resolve 18.5+ (Free oder Studio)
Python 3.10+ auf Ihrem Rechner
Ein MCP-kompatibler KI-Assistent (Claude Desktop, Cursor, Devin usw.)

Schritt 1 — Bridge-Skript installieren

Führen Sie den Installer aus:

python install.py

Oder kopieren Sie bridge/Bridge-Connection-Script.py manuell in den Skriptordner von Resolve:

Plattform	Pfad
Windows	`%APPDATA%\Roaming\Blackmagic Design\DaVinci Resolve\Support\Fusion\Scripts\Utility\`
macOS	`~/Library/Application Support/Blackmagic Design/DaVinci Resolve/Fusion/Scripts/Utility/`
Linux	`~/.local/share/DaVinciResolve/Fusion/Scripts/Utility/`

Schritt 2 — MCP-Server-Abhängigkeiten installieren

pip install -r requirements.txt

Schritt 3 — KI-Assistent konfigurieren

Fügen Sie den MCP-Server zur Konfigurationsdatei Ihres Assistenten hinzu. Der Serverpfad ist mcp_server/server.py in diesem Repository.

Claude Desktop

Bearbeiten Sie claude_desktop_config.json:

{
  "mcpServers": {
    "davinci-resolve-local-bridge": {
      "command": "python",
      "args": ["C:/path/to/Davinc-Resolve-Local-Bridge-MCP/mcp_server/server.py"]
    }
  }
}

Cursor

Bearbeiten Sie .cursor/mcp.json:

{
  "mcpServers": {
    "davinci-resolve-local-bridge": {
      "command": "python",
      "args": ["C:/path/to/Davinc-Resolve-Local-Bridge-MCP/mcp_server/server.py"]
    }
  }
}

Devin

Bearbeiten Sie mcp_config.json:

{
  "mcpServers": {
    "resolve-local-bridge": {
      "command": "python",
      "args": ["C:/path/to/Davinc-Resolve-Local-Bridge-MCP/mcp_server/server.py"]
    }
  }
}

Claude Code

claude mcp add davinci-resolve-local-bridge -- python C:/path/to/Davinc-Resolve-Local-Bridge-MCP/mcp_server/server.py

Beliebiger MCP-Client (allgemein)

Der Server verwendet stdio-Transport. Starten Sie ihn mit:

python mcp_server/server.py

Schritt 4 — Bridge in DaVinci Resolve starten

Öffnen Sie DaVinci Resolve
Gehen Sie zu Workspace → Scripts → Bridge-Connection-Script
Suchen Sie in der Konsole (Workspace → Console) nach:

[Resolve Bridge] Connected to Resolve 21.0.4.5
[Resolve Bridge] HTTP server running on http://127.0.0.1:8787
[Resolve Bridge] 215 actions available

Schritt 5 — Loslegen

Fragen Sie Ihren KI-Assistenten:

„Prüfen Sie, ob DaVinci Resolve verbunden ist"

Der Assistent ruft das Tool resolve_status auf und meldet das Ergebnis. Versuchen Sie dann:

„Erstellen Sie ein neues 1920x1080-30fps-Projekt namens ‚My Video' und fügen Sie eine Timeline hinzu"

Architektur

Bridge-Skript (`bridge/Bridge-Connection-Script.py`)

Ein Python-Skript, das innerhalb von DaVinci Resolve über das Menü Workspace > Scripts läuft. Es:

Ruft das Live-resolve-Objekt aus den Fusion-Globals ab
Startet einen HTTP-Server auf 127.0.0.1:8787
Stellt 3 Endpunkte bereit:
- GET /health — prüft, ob die Bridge aktiv ist
- GET /actions — listet alle verfügbaren Aktionsnamen auf
- POST /action — führt eine Aktion anhand des Namens mit Parametern aus
Bleibt mit einem blockierenden serve_forever()-Aufruf aktiv
Beendet vor dem Start jede vorherige Instanz auf demselben Port

MCP-Server (`mcp_server/server.py`)

Ein eigenständiger MCP-Server, der:

über HTTP auf localhost eine Verbindung zur Bridge herstellt
automatisch alle 215 Aktionen vom /actions-Endpunkt der Bridge erkennt
jede Aktion als MCP-Tool mit dem Präfix resolve_ bereitstellt
Tool-Aufrufe über POST /action an die Bridge weiterleitet
mit der Bridge synchron bleibt — keine manuellen Tool-Definitionen erforderlich

Alle 215 Tools

Der MCP-Server erkennt Tools automatisch von der Bridge. Jedes Tool hat das Präfix resolve_ (z. B. wird aus status resolve_status). Übergeben Sie Parameter als params-Objekt.

Resolve-Anwendung (15 Tools)

Tool	Parameter	Beschreibung
`resolve_status`	—	Bridge-Verbindung prüfen und aktuelle Projekt-/Timeline-Informationen abrufen
`resolve_get_version`	—	Resolve-Versionsinformationen abrufen
`resolve_get_current_page`	—	Die aktive Seite abrufen (edit, cut, color usw.)
`resolve_open_page`	`page`	Zu einer Seite wechseln: edit, cut, fusion, color, fairlight, deliver, media
`resolve_get_layout_presets`	—	Verfügbare Layout-Voreinstellungen auflisten
`resolve_load_layout_preset`	`presetName`	Eine Layout-Voreinstellung anhand des Namens laden
`resolve_get_keyframe_mode`	—	Aktuellen Keyframe-Modus abrufen
`resolve_set_keyframe_mode`	`keyframeMode`	Keyframe-Modus festlegen
`resolve_get_fairlight_presets`	—	Fairlight-Audio-Voreinstellungen auflisten
`resolve_get_burnin_presets`	—	Burn-in-Voreinstellungen auflisten
`resolve_import_render_preset`	`presetPath`	Eine Render-Voreinstellung aus einer Datei importieren
`resolve_export_render_preset`	`presetName`, `exportPath`	Eine Render-Voreinstellung in eine Datei exportieren
`resolve_open_fusion_page`	—	Zur Fusion-Seite wechseln
`resolve_open_edit_page`	—	Zur Edit-Seite wechseln
`resolve_open_deliver_page`	—	Zur Deliver-Seite wechseln

Projektmanager (18 Tools)

Tool	Parameter	Beschreibung
`resolve_create_project`	`name`, `width`, `height`, `fps`	Ein neues Projekt erstellen
`resolve_load_project`	`name`	Ein vorhandenes Projekt laden
`resolve_save_project`	—	Das aktuelle Projekt speichern
`resolve_close_project`	—	Das aktuelle Projekt schließen
`resolve_delete_project`	`name`	Ein Projekt löschen
`resolve_create_folder`	`folderName`	Einen Projektordner erstellen
`resolve_delete_folder`	`folderName`	Einen Projektordner löschen
`resolve_get_project_list`	—	Projekte im aktuellen Ordner auflisten
`resolve_get_folder_list`	—	Unterordner im aktuellen Ordner auflisten
`resolve_get_current_folder`	—	Aktuellen Ordnernamen abrufen
`resolve_open_folder`	`folderName`	Einen Ordner öffnen
`resolve_goto_root_folder`	—	Zum Stammordner navigieren
`resolve_goto_parent_folder`	—	Zum übergeordneten Ordner navigieren
`resolve_import_project`	`filePath`, `projectName`	Ein .drp-Projekt importieren
`resolve_export_project`	`projectName`, `filePath`, `withStillsAndLUTs`	Ein Projekt als .drp exportieren
`resolve_archive_project`	`projectName`, `filePath`, ...	Ein Projekt archivieren
`resolve_get_current_database`	—	Aktuellen Datenbanknamen abrufen
`resolve_get_database_list`	—	Verfügbare Datenbanken auflisten

Projekteinstellungen (7 Tools)

Tool	Parameter	Beschreibung
`resolve_get_project_name`	—	Aktuellen Projektnamen abrufen
`resolve_set_project_name`	`name`	Das aktuelle Projekt umbenennen
`resolve_get_project_setting`	`key`	Eine Projekteinstellung anhand des Schlüssels abrufen
`resolve_set_project_setting`	`key`, `value`	Eine Projekteinstellung festlegen
`resolve_get_project_settings`	—	Alle Projekteinstellungen abrufen
`resolve_get_project_preset_list`	—	Projekt-Voreinstellungen auflisten
`resolve_set_project_preset`	`presetName`	Eine Projekt-Voreinstellung anwenden

Medienspeicher (4 Tools)

Tool	Parameter	Beschreibung
`resolve_get_mounted_volumes`	—	Gemountete Speichervolumes auflisten
`resolve_get_subfolder_list`	`folderPath`	Unterordner in einem Pfad auflisten
`resolve_get_file_list`	`folderPath`	Dateien in einem Ordner auflisten
`resolve_reveal_in_storage`	`path`	Eine Datei im Dateibrowser des Betriebssystems anzeigen

Medienpool (13 Tools)

Tool	Parameter	Beschreibung
`resolve_import_media`	`paths` (Liste)	Mediendateien in den Pool importieren
`resolve_get_media_pool`	—	Alle Clips im Stammordner auflisten
`resolve_get_root_folder`	—	Informationen zum Stammordner abrufen
`resolve_add_sub_folder`	`folderName`, `parentFolderName`	Einen Unterordner erstellen
`resolve_set_current_folder`	`folderName`	Den aktuellen Ordner festlegen
`resolve_delete_clips`	`clipNames` (Liste)	Clips aus dem Pool löschen
`resolve_move_clips`	`clipNames`, `targetFolder`	Clips in einen Ordner verschieben
`resolve_relink_clips`	`clipNames`, `folderPath`	Clips neu verknüpfen
`resolve_unlink_clips`	`clipNames`	Clips trennen
`resolve_export_metadata`	`fileName`, `clipNames`	Metadaten-CSV exportieren
`resolve_get_selected_clips`	—	Ausgewählte Clips auflisten
`resolve_set_selected_clip`	`clipName`	Einen Clip auswählen
`resolve_add_timeline_mattes`	`paths` (Liste)	Matte-Dateien hinzufügen

Timeline (21 Tools)

Tool	Parameter	Beschreibung
`resolve_create_timeline`	`name`	Neue leere Timeline erstellen
`resolve_create_timeline_from_clips`	`name`, `clipNames`	Timeline aus Clips erstellen
`resolve_list_timelines`	—	Alle Timelines auflisten
`resolve_get_timeline_name`	—	Aktuellen Timelinenamen abrufen
`resolve_set_timeline_name`	`name`	Aktuelle Timeline umbenennen
`resolve_set_current_timeline`	`timelineIndex`	Zu Timeline per Index wechseln (1-basiert)
`resolve_duplicate_timeline`	—	Aktuelle Timeline duplizieren
`resolve_delete_timelines`	`timelineNames`	Timelines löschen
`resolve_get_timeline_start_frame`	—	Startframe abrufen
`resolve_get_timeline_end_frame`	—	Endframe abrufen
`resolve_get_start_timecode`	—	Start-Timecode abrufen
`resolve_set_start_timecode`	`timecode`	Start-Timecode festlegen
`resolve_get_current_timecode`	—	Aktuellen Timecode abrufen
`resolve_set_current_timecode`	`timecode`	Aktuellen Timecode festlegen
`resolve_detect_scene_cuts`	—	Schnitte erkennen
`resolve_create_subtitles_from_audio`	`settings`	Untertitel automatisch generieren
`resolve_timeline_export`	`fileName`, `exportType`, `exportSubtype`	Timeline exportieren
`resolve_import_timeline_from_file`	`filePath`	Timeline aus Datei importieren
`resolve_append_to_timeline`	`clipNames`	Clips an Timeline anhängen
`resolve_get_timeline_setting`	`key`	Timeline-Einstellung abrufen
`resolve_set_timeline_setting`	`key`, `value`	Timeline-Einstellung festlegen

Timeline-Spuren (11 Tools)

Tool	Parameter	Beschreibung
`resolve_get_track_count`	`trackType`	Spuren zählen (Video/Audio/Untertitel)
`resolve_add_track`	`trackType`	Spur hinzufügen
`resolve_delete_track`	`trackType`, `trackIndex`	Spur löschen
`resolve_set_track_enable`	`trackType`, `trackIndex`, `enabled`	Spur aktivieren/deaktivieren
`resolve_get_track_enable`	`trackType`, `trackIndex`	Prüfen, ob Spur aktiviert ist
`resolve_set_track_lock`	`trackType`, `trackIndex`, `locked`	Spur sperren/entsperren
`resolve_get_track_lock`	`trackType`, `trackIndex`	Prüfen, ob Spur gesperrt ist
`resolve_get_track_name`	`trackType`, `trackIndex`	Spurname abrufen
`resolve_set_track_name`	`trackType`, `trackIndex`, `name`	Spurname festlegen
`resolve_get_items_in_track`	`trackType`, `index`	Clips auf einer Spur auflisten
`resolve_get_timeline_selected_clips`	—	Ausgewählte Timeline-Clips auflisten

Timeline-Elemente (66 Tools)

Alle Elementaktionen akzeptieren optionale trackType, trackIndex, itemIndex, um einen bestimmten Clip anzusteuern, oder arbeiten auf dem ersten ausgewählten Clip, wenn diese weggelassen werden.

Tool	Parameter	Beschreibung
`resolve_get_item_name`	`trackType?`, `trackIndex?`, `itemIndex?`	Clipnamen abrufen
`resolve_set_item_name`	`name`, `trackType?`, ...	Clip umbenennen
`resolve_get_item_duration`	`trackType?`, ...	Clipdauer abrufen
`resolve_get_item_start`	`trackType?`, ...	Startframe des Clips abrufen
`resolve_get_item_end`	`trackType?`, ...	Endframe des Clips abrufen
`resolve_get_item_property`	`key?`, `trackType?`, ...	Eine Clipeigenschaft abrufen
`resolve_set_item_property`	`key`, `value`, `trackType?`, ...	Eine Clipeigenschaft festlegen
`resolve_get_item_enabled`	`trackType?`, ...	Prüfen, ob Clip aktiviert ist
`resolve_set_item_enabled`	`enabled`, `trackType?`, ...	Clip aktivieren/deaktivieren
`resolve_set_item_color`	`colorName`, `trackType?`, ...	Clipfarbe festlegen
`resolve_get_item_color`	`trackType?`, ...	Clipfarbe abrufen
`resolve_clear_item_color`	`trackType?`, ...	Clipfarbe löschen
`resolve_add_item_flag`	`color`, `trackType?`, ...	Flag hinzufügen
`resolve_get_item_flags`	`trackType?`, ...	Flags abrufen
`resolve_clear_item_flags`	`color`, `trackType?`, ...	Flags löschen
`resolve_add_item_marker`	`frameId`, `color`, `name`, `note?`, ...	Marker hinzufügen
`resolve_get_item_markers`	`trackType?`, ...	Marker abrufen
`resolve_insert_generator`	`generatorName`	Generator einfügen
`resolve_insert_fusion_generator`	`generatorName`	Fusion-Generator einfügen
`resolve_insert_fusion_composition`	—	Fusion-Komposition einfügen
`resolve_insert_ofx_generator`	`generatorName`	OFX-Generator einfügen
`resolve_insert_title`	`titleName`	Titel einfügen
`resolve_insert_fusion_title`	`titleName`	Fusion-Titel einfügen
`resolve_grab_still`	—	Standbild vom aktuellen Frame aufnehmen
`resolve_grab_all_stills`	—	Standbilder von allen Clips aufnehmen
`resolve_create_compound_clip`	`name`	Verbundclip erstellen
`resolve_create_fusion_clip`	—	Fusion-Clip erstellen
`resolve_import_into_timeline`	`filePath`, `importOptions?`	In Timeline importieren
`resolve_stabilize`	`trackType?`, ...	Clip stabilisieren
`resolve_smart_reframe`	`trackType?`, ...	Clip per Smart Reframe neu einrahmen
`resolve_create_magic_mask`	`mode`, `trackType?`, ...	Magic Mask erstellen
`resolve_regenerate_magic_mask`	`trackType?`, ...	Magic Mask neu generieren
`resolve_get_item_track_info`	`trackType?`, ...	Spurinformationen für einen Clip abrufen
`resolve_get_linked_items`	`trackType?`, ...	Verknüpfte Elemente abrufen
`resolve_set_item_cdl`	`cdl`, `trackType?`, ...	CDL-Werte festlegen
`resolve_add_take`	`mediaPoolItemName`, `startFrame?`, `endFrame?`	Take hinzufügen
`resolve_get_takes_count`	`trackType?`, ...	Takes zählen
`resolve_select_take_by_index`	`idx`, `trackType?`, ...	Take auswählen
`resolve_finalize_take`	`trackType?`, ...	Aktuellen Take abschließen
`resolve_copy_grades`	`targetItemNames`, `trackType?`, ...	Gradings auf andere Clips kopieren
`resolve_export_lut`	`exportType`, `path`, `trackType?`, ...	LUT exportieren
`resolve_set_color_output_cache`	`cache_value`, `trackType?`, ...	Farbausgabe-Cache festlegen
`resolve_set_fusion_output_cache`	`cache_value`, `trackType?`, ...	Fusion-Ausgabe-Cache festlegen
`resolve_get_clip_metadata`	`metadataType?`	Clip-Metadaten abrufen
`resolve_set_clip_metadata`	`metadataType`, `metadataValue`	Clip-Metadaten festlegen
`resolve_get_clip_property`	`propertyName?`	Clipeigenschaft abrufen
`resolve_set_clip_property`	`propertyName`, `propertyValue`	Clipeigenschaft festlegen
`resolve_link_proxy_media`	`proxyMediaFilePath`	Proxy-Medien verknüpfen
`resolve_unlink_proxy_media`	—	Proxy-Medien-Verknüpfung aufheben
`resolve_replace_clip`	`filePath`	Clip durch Datei ersetzen
`resolve_add_clip_marker`	`frameId`, `color`, `name`, `note?`	Clip-Marker hinzufügen
`resolve_get_clip_markers`	—	Clip-Marker abrufen
`resolve_set_clip_color`	`colorName`	Clipfarbe festlegen (Medienpool)
`resolve_add_clip_flag`	`color`	Clip-Flag hinzufügen
`resolve_transcribe_clip_audio`	`useSpeakerDetection?`	Audio transkribieren
`resolve_set_clip_mark_inout`	`markIn`, `markOut`, `type`	Mark In/Out festlegen
`resolve_clear_clip_mark_inout`	`type`	Mark In/Out löschen
`resolve_add_timeline_marker`	`frameId`, `color`, `name`, `note?`	Timeline-Marker hinzufügen
`resolve_get_timeline_markers`	—	Timeline-Marker abrufen
`resolve_delete_timeline_markers_by_color`	`color`	Marker nach Farbe löschen
`resolve_delete_timeline_marker_at_frame`	`frameNum`	Marker an Frame löschen
`resolve_export_current_frame`	`filePath`	Aktuellen Frame als Standbild exportieren
`resolve_apply_fairlight_preset`	`name`	Fairlight-Preset anwenden
`resolve_get_quick_export_presets`	—	Schnellexport-Presets auflisten

Fusion-Kompositionen (14 Tools)

Tool	Parameter	Beschreibung
`resolve_create_fusion_comp`	`name`	Fusion-Komposition erstellen
`resolve_add_fusion_comp`	`trackType?`, ...	Fusion-Komposition zu einem Clip hinzufügen
`resolve_import_fusion_comp`	`path`, `trackType?`, ...	.comp-Datei importieren
`resolve_export_fusion_comp`	`path`, `compIndex?`, `trackType?`, ...	Fusion-Komposition exportieren
`resolve_load_fusion_comp_by_name`	`compName`, `trackType?`, ...	Komposition nach Namen laden
`resolve_delete_fusion_comp_by_name`	`compName`, `trackType?`, ...	Komposition nach Namen löschen
`resolve_rename_fusion_comp`	`oldName`, `newName`, `trackType?`, ...	Komposition umbenennen
`resolve_get_item_fusion_comp_count`	`trackType?`, ...	Fusion-Kompositionen auf einem Clip zählen
`resolve_get_item_fusion_comp_names`	`trackType?`, ...	Fusion-Kompositionsnamen auflisten
`resolve_get_current_comp`	—	Aktuelle Fusion-Komposition abrufen
`resolve_fusion_get_comp_list`	—	Alle offenen Kompositionen auflisten
`resolve_fusion_new_comp`	—	Neue Fusion-Komposition erstellen
`resolve_fusion_save_comp`	`filePath`	Aktuelle Komposition speichern
`resolve_fusion_load_comp`	`filePath`	Kompositionsdatei laden
`resolve_fusion_close_comp`	—	Aktuelle Komposition schließen
`resolve_fusion_render_comp`	—	Aktuelle Komposition rendern

Fusion-Tools (11 Tools)

Tool	Parameter	Beschreibung
`resolve_fusion_get_tool_list`	—	Alle Tools/Node im aktuellen Comp auflisten
`resolve_fusion_find_tool`	`name`	Ein Tool anhand des Namens finden
`resolve_fusion_delete_tool`	`name`	Ein Tool löschen
`resolve_fusion_get_attrs`	`name`	Tool-Attribute abrufen
`resolve_fusion_set_attrs`	`name`, `attrs`	Tool-Attribute festlegen
`resolve_fusion_add_node`	`nodeType`, `name`	Einen Node hinzufügen (Background, Paint, Merge usw.)
`resolve_fusion_connect`	`fromNode`, `toNode`, `input`	Zwei Node verbinden
`resolve_fusion_set_input`	`node`, `input`, `value`, `frame?`	Einen Node-Input festlegen (kann keyframen)
`resolve_fusion_get_input`	`node`, `input`	Einen Node-Input-Wert abrufen
`resolve_fusion_set_current_frame`	`frame`	Den aktuellen Frame festlegen
`resolve_fusion_get_current_frame`	—	Den aktuellen Frame abrufen

Galerie (4 Tools)

Tool	Parameter	Beschreibung
`resolve_get_gallery_still_albums`	—	Galerie-Still-Alben auflisten
`resolve_get_gallery_powergrade_albums`	—	PowerGrade-Alben auflisten
`resolve_create_gallery_still_album`	—	Ein Still-Album erstellen
`resolve_create_powergrade_album`	—	Ein PowerGrade-Album erstellen

Farbe / Node (7 Tools)

Tool	Parameter	Beschreibung
`resolve_get_node_count`	—	Node-Anzahl des aktuellen Clips abrufen
`resolve_get_node_label`	`nodeIndex`	Ein Node-Label abrufen
`resolve_get_node_lut`	`nodeIndex`	Die LUT eines Node abrufen
`resolve_set_node_lut`	`nodeIndex`, `lutPath`	Eine LUT auf einem Node festlegen
`resolve_set_node_enabled`	`nodeIndex`, `isEnabled`	Einen Node aktivieren/deaktivieren
`resolve_reset_all_grades`	—	Alle Grade zurücksetzen
`resolve_refresh_lut_list`	—	Die LUT-Liste aktualisieren

Rendering (22 Tools)

Tool	Parameter	Beschreibung
`resolve_get_render_formats`	—	Render-Formate auflisten
`resolve_get_render_codecs`	`renderFormat`	Codecs für ein Format auflisten
`resolve_get_current_render_format_codec`	—	Aktuelles Format/Codec abrufen
`resolve_set_render_format_codec`	`format`, `codec`	Render-Format und Codec festlegen
`resolve_get_render_mode`	—	Render-Modus abrufen
`resolve_set_render_mode`	`renderMode`	Render-Modus festlegen
`resolve_get_render_resolutions`	`format`, `codec`	Render-Auflösungen auflisten
`resolve_get_render_preset_list`	—	Render-Presets auflisten
`resolve_load_render_preset`	`presetName`	Ein Render-Preset laden
`resolve_save_as_new_render_preset`	`presetName`	Ein neues Render-Preset speichern
`resolve_delete_render_preset`	`presetName`	Ein Render-Preset löschen
`resolve_set_render_settings`	`settings`	Render-Einstellungen festlegen (TargetDir, CustomName usw.)
`resolve_add_render_job`	—	Einen Render-Job hinzufügen
`resolve_delete_render_job`	`jobId`	Einen Render-Job löschen
`resolve_delete_all_render_jobs`	—	Alle Render-Jobs löschen
`resolve_get_render_job_list`	—	Render-Jobs auflisten
`resolve_start_rendering`	`jobIds?`, `isInteractiveMode?`	Rendering starten
`resolve_stop_rendering`	—	Rendering stoppen
`resolve_is_rendering_in_progress`	—	Prüfen, ob gerendert wird
`resolve_get_render_status`	`jobId`	Render-Job-Status abrufen
`resolve_render_with_quick_export`	`presetName`	Schnellexport
`resolve_render`	`settings?`	Job hinzufügen und Rendering starten

Sprache & Untertitel (1 Tool)

Tool	Parameter	Beschreibung
`resolve_generate_speech`	`text`, `voice?`	KI-Sprachaudio generieren

Spezial (1 Tool)

Tool	Parameter	Beschreibung
`resolve_create_hand_animation`	`imagePath`, `...`	Eine Handzeichnungs-Animation erstellen (Daniel-Batal-Technik)

Fehlerbehebung

Bridge startet nicht

Stellen Sie sicher, dass DaVinci Resolve läuft und ein Projekt geöffnet ist
Prüfen Sie die Konsole (Workspace → Console) auf Fehlermeldungen
Starten Sie DaVinci Resolve neu — es scannt den Scripts-Ordner nur beim Start

„Could not connect to Resolve Bridge"

Stellen Sie sicher, dass Sie Workspace → Scripts → Bridge-Connection-Script in Resolve ausgeführt haben
Prüfen Sie, dass die Konsole [Resolve Bridge] HTTP server running on http://127.0.0.1:8787 anzeigt
Wenn der Port bereits belegt ist, schließen Sie Resolve und öffnen Sie es erneut (veraltete fuscript.exe-Prozesse können den Port belegen)

Tools geben Fehler zurück

Rufen Sie zuerst resolve_status auf, um die Verbindung zu prüfen
Einige Aktionen erfordern ein geöffnetes Projekt, eine vorhandene Timeline oder einen ausgewählten Clip
Fehlermeldungen der Bridge zeigen an, was fehlt

Technische Details

Bridge-Port: 127.0.0.1:8787 (nur localhost, kein externer Zugriff)
Transport: HTTP/1.0 mit Connection: close
MCP-Transport: stdio
Abhängigkeiten: mcp, requests (nur MCP-Server; Bridge verwendet reine stdlib)
Resolve-Version: 18.5+ (getestet auf 21.0.4.5)
Python: 3.10+ für den MCP-Server; Bridge verwendet das eingebettete Python von Resolve

Lizenz

MIT-Lizenz — siehe Datei LICENSE.

Danksagungen

Erstellt von The Geek Gods. Inspiriert von der DaVinci-Resolve-Scripting-Community.

Available Tools

1 tool

resolve_healthA

Check if DaVinci Resolve bridge is running. The bridge script must be running inside Resolve via Workspace > Scripts > DaVinciResolveBridge. If this returns an error, the bridge is not running.

ParametersJSON Schema

Name	Required	Description	Default
No parameters

TDQS

A4.4/5.0

Behavior4/5

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 explicitly states the error behavior: 'If this returns an error, the bridge is not running.' This is key behavioral information. However, it does not disclose what a successful response contains or whether the tool has any side effects, though 'check' implies a read-only operation. Still, the error semantics are clearly and usefully disclosed.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is three sentences, each earning its place. The first sentence states the purpose, the second gives the setup prerequisite, and the third explains error interpretation. It is front-loaded with the core function and contains no filler or redundant phrases.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

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, no output schema, and no siblings. The description covers what the tool checks and how to interpret an error. A minor gap is that it does not explicitly describe the success response, but for a health-check tool, the error condition is the most critical information. The description is otherwise complete for an agent to select and invoke the tool.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

This tool has zero parameters, so there is nothing to document. According to the guidelines, a baseline of 4 is appropriate when no parameters exist. The description does not need to add parameter-level detail, and it doesn't waste space on it.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description states exactly what the tool does: 'Check if DaVinci Resolve bridge is running.' The verb 'check' and resource 'DaVinci Resolve bridge' are specific and unambiguous. Since there are no sibling tools, there is no need for differentiation, and the description is fully self-contained.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides clear usage context by explaining the prerequisite: the bridge script must be running inside Resolve via Workspace > Scripts > DaVinciResolveBridge. It also tells the agent how to interpret the result, which is effectively guidance for using the tool. There are no alternatives to contrast, so no exclusions are necessary, but it doesn't explicitly say 'use this when you need to verify connectivity.'

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

1 tool updatev1.2.5Sep 6, 2026
- First observedresolve_health

Deploy Server

One endpoint for every MCP toolRayrun runs every MCP server behind one URL and holds the credentials. Each call is decided per client, tool, and argument, then recorded.ray.runAd

TDQS

A4.1/5.0

Scored 2026-09-06 05:40 across 1 tool

Disambiguation5/5

Only one tool exists, so there is no possibility of confusion or overlapping purposes. The tool's purpose is unambiguous.

Naming Consistency5/5

The single tool name follows a clear verb_noun pattern (resolve_health), which is consistent and descriptive. With only one tool, naming consistency is inherently strong.

Tool Count2/5

A single health-check tool is far too few for a server presumably meant to bridge to DaVinci Resolve. Even as a minimal health-only server, one tool feels extremely thin and provides little value beyond a ping.

Completeness1/5

The server only provides a health check, with no ability to interact with DaVinci Resolve projects, timelines, renders, or any other meaningful operations. This is a severely incomplete surface for a bridge to a complex application.

Maintenance

ActivitySlowing

ResponsivenessNo issues

Resources

Need Help?

Related Servers

Related MCP Connectors

arsaze-mcp A
io.github.AnrosPrac
AI video editor for agents and humans: timeline, captions, color, audio and generation as MCP tools.
Image & Video Processing Multimedia Processing
241
ViewMax MCP A
io.github.bytevirts
Remote MCP for AI video, image, music and speech generation.
Audio Processing Image & Video Processing Speech Processing
141
CueFrameOAuth
ai.cueframe
Compose, edit and render video with your AI agent. Turn footage into finished edits with content-aware reframing, word-timed captions and motion graphics. Hosted MCP with OAuth sign-in; cloud processing uses credits.
Image & Video Processing Multimedia Processing
722
MaxVideoAI AOAuth
com.maxvideoai
Plan, compare, price, generate, and recover AI video from compatible MCP clients.
AI & Machine Learning Image & Video Processing
161

Related MCP Servers

resolve-mcp
Multimedia Processing Image & Video Processing
jenkinsm13
A
license
Not graded
quality
F
maintenance
Comprehensive MCP server for DaVinci Resolve with 295+ tools to control projects, timelines, editing, color grading, rendering, and more via natural language.
Updated 6 months ago (2026-04-18 00:51 UTC)
83 PyPI
6
MIT
davinci-resolve-mcp
Multimedia Processing Audio Processing
lordhoell
A
license
Not graded
quality
D
maintenance
An MCP server that exposes the complete DaVinci Resolve scripting API, enabling AI assistants to control DaVinci Resolve programmatically with over 440 tools for project management, timeline editing, color grading, rendering, and more.
Updated 6 months ago (2026-04-03 02:08 UTC)
13
MIT
davinci-resolve-mcp-free
Multimedia Processing Image & Video Processing
MDizzleZA
A
license
Not graded
quality
C
maintenance
Enables AI assistants to control DaVinci Resolve (Free and Studio) through natural language, providing 162 tools for timeline editing, color grading, rendering, and more. Includes local AI replacements for Studio-only features like voice isolation, background removal, and transcription.
Updated 2 months ago (2026-08-16 15:40 UTC)
MIT
davinci-resolve-mcp
Multimedia Processing Image & Video Processing Audio Processing
realmikeshu
A
license
Not graded
quality
Not graded
maintenance
Enables AI assistants to control DaVinci Resolve Studio via MCP, providing full scripting API coverage plus workflow helpers for editing, media organization, rendering, grading, and more.
Updated 2 months ago (2026-08-17 16:47 UTC)
5,556 npm
MIT

Davinc-Resolve-Local-Bridge-MCP

Was ist das?

So funktioniert es

Schnellstart

Voraussetzungen

Schritt 1 — Bridge-Skript installieren

Schritt 2 — MCP-Server-Abhängigkeiten installieren

Schritt 3 — KI-Assistent konfigurieren

Claude Desktop

Cursor

Devin

Claude Code

Beliebiger MCP-Client (allgemein)

Schritt 4 — Bridge in DaVinci Resolve starten

Schritt 5 — Loslegen

Architektur

Bridge-Skript (bridge/Bridge-Connection-Script.py)

MCP-Server (mcp_server/server.py)

Alle 215 Tools

Resolve-Anwendung (15 Tools)

Projektmanager (18 Tools)

Projekteinstellungen (7 Tools)

Medienspeicher (4 Tools)

Medienpool (13 Tools)

Timeline (21 Tools)

Timeline-Spuren (11 Tools)

Timeline-Elemente (66 Tools)

Fusion-Kompositionen (14 Tools)

Fusion-Tools (11 Tools)

Galerie (4 Tools)

Farbe / Node (7 Tools)

Rendering (22 Tools)

Sprache & Untertitel (1 Tool)

Spezial (1 Tool)

Fehlerbehebung

Bridge startet nicht

„Could not connect to Resolve Bridge"

Tools geben Fehler zurück

Technische Details

Lizenz

Danksagungen

Available Tools

TDQS

Tool Schema Changelog

TDQS

Maintenance

Resources

Related MCP Connectors

Related MCP Servers

resolve-mcp

davinci-resolve-mcp

davinci-resolve-mcp-free

davinci-resolve-mcp

Bridge-Skript (`bridge/Bridge-Connection-Script.py`)

MCP-Server (`mcp_server/server.py`)