Integracja Rendervid AI - Generuj Wideo za pomocą Claude Code, Cursor i MCP

Wprowadzenie: Generowanie Wideo Napędzane AI

Programowe tworzenie wideo tradycyjnie wymagało głębokiej wiedzy o kodekach wideo, frameworkach animacji i pipeline’ach renderowania. Rendervid eliminuje tę złożoność, akceptując szablony JSON i wyprowadzając gotowe wideo. Kiedy połączysz to z agentami AI, które rozumieją język naturalny, otrzymujesz coś potężnego: możliwość opisania wideo w prostym języku angielskim i otrzymania wyrenderowanego pliku MP4 w zamian.

Rendervid wypełnia lukę między modelami językowymi AI a produkcją wideo. Zamiast pisać kod, projektować klatki kluczowe lub uczyć się edytora wideo, mówisz agentowi AI, czego chcesz. Agent generuje prawidłowy szablon JSON , waliduje go i renderuje ostateczny wynik za pomocą silnika Rendervid. Cały proces odbywa się w jednej rozmowie.

Ta integracja jest zbudowana na Model Context Protocol (MCP), otwartym standardzie, który pozwala narzędziom AI na interakcję z zewnętrznymi usługami poprzez ustrukturyzowany interfejs. Serwer MCP Rendervid udostępnia 11 narzędzi obejmujących renderowanie, walidację, odkrywanie szablonów i dokumentację, dając agentom AI wszystko, czego potrzebują do autonomicznej produkcji profesjonalnych treści wideo.

Czym jest Model Context Protocol (MCP)?

Model Context Protocol to otwarty standard opracowany w celu zapewnienia asystentom AI ustrukturyzowanego dostępu do zewnętrznych narzędzi i źródeł danych. Zamiast polegać na tym, że modele AI będą zgadywać formaty API lub generować kod wywołujący punkty końcowe REST, MCP zapewnia typowany, odkrywalny interfejs, który agenci AI mogą odpytywać w czasie wykonania.

W przypadku generowania wideo MCP rozwiązuje krytyczny problem: agenci AI muszą wiedzieć, co jest możliwe, zanim będą mogli wygenerować prawidłowe wyjście. Bez MCP model AI musiałby być wytrenowany na konkretnym formacie szablonu Rendervid, znać każdy dostępny preset animacji i rozumieć ograniczenia każdego typu warstwy. Z MCP agent po prostu wywołuje get_capabilities i otrzymuje kompletny opis systemu, w tym schematy JSON dla każdego komponentu.

Dlaczego MCP ma znaczenie dla generowania wideo AI

• Odkrywanie w czasie wykonania: Agenci AI uczą się, co Rendervid może zrobić w momencie połączenia, a nie w czasie treningu. Oznacza to, że nowe funkcje są natychmiast dostępne bez ponownego treningu.
• Bezpieczeństwo typów: Każde narzędzie ma zdefiniowany schemat wejściowy i wyjściowy. Agent AI dokładnie wie, jakie parametry są wymagane i jakiego typu muszą być.
• Walidacja przed renderowaniem: Zamiast przesyłać szablon i mieć nadzieję, że zadziała, agent może najpierw zwalidować szablon i naprawić wszelkie problemy przed poświęceniem czasu na renderowanie.
• Kompozycyjność narzędzi: Agenci AI mogą łączyć narzędzia w łańcuch, wywołując list_examples w celu znalezienia szablonu początkowego, modyfikując go, wywołując validate_template w celu sprawdzenia go, a następnie wywołując render_video w celu wyprodukowania wyniku. Wszystko w jednej turze rozmowy.

Dokumentacja Narzędzi Serwera MCP

Serwer MCP Rendervid udostępnia 11 narzędzi zorganizowanych w trzy kategorie: Renderowanie, Walidacja i Odkrywanie oraz Dokumentacja. Każde narzędzie jest zaprojektowane, aby zapewnić agentom AI maksymalną autonomię podczas generowania treści wideo.

Narzędzia Renderowania

Te narzędzia obsługują rzeczywistą produkcję wideo i obrazów z szablonów JSON.

render_video

Generuje kompletny plik wideo z szablonu JSON. To podstawowe narzędzie renderowania do produkcji wyjścia MP4, WebM lub MOV.

Parametry:

• template (obiekt, wymagany) – Kompletny szablon JSON definiujący sceny, warstwy, animacje i ustawienia wyjściowe.
• inputs (obiekt, opcjonalny) – Pary klucz-wartość do podstawiania zmiennych szablonu.
• output_format (ciąg znaków, opcjonalny) – Format wyjściowy: mp4, webm lub mov. Domyślnie mp4.

Przykład użycia przez agenta AI:

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

Zwraca: URL lub ścieżkę do wyrenderowanego pliku wideo.

render_image

Generuje pojedynczą klatkę lub obraz statyczny z szablonu JSON. Przydatne do tworzenia miniatur, grafik dla mediów społecznościowych, klatek plakatowych i statycznych materiałów marketingowych.

Parametry:

• template (obiekt, wymagany) – Szablon JSON definiujący kompozycję obrazu.
• inputs (obiekt, opcjonalny) – Wartości podstawiania zmiennych szablonu.
• output_format (ciąg znaków, opcjonalny) – Format wyjściowy: png, jpeg lub webp. Domyślnie png.
• frame (liczba, opcjonalny) – Która klatka ma być renderowana (do wyodrębnienia konkretnego momentu z animowanego szablonu).

Kiedy używać render_image vs render_video:

• Użyj render_image dla statycznego wyjścia: miniatur, banerów, postów w mediach społecznościowych, slajdów prezentacji.
• Użyj render_video dla wszystkiego z ruchem: animacji, przejść, dźwięku, klipów wideo.

start_render_async

Rozpoczyna asynchroniczne zadanie renderowania dla wideo o długim czasie trwania (zazwyczaj powyżej 30 sekund). Zamiast czekać na zakończenie renderowania synchronicznie, to narzędzie zwraca identyfikator zadania, który możesz odpytywać za pomocą check_render_status.

Parametry:

• template (obiekt, wymagany) – Kompletny szablon JSON.
• inputs (obiekt, opcjonalny) – Wartości zmiennych szablonu.
• output_format (ciąg znaków, opcjonalny) – Pożądany format wyjściowy.

Zwraca: Ciąg znaków job_id, który może być użyty z check_render_status i list_render_jobs.

Kiedy używać renderowania asynchronicznego:

• Wideo dłuższe niż 30 sekund
• Szablony z wieloma scenami lub złożonymi animacjami
• Przepływy pracy renderowania wsadowego, gdzie chcesz przesłać wiele zadań i zebrać wyniki później
• Środowiska renderowania w chmurze, gdzie długotrwałe żądania synchroniczne mogą przekroczyć limit czasu

check_render_status

Sprawdza aktualny status asynchronicznego zadania renderowania rozpoczętego za pomocą start_render_async.

Parametry:

• job_id (ciąg znaków, wymagany) – Identyfikator zadania zwrócony przez start_render_async.

Zwraca: Obiekt zawierający:

• status – Jeden z: queued, rendering, completed lub failed.
• progress – Procent (0-100) wskazujący postęp renderowania.
• output_url – URL gotowego wideo (obecny tylko gdy status to completed).
• error – Komunikat o błędzie, jeśli zadanie nie powiodło się.

Przykład przepływu pracy odpytywania:

Agent AI:
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

Wyświetla wszystkie asynchroniczne zadania renderowania, zarówno aktywne, jak i zakończone. Przydatne do monitorowania operacji renderowania wsadowego lub przeglądania ostatnich wyników.

Parametry:

• status_filter (ciąg znaków, opcjonalny) – Filtruj według statusu: queued, rendering, completed, failed lub all. Domyślnie all.
• limit (liczba, opcjonalny) – Maksymalna liczba zadań do zwrócenia.

Zwraca: Tablicę obiektów zadań, każdy z job_id, status, progress, created_at i output_url (jeśli zakończone).

Narzędzia Walidacji i Odkrywania

Te narzędzia pomagają agentom AI zrozumieć, co Rendervid może zrobić i zweryfikować, że szablony są poprawne przed renderowaniem.

validate_template

Waliduje szablon JSON przed renderowaniem. To narzędzie sprawdza strukturę szablonu, typy pól, ograniczenia wartości, a nawet weryfikuje, czy adresy URL multimediów (obrazy, wideo, pliki audio) są dostępne. Uruchomienie walidacji przed renderowaniem zapobiega marnowaniu czasu na szablony, które zawiodłyby podczas procesu renderowania.

Parametry:

• template (obiekt, wymagany) – Szablon JSON do walidacji.
• check_urls (boolean, opcjonalny) – Czy weryfikować dostępność adresów URL multimediów. Domyślnie true.

Zwraca: Obiekt zawierający:

• valid – Boolean wskazujący, czy szablon jest prawidłowy.
• errors – Tablica obiektów błędów z path, message i severity dla każdego znalezionego problemu.
• warnings – Tablica obiektów ostrzeżeń dla problemów niekrytycznych (np. nieużywane zmienne, bardzo duże wymiary).

Co wykrywa walidacja:

• Brakujące wymagane pola (np. scena bez duration)
• Nieprawidłowe typy pól (np. ciąg znaków tam, gdzie oczekiwana jest liczba)
• Nieznane typy warstw lub presety animacji
• Zepsute lub niedostępne adresy URL multimediów (obrazy, wideo, pliki audio)
• Wartości poza zakresem (np. ujemne wymiary, fps powyżej maksimum)
• Błędy składni zmiennych szablonu

Przykład odpowiedzi walidacji:

{
  "valid": false,
  "errors": [
    {
      "path": "scenes[0].layers[2].src",
      "message": "URL returned HTTP 404: https://example.com/missing-image.png",
      "severity": "error"
    },
    {
      "path": "scenes[1].duration",
      "message": "Scene duration must be a positive number",
      "severity": "error"
    }
  ],
  "warnings": [
    {
      "path": "outputSettings.width",
      "message": "Width 7680 is very large and may result in slow rendering",
      "severity": "warning"
    }
  ]
}

get_capabilities

Zwraca kompleksowy opis wszystkiego, co Rendervid może zrobić. To zazwyczaj pierwsze narzędzie, które agent AI wywołuje, rozpoczynając zadanie generowania wideo. Odpowiedź zawiera dostępne typy warstw, presety animacji, funkcje easingu, filtry, formaty wyjściowe i ich schematy JSON.

Parametry: Brak.

Zwraca: Ustrukturyzowany obiekt zawierający:

• layerTypes – Wszystkie dostępne typy warstw (text, image, video, shape, audio, group, lottie, custom) z ich schematami JSON i konfigurowalnymi właściwościami.
• animations – Wszystkie presety animacji pogrupowane według kategorii (entrance, exit, emphasis, keyframe) z opisami i konfigurowalnymi parametrami.
• easingFunctions – Wszystkie ponad 30 funkcji easingu z opisami i przykładami użycia.
• filters – Dostępne filtry wizualne (blur, brightness, contrast, saturate, grayscale, sepia, itp.) z zakresami parametrów.
• outputFormats – Obsługiwane formaty wyjściowe dla renderowania wideo i obrazów z ich ograniczeniami.
• inputTypes – Typy zmiennych szablonu i reguły walidacji.
• sceneTransitions – Wszystkie 17 typów przejść scen z ich parametrami.

Dlaczego to narzędzie jest krytyczne dla agentów AI:

Odpowiedź capabilities to samoopisujące się API. Agent AI nie musi być wytrenowany na formacie szablonu Rendervid. Może wywołać get_capabilities w czasie wykonania, otrzymać kompletny schemat i wygenerować prawidłowe szablony przy pierwszej próbie. Gdy Rendervid dodaje nowe funkcje, animacje lub typy warstw, agenci AI automatycznie uzyskują do nich dostęp poprzez to narzędzie bez żadnych zmian w kodzie.

get_example

Ładuje konkretny przykładowy szablon według nazwy. Agenci AI używają tego do pobrania działającego szablonu jako punktu wyjścia, a następnie modyfikują go, aby dopasować do wymagań użytkownika.

Parametry:

• name (ciąg znaków, wymagany) – Nazwa przykładowego szablonu (np. instagram-story, product-showcase, animated-bar-chart).

Zwraca: Kompletny szablon JSON dla żądanego przykładu, gotowy do renderowania lub modyfikacji.

Przykład:

Agent AI wywołuje: get_example("instagram-story")
Zwraca: Kompletny szablon Instagram story 1080x1920 z warstwami tekstowymi,
         obrazem tła i animacjami wejścia

list_examples

Przegląda pełny katalog ponad 50 przykładowych szablonów zorganizowanych według kategorii. Agenci AI używają tego do znajdowania odpowiednich szablonów początkowych dla żądania użytkownika.

Parametry:

• category (ciąg znaków, opcjonalny) – Filtruj według kategorii (np. social-media, marketing, data-visualization, typography, e-commerce).

Zwraca: Tablicę obiektów metadanych przykładów, każdy z:

• name – Identyfikator szablonu do użycia z get_example.
• category – Kategoria szablonu.
• description – Co szablon tworzy.
• dimensions – Szerokość i wysokość wyjścia.
• duration – Czas trwania szablonu w sekundach.

Narzędzia Dokumentacji

Te narzędzia zapewniają szczegółową dokumentację referencyjną, którą agenci AI mogą konsultować podczas konstruowania szablonów.

get_component_docs

Zwraca szczegółową dokumentację dla konkretnego komponentu lub typu warstwy . Zawiera opisy właściwości, wymagane vs opcjonalne pola, wartości domyślne i przykłady użycia.

Parametry:

• component (ciąg znaków, wymagany) – Nazwa komponentu/typu warstwy (np. text, image, video, shape, audio, group, lottie, custom, AnimatedLineChart, TypewriterEffect).

Zwraca: Kompleksową dokumentację zawierającą:

• Tabelę właściwości z typami, wartościami domyślnymi i opisami
• Schemat JSON dla komponentu
• Przykłady użycia
• Uwagi dotyczące różnic w renderowaniu w przeglądarce vs Node.js

get_animation_docs

Zwraca kompletną dokumentację efektów animacji, w tym wszystkie presety animacji wejścia, wyjścia, nacisku i klatek kluczowych.

Parametry:

• animation (ciąg znaków, opcjonalny) – Konkretna nazwa animacji, dla której uzyskać szczegółową dokumentację (np. fadeInUp, bounceIn, slideOutLeft). Jeśli pominięto, zwraca pełny katalog animacji.

Zwraca: Dokumentację animacji zawierającą:

• Nazwę animacji i kategorię (entrance, exit, emphasis, keyframe)
• Opis efektu wizualnego
• Konfigurowalne parametry (duration, delay, easing)
• Wartości domyślne
• Zalecane przypadki użycia

get_component_defaults

Zwraca wartości domyślne i pełny schemat JSON dla konkretnego typu komponentu. Agenci AI używają tego do zrozumienia, jak wygląda minimalny prawidłowy komponent i jakie właściwości mogą nadpisać.

Parametry:

• component (ciąg znaków, wymagany) – Nazwa komponentu/typu warstwy.

Zwraca: Obiekt JSON z:

• defaults – Kompletne wartości domyślne dla każdej właściwości
• schema – Schemat JSON definiujący strukturę, typy i ograniczenia komponentu
• required – Lista wymaganych właściwości

Przykład odpowiedzi dla warstwy tekstowej:

{
  "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": "The text content to display" },
      "fontSize": { "type": "number", "minimum": 1, "maximum": 500 },
      "fontFamily": { "type": "string", "description": "Google Font name or system font" },
      "color": { "type": "string", "pattern": "^#[0-9a-fA-F]{6}$" }
    }
  }
}

get_easing_docs

Zwraca kompletną dokumentację dla wszystkich dostępnych funkcji easingu. Funkcje easingu kontrolują krzywą przyspieszenia animacji, określając, czy zaczynają się wolno, kończą wolno, odbijają się lub podążają za krzywą elastyczną.

Parametry:

• easing (ciąg znaków, opcjonalny) – Konkretna nazwa funkcji easingu dla szczegółowej dokumentacji. Jeśli pominięto, zwraca pełną listę.

Zwraca: Dokumentację dla każdej funkcji easingu zawierającą:

• Nazwę funkcji (np. easeInOutCubic, easeOutBounce, spring)
• Matematyczny opis krzywej
• Wizualny opis wrażenia ruchu
• Zalecane przypadki użycia
• Odpowiednik CSS (gdzie ma zastosowanie)

Konfiguracja Integracji AI

Podłączenie Rendervid do narzędzia AI wymaga dodania serwera MCP do konfiguracji narzędzia. Proces konfiguracji różni się nieznacznie między narzędziami, ale podstawowa koncepcja jest taka sama: wskaż narzędziu AI punkt wejścia serwera MCP Rendervid.

Wymagania wstępne

Przed skonfigurowaniem dowolnego narzędzia AI upewnij się, że masz:

1. Node.js 18+ zainstalowany w systemie
2. Rendervid sklonowany i zbudowany z repozytorium GitHub :

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

3. FFmpeg zainstalowany (wymagany do wyjścia wideo):

# macOS
brew install ffmpeg

# Ubuntu/Debian
sudo apt install ffmpeg

# Windows (z Chocolatey)
choco install ffmpeg

Claude Desktop / Claude Code

Dodaj serwer MCP Rendervid do pliku konfiguracyjnego Claude Desktop.

Lokalizacja pliku konfiguracyjnego:

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

Konfiguracja:

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

Zamień /path/to/rendervid na rzeczywistą ścieżkę do instalacji Rendervid.

Dla Claude Code (CLI), dodaj tę samą konfigurację do pliku .claude/mcp.json projektu lub globalnych ustawień Claude Code. Claude Code automatycznie wykryje serwer MCP i udostępni wszystkie 11 narzędzi podczas sesji kodowania.

Po zapisaniu konfiguracji uruchom ponownie Claude Desktop lub Claude Code. Możesz zweryfikować połączenie, pytając Claude: “Jakie narzędzia Rendervid są dostępne?” Claude powinien wyświetlić wszystkie 11 narzędzi MCP.

Cursor IDE

Dodaj serwer MCP Rendervid do konfiguracji MCP Cursora.

Plik konfiguracyjny: .cursor/mcp.json w katalogu głównym projektu (lub globalne ustawienia Cursora).

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

Po zapisaniu uruchom ponownie Cursor. Narzędzia Rendervid będą dostępne w asystencie AI Cursora, umożliwiając generowanie wideo bezpośrednio z edytora.

Windsurf IDE

Windsurf obsługuje serwery MCP poprzez swoją konfigurację AI. Dodaj serwer Rendervid do ustawień MCP Windsurf:

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

Zapoznaj się z dokumentacją Windsurf, aby poznać dokładną lokalizację pliku konfiguracyjnego, ponieważ może się ona różnić w zależności od wersji i systemu operacyjnego.

Ogólna Konfiguracja MCP

Każde narzędzie, które implementuje specyfikację klienta MCP, może połączyć się z serwerem MCP Rendervid. Serwer komunikuje się przez stdio (standardowe wejście/wyjście), co jest domyślnym transportem MCP.

Aby zintegrować z niestandardowym klientem MCP:

1. Uruchom proces serwera MCP:

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

2. Komunikuj się przez stdin/stdout używając protokołu JSON-RPC MCP.
3. Wywołaj tools/list, aby odkryć dostępne narzędzia.
4. Wywołaj tools/call z nazwą narzędzia i argumentami, aby wykonać dowolne narzędzie.

Serwer MCP jest bezstanowy. Każde wywołanie narzędzia jest niezależne, a serwer może obsługiwać równoczesne żądania od wielu klientów.

Przepływ Pracy AI: Przykłady End-to-End

Poniższe przykłady pokazują, jak agenci AI używają narzędzi MCP Rendervid, aby przejść od promptu w języku naturalnym do gotowego wideo.

Przykład 1: Tworzenie Treści dla Mediów Społecznościowych

Prompt użytkownika: “Stwórz 10-sekundową Instagram story promującą letnią wyprzedaż z animowanym tekstem i gradientowym tłem”

Przepływ pracy agenta AI:

Krok 1 – Odkryj możliwości:

Agent wywołuje get_capabilities, aby dowiedzieć się o dostępnych typach warstw, presetach animacji i ograniczeniach wyjściowych. Odkrywa, że dostępne są warstwy text i shape, istnieją animacje fadeInUp i scaleIn, a Instagram stories używają rozdzielczości 1080x1920.

Krok 2 – Znajdź szablon początkowy:

Agent wywołuje list_examples z category: "social-media" i znajduje szablon instagram-story. Następnie wywołuje get_example("instagram-story"), aby załadować pełny JSON szablonu.

Krok 3 – Zbuduj szablon:

Używając przykładu jako odniesienia, agent konstruuje niestandardowy szablon:

{
  "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": "SUMMER SALE",
          "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% OFF EVERYTHING",
          "fontSize": 64,
          "fontFamily": "Montserrat",
          "color": "#FFE066",
          "position": { "x": 540, "y": 850 },
          "animations": [
            { "type": "fadeInUp", "duration": 0.8, "delay": 0.6 }
          ]
        },
        {
          "type": "text",
          "text": "Shop Now  →",
          "fontSize": 48,
          "fontFamily": "Montserrat",
          "color": "#FFFFFF",
          "position": { "x": 540, "y": 1200 },
          "animations": [
            { "type": "scaleIn", "duration": 0.6, "delay": 1.2 }
          ]
        }
      ]
    }
  ]
}

Krok 4 – Waliduj:

Agent wywołuje validate_template z JSON szablonu. Odpowiedź wraca jako valid: true bez błędów.

Krok 5 – Renderuj:

Agent wywołuje render_video ze zwalidowanym szablonem i otrzymuje URL do gotowego pliku MP4.

Przykład 2: Automatyzacja Wideo Marketingowego

Prompt użytkownika: “Wygeneruj wideo prezentacji produktu dla naszych nowych słuchawek. Użyj tego obrazu produktu: https://example.com/headphones.png . Nazwa produktu to ‘SoundPro X1’, a cena to $299.”

Przepływ pracy agenta AI:

1. get_capabilities – Dowiaduje się o warstwach obrazów, stylizacji tekstu i opcjach animacji.
2. list_examples – Znajduje szablon product-showcase w kategorii e-commerce.
3. get_example("product-showcase") – Ładuje kompletny szablon prezentacji produktu, który używa zmiennych szablonu dla nazwy produktu, obrazu i ceny.
4. Modyfikuje szablon – Aktualizuje inputs danymi produktu użytkownika:

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

5. validate_template – Weryfikuje szablon i potwierdza, że https://example.com/headphones.png jest dostępny.
6. render_video – Produkuje finalne wideo prezentacji produktu.

Ten przepływ pracy demonstruje, jak agenci AI wykorzystują zmienne szablonu do tworzenia spersonalizowanych treści z szablonów wielokrotnego użytku. Ten sam szablon prezentacji produktu może wygenerować setki unikalnych wideo poprzez zamianę danych wejściowych.

Przykład 3: Generowanie Wizualizacji Danych

Prompt użytkownika: “Stwórz animowany wykres słupkowy pokazujący kwartalne przychody: Q1: $1.2M, Q2: $1.8M, Q3: $2.1M, Q4: $2.7M”

Przepływ pracy agenta AI:

1. get_capabilities – Odkrywa typ warstwy custom i wbudowany komponent AnimatedLineChart.
2. get_component_docs("AnimatedLineChart") – Czyta dokumentację komponentu wykresu, ucząc się o formacie danych, konfiguracji kolorów, etykietach osi i opcjach animacji.
3. get_component_defaults("AnimatedLineChart") – Otrzymuje wartości domyślne i schemat JSON, aby zrozumieć minimalną wymaganą konfigurację.
4. Buduje szablon z warstwą komponentu niestandardowego:

   {
     "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": "Quarterly Revenue 2025",
       "yAxisLabel": "Revenue (USD)",
       "animationDuration": 2
     }
   }
   

5. validate_template – Potwierdza, że struktura szablonu jest poprawna.
6. render_video – Generuje wideo animowanego wykresu.

Samoopisujące się API: Jak Capabilities Czynią Agentów AI Efektywnymi

Narzędzie get_capabilities jest kamieniem węgielnym integracji AI Rendervid. Implementuje wzorzec samoopisującego się API, gdzie system mówi agentom AI dokładnie, co może zrobić, jakie parametry są wymagane i jakie wartości są prawidłowe. To eliminuje potrzebę zapamiętywania lub trenowania modeli AI na konkretnym API Rendervid.

Co Zawiera Odpowiedź Capabilities

Gdy agent AI wywołuje get_capabilities, otrzymuje ustrukturyzowaną odpowiedź obejmującą każdy aspekt systemu renderowania:

Typy Warstw ze Schematami JSON:

{
  "layerTypes": {
    "text": {
      "description": "Renders text with full styling control",
      "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": { "..." : "..." },
    "video": { "..." : "..." },
    "shape": { "..." : "..." },
    "audio": { "..." : "..." },
    "group": { "..." : "..." },
    "lottie": { "..." : "..." },
    "custom": { "..." : "..." }
  }
}

Presety Animacji:

Odpowiedź capabilities wymienia każdy preset animacji z jego kategorią, konfigurowalnymi parametrami i opisem. Agent AI otrzymujący te dane wie, że fadeInUp to animacja wejścia z parametrami duration, delay i easing, i że przesuwa element w górę, jednocześnie go rozjaśniając.

Funkcje Easingu:

Wszystkie ponad 30 funkcji easingu jest wymienionych z opisami, więc agent AI może wybrać odpowiednią krzywą dla każdej animacji. Na przykład easeOutBounce jest opisywany jako symulujący efekt odbicia na końcu animacji, który agent może polecić dla treści zabawnych lub przyciągających uwagę.

Filtry i Efekty:

Filtry wizualne takie jak blur, brightness, contrast, saturate, grayscale i sepia są udokumentowane z zakresami parametrów, pozwalając agentowi AI stosować efekty postprocessingu do dowolnej warstwy.

Dlaczego Samoopisujące się API Ma Znaczenie

Tradycyjne API wymagają dokumentacji, którą modele AI mogły lub nie widzieć podczas treningu. Samoopisujące się API dostarcza dokumentację w czasie wykonania, zapewniając, że agent AI zawsze ma aktualne, dokładne informacje. Gdy Rendervid dodaje nowy preset animacji lub typ warstwy, każdy podłączony agent AI natychmiast go widzi poprzez get_capabilities. Bez aktualizacji dokumentacji, bez ponownego treningu, bez niezgodności wersji.

Najlepsze Praktyki dla Generowania Wideo AI

Postępuj zgodnie z tymi wytycznymi, aby uzyskać najlepsze wyniki podczas używania agentów AI do generowania wideo Rendervid.

1. Zawsze Waliduj Przed Renderowaniem

Wywołaj validate_template przed każdym renderowaniem. Renderowanie jest obliczeniowo kosztowne, a walidacja jest niemal natychmiastowa. Narzędzie walidacji wychwytuje problemy, które spowodowałyby niepowodzenie renderowania lub nieoczekiwane wyjście:

• Zepsute adresy URL multimediów (obrazy, wideo, pliki audio zwracające 404)
• Nieprawidłowa struktura JSON lub brakujące wymagane pola
• Wartości poza zakresem dla wymiarów, rozmiarów czcionek lub czasów trwania
• Nieznane presety animacji lub typy warstw

Typowy przepływ pracy AI powinien zawsze zawierać walidację jako krok przed wywołaniem render_video lub render_image.

2. Zacznij od Przykładów

Zamiast budować szablony od zera, agenci AI powinni używać list_examples i get_example, aby znaleźć odpowiedni szablon początkowy. Przykładowe szablony są przetestowane i wiadomo, że produkują dobre wyjście. Rozpoczęcie od przykładu i jego modyfikacja jest szybsza i mniej podatna na błędy niż generowanie całkowicie nowej struktury szablonu.

Zalecane podejście:

1. Wywołaj list_examples z odpowiednią kategorią
2. Wywołaj get_example dla najbliższego pasującego szablonu
3. Zmodyfikuj szablon, aby dopasować do konkretnych wymagań użytkownika
4. Waliduj i renderuj

3. Używaj Opisowych Promptów

Podczas żądania wideo od agenta AI, bądź konkretny co do:

• Wymiarów i platformy – “1080x1920 Instagram story” jest lepsze niż “pionowe wideo”
• Czasu trwania – “10-sekundowe intro” jest lepsze niż “krótkie wideo”
• Stylu i nastroju – “ciemne tło z neonowym tekstem i odbijającymi się animacjami” daje agentowi AI jasny kierunek
• Struktury treści – “Trzy linie tekstu pojawiające się jedna po drugiej z animacjami fade-in” jest bardziej wykonalne niż “jakiś animowany tekst”

4. Iteruj nad Szablonami

Generowanie wideo jest iteracyjne. Po pierwszym renderowaniu przejrzyj wynik i poproś agenta AI o dostosowanie konkretnych elementów:

• “Zwiększ rozmiar tekstu tytułu i zmień kolor na złoty”
• “Spowolnij animacje wejścia i dodaj 0,5-sekundowe opóźnienie między każdą linią”
• “Dodaj subtelny filtr rozmycia do obrazu tła”
• “Zmień easing z linear na easeOutCubic dla płynniejszego ruchu”

Agent AI może modyfikować istniejący szablon i ponownie renderować bez rozpoczynania od nowa, czyniąc iterację szybką i efektywną.

5. Wykorzystaj Zmienne Szablonu dla Produkcji Wsadowej

Jeśli potrzebujesz wielu wariantów tego samego wideo (różne produkty, różne języki, różne dane), poproś agenta AI o stworzenie szablonu ze zmiennymi . To pozwala renderować wiele wideo z jednego szablonu poprzez przekazywanie różnych inputs:

{
  "inputs": {
    "productName": "Running Shoes Pro",
    "productImage": "https://example.com/shoes.png",
    "price": "$149",
    "tagline": "Run Faster, Go Further"
  }
}

6. Używaj Renderowania Asynchronicznego dla Długich Wideo

Dla wideo dłuższych niż 30 sekund lub szablonów ze złożonymi animacjami, użyj start_render_async zamiast render_video. To zapobiega przekroczeniu limitu czasu i pozwala agentowi AI wykonywać inne zadania, podczas gdy wideo renderuje się w tle.

Odkrywanie Szablonów: Przeglądanie ponad 100 Przykładów

Rendervid zawiera ponad 100 przykładowych szablonów obejmujących 32 kategorie, dając agentom AI bogatą bibliotekę punktów startowych dla dowolnego zadania generowania wideo.

Jak Agenci AI Odkrywają Szablony

Przepływ pracy odkrywania szablonów używa dwóch narzędzi w sekwencji:

1. list_examples – Przeglądaj katalog z opcjonalnym filtrowaniem kategorii, aby znaleźć odpowiednie szablony.
2. get_example – Załaduj pełny szablon JSON dla konkretnego przykładu.

Kategorie Szablonów

Agenci AI mogą filtrować przykłady według kategorii, aby szybko znaleźć odpowiednie punkty startowe:

Odkrywanie Szablonów w Praktyce

Gdy użytkownik prosi o “animowany wykres pokazujący dane sprzedaży”, agent AI:

1. Wywołuje list_examples(category: "data-visualization") i otrzymuje listę szablonów związanych z wykresami.
2. Identyfikuje animated-bar-chart jako najlepsze dopasowanie na podstawie opisu.
3. Wywołuje get_example("animated-bar-chart"), aby załadować kompletny szablon.
4. Bada strukturę szablonu, aby zrozumieć, jak dane są sformatowane.
5. Zastępuje przykładowe dane rzeczywistymi liczbami sprzedaży użytkownika.
6. Waliduje i renderuje.

To podejście oparte na odkrywaniu oznacza, że agenci AI konsekwentnie produkują dobrze ustrukturyzowane szablony, ponieważ budują na przetestowanych przykładach, zamiast generować JSON szablonu od zera.

Eksploracja Wszystkich Dostępnych Szablonów

Aby zobaczyć każdy dostępny szablon, agent AI może wywołać list_examples bez filtra kategorii. Odpowiedź zawiera metadane dla wszystkich ponad 100 szablonów, pozwalając agentowi przeszukiwać kategorie w poszukiwaniu najlepszego dopasowania. Każdy wpis zawiera nazwę szablonu, kategorię, opis, wymiary i czas trwania, dając agentowi wystarczająco dużo informacji do podjęcia świadomej decyzji.

Obsługiwane Narzędzia AI

Serwer MCP Rendervid działa z dowolnym narzędziem, które implementuje specyfikację klienta Model Context Protocol. Następujące narzędzia zostały przetestowane i potwierdzone jako działające z Rendervid:

Ponieważ MCP jest otwartym standardem, każde przyszłe narzędzie, które doda wsparcie klienta MCP, będzie automatycznie kompatybilne z serwerem MCP Rendervid. Nie są wymagane żadne zmiany w serwerze ani jego narzędziach.

Następne Kroki

• Przegląd Rendervid – Dowiedz się o wszystkich funkcjach Rendervid, formatach wyjściowych i architekturze.
• System Szablonów – Głębokie zanurzenie w strukturę szablonu JSON, zmienne i system wejściowy.
• Dokumentacja Komponentów – Dokumentacja dla wszystkich typów warstw i niestandardowych komponentów React.
• Przewodnik Wdrożenia – Wdróż Rendervid na AWS Lambda, Azure Functions, Google Cloud Run lub Docker dla renderowania w skali chmury.
• Repozytorium GitHub – Kod źródłowy, tracker problemów i wkłady społeczności.