Rendervid AI-Integration - Videos mit Claude Code, Cursor & MCP generieren

Einführung: KI-gestützte Videogenerierung

Die programmatische Erstellung von Videos erforderte traditionell fundierte Kenntnisse über Video-Codecs, Animations-Frameworks und Rendering-Pipelines. Rendervid beseitigt diese Komplexität, indem es JSON-Templates akzeptiert und fertige Videos ausgibt. Wenn Sie dies mit KI-Agenten kombinieren, die natürliche Sprache verstehen, erhalten Sie etwas Mächtiges: die Fähigkeit, ein Video in einfachem Deutsch zu beschreiben und ein gerendertes MP4 als Antwort zu erhalten.

Rendervid überbrückt die Lücke zwischen KI-Sprachmodellen und Videoproduktion. Anstatt Code zu schreiben, Keyframes zu gestalten oder einen Video-Editor zu erlernen, sagen Sie einem KI-Agenten, was Sie möchten. Der Agent generiert ein gültiges JSON-Template , validiert es und rendert die finale Ausgabe über Rendervids Engine. Der gesamte Prozess findet in einer einzigen Konversation statt.

Diese Integration basiert auf dem Model Context Protocol (MCP), einem offenen Standard, der es KI-Tools ermöglicht, über eine strukturierte Schnittstelle mit externen Diensten zu interagieren. Rendervids MCP-Server stellt 11 Tools für Rendering, Validierung, Template-Entdeckung und Dokumentation bereit und gibt KI-Agenten alles, was sie brauchen, um professionelle Videoinhalte autonom zu produzieren.

Was ist das Model Context Protocol (MCP)?

Das Model Context Protocol ist ein offener Standard, der entwickelt wurde, um KI-Assistenten strukturierten Zugriff auf externe Tools und Datenquellen zu geben. Anstatt sich darauf zu verlassen, dass KI-Modelle API-Formate erraten oder Code generieren, der REST-Endpunkte aufruft, bietet MCP eine typisierte, auffindbare Schnittstelle, die KI-Agenten zur Laufzeit abfragen können.

Für die Videogenerierung löst MCP ein kritisches Problem: KI-Agenten müssen wissen, was möglich ist, bevor sie gültige Ausgaben generieren können. Ohne MCP müsste ein KI-Modell auf Rendervids spezifisches Template-Format trainiert werden, jedes verfügbare Animations-Preset kennen und die Einschränkungen jedes Layer-Typs verstehen. Mit MCP ruft der Agent einfach get_capabilities auf und erhält eine vollständige Beschreibung des Systems, einschließlich JSON-Schemas für jede Komponente.

Warum MCP für die KI-Videogenerierung wichtig ist

• Laufzeit-Entdeckung: KI-Agenten lernen, was Rendervid kann, in dem Moment, in dem sie sich verbinden, nicht während des Trainings. Das bedeutet, dass neue Funktionen sofort verfügbar sind, ohne erneutes Training.
• Typ-Sicherheit: Jedes Tool hat ein definiertes Eingabe- und Ausgabe-Schema. Der KI-Agent weiß genau, welche Parameter erforderlich sind und welche Typen sie haben müssen.
• Validierung vor dem Rendering: Anstatt ein Template einzureichen und zu hoffen, dass es funktioniert, kann der Agent das Template zuerst validieren und alle Probleme beheben, bevor Zeit für das Rendering aufgewendet wird.
• Tool-Kompositionsfähigkeit: KI-Agenten können Tools verketten, list_examples aufrufen, um ein Ausgangs-Template zu finden, es modifizieren, validate_template aufrufen, um es zu prüfen, und dann render_video aufrufen, um die Ausgabe zu produzieren. Alles in einem einzigen Konversations-Turn.

MCP Server Tools Referenz

Rendervids MCP-Server stellt 11 Tools bereit, die in drei Kategorien organisiert sind: Rendering, Validierung & Entdeckung und Dokumentation. Jedes Tool ist so konzipiert, dass es KI-Agenten maximale Autonomie bei der Generierung von Videoinhalten gibt.

Rendering-Tools

Diese Tools handhaben die tatsächliche Produktion von Video- und Bildausgaben aus JSON-Templates.

render_video

Generiert eine vollständige Videodatei aus einem JSON-Template. Dies ist das primäre Rendering-Tool für die Produktion von MP4-, WebM- oder MOV-Ausgaben.

Parameter:

• template (object, erforderlich) – Das vollständige JSON-Template, das Szenen, Layer, Animationen und Ausgabeeinstellungen definiert.
• inputs (object, optional) – Schlüssel-Wert-Paare für die Substitution von Template-Variablen.
• output_format (string, optional) – Ausgabeformat: mp4, webm oder mov. Standard ist mp4.

Beispielverwendung durch einen KI-Agenten:

{
  "tool": "render_video",
  "arguments": {
    "template": {
      "outputSettings": {
        "width": 1080,
        "height": 1920,
        "fps": 30,
        "duration": 10
      },
      "scenes": [
        {
          "duration": 10,
          "layers": [
            {
              "type": "text",
              "text": "Sommerschlussverkauf - 50% Rabatt",
              "fontSize": 72,
              "fontFamily": "Montserrat",
              "color": "#FFFFFF",
              "position": { "x": 540, "y": 960 },
              "animations": [
                {
                  "type": "fadeInUp",
                  "duration": 0.8,
                  "delay": 0.2
                }
              ]
            }
          ]
        }
      ]
    },
    "output_format": "mp4"
  }
}

Gibt zurück: Eine URL oder einen Dateipfad zur gerenderten Videodatei.

render_image

Generiert ein einzelnes Frame oder Standbild aus einem JSON-Template. Nützlich für die Erstellung von Thumbnails, Social-Media-Grafiken, Poster-Frames und statischen Marketingmaterialien.

Parameter:

• template (object, erforderlich) – Das JSON-Template, das die Bildkomposition definiert.
• inputs (object, optional) – Werte für die Substitution von Template-Variablen.
• output_format (string, optional) – Ausgabeformat: png, jpeg oder webp. Standard ist png.
• frame (number, optional) – Welches Frame gerendert werden soll (zum Extrahieren eines bestimmten Moments aus einem animierten Template).

Wann render_image vs render_video verwendet werden sollte:

• Verwenden Sie render_image für statische Ausgaben: Thumbnails, Banner, Social-Media-Posts, Präsentationsfolien.
• Verwenden Sie render_video für alles mit Bewegung: Animationen, Übergänge, Audio, Videoclips.

start_render_async

Startet einen asynchronen Render-Job für Videos mit langer Dauer (typischerweise über 30 Sekunden). Anstatt darauf zu warten, dass das Rendering synchron abgeschlossen wird, gibt dieses Tool eine Job-ID zurück, die Sie mit check_render_status abfragen können.

Parameter:

• template (object, erforderlich) – Das vollständige JSON-Template.
• inputs (object, optional) – Template-Variablenwerte.
• output_format (string, optional) – Gewünschtes Ausgabeformat.

Gibt zurück: Eine job_id-Zeichenkette, die mit check_render_status und list_render_jobs verwendet werden kann.

Wann asynchrones Rendering verwendet werden sollte:

• Videos länger als 30 Sekunden
• Templates mit vielen Szenen oder komplexen Animationen
• Batch-Rendering-Workflows, bei denen Sie mehrere Jobs einreichen und Ergebnisse später sammeln möchten
• Cloud-Rendering-Umgebungen, bei denen lang laufende synchrone Anfragen möglicherweise ein Timeout erreichen

check_render_status

Überprüft den aktuellen Status eines asynchronen Render-Jobs, der mit start_render_async gestartet wurde.

Parameter:

• job_id (string, erforderlich) – Die Job-ID, die von start_render_async zurückgegeben wurde.

Gibt zurück: Ein Objekt, das Folgendes enthält:

• status – Einer von queued, rendering, completed oder failed.
• progress – Ein Prozentsatz (0-100), der den Rendering-Fortschritt anzeigt.
• output_url – Die URL des fertigen Videos (nur vorhanden, wenn status completed ist).
• error – Fehlermeldung, wenn der Job fehlgeschlagen ist.

Beispiel-Polling-Workflow:

KI-Agent:
1. start_render_async → job_id: "abc-123"
2. check_render_status("abc-123") → status: "rendering", progress: 35
3. check_render_status("abc-123") → status: "rendering", progress: 78
4. check_render_status("abc-123") → status: "completed", output_url: "https://..."

list_render_jobs

Listet alle asynchronen Rendering-Jobs auf, sowohl aktive als auch abgeschlossene. Nützlich für die Überwachung von Batch-Rendering-Operationen oder die Überprüfung kürzlicher Ausgaben.

Parameter:

• status_filter (string, optional) – Nach Status filtern: queued, rendering, completed, failed oder all. Standard ist all.
• limit (number, optional) – Maximale Anzahl der zurückzugebenden Jobs.

Gibt zurück: Ein Array von Job-Objekten, jeweils mit job_id, status, progress, created_at und output_url (falls abgeschlossen).

Validierungs- & Entdeckungs-Tools

Diese Tools helfen KI-Agenten zu verstehen, was Rendervid kann, und zu überprüfen, dass Templates vor dem Rendering korrekt sind.

validate_template

Validiert ein JSON-Template vor dem Rendering. Dieses Tool überprüft die Template-Struktur, Feldtypen, Wertbeschränkungen und verifiziert sogar, dass Medien-URLs (Bilder, Videos, Audiodateien) zugänglich sind. Die Validierung vor dem Rendering verhindert verschwendete Zeit bei Templates, die während des Rendering-Prozesses fehlschlagen würden.

Parameter:

• template (object, erforderlich) – Das zu validierende JSON-Template.
• check_urls (boolean, optional) – Ob Medien-URLs auf Zugänglichkeit überprüft werden sollen. Standard ist true.

Gibt zurück: Ein Objekt, das Folgendes enthält:

• valid – Boolean, der angibt, ob das Template gültig ist.
• errors – Array von Fehlerobjekten mit path, message und severity für jedes gefundene Problem.
• warnings – Array von Warnungsobjekten für nicht-kritische Probleme (z.B. ungenutzte Variablen, sehr große Dimensionen).

Was die Validierung erkennt:

• Fehlende erforderliche Felder (z.B. eine Szene ohne duration)
• Ungültige Feldtypen (z.B. eine Zeichenkette, wo eine Zahl erwartet wird)
• Unbekannte Layer-Typen oder Animations-Presets
• Defekte oder nicht zugängliche Medien-URLs (Bilder, Videos, Audiodateien)
• Werte außerhalb des Bereichs (z.B. negative Dimensionen, fps über Maximum)
• Template-Variablen-Syntaxfehler

Beispiel-Validierungsantwort:

{
  "valid": false,
  "errors": [
    {
      "path": "scenes[0].layers[2].src",
      "message": "URL gab HTTP 404 zurück: https://example.com/missing-image.png",
      "severity": "error"
    },
    {
      "path": "scenes[1].duration",
      "message": "Szenendauer muss eine positive Zahl sein",
      "severity": "error"
    }
  ],
  "warnings": [
    {
      "path": "outputSettings.width",
      "message": "Breite 7680 ist sehr groß und kann zu langsamem Rendering führen",
      "severity": "warning"
    }
  ]
}

get_capabilities

Gibt eine umfassende Beschreibung von allem zurück, was Rendervid kann. Dies ist typischerweise das erste Tool, das ein KI-Agent aufruft, wenn er eine Videogenerierungsaufgabe startet. Die Antwort enthält verfügbare Layer-Typen, Animations-Presets, Easing-Funktionen, Filter, Ausgabeformate und deren JSON-Schemas.

Parameter: Keine.

Gibt zurück: Ein strukturiertes Objekt, das Folgendes enthält:

• layerTypes – Alle verfügbaren Layer-Typen (text, image, video, shape, audio, group, lottie, custom) mit ihren JSON-Schemas und konfigurierbaren Eigenschaften.
• animations – Alle Animations-Presets gruppiert nach Kategorie (entrance, exit, emphasis, keyframe) mit Beschreibungen und konfigurierbaren Parametern.
• easingFunctions – Alle 30+ Easing-Funktionen mit Beschreibungen und Verwendungsbeispielen.
• filters – Verfügbare visuelle Filter (blur, brightness, contrast, saturate, grayscale, sepia, etc.) mit Parameterbereichen.
• outputFormats – Unterstützte Ausgabeformate für Video- und Bild-Rendering mit ihren Einschränkungen.
• inputTypes – Template-Variablentypen und Validierungsregeln.
• sceneTransitions – Alle 17 Szenenübergangstypen mit ihren Parametern.

Warum dieses Tool für KI-Agenten kritisch ist:

Die Capabilities-Antwort ist eine selbstbeschreibende API. Ein KI-Agent muss nicht auf Rendervids Template-Format vortrainiert sein. Er kann get_capabilities zur Laufzeit aufrufen, das vollständige Schema erhalten und beim ersten Versuch gültige Templates generieren. Wenn Rendervid neue Funktionen, Animationen oder Layer-Typen hinzufügt, erhalten KI-Agenten automatisch über dieses Tool Zugriff darauf, ohne Codeänderungen.

get_example

Lädt ein bestimmtes Beispiel-Template nach Namen. KI-Agenten verwenden dies, um ein funktionierendes Template als Ausgangspunkt abzurufen und es dann an die Anforderungen des Benutzers anzupassen.

Parameter:

• name (string, erforderlich) – Der Name des Beispiel-Templates (z.B. instagram-story, product-showcase, animated-bar-chart).

Gibt zurück: Das vollständige JSON-Template für das angeforderte Beispiel, bereit zum Rendern oder Modifizieren.

Beispiel:

KI-Agent ruft auf: get_example("instagram-story")
Gibt zurück: Vollständiges 1080x1920 Instagram Story Template mit Text-Layern,
         Hintergrundbild und Eingangsanimationen

list_examples

Durchsucht den vollständigen Katalog von 50+ Beispiel-Templates, organisiert nach Kategorien. KI-Agenten verwenden dies, um relevante Ausgangs-Templates für die Anfrage des Benutzers zu finden.

Parameter:

• category (string, optional) – Nach Kategorie filtern (z.B. social-media, marketing, data-visualization, typography, e-commerce).

Gibt zurück: Ein Array von Beispiel-Metadaten-Objekten, jeweils mit:

• name – Template-Identifikator zur Verwendung mit get_example.
• category – Template-Kategorie.
• description – Was das Template erstellt.
• dimensions – Ausgabebreite und -höhe.
• duration – Template-Dauer in Sekunden.

Dokumentations-Tools

Diese Tools bieten detaillierte Referenzdokumentation, die KI-Agenten beim Erstellen von Templates konsultieren können.

get_component_docs

Gibt detaillierte Dokumentation für eine bestimmte Komponente oder einen Layer-Typ zurück. Enthält Eigenschaftsbeschreibungen, erforderliche vs. optionale Felder, Standardwerte und Verwendungsbeispiele.

Parameter:

• component (string, erforderlich) – Der Name der Komponente/des Layer-Typs (z.B. text, image, video, shape, audio, group, lottie, custom, AnimatedLineChart, TypewriterEffect).

Gibt zurück: Umfassende Dokumentation einschließlich:

• Eigenschaftstabelle mit Typen, Standardwerten und Beschreibungen
• JSON-Schema für die Komponente
• Verwendungsbeispiele
• Hinweise zu Unterschieden beim Browser- vs. Node.js-Rendering

get_animation_docs

Gibt die vollständige Animationseffekt-Referenz zurück, einschließlich aller Eingangs-, Ausgangs-, Betonungs- und Keyframe-Animations-Presets.

Parameter:

• animation (string, optional) – Spezifischer Animationsname, um detaillierte Dokumentation zu erhalten (z.B. fadeInUp, bounceIn, slideOutLeft). Wenn weggelassen, wird der vollständige Animationskatalog zurückgegeben.

Gibt zurück: Animationsdokumentation einschließlich:

• Animationsname und Kategorie (entrance, exit, emphasis, keyframe)
• Beschreibung des visuellen Effekts
• Konfigurierbare Parameter (duration, delay, easing)
• Standardwerte
• Empfohlene Anwendungsfälle

get_component_defaults

Gibt die Standardwerte und das vollständige JSON-Schema für einen bestimmten Komponententyp zurück. KI-Agenten verwenden dies, um zu verstehen, wie eine minimal gültige Komponente aussieht und welche Eigenschaften sie überschreiben können.

Parameter:

• component (string, erforderlich) – Der Name der Komponente/des Layer-Typs.

Gibt zurück: Ein JSON-Objekt mit:

• defaults – Vollständige Standardwerte für jede Eigenschaft
• schema – JSON-Schema, das die Struktur, Typen und Einschränkungen der Komponente definiert
• required – Liste der erforderlichen Eigenschaften

Beispielantwort für einen Text-Layer:

{
  "defaults": {
    "type": "text",
    "text": "",
    "fontSize": 24,
    "fontFamily": "Arial",
    "color": "#000000",
    "fontWeight": "normal",
    "textAlign": "center",
    "position": { "x": 0, "y": 0 },
    "opacity": 1,
    "rotation": 0,
    "animations": []
  },
  "required": ["type", "text"],
  "schema": {
    "type": "object",
    "properties": {
      "text": { "type": "string", "description": "Der anzuzeigende Textinhalt" },
      "fontSize": { "type": "number", "minimum": 1, "maximum": 500 },
      "fontFamily": { "type": "string", "description": "Google Font Name oder Systemschriftart" },
      "color": { "type": "string", "pattern": "^#[0-9a-fA-F]{6}$" }
    }
  }
}

get_easing_docs

Gibt die vollständige Referenz für alle verfügbaren Easing-Funktionen zurück. Easing-Funktionen steuern die Beschleunigungskurve von Animationen und bestimmen, ob sie langsam starten, langsam enden, springen oder einer elastischen Kurve folgen.

Parameter:

• easing (string, optional) – Spezifischer Easing-Funktionsname für detaillierte Dokumentation. Wenn weggelassen, wird die vollständige Liste zurückgegeben.

Gibt zurück: Dokumentation für jede Easing-Funktion einschließlich:

• Funktionsname (z.B. easeInOutCubic, easeOutBounce, spring)
• Mathematische Beschreibung der Kurve
• Visuelle Beschreibung des Bewegungsgefühls
• Empfohlene Anwendungsfälle
• CSS-Äquivalent (falls zutreffend)

Einrichtung der KI-Integration

Die Verbindung von Rendervid mit Ihrem KI-Tool erfordert das Hinzufügen des MCP-Servers zur Konfiguration Ihres Tools. Der Einrichtungsprozess variiert leicht zwischen den Tools, aber das Kernkonzept ist dasselbe: Richten Sie Ihr KI-Tool auf den Einstiegspunkt des MCP-Servers von Rendervid aus.

Voraussetzungen

Bevor Sie ein KI-Tool konfigurieren, stellen Sie sicher, dass Sie Folgendes haben:

1. Node.js 18+ auf Ihrem System installiert
2. Rendervid geklont und gebaut aus dem GitHub-Repository :

git clone https://github.com/AceDZN/rendervid.git
cd rendervid
npm install
cd mcp
npm install
npm run build

3. FFmpeg installiert (erforderlich für Videoausgabe):

# macOS
brew install ffmpeg

# Ubuntu/Debian
sudo apt install ffmpeg

# Windows (mit Chocolatey)
choco install ffmpeg

Claude Desktop / Claude Code

Fügen Sie den Rendervid MCP-Server zu Ihrer Claude Desktop Konfigurationsdatei hinzu.

Speicherort der Konfigurationsdatei:

• macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
• Windows: %APPDATA%\Claude\claude_desktop_config.json
• Linux: ~/.config/Claude/claude_desktop_config.json

Konfiguration:

{
  "mcpServers": {
    "rendervid": {
      "command": "node",
      "args": ["/path/to/rendervid/mcp/build/index.js"],
      "env": {}
    }
  }
}

Ersetzen Sie /path/to/rendervid durch den tatsächlichen Pfad zu Ihrer Rendervid-Installation.

Für Claude Code (CLI) fügen Sie dieselbe Konfiguration zur .claude/mcp.json-Datei Ihres Projekts oder zu Ihren globalen Claude Code Einstellungen hinzu. Claude Code erkennt den MCP-Server automatisch und stellt alle 11 Tools während Ihrer Coding-Sitzungen zur Verfügung.

Nach dem Speichern der Konfiguration starten Sie Claude Desktop oder Claude Code neu. Sie können die Verbindung überprüfen, indem Sie Claude fragen: “Welche Rendervid-Tools sind verfügbar?” Claude sollte alle 11 MCP-Tools auflisten.

Cursor IDE

Fügen Sie den Rendervid MCP-Server zur MCP-Konfiguration von Cursor hinzu.

Konfigurationsdatei: .cursor/mcp.json im Stammverzeichnis Ihres Projekts (oder globale Cursor-Einstellungen).

{
  "mcpServers": {
    "rendervid": {
      "command": "node",
      "args": ["/path/to/rendervid/mcp/build/index.js"]
    }
  }
}

Nach dem Speichern starten Sie Cursor neu. Die Rendervid-Tools sind im KI-Assistenten von Cursor verfügbar und ermöglichen es Ihnen, Videos direkt aus Ihrem Editor zu generieren.

Windsurf IDE

Windsurf unterstützt MCP-Server über seine KI-Konfiguration. Fügen Sie den Rendervid-Server zu Ihren Windsurf MCP-Einstellungen hinzu:

{
  "mcpServers": {
    "rendervid": {
      "command": "node",
      "args": ["/path/to/rendervid/mcp/build/index.js"]
    }
  }
}

Konsultieren Sie die Dokumentation von Windsurf für den genauen Speicherort der Konfigurationsdatei, da dieser je nach Version und Betriebssystem variieren kann.

Generisches MCP-Setup

Jedes Tool, das die MCP-Client-Spezifikation implementiert, kann sich mit Rendervids MCP-Server verbinden. Der Server kommuniziert über stdio (Standardeingabe/-ausgabe), was der Standard-MCP-Transport ist.

Um mit einem benutzerdefinierten MCP-Client zu integrieren:

1. Starten Sie den MCP-Server-Prozess:

   node /path/to/rendervid/mcp/build/index.js
   

2. Kommunizieren Sie über stdin/stdout unter Verwendung des MCP JSON-RPC-Protokolls.
3. Rufen Sie tools/list auf, um verfügbare Tools zu entdecken.
4. Rufen Sie tools/call mit dem Tool-Namen und Argumenten auf, um ein beliebiges Tool auszuführen.

Der MCP-Server ist zustandslos. Jeder Tool-Aufruf ist unabhängig, und der Server kann gleichzeitige Anfragen von mehreren Clients verarbeiten.

KI-Workflow: End-to-End-Beispiele

Die folgenden Beispiele zeigen, wie KI-Agenten Rendervids MCP-Tools verwenden, um von einem natürlichsprachlichen Prompt zu einem fertigen Video zu gelangen.

Beispiel 1: Social-Media-Content-Erstellung

Benutzer-Prompt: “Erstelle eine 10-sekündige Instagram Story, die einen Sommerschlussverkauf mit animiertem Text und einem Farbverlaufshintergrund bewirbt”

KI-Agent-Workflow:

Schritt 1 – Fähigkeiten entdecken:

Der Agent ruft get_capabilities auf, um über verfügbare Layer-Typen, Animations-Presets und Ausgabebeschränkungen zu lernen. Er entdeckt, dass text- und shape-Layer verfügbar sind, fadeInUp- und scaleIn-Animationen existieren und Instagram Stories eine Auflösung von 1080x1920 verwenden.

Schritt 2 – Ein Ausgangs-Template finden:

Der Agent ruft list_examples mit category: "social-media" auf und findet ein instagram-story-Template. Er ruft dann get_example("instagram-story") auf, um das vollständige Template-JSON zu laden.

Schritt 3 – Das Template erstellen:

Unter Verwendung des Beispiels als Referenz erstellt der Agent ein benutzerdefiniertes Template:

{
  "outputSettings": {
    "width": 1080,
    "height": 1920,
    "fps": 30,
    "duration": 10
  },
  "scenes": [
    {
      "duration": 10,
      "layers": [
        {
          "type": "shape",
          "shapeType": "rectangle",
          "width": 1080,
          "height": 1920,
          "gradient": {
            "type": "linear",
            "angle": 135,
            "stops": [
              { "color": "#FF6B35", "position": 0 },
              { "color": "#F72585", "position": 0.5 },
              { "color": "#7209B7", "position": 1 }
            ]
          }
        },
        {
          "type": "text",
          "text": "SOMMERSCHLUSSVERKAUF",
          "fontSize": 96,
          "fontFamily": "Montserrat",
          "fontWeight": "bold",
          "color": "#FFFFFF",
          "position": { "x": 540, "y": 700 },
          "animations": [
            { "type": "fadeInUp", "duration": 0.8, "delay": 0.3 }
          ]
        },
        {
          "type": "text",
          "text": "50% RABATT AUF ALLES",
          "fontSize": 64,
          "fontFamily": "Montserrat",
          "color": "#FFE066",
          "position": { "x": 540, "y": 850 },
          "animations": [
            { "type": "fadeInUp", "duration": 0.8, "delay": 0.6 }
          ]
        },
        {
          "type": "text",
          "text": "Jetzt einkaufen  →",
          "fontSize": 48,
          "fontFamily": "Montserrat",
          "color": "#FFFFFF",
          "position": { "x": 540, "y": 1200 },
          "animations": [
            { "type": "scaleIn", "duration": 0.6, "delay": 1.2 }
          ]
        }
      ]
    }
  ]
}

Schritt 4 – Validieren:

Der Agent ruft validate_template mit dem Template-JSON auf. Die Antwort kommt als valid: true ohne Fehler zurück.

Schritt 5 – Rendern:

Der Agent ruft render_video mit dem validierten Template auf und erhält eine URL zur fertigen MP4-Datei.

Beispiel 2: Marketing-Video-Automatisierung

Benutzer-Prompt: “Generiere ein Produktpräsentations-Video für unsere neuen Kopfhörer. Verwende dieses Produktbild: https://example.com/headphones.png . Der Produktname ist ‘SoundPro X1’ und der Preis beträgt 299€.”

KI-Agent-Workflow:

1. get_capabilities – Lernt über Bild-Layer, Textstile und Animationsoptionen.
2. list_examples – Findet ein product-showcase-Template in der e-commerce-Kategorie.
3. get_example("product-showcase") – Lädt das vollständige Produktpräsentations-Template, das Template-Variablen für Produktname, Bild und Preis verwendet.
4. Modifiziert das Template – Aktualisiert die inputs mit den Produktdaten des Benutzers:

   {
     "inputs": {
       "productName": "SoundPro X1",
       "productImage": "https://example.com/headphones.png",
       "price": "299€",
       "tagline": "Premium Sound, neu definiert"
     }
   }
   

5. validate_template – Überprüft das Template und bestätigt, dass https://example.com/headphones.png zugänglich ist.
6. render_video – Produziert das finale Produktpräsentations-Video.

Dieser Workflow demonstriert, wie KI-Agenten Template-Variablen nutzen, um personalisierten Content aus wiederverwendbaren Templates zu erstellen. Dasselbe Produktpräsentations-Template kann Hunderte von einzigartigen Videos generieren, indem die Inputs ausgetauscht werden.

Beispiel 3: Datenvisualisierungs-Generierung

Benutzer-Prompt: “Erstelle ein animiertes Balkendiagramm, das den vierteljährlichen Umsatz zeigt: Q1: 1,2M€, Q2: 1,8M€, Q3: 2,1M€, Q4: 2,7M€”

KI-Agent-Workflow:

1. get_capabilities – Entdeckt den custom-Layer-Typ und die eingebaute Komponente AnimatedLineChart.
2. get_component_docs("AnimatedLineChart") – Liest die Dokumentation für die Diagramm-Komponente und lernt über Datenformat, Farbkonfiguration, Achsenbeschriftungen und Animationsoptionen.
3. get_component_defaults("AnimatedLineChart") – Erhält die Standardwerte und das JSON-Schema, um die minimal erforderliche Konfiguration zu verstehen.
4. Erstellt ein Template mit einem benutzerdefinierten Komponenten-Layer:

   {
     "type": "custom",
     "component": "AnimatedLineChart",
     "props": {
       "data": [
         { "label": "Q1", "value": 1200000 },
         { "label": "Q2", "value": 1800000 },
         { "label": "Q3", "value": 2100000 },
         { "label": "Q4", "value": 2700000 }
       ],
       "colors": ["#4361EE", "#3A0CA3", "#7209B7", "#F72585"],
       "title": "Vierteljährlicher Umsatz 2025",
       "yAxisLabel": "Umsatz (EUR)",
       "animationDuration": 2
     }
   }
   

5. validate_template – Bestätigt, dass die Template-Struktur korrekt ist.
6. render_video – Generiert das animierte Diagramm-Video.

Selbstbeschreibende API: Wie Capabilities KI-Agenten effektiv machen

Das get_capabilities-Tool ist der Grundstein von Rendervids KI-Integration. Es implementiert ein selbstbeschreibendes API-Muster, bei dem das System KI-Agenten genau sagt, was es kann, welche Parameter erforderlich sind und welche Werte gültig sind. Dies eliminiert die Notwendigkeit, dass KI-Modelle Rendervids spezifische API auswendig lernen oder darauf trainiert werden müssen.

Was die Capabilities-Antwort enthält

Wenn ein KI-Agent get_capabilities aufruft, erhält er eine strukturierte Antwort, die jeden Aspekt des Rendering-Systems abdeckt:

Layer-Typen mit JSON-Schemas:

{
  "layerTypes": {
    "text": {
      "description": "Rendert Text mit voller Stilkontrolle",
      "schema": {
        "properties": {
          "text": { "type": "string", "required": true },
          "fontSize": { "type": "number", "default": 24, "min": 1, "max": 500 },
          "fontFamily": { "type": "string", "default": "Arial" },
          "color": { "type": "string", "format": "hex-color" },
          "position": { "type": "object", "properties": { "x": {}, "y": {} } },
          "animations": { "type": "array", "items": { "$ref": "#/animations" } }
        }
      }
    },
    "image": {
      "description": "Rendert statische oder animierte Bilder",
      "schema": {
        "properties": {
          "src": { "type": "string", "format": "uri", "required": true },
          "width": { "type": "number" },
          "height": { "type": "number" },
          "position": { "type": "object" },
          "opacity": { "type": "number", "min": 0, "max": 1 }
        }
      }
    }
  }
}

Animations-Presets nach Kategorie:

{
  "animations": {
    "entrance": [
      {
        "name": "fadeInUp",
        "description": "Element erscheint von unten einblendend",
        "parameters": {
          "duration": { "type": "number", "default": 0.6 },
          "delay": { "type": "number", "default": 0 },
          "easing": { "type": "string", "default": "easeOutCubic" }
        }
      },
      {
        "name": "bounceIn",
        "description": "Element springt mit elastischem Effekt herein",
        "parameters": {
          "duration": { "type": "number", "default": 0.8 },
          "delay": { "type": "number", "default": 0 },
          "easing": { "type": "string", "default": "easeOutBounce" }
        }
      }
    ],
    "exit": [
      {
        "name": "fadeOutDown",
        "description": "Element verblasst nach unten",
        "parameters": {
          "duration": { "type": "number", "default": 0.6 },
          "delay": { "type": "number", "default": 0 }
        }
      }
    ]
  }
}

Easing-Funktionen:

{
  "easingFunctions": [
    {
      "name": "easeInOutCubic",
      "description": "Beginnt langsam, beschleunigt in der Mitte, endet langsam",
      "curve": "cubic-bezier(0.65, 0, 0.35, 1)",
      "useCases": ["Sanfte Übergänge", "UI-Animationen", "Szenenübergänge"]
    },
    {
      "name": "easeOutBounce",
      "description": "Springt am Ende wie ein Ball",
      "useCases": ["Aufmerksamkeit erregende Animationen", "Spielerische Effekte"]
    },
    {
      "name": "spring",
      "description": "Physikbasierte Federbewegung",
      "useCases": ["Natürliche Bewegung", "Interaktive Elemente"]
    }
  ]
}

Ausgabeformate und Einschränkungen:

{
  "outputFormats": {
    "video": [
      {
        "format": "mp4",
        "codecs": ["h264", "h265"],
        "maxResolution": "7680x4320",
        "maxFps": 120,
        "maxDuration": 3600
      },
      {
        "format": "webm",
        "codecs": ["vp8", "vp9"],
        "maxResolution": "7680x4320",
        "maxFps": 120
      }
    ],
    "image": [
      {
        "format": "png",
        "maxResolution": "16384x16384",
        "supportsTransparency": true
      },
      {
        "format": "jpeg",
        "maxResolution": "16384x16384",
        "supportsTransparency": false,
        "quality": { "min": 0, "max": 100, "default": 90 }
      }
    ]
  }
}

Wie KI-Agenten Capabilities nutzen

Wenn ein Benutzer einen KI-Agenten bittet, ein Video zu erstellen, folgt der Agent diesem Muster:

1. get_capabilities aufrufen – Lernen Sie, was das System kann
2. Schema analysieren – Verstehen Sie verfügbare Layer-Typen, Animationen und Einschränkungen
3. Template erstellen – Generieren Sie gültiges JSON basierend auf dem Schema
4. Validieren – Überprüfen Sie das Template mit validate_template
5. Rendern – Produzieren Sie die finale Ausgabe mit render_video oder render_image

Da die Capabilities-Antwort vollständige JSON-Schemas enthält, kann der KI-Agent:

• Gültige Templates beim ersten Versuch generieren – Kein Raten oder Trial-and-Error
• Neue Funktionen automatisch entdecken – Wenn Rendervid neue Animationen oder Layer-Typen hinzufügt, erscheinen sie in der Capabilities-Antwort
• Benutzereingaben validieren – Wissen Sie, ob eine Anfrage möglich ist, bevor Sie versuchen, sie zu rendern
• Intelligente Vorschläge machen – “Ich sehe, Sie möchten einen Bounce-Effekt. Rendervid hat bounceIn, bounceOut und bounceInDown Animationen verfügbar.”

Erweiterte Workflows

Batch-Rendering mit Template-Variablen

KI-Agenten können mehrere Videos aus einem einzigen Template generieren, indem sie Template-Variablen verwenden. Dies ist ideal für:

• Personalisierte Marketingvideos – Ein Template, Hunderte von Videos mit unterschiedlichen Namen, Produkten oder Angeboten
• Datengetriebene Visualisierungen – Aktualisieren Sie Diagramme automatisch mit neuen Daten
• A/B-Testing – Generieren Sie Varianten mit unterschiedlichen Texten, Farben oder Layouts

Beispiel-Workflow:

Benutzer: "Erstelle Produktvideos für diese 10 Produkte"
[Benutzer stellt eine CSV- oder JSON-Liste mit Produktdaten bereit]

KI-Agent:
1. get_example("product-showcase") → Lädt das Basis-Template
2. Für jedes Produkt:
   - Modifiziert inputs mit Produktname, Bild, Preis
   - validate_template() → Stellt sicher, dass Produktbild zugänglich ist
   - start_render_async() → Startet den Render-Job
3. list_render_jobs() → Überwacht den Fortschritt
4. Sammelt alle output_urls, wenn abgeschlossen

Dynamische Template-Generierung

Anstatt Beispiele zu verwenden, können KI-Agenten Templates von Grund auf neu generieren, indem sie Capabilities konsultieren:

Benutzer: "Erstelle ein Countdown-Timer-Video, das von 10 auf 0 herunterzählt, mit jedem Countdown in einer anderen Farbe"

KI-Agent:
1. get_capabilities() → Lernt über text-Layer, Szenen, Animationen
2. Erstellt 11 Szenen (eine für jeden Countdown-Wert 10-0)
3. Jede Szene hat:
   - 1 Sekunde Dauer
   - Text-Layer mit der Nummer
   - Zufällige Farbe aus einer Palette
   - scaleIn-Animation beim Eingang
   - fadeOut-Animation beim Ausgang
4. validate_template()
5. render_video()

Fehlerbehandlung und Wiederholungen

KI-Agenten können Validierungsfehler intelligent behandeln:

KI-Agent erstellt Template → validate_template() gibt Fehler zurück:
"scenes[0].layers[1].src: URL gab HTTP 404 zurück"

KI-Agent:
1. Identifiziert, dass Bild-URL defekt ist
2. Fragt Benutzer nach einer alternativen URL ODER
3. Ersetzt durch Platzhalter-Bild ODER
4. Entfernt den Bild-Layer und passt das Layout an
5. validate_template() erneut → Erfolgreich
6. render_video()

Best Practices für KI-Agenten

1. Rufen Sie immer zuerst Capabilities auf

Bevor Sie ein Template generieren, rufen Sie get_capabilities auf, um zu erfahren, was verfügbar ist. Dies verhindert, dass Sie ungültige Layer-Typen oder nicht existierende Animationen verwenden.

2. Validieren Sie vor dem Rendern

Rufen Sie immer validate_template auf, bevor Sie render_video aufrufen. Die Validierung dauert Millisekunden; das Rendering kann Sekunden oder Minuten dauern. Das frühzeitige Erkennen von Fehlern spart Zeit.

3. Verwenden Sie Beispiele als Ausgangspunkte

Anstatt Templates von Grund auf neu zu erstellen, rufen Sie list_examples auf, um ein relevantes Template zu finden, und modifizieren Sie es dann. Beispiele sind produktionsgetestet und folgen Best Practices.

4. Nutzen Sie Template-Variablen

Wenn Sie mehrere ähnliche Videos erstellen, verwenden Sie Template-Variablen anstatt mehrere statische Templates zu generieren. Dies macht Templates wiederverwendbar und wartbar.

5. Verwenden Sie asynchrones Rendering für lange Videos

Für Videos über 30 Sekunden verwenden Sie start_render_async anstatt render_video. Dies verhindert Timeouts und ermöglicht es Ihnen, mehrere Renders parallel zu verarbeiten.

6. Überprüfen Sie URLs vor dem Rendering

Aktivieren Sie check_urls: true in validate_template, um zu überprüfen, dass alle Medien-URLs zugänglich sind. Dies verhindert Rendering-Fehler aufgrund defekter Bilder oder Videos.

7. Konsultieren Sie die Dokumentation für komplexe Komponenten

Wenn Sie benutzerdefinierte Komponenten wie AnimatedLineChart oder TypewriterEffect verwenden, rufen Sie get_component_docs auf, um die vollständige Dokumentation zu lesen. Diese Komponenten haben oft spezifische Anforderungen an das Datenformat.

8. Verwenden Sie Easing-Funktionen bewusst

Verschiedene Easing-Funktionen erzeugen unterschiedliche Bewegungsgefühle. Rufen Sie get_easing_docs auf, um zu erfahren, wann Sie easeOutBounce (spielerisch), easeInOutCubic (sanft) oder spring (natürlich) verwenden sollten.

Fehlerbehebung

MCP-Server verbindet sich nicht

Symptom: KI-Tool zeigt keine Rendervid-Tools an

Lösungen:

1. Überprüfen Sie, dass der Pfad zu index.js in Ihrer Konfiguration korrekt ist
2. Stellen Sie sicher, dass npm run build im mcp/-Verzeichnis ausgeführt wurde
3. Überprüfen Sie, dass Node.js 18+ installiert ist: node --version
4. Starten Sie Ihr KI-Tool nach dem Ändern der Konfiguration neu
5. Überprüfen Sie die Logs Ihres KI-Tools auf MCP-Verbindungsfehler

Rendering schlägt mit FFmpeg-Fehler fehl

Symptom: render_video gibt “FFmpeg nicht gefunden” oder ähnliche Fehler zurück

Lösungen:

1. Installieren Sie FFmpeg: brew install ffmpeg (macOS) oder sudo apt install ffmpeg (Linux)
2. Überprüfen Sie, dass FFmpeg im PATH ist: ffmpeg -version
3. Starten Sie Ihr Terminal/Ihre IDE nach der Installation von FFmpeg neu

Template-Validierung schlägt mit Schemafehlern fehl

Symptom: validate_template gibt Fehler über ungültige Felder zurück

Lösungen:

1. Rufen Sie get_capabilities auf, um die richtigen Feldnamen und -typen zu sehen
2. Rufen Sie get_component_defaults für den spezifischen Layer-Typ auf
3. Vergleichen Sie Ihr Template mit einem funktionierenden Beispiel aus get_example
4. Überprüfen Sie, dass alle erforderlichen Felder vorhanden sind
5. Stellen Sie sicher, dass Zahlen Zahlen sind, nicht Strings (z.B. "fontSize": 24, nicht "fontSize": "24")

Gerenderte Videos haben defekte Bilder

Symptom: Video wird gerendert, aber Bilder werden nicht angezeigt

Lösungen:

1. Verwenden Sie validate_template mit check_urls: true, um URL-Zugänglichkeit zu überprüfen
2. Stellen Sie sicher, dass Bild-URLs öffentlich zugänglich sind (keine Authentifizierung erforderlich)
3. Überprüfen Sie, dass URLs mit https:// beginnen, nicht http://
4. Stellen Sie sicher, dass CORS-Header für externe Bilder korrekt gesetzt sind

Asynchrone Render-Jobs bleiben in “Warteschlange” stecken

Symptom: check_render_status zeigt dauerhaft status: "queued" an

Lösungen:

1. Überprüfen Sie, dass der MCP-Server läuft und nicht abgestürzt ist
2. Überprüfen Sie die Systemressourcen (CPU, Speicher, Festplattenspeicher)
3. Versuchen Sie, einen einfacheren Test-Render auszuführen, um zu sehen, ob das System funktioniert
4. Rufen Sie list_render_jobs auf, um zu sehen, ob andere Jobs die Warteschlange blockieren

Nächste Schritte

Jetzt, da Sie verstehen, wie Rendervid mit KI-Agenten integriert wird:

1. Richten Sie Ihr erstes MCP-Tool ein – Folgen Sie den Anweisungen für Claude Code, Cursor oder Windsurf
2. Erkunden Sie die Beispiele – Verwenden Sie list_examples, um den Katalog von 50+ Templates zu durchsuchen
3. Experimentieren Sie mit Capabilities – Rufen Sie get_capabilities auf und sehen Sie, was Rendervid alles kann
4. Erstellen Sie Ihr erstes Video – Beginnen Sie mit einem einfachen Prompt wie “Erstelle eine Instagram Story mit meinem Firmennamen”
5. Lesen Sie die Template-System-Dokumentation – Lernen Sie über Template-Variablen, Szenen und Layer-Komposition
6. Erkunden Sie benutzerdefinierte Komponenten – Entdecken Sie vorgefertigte Komponenten wie Diagramme, Effekte und Widgets

Die Kombination von Rendervids leistungsstarker Rendering-Engine mit der natürlichsprachlichen Verständnisfähigkeit von KI-Agenten eröffnet neue Möglichkeiten für die Videoproduktion. Von der Automatisierung repetitiver Marketingaufgaben bis zur Generierung datengesteuerter Visualisierungen on-the-fly – die Möglichkeiten sind grenzenlos.

Beginnen Sie mit dem Experimentieren und sehen Sie, was Sie erstellen können.