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 Related Servers Score Discussions

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: 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.

This server cannot be installed

license - permissive license

Not graded

quality - not tested

maintenance

How are these scores calculated?

Maintenance

–Maintainers

–Response time

–Release cycle

–Releases (12mo)

Commit activity

Resources

GitHub Repository

Need Help?

Related Servers

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Servers

DaVinci Resolve MCP Server
Multimedia Processing Developer Tools
Poechant
A
license
Not graded
quality
C
maintenance
Exposes 20 tools for project, media, render, and timeline control in DaVinci Resolve 18+ via stdio MCP, enabling AI agents to operate the software through natural language.
Updated 3 months ago (2026-05-22 03:59 UTC)
51
MIT
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 4 months ago (2026-04-18 00:51 UTC)
3
MIT
resolve-mcp
Image & Video Processing Multimedia Processing AI & Machine Learning
DigitalWorkflowCompany
A
license
B
quality
D
maintenance
Enables AI-driven DaVinci Resolve 21 automation with 88 tools for project management, timeline editing, color grading, AI analysis, rendering, and dailies creation.
Updated 3 months ago (2026-06-06 16:11 UTC)
88
2
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 5 months ago (2026-04-03 02:08 UTC)
5
MIT

View all related MCP servers

Related MCP Connectors

Frenchie
OCR, transcription, file extraction, and image generation for AI agents via MCP.
mcpcut
A real timeline video editor for AI agents: journaled edits, FFmpeg/MLT rendering, exports
clipkit
MCP server for Clipkit — gives AI agents a video toolbox via the Clipkit schema.

View all MCP Connectors

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/Airta-Admin/Davinc-Resolve-Local-Bridge-MCP'

If you have feedback or need assistance with the MCP directory API, please join our Discord server