Rendervid AI Integrácia - Generujte videá s Claude Code, Cursor & MCP

Úvod: AI-poháňané generovanie videí

Vytváranie videí programaticky tradične vyžadovalo hlboké znalosti video kodekov, animačných frameworkov a renderovacích pipeline. Rendervid eliminuje túto zložitosť prijímaním JSON šablón a výstupom hotových videí. Keď to skombinujete s AI agentmi, ktorí rozumejú prirodzenému jazyku, získate niečo silné: schopnosť opísať video v jednoduchej angličtine a dostať renderované MP4 späť.

Rendervid premosťuje priepasť medzi AI jazykovými modelmi a produkciou videa. Namiesto písania kódu, navrhovania kľúčových snímok alebo učenia sa video editora poviete AI agentovi, čo chcete. Agent vygeneruje platnú JSON šablónu , validuje ju a renderuje finálny výstup cez Rendervid engine. Celý proces sa odohráva v jednej konverzácii.

Táto integrácia je postavená na Model Context Protocol (MCP), otvorenom štandarde, ktorý umožňuje AI nástrojom interagovať s externými službami cez štruktúrované rozhraní. Rendervid MCP server vystavuje 11 nástrojov pokrývajúcich renderovanie, validáciu, objavovanie šablón a dokumentáciu, čím poskytuje AI agentom všetko, čo potrebujú na autonómnu produkciu profesionálneho video obsahu.

Čo je Model Context Protocol (MCP)?

Model Context Protocol je otvorený štandard vyvinutý na poskytnutie AI asistentom štruktúrovaného prístupu k externým nástrojom a zdrojom dát. Namiesto spoliehania sa na AI modely, aby hádali formáty API alebo generovali kód, ktorý volá REST endpointy, MCP poskytuje typované, objaviteľné rozhraní, ktoré AI agenti môžu dopytovať počas behu.

Pre generovanie videa MCP rieši kritický problém: AI agenti potrebujú vedieť, čo je možné, predtým než môžu generovať platný výstup. Bez MCP by AI model potreboval byť trénovaný na špecifickom formáte šablón Rendervid, poznať každú dostupnú animačnú predvoľbu a rozumieť obmedzeniam každého typu vrstvy. S MCP agent jednoducho zavolá get_capabilities a dostane kompletný popis systému, vrátane JSON schém pre každý komponent.

Prečo MCP záleží pre AI generovanie videa

• Objavovanie počas behu: AI agenti sa učia, čo Rendervid dokáže, v momente pripojenia, nie v čase tréningu. To znamená, že nové funkcie sú okamžite dostupné bez pretrénovávania.
• Typová bezpečnosť: Každý nástroj má definovanú vstupnú a výstupnú schému. AI agent presne vie, jaké parametre sú vyžadované a aké typy musia mať.
• Validácia pred renderovaním: Namiesto odoslania šablóny a dúfania, že funguje, agent môže šablónu najprv validovať a opraviť akékoľvek problémy pred strávením času na renderovaní.
• Kompozitabilita nástrojov: AI agenti môžu reťaziť nástroje, volať list_examples na nájdenie počiatočnej šablóny, upraviť ju, volať validate_template na kontrolu a potom volať render_video na produkciu výstupu. Všetko v jednom konverzačnom ťahu.

Referencia nástrojov MCP servera

Rendervid MCP server vystavuje 11 nástrojov organizovaných do troch kategórií: Renderovanie, Validácia & Objavovanie a Dokumentácia. Každý nástroj je navrhnutý tak, aby poskytol AI agentom maximálnu autonómiu pri generovaní video obsahu.

Nástroje pre renderovanie

Tieto nástroje spracúvajú skutočnú produkciu video a obrazového výstupu z JSON šablón.

render_video

Generuje kompletný video súbor z JSON šablóny. Toto je primárny renderovací nástroj pre produkciu MP4, WebM alebo MOV výstupu.

Parametre:

• template (objekt, povinný) – Kompletná JSON šablóna definujúca scény, vrstvy, animácie a výstupné nastavenia.
• inputs (objekt, voliteľný) – Páry kľúč-hodnota pre substitúciu premenných šablóny.
• output_format (reťazec, voliteľný) – Výstupný formát: mp4, webm alebo mov. Predvolené je mp4.

Príklad použitia AI agentom:

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

Vracia: URL alebo cestu k súboru renderovaného videa.

render_image

Generuje jeden snímok alebo statický obrázok z JSON šablóny. Užitočné pre vytváranie náhľadov, grafiky pre sociálne médiá, posterových snímok a statických marketingových materiálov.

Parametre:

• template (objekt, povinný) – JSON šablóna definujúca kompozíciu obrázka.
• inputs (objekt, voliteľný) – Hodnoty substitúcie premenných šablóny.
• output_format (reťazec, voliteľný) – Výstupný formát: png, jpeg alebo webp. Predvolené je png.
• frame (číslo, voliteľné) – Ktorý snímok renderovať (pre extrahovanie špecifického momentu z animovanej šablóny).

Kedy použiť render_image vs render_video:

• Použite render_image pre statický výstup: náhľady, bannery, príspevky na sociálne médiá, prezentačné snímky.
• Použite render_video pre čokoľvek s pohybom: animácie, prechody, audio, video klipy.

start_render_async

Spustí asynchrónnu renderovú úlohu pre dlhé videá (typicky nad 30 sekúnd). Namiesto čakania na dokončenie renderovania synchrónne, tento nástroj vracia ID úlohy, ktoré môžete opytovať pomocou check_render_status.

Parametre:

• template (objekt, povinný) – Kompletná JSON šablóna.
• inputs (objekt, voliteľný) – Hodnoty premenných šablóny.
• output_format (reťazec, voliteľný) – Požadovaný výstupný formát.

Vracia: Reťazec job_id, ktorý môže byť použitý s check_render_status a list_render_jobs.

Kedy použiť asynchrónne renderovanie:

• Videá dlhšie ako 30 sekúnd
• Šablóny s mnohými scénami alebo komplexnými animáciami
• Dávkové renderovanie, kde chcete odoslať viacero úloh a zbierať výsledky neskôr
• Cloudové renderovanie, kde dlhotrvajúce synchrónne požiadavky môžu vypršať

check_render_status

Kontroluje aktuálny stav asynchrónnej renderovej úlohy spustenej pomocou start_render_async.

Parametre:

• job_id (reťazec, povinný) – ID úlohy vrátené pomocou start_render_async.

Vracia: Objekt obsahujúci:

• status – Jeden z queued, rendering, completed alebo failed.
• progress – Percento (0-100) indikujúce pokrok renderovania.
• output_url – URL hotového videa (prítomné iba keď status je completed).
• error – Chybová správa, ak úloha zlyhala.

Príklad workflow opytovanie:

AI 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

Zoznam všetkých asynchrónnych renderovacích úloh, aktívnych aj dokončených. Užitočné pre monitorovanie dávkových renderovacích operácií alebo preskúmanie nedávneho výstupu.

Parametre:

• status_filter (reťazec, voliteľný) – Filtrovať podľa stavu: queued, rendering, completed, failed alebo all. Predvolené je all.
• limit (číslo, voliteľné) – Maximálny počet úloh na vrátenie.

Vracia: Pole objektov úloh, každý s job_id, status, progress, created_at a output_url (ak je dokončené).

Nástroje pre validáciu a objavovanie

Tieto nástroje pomáhajú AI agentom pochopiť, čo Rendervid dokáže, a overiť, že šablóny sú správne pred renderovaním.

validate_template

Validuje JSON šablónu pred renderovaním. Tento nástroj kontroluje štruktúru šablóny, typy polí, obmedzenia hodnôt a dokonca overuje, že URL médií (obrázky, videá, audio súbory) sú prístupné. Spustenie validácie pred renderovaním zabráni stratenému času na šablónach, ktoré by zlyhali počas procesu renderovania.

Parametre:

• template (objekt, povinný) – JSON šablóna na validáciu.
• check_urls (boolean, voliteľný) – Či overiť, že URL médií sú prístupné. Predvolené je true.

Vracia: Objekt obsahujúci:

• valid – Boolean indikujúci, či je šablóna platná.
• errors – Pole chybových objektov s path, message a severity pre každý nájdený problém.
• warnings – Pole varovných objektov pre nekritické problémy (napr. nepoužité premenné, veľmi veľké rozmery).

Čo validácia zachytáva:

• Chýbajúce povinné polia (napr. scéna bez duration)
• Neplatné typy polí (napr. reťazec, kde sa očakáva číslo)
• Neznáme typy vrstiev alebo animačné predvoľby
• Poškodené alebo neprístupné URL médií (obrázky, videá, audio súbory)
• Hodnoty mimo rozsahu (napr. negatívne rozmery, fps nad maximom)
• Syntaktické chyby premenných šablóny

Príklad validačnej odpovede:

{
  "valid": false,
  "errors": [
    {
      "path": "scenes[0].layers[2].src",
      "message": "URL vrátilo HTTP 404: https://example.com/missing-image.png",
      "severity": "error"
    },
    {
      "path": "scenes[1].duration",
      "message": "Trvanie scény musí byť kladné číslo",
      "severity": "error"
    }
  ],
  "warnings": [
    {
      "path": "outputSettings.width",
      "message": "Šírka 7680 je veľmi veľká a môže viesť k pomalému renderovaniu",
      "severity": "warning"
    }
  ]
}

get_capabilities

Vracia komplexný popis všetkého, čo Rendervid dokáže. Toto je typicky prvý nástroj, ktorý AI agent zavolá pri začatí úlohy generovania videa. Odpoveď zahŕňa dostupné typy vrstiev, animačné predvoľby, easing funkcie, filtre, výstupné formáty a ich JSON schémy.

Parametre: Žiadne.

Vracia: Štruktúrovaný objekt obsahujúci:

• layerTypes – Všetky dostupné typy vrstiev (text, image, video, shape, audio, group, lottie, custom) s ich JSON schémami a konfigurovateľnými vlastnosťami.
• animations – Všetky animačné predvoľby zoskupené podľa kategórie (entrance, exit, emphasis, keyframe) s popismi a konfigurovateľnými parametrami.
• easingFunctions – Všetkých 30+ easing funkcií s popismi a príkladmi použitia.
• filters – Dostupné vizuálne filtre (blur, brightness, contrast, saturate, grayscale, sepia, atď.) s rozsahmi parametrov.
• outputFormats – Podporované výstupné formáty pre renderovanie videa a obrázkov s ich obmedzeniami.
• inputTypes – Typy premenných šablón a validačné pravidlá.
• sceneTransitions – Všetkých 17 typov prechodov scén s ich parametrami.

Prečo je tento nástroj kritický pre AI agentov:

Odpoveď capabilities je samoopisné API. AI agent nemusí byť pretrénovaný na formáte šablón Rendervid. Môže zavolať get_capabilities počas behu, dostať kompletnú schému a generovať platné šablóny pri prvom pokuse. Keď Rendervid pridá nové funkcie, animácie alebo typy vrstiev, každý pripojený AI agent k nim automaticky získa prístup cez tento nástroj bez akýchkoľvek zmien kódu.

get_example

Načíta špecifickú príkladovú šablónu podľa názvu. AI agenti to používajú na získanie funkčnej šablóny ako východiskového bodu, potom ju upravujú tak, aby zodpovedala požiadavkám používateľa.

Parametre:

• name (reťazec, povinný) – Názov príkladovej šablóny (napr. instagram-story, product-showcase, animated-bar-chart).

Vracia: Kompletnú JSON šablónu pre požadovaný príklad, pripravenú na renderovanie alebo úpravu.

Príklad:

AI Agent volá: get_example("instagram-story")
Vracia: Kompletnú 1080x1920 Instagram story šablónu s textovými vrstvami,
        obrázkom na pozadí a vstupnými animáciami

list_examples

Prehliadanie plného katalógu 50+ príkladových šablón organizovaných podľa kategórie. AI agenti to používajú na nájdenie relevantných počiatočných šablón pre požiadavku používateľa.

Parametre:

• category (reťazec, voliteľný) – Filtrovať podľa kategórie (napr. social-media, marketing, data-visualization, typography, e-commerce).

Vracia: Pole objektov metadát príkladov, každý s:

• name – Identifikátor šablóny pre použitie s get_example.
• category – Kategória šablóny.
• description – Čo šablóna vytvára.
• dimensions – Výstupná šírka a výška.
• duration – Trvanie šablóny v sekundách.

Nástroje dokumentácie

Tieto nástroje poskytujú podrobnú referenčnú dokumentáciu, ktorú AI agenti môžu konzultovať pri konštrukcii šablón.

get_component_docs

Vracia podrobnú dokumentáciu pre špecifický komponent alebo typ vrstvy . Zahŕňa popisy vlastností, povinné vs voliteľné polia, predvolené hodnoty a príklady použitia.

Parametre:

• component (reťazec, povinný) – Názov komponentu/typu vrstvy (napr. text, image, video, shape, audio, group, lottie, custom, AnimatedLineChart, TypewriterEffect).

Vracia: Komplexnú dokumentáciu zahŕňajúcu:

• Tabuľku vlastností s typmi, predvolenými hodnotami a popismi
• JSON schému pre komponent
• Príklady použitia
• Poznámky o rozdieloch renderovania v prehliadači vs Node.js

get_animation_docs

Vracia kompletnú referenciu animačných efektov, vrátane všetkých vstupných, výstupných, dôrazových a kľúčových snímkových animačných predvolieb.

Parametre:

• animation (reťazec, voliteľný) – Špecifický názov animácie pre získanie podrobnej dokumentácie (napr. fadeInUp, bounceIn, slideOutLeft). Ak je vynechané, vracia plný katalóg animácií.

Vracia: Dokumentáciu animácie zahŕňajúcu:

• Názov animácie a kategóriu (entrance, exit, emphasis, keyframe)
• Popis vizuálneho efektu
• Konfigurovateľné parametre (duration, delay, easing)
• Predvolené hodnoty
• Odporúčané prípady použitia

get_component_defaults

Vracia predvolené hodnoty a kompletnú JSON schému pre špecifický typ komponentu. AI agenti to používajú na pochopenie, ako vyzerá minimálny platný komponent a aké vlastnosti môžu prepísať.

Parametre:

• component (reťazec, povinný) – Názov komponentu/typu vrstvy.

Vracia: JSON objekt s:

• defaults – Kompletné predvolené hodnoty pre každú vlastnosť
• schema – JSON schéma definujúca štruktúru, typy a obmedzenia komponentu
• required – Zoznam povinných vlastností

Príklad odpovede pre textovú vrstvu:

{
  "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": "Textový obsah na zobrazenie" },
      "fontSize": { "type": "number", "minimum": 1, "maximum": 500 },
      "fontFamily": { "type": "string", "description": "Názov Google fontu alebo systémový font" },
      "color": { "type": "string", "pattern": "^#[0-9a-fA-F]{6}$" }
    }
  }
}

get_easing_docs

Vracia kompletnú referenciu pre všetky dostupné easing funkcie. Easing funkcie kontrolujú akceleračnú krivku animácií, určujúc, či začínajú pomaly, končia pomaly, poskakujú alebo nasledujú elastickú krivku.

Parametre:

• easing (reťazec, voliteľný) – Špecifický názov easing funkcie pre podrobnú dokumentáciu. Ak je vynechané, vracia plný zoznam.

Vracia: Dokumentáciu pre každú easing funkciu zahŕňajúcu:

• Názov funkcie (napr. easeInOutCubic, easeOutBounce, spring)
• Matematický popis krivky
• Vizuálny popis pocitu pohybu
• Odporúčané prípady použitia
• CSS ekvivalent (kde je použiteľné)

Nastavenie AI integrácie

Pripojenie Rendervid k vášmu AI nástroju vyžaduje pridanie MCP servera do konfigurácie vášho nástroja. Proces nastavenia sa mierne líši medzi nástrojmi, ale základný koncept je rovnaký: namieriť váš AI nástroj na vstupný bod MCP servera Rendervid.

Predpoklady

Pred konfiguráciou akéhokoľvek AI nástroja sa uistite, že máte:

1. Node.js 18+ nainštalovaný na vašom systéme
2. Rendervid naklonovaný a zostrojený z GitHub repozitára :

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

3. FFmpeg nainštalovaný (vyžadované pre video výstup):

# macOS
brew install ffmpeg

# Ubuntu/Debian
sudo apt install ffmpeg

# Windows (s Chocolatey)
choco install ffmpeg

Claude Desktop / Claude Code

Pridajte Rendervid MCP server do vášho konfiguračného súboru Claude Desktop.

Umiestnenie konfiguračného súboru:

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

Konfigurácia:

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

Nahraďte /path/to/rendervid skutočnou cestou k vašej inštalácii Rendervid.

Pre Claude Code (CLI), pridajte rovnakú konfiguráciu do súboru .claude/mcp.json vášho projektu alebo do globálnych nastavení Claude Code. Claude Code automaticky deteguje MCP server a vystaví všetkých 11 nástrojov počas vašich kódovacích relácií.

Po uložení konfigurácie reštartujte Claude Desktop alebo Claude Code. Pripojenie môžete overiť opýtaním sa Claude: “Aké Rendervid nástroje sú dostupné?” Claude by mal vypísať všetkých 11 MCP nástrojov.

Cursor IDE

Pridajte Rendervid MCP server do MCP konfigurácie Cursor.

Konfiguračný súbor: .cursor/mcp.json v koreňovom adresári vášho projektu (alebo globálne nastavenia Cursor).

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

Po uložení reštartujte Cursor. Rendervid nástroje budú dostupné v AI asistentovi Cursor, čo vám umožní generovať videá priamo z vášho editora.

Windsurf IDE

Windsurf podporuje MCP servery cez svoju AI konfiguráciu. Pridajte Rendervid server do vašich Windsurf MCP nastavení:

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

Konzultujte dokumentáciu Windsurf pre presné umiestnenie konfiguračného súboru, keďže sa môže líšiť podľa verzie a operačného systému.

Generické nastavenie MCP

Akýkoľvek nástroj, ktorý implementuje špecifikáciu MCP klienta, sa môže pripojiť k MCP serveru Rendervid. Server komunikuje cez stdio (štandardný vstup/výstup), čo je predvolený MCP transport.

Pre integráciu s vlastným MCP klientom:

1. Spustite proces MCP servera:

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

2. Komunikujte cez stdin/stdout pomocou MCP JSON-RPC protokolu.
3. Zavolajte tools/list na objavenie dostupných nástrojov.
4. Zavolajte tools/call s názvom nástroja a argumentmi na vykonanie akéhokoľvek nástroja.

MCP server je bezstavový. Každé volanie nástroja je nezávislé a server môže spracovávať súbežné požiadavky od viacerých klientov.

AI Workflow: End-to-End príklady

Nasledujúce príklady ukazujú, ako AI agenti používajú MCP nástroje Rendervid na prechod od prirodzeného jazykového príkazu k hotovému videu.

Príklad 1: Tvorba obsahu pre sociálne médiá

Príkaz používateľa: “Vytvor 10-sekundové Instagram story propagujúce letný výpredaj s animovaným textom a gradientovým pozadím”

Workflow AI agenta:

Krok 1 – Objavenie možností:

Agent zavolá get_capabilities na naučenie sa dostupných typov vrstiev, animačných predvolieb a výstupných obmedzení. Objaví, že text a shape vrstvy sú dostupné, fadeInUp a scaleIn animácie existujú a Instagram stories používajú rozlíšenie 1080x1920.

Krok 2 – Nájdenie počiatočnej šablóny:

Agent zavolá list_examples s category: "social-media" a nájde šablónu instagram-story. Potom zavolá get_example("instagram-story") na načítanie plnej JSON šablóny.

Krok 3 – Zostavenie šablóny:

Použitím príkladu ako referencie agent konštruuje vlastnú šablónu:

{
  "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": "LETNÝ VÝPREDAJ",
          "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% ZĽAVA NA VŠETKO",
          "fontSize": 64,
          "fontFamily": "Montserrat",
          "color": "#FFE066",
          "position": { "x": 540, "y": 850 },
          "animations": [
            { "type": "fadeInUp", "duration": 0.8, "delay": 0.6 }
          ]
        },
        {
          "type": "text",
          "text": "Nakupujte teraz  →",
          "fontSize": 48,
          "fontFamily": "Montserrat",
          "color": "#FFFFFF",
          "position": { "x": 540, "y": 1200 },
          "animations": [
            { "type": "scaleIn", "duration": 0.6, "delay": 1.2 }
          ]
        }
      ]
    }
  ]
}

Krok 4 – Validácia:

Agent zavolá validate_template s JSON šablónou. Odpoveď sa vráti ako valid: true bez chýb.

Krok 5 – Renderovanie:

Agent zavolá render_video s validovanou šablónou a dostane URL k hotovému MP4 súboru.

Príklad 2: Automatizácia marketingového videa

Príkaz používateľa: “Vygeneruj produktové prezentačné video pre naše nové slúchadlá. Použi tento produktový obrázok: https://example.com/headphones.png . Názov produktu je ‘SoundPro X1’ a cena je $299.”

Workflow AI agenta:

1. get_capabilities – Naučí sa o obrazových vrstvách, štýlovaní textu a možnostiach animácie.
2. list_examples – Nájde šablónu product-showcase v kategórii e-commerce.
3. get_example("product-showcase") – Načíta kompletnú šablónu produktovej prezentácie, ktorá používa premenné šablóny pre názov produktu, obrázok a cenu.
4. Upraví šablónu – Aktualizuje inputs s produktovými dátami používateľa:

   {
     "inputs": {
       "productName": "SoundPro X1",
       "productImage": "https://example.com/headphones.png",
       "price": "$299",
       "tagline": "Prémiový zvuk, predefinovaný"
     }
   }
   

5. validate_template – Overí šablónu a potvrdí, že https://example.com/headphones.png je prístupné.
6. render_video – Produkuje finálne produktové prezentačné video.

Tento workflow demonštruje, ako AI agenti využívajú premenné šablón na vytvorenie personalizovaného obsahu z opakovane použiteľných šablón. Tá istá šablóna produktovej prezentácie môže generovať stovky unikátnych videí výmenou vstupov.

Príklad 3: Generovanie vizualizácie dát

Príkaz používateľa: “Vytvor animovaný stĺpcový graf ukazujúci štvrťročné príjmy: Q1: $1.2M, Q2: $1.8M, Q3: $2.1M, Q4: $2.7M”

Workflow AI agenta:

1. get_capabilities – Objaví typ vrstvy custom a vstavaný komponent AnimatedLineChart.
2. get_component_docs("AnimatedLineChart") – Prečíta dokumentáciu pre komponent grafu, naučí sa o formáte dát, konfigurácii farieb, označeniach osí a možnostiach animácie.
3. get_component_defaults("AnimatedLineChart") – Získa predvolené hodnoty a JSON schému na pochopenie minimálnej požadovanej konfigurácie.
4. Zostaví šablónu s vrstvou vlastného komponentu:

   {
     "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": "Štvrťročné príjmy 2025",
       "yAxisLabel": "Príjmy (USD)",
       "animationDuration": 2
     }
   }
   

5. validate_template – Potvrdí, že štruktúra šablóny je správna.
6. render_video – Generuje animované video grafu.

Samoopisné API: Ako schopnosti robia AI agentov efektívnymi

Nástroj get_capabilities je základným kameňom AI integrácie Rendervid. Implementuje vzor samoopisného API, kde systém hovorí AI agentom presne, čo dokáže, aké parametre sú vyžadované a aké hodnoty sú platné. To eliminuje potrebu AI modelov memorovať alebo byť trénované na špecifickom API Rendervid.

Čo obsahuje odpoveď Capabilities

Keď AI agent zavolá get_capabilities, dostane štruktúrovanú odpoveď pokrývajúcu každý aspekt renderovacieho systému:

Typy vrstiev s JSON schémami:

{
  "layerTypes": {
    "text": {
      "description": "Renderuje text s plnou kontrolou štýlovania",
      "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": { "..." : "..." }
  }
}

Animačné predvoľby:

Odpoveď capabilities vypíše každú animačnú predvoľbu s jej kategóriou, konfigurovateľnými parametrami a popisom. AI agent prijímajúci tieto dáta vie, že fadeInUp je vstupná animácia s parametrami duration, delay a easing a že posúva element nahor pri rozjasnení.

Easing funkcie:

Všetkých 30+ easing funkcií je vypísaných s popismi, takže AI agent môže vybrať správnu krivku pre každú animáciu. Napríklad easeOutBounce je popísané ako simulujúce poskakujúci efekt na konci animácie, ktorý agent môže odporučiť pre hravý alebo upútavajúci obsah.

Filtre a efekty:

Vizuálne filtre ako blur, brightness, contrast, saturate, grayscale a sepia sú zdokumentované s ich rozsahmi parametrov, čo umožňuje AI agentovi aplikovať post-processingové efekty na akúkoľvek vrstvu.

Prečo samoopisné API záleží

Tradičné API vyžadujú dokumentáciu, ktorú AI modely mohli alebo nemohli vidieť počas tréningu. Samoopisné API poskytuje dokumentáciu počas behu, čo zabezpečuje, že AI agent má vždy aktuálne, presné informácie. Keď Rendervid pridá novú animačnú predvoľbu alebo typ vrstvy, každý pripojený AI agent ju okamžite uvidí cez get_capabilities. Žiadne aktualizácie dokumentácie, žiadne pretrenovanie, žiadne nesúlady verzií.

Najlepšie postupy pre AI generovanie videa

Nasledujte tieto pokyny na dosiahnutie najlepších výsledkov pri používaní AI agentov na generovanie Rendervid videí.

1. Vždy validujte pred renderovaním

Zavolajte validate_template pred každým renderovaním. Renderovanie je výpočtovo náročné a validácia je takmer okamžitá. Validačný nástroj zachytáva problémy, ktoré by spôsobili zlyhanie renderovania alebo produkciu neočakávaného výstupu:

• Poškodené URL médií (obrázky, videá, audio súbory, ktoré vrátia 404)
• Neplatná JSON štruktúra alebo chýbajúce povinné polia
• Hodnoty mimo rozsahu pre rozmery, veľkosti fontov alebo trvania
• Neznáme animačné predvoľby alebo typy vrstiev

Typický AI workflow by mal vždy zahŕňať validáciu ako krok pred volaním render_video alebo render_image.

2. Začnite z príkladov

Namiesto zostavovania šablón od nuly by AI agenti mali používať list_examples a get_example na nájdenie relevantnej počiatočnej šablóny. Príkladové šablóny sú testované a vedia produkovať dobrý výstup. Začatie z príkladu a jeho úprava je rýchlejšia a menej náchylná k chybám ako generovanie úplne novej štruktúry šablóny.

Odporúčaný prístup:

1. Zavolajte list_examples s relevantnou kategóriou
2. Zavolajte get_example pre najbližšiu zodpovedajúcu šablónu
3. Upravte šablónu tak, aby zodpovedala špecifickým požiadavkám používateľa
4. Validujte a renderujte

3. Používajte popisné príkazy

Pri požiadaní videí od AI agenta buďte špecifickí o:

• Rozmery a platforma – “1080x1920 Instagram story” je lepšie ako “vertikálne video”
• Trvanie – “10-sekundový úvod” je lepšie ako “krátke video”
• Štýl a nálada – “tmavé pozadie s neónovým textom a poskakujúcimi animáciami” dáva AI agentovi jasný smer
• Štruktúra obsahu – “Tri textové riadky objavujúce sa jeden po druhom s fade-in animáciami” je viac akčné ako “nejaký animovaný text”

4. Iterujte na šablónach

Generovanie videa je iteratívne. Po prvom renderovaní preskúmajte výstup a požiadajte AI agenta o úpravu špecifických elementov:

• “Urob titulný text väčší a zmeň farbu na zlatú”
• “Spomaľ vstupné animácie a pridaj 0.5-sekundové oneskorenie medzi každý riadok”
• “Pridaj jemný blur filter na obrázok na pozadí”
• “Zmeň easing z lineárneho na easeOutCubic pre plynulejší pohyb”

AI agent môže upraviť existujúcu šablónu a znovu renderovať bez začínania odznova, čo robí iteráciu rýchlou a efektívnou.

5. Využívajte premenné šablón pre dávkovú produkciu

Ak potrebujete viacero variácií toho istého videa (rôzne produkty, rôzne jazyky, rôzne dáta), požiadajte AI agenta o vytvorenie šablóny s premennými . To vám umožní renderovať mnoho videí z jednej šablóny odovzdaním rôznych inputs:

{
  "inputs": {
    "productName": "Bežecké topánky Pro",
    "productImage": "https://example.com/shoes.png",
    "price": "$149",
    "tagline": "Bežte rýchlejšie, choďte ďalej"
  }
}

6. Používajte asynchrónne renderovanie pre dlhé videá

Pre videá dlhšie ako 30 sekúnd alebo šablóny s komplexnými animáciami používajte start_render_async namiesto render_video. To zabráni vypršaniu časového limitu a umožní AI agentovi vykonávať iné úlohy, zatiaľ čo sa video renderuje na pozadí.

Objavovanie šablón: Prehliadanie 100+ príkladov

Rendervid zahŕňa viac ako 100 príkladových šablón pokrývajúcich 32 kategórií, čo poskytuje AI agentom bohatú knižnicu východiskových bodov pre akúkoľvek úlohu generovania videa.

Ako AI agenti objavujú šablóny

Workflow objavovania šablón používa dva nástroje v sekvencii:

1. list_examples – Prehliadajte katalóg s voliteľným filtrovaním kategórií na nájdenie relevantných šablón.
2. get_example – Načítajte plnú JSON šablónu pre špecifický príklad.

Kategórie šablón

AI agenti môžu filtrovať príklady podľa kategórie na rýchle nájdenie relevantných východiskových bodov:

Objavovanie šablón v praxi

Keď používateľ požiada o “animovaný graf ukazujúci predajné dáta,” AI agent:

1. Zavolá list_examples(category: "data-visualization") a dostane zoznam šablón súvisiacich s grafmi.
2. Identifikuje animated-bar-chart ako najlepšiu zhodu na základe popisu.
3. Zavolá get_example("animated-bar-chart") na načítanie kompletnej šablóny.
4. Preskúma štruktúru šablóny na pochopenie, ako sú dáta formátované.
5. Nahradí príkladové dáta skutočnými predajnými číslami používateľa.
6. Validuje a renderuje.

Tento prístup zameraný na objavovanie znamená, že AI agenti konzistentne produkujú dobre štruktúrované šablóny, pretože stavajú na testovaných príkladoch namiesto generovania JSON šablón od nuly.

Preskúmanie všetkých dostupných šablón

Na zobrazenie každej dostupnej šablóny môže AI agent zavolať list_examples bez filtra kategórie. Odpoveď zahŕňa metadáta pre všetkých 100+ šablón, čo umožňuje agentovi vyhľadávať naprieč kategóriami pre najlepšiu zhodu. Každý záznam zahŕňa názov šablóny, kategóriu, popis, rozmery a trvanie, čo poskytuje agentovi dostatok informácií na informované rozhodnutie.

Podporované AI nástroje

MCP server Rendervid funguje s akýmkoľvek nástrojom, ktorý implementuje špecifikáciu klienta Model Context Protocol. Nasledujúce nástroje boli testované a potvrdené, že fungujú s Rendervid:

Pretože MCP je otvorený štandard, akýkoľvek budúci nástroj, ktorý pridá podporu MCP klienta, bude automaticky kompatibilný s MCP serverom Rendervid. Nie sú potrebné žiadne zmeny servera alebo jeho nástrojov.

Ďalšie kroky

• Prehľad Rendervid – Naučte sa o všetkých funkciách Rendervid, výstupných formátoch a architektúre.
• Systém šablón – Hlboký ponor do štruktúry JSON šablón, premenných a vstupného systému.
• Referencia komponentov – Dokumentácia pre všetky typy vrstiev a vlastné React komponenty.
• Návod na nasadenie – Nasaďte Rendervid na AWS Lambda, Azure Functions, Google Cloud Run alebo Docker pre cloudové renderovanie v mierke.
• GitHub repozitár – Zdrojový kód, tracker problémov a komunitné príspevky.