Rendervid AI-integration - Generera videor med Claude Code, Cursor & MCP

Introduktion: AI-driven videogenerering

Att skapa videor programmatiskt har traditionellt krävt djup kunskap om videokodekar, animationsramverk och renderingspipelines. Rendervid eliminerar denna komplexitet genom att acceptera JSON-mallar och producera färdiga videor. När du kombinerar detta med AI-agenter som förstår naturligt språk får du något kraftfullt: möjligheten att beskriva en video på ren svenska och få en renderad MP4 i retur.

Rendervid bygger bron mellan AI-språkmodeller och videoproduktion. Istället för att skriva kod, designa nyckelrutor eller lära dig ett videoredigeringsprogram berättar du för en AI-agent vad du vill ha. Agenten genererar en giltig JSON-mall , validerar den och renderar det slutliga resultatet genom Rendervids motor. Hela processen sker i en enda konversation.

Denna integration är byggd på Model Context Protocol (MCP), en öppen standard som tillåter AI-verktyg att interagera med externa tjänster genom ett strukturerat gränssnitt. Rendervids MCP-server exponerar 11 verktyg som täcker rendering, validering, mallupptäckt och dokumentation, vilket ger AI-agenter allt de behöver för att producera professionellt videoinnehåll autonomt.

Vad är Model Context Protocol (MCP)?

Model Context Protocol är en öppen standard som utvecklats för att ge AI-assistenter strukturerad åtkomst till externa verktyg och datakällor. Istället för att förlita sig på att AI-modeller gissar API-format eller genererar kod som anropar REST-endpoints, tillhandahåller MCP ett typat, upptäckbart gränssnitt som AI-agenter kan fråga vid körning.

För videogenerering löser MCP ett kritiskt problem: AI-agenter behöver veta vad som är möjligt innan de kan generera giltig utdata. Utan MCP skulle en AI-modell behöva tränas på Rendervids specifika mallformat, känna till varje tillgänglig animationsförinställning och förstå begränsningarna för varje lagertyp. Med MCP anropar agenten helt enkelt get_capabilities och får en fullständig beskrivning av systemet, inklusive JSON-scheman för varje komponent.

Varför MCP är viktigt för AI-videogenerering

• Körningsupptäckt: AI-agenter lär sig vad Rendervid kan göra i det ögonblick de ansluter, inte vid träningstillfället. Detta innebär att nya funktioner är omedelbart tillgängliga utan omträning.
• Typsäkerhet: Varje verktyg har ett definierat in- och utdataschema. AI-agenten vet exakt vilka parametrar som krävs och vilka typer de måste vara.
• Validering före rendering: Istället för att skicka in en mall och hoppas att den fungerar kan agenten validera mallen först och åtgärda eventuella problem innan tid spenderas på rendering.
• Verktygskomponibilitet: AI-agenter kan kedja ihop verktyg och anropa list_examples för att hitta en startmall, modifiera den, anropa validate_template för att kontrollera den och sedan anropa render_video för att producera utdata. Allt i en enda konversationstur.

MCP-serververktygsreferens

Rendervids MCP-server exponerar 11 verktyg organiserade i tre kategorier: Rendering, Validering & Upptäckt och Dokumentation. Varje verktyg är utformat för att ge AI-agenter maximal autonomi när de genererar videoinnehåll.

Renderingsverktyg

Dessa verktyg hanterar den faktiska produktionen av video- och bildutdata från JSON-mallar.

render_video

Genererar en komplett videofil från en JSON-mall. Detta är det primära renderingsverktyget för att producera MP4-, WebM- eller MOV-utdata.

Parametrar:

• template (objekt, obligatoriskt) – Den kompletta JSON-mallen som definierar scener, lager, animationer och utdatainställningar.
• inputs (objekt, valfritt) – Nyckel-värde-par för ersättning av mallvariabler.
• output_format (sträng, valfritt) – Utdataformat: mp4, webm eller mov. Standard är mp4.

Exempel på användning av en AI-agent:

{
  "tool": "render_video",
  "arguments": {
    "template": {
      "outputSettings": {
        "width": 1080,
        "height": 1920,
        "fps": 30,
        "duration": 10
      },
      "scenes": [
        {
          "duration": 10,
          "layers": [
            {
              "type": "text",
              "text": "Sommarrea - 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"
  }
}

Returnerar: En URL eller filsökväg till den renderade videofilen.

render_image

Genererar en enskild bildruta eller stillbild från en JSON-mall. Användbart för att skapa miniatyrer, grafik för sociala medier, posterbilder och statiskt marknadsföringsmaterial.

Parametrar:

• template (objekt, obligatoriskt) – JSON-mallen som definierar bildkompositionen.
• inputs (objekt, valfritt) – Ersättningsvärden för mallvariabler.
• output_format (sträng, valfritt) – Utdataformat: png, jpeg eller webp. Standard är png.
• frame (nummer, valfritt) – Vilken bildruta som ska renderas (för att extrahera ett specifikt ögonblick från en animerad mall).

När ska man använda render_image vs render_video:

• Använd render_image för statisk utdata: miniatyrer, banners, inlägg på sociala medier, presentationsbilder.
• Använd render_video för allt med rörelse: animationer, övergångar, ljud, videoklipp.

start_render_async

Startar ett asynkront renderingsjobb för videor med lång varaktighet (vanligtvis över 30 sekunder). Istället för att vänta på att renderingen ska slutföras synkront returnerar detta verktyg ett jobb-ID som du kan polla med check_render_status.

Parametrar:

• template (objekt, obligatoriskt) – Den kompletta JSON-mallen.
• inputs (objekt, valfritt) – Mallvariabelvärden.
• output_format (sträng, valfritt) – Önskat utdataformat.

Returnerar: En job_id-sträng som kan användas med check_render_status och list_render_jobs.

När ska man använda asynkron rendering:

• Videor längre än 30 sekunder
• Mallar med många scener eller komplexa animationer
• Batchrenderingsarbetsflöden där du vill skicka in flera jobb och samla in resultat senare
• Molnrenderingsmiljöer där långvariga synkrona förfrågningar kan ta för lång tid

check_render_status

Kontrollerar den aktuella statusen för ett asynkront renderingsjobb som startats med start_render_async.

Parametrar:

• job_id (sträng, obligatoriskt) – Jobb-ID:t som returnerades av start_render_async.

Returnerar: Ett objekt som innehåller:

• status – En av queued, rendering, completed eller failed.
• progress – En procentandel (0-100) som indikerar renderingsframsteg.
• output_url – URL:en till den färdiga videon (finns endast när status är completed).
• error – Felmeddelande om jobbet misslyckades.

Exempel på pollningsarbetsflöde:

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

Listar alla asynkrona renderingsjobb, både aktiva och slutförda. Användbart för att övervaka batchrenderingsoperationer eller granska senaste utdata.

Parametrar:

• status_filter (sträng, valfritt) – Filtrera efter status: queued, rendering, completed, failed eller all. Standard är all.
• limit (nummer, valfritt) – Maximalt antal jobb att returnera.

Returnerar: En array av jobbobjekt, var och en med job_id, status, progress, created_at och output_url (om slutförd).

Validerings- och upptäcktsverktyg

Dessa verktyg hjälper AI-agenter att förstå vad Rendervid kan göra och verifiera att mallar är korrekta innan rendering.

validate_template

Validerar en JSON-mall innan rendering. Detta verktyg kontrollerar mallstruktur, fälttyper, värdebegränsningar och verifierar till och med att medie-URL:er (bilder, videor, ljudfiler) är tillgängliga. Att köra validering före rendering förhindrar bortkastad tid på mallar som skulle misslyckas under renderingsprocessen.

Parametrar:

• template (objekt, obligatoriskt) – JSON-mallen som ska valideras.
• check_urls (boolesk, valfritt) – Om medie-URL:er ska verifieras som tillgängliga. Standard är true.

Returnerar: Ett objekt som innehåller:

• valid – Boolesk som indikerar om mallen är giltig.
• errors – Array av felobjekt med path, message och severity för varje problem som hittats.
• warnings – Array av varningsobjekt för icke-kritiska problem (t.ex. oanvända variabler, mycket stora dimensioner).

Vad validering fångar upp:

• Saknade obligatoriska fält (t.ex. en scen utan duration)
• Ogiltiga fälttyper (t.ex. en sträng där ett nummer förväntas)
• Okända lagertyper eller animationsförinställningar
• Trasiga eller otillgängliga medie-URL:er (bilder, videor, ljudfiler)
• Värden utanför intervallet (t.ex. negativa dimensioner, fps över maximum)
• Syntaxfel för mallvariabler

Exempel på valideringssvar:

{
  "valid": false,
  "errors": [
    {
      "path": "scenes[0].layers[2].src",
      "message": "URL returnerade HTTP 404: https://example.com/missing-image.png",
      "severity": "error"
    },
    {
      "path": "scenes[1].duration",
      "message": "Scenvaraktighet måste vara ett positivt nummer",
      "severity": "error"
    }
  ],
  "warnings": [
    {
      "path": "outputSettings.width",
      "message": "Bredd 7680 är mycket stor och kan resultera i långsam rendering",
      "severity": "warning"
    }
  ]
}

get_capabilities

Returnerar en omfattande beskrivning av allt som Rendervid kan göra. Detta är vanligtvis det första verktyget en AI-agent anropar när den startar en videogenereringsuppgift. Svaret inkluderar tillgängliga lagertyper, animationsförinställningar, easing-funktioner, filter, utdataformat och deras JSON-scheman.

Parametrar: Inga.

Returnerar: Ett strukturerat objekt som innehåller:

• layerTypes – Alla tillgängliga lagertyper (text, bild, video, form, ljud, grupp, lottie, anpassad) med deras JSON-scheman och konfigurerbara egenskaper.
• animations – Alla animationsförinställningar grupperade efter kategori (inträde, utträde, betoning, nyckelruta) med beskrivningar och konfigurerbara parametrar.
• easingFunctions – Alla 30+ easing-funktioner med beskrivningar och användningsexempel.
• filters – Tillgängliga visuella filter (oskärpa, ljusstyrka, kontrast, mättnad, gråskala, sepia, etc.) med parameterintervall.
• outputFormats – Stödda utdataformat för video- och bildrendering med deras begränsningar.
• inputTypes – Mallvariabeltyper och valideringsregler.
• sceneTransitions – Alla 17 scenövergångstyper med deras parametrar.

Varför detta verktyg är kritiskt för AI-agenter:

Capabilities-svaret är ett självbeskrivande API. En AI-agent behöver inte vara förtränad på Rendervids mallformat. Den kan anropa get_capabilities vid körning, ta emot det fullständiga schemat och generera giltiga mallar vid första försöket. När Rendervid lägger till nya funktioner, animationer eller lagertyper får AI-agenter automatiskt tillgång till dem genom detta verktyg utan några kodändringar.

get_example

Laddar en specifik exempelmall efter namn. AI-agenter använder detta för att hämta en fungerande mall som startpunkt och sedan modifiera den för att matcha användarens krav.

Parametrar:

• name (sträng, obligatoriskt) – Exempelmallens namn (t.ex. instagram-story, product-showcase, animated-bar-chart).

Returnerar: Den kompletta JSON-mallen för det begärda exemplet, redo att renderas eller modifieras.

Exempel:

AI-agent anropar: get_example("instagram-story")
Returnerar: Komplett 1080x1920 Instagram story-mall med textlager,
         bakgrundsbild och inträdesanimationer

list_examples

Bläddrar i den fullständiga katalogen med 50+ exempelmallar organiserade efter kategori. AI-agenter använder detta för att hitta relevanta startmallar för användarens begäran.

Parametrar:

• category (sträng, valfritt) – Filtrera efter kategori (t.ex. social-media, marketing, data-visualization, typography, e-commerce).

Returnerar: En array av exempelmetadataobjekt, var och en med:

• name – Mallidentifierare för användning med get_example.
• category – Mallkategori.
• description – Vad mallen skapar.
• dimensions – Utdatabredd och höjd.
• duration – Mallens varaktighet i sekunder.

Dokumentationsverktyg

Dessa verktyg tillhandahåller detaljerad referensdokumentation som AI-agenter kan konsultera när de konstruerar mallar.

get_component_docs

Returnerar detaljerad dokumentation för en specifik komponent eller lagertyp . Inkluderar egenskapsbeskrivningar, obligatoriska vs valfria fält, standardvärden och användningsexempel.

Parametrar:

• component (sträng, obligatoriskt) – Komponent-/lagertypnamnet (t.ex. text, image, video, shape, audio, group, lottie, custom, AnimatedLineChart, TypewriterEffect).

Returnerar: Omfattande dokumentation inklusive:

• Egenskapstabell med typer, standardvärden och beskrivningar
• JSON-schema för komponenten
• Användningsexempel
• Anteckningar om skillnader mellan webbläsar- och Node.js-rendering

get_animation_docs

Returnerar den fullständiga animationseffektreferensen, inklusive alla inträdes-, utträdes-, betonings- och nyckelruteanimationsförinställningar.

Parametrar:

• animation (sträng, valfritt) – Specifikt animationsnamn för att få detaljerad dokumentation (t.ex. fadeInUp, bounceIn, slideOutLeft). Om det utelämnas returneras den fullständiga animationskatalogen.

Returnerar: Animationsdokumentation inklusive:

• Animationsnamn och kategori (inträde, utträde, betoning, nyckelruta)
• Beskrivning av den visuella effekten
• Konfigurerbara parametrar (varaktighet, fördröjning, easing)
• Standardvärden
• Rekommenderade användningsfall

get_component_defaults

Returnerar standardvärdena och det fullständiga JSON-schemat för en specifik komponenttyp. AI-agenter använder detta för att förstå hur en minimal giltig komponent ser ut och vilka egenskaper de kan åsidosätta.

Parametrar:

• component (sträng, obligatoriskt) – Komponent-/lagertypnamnet.

Returnerar: Ett JSON-objekt med:

• defaults – Fullständiga standardvärden för varje egenskap
• schema – JSON-schema som definierar komponentens struktur, typer och begränsningar
• required – Lista över obligatoriska egenskaper

Exempel på svar för ett textlager:

{
  "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": "Textinnehållet som ska visas" },
      "fontSize": { "type": "number", "minimum": 1, "maximum": 500 },
      "fontFamily": { "type": "string", "description": "Google Font-namn eller systemtypsnitt" },
      "color": { "type": "string", "pattern": "^#[0-9a-fA-F]{6}$" }
    }
  }
}

get_easing_docs

Returnerar den fullständiga referensen för alla tillgängliga easing-funktioner. Easing-funktioner styr accelerationskurvan för animationer och bestämmer om de startar långsamt, slutar långsamt, studsar eller följer en elastisk kurva.

Parametrar:

• easing (sträng, valfritt) – Specifikt easing-funktionsnamn för detaljerad dokumentation. Om det utelämnas returneras den fullständiga listan.

Returnerar: Dokumentation för varje easing-funktion inklusive:

• Funktionsnamn (t.ex. easeInOutCubic, easeOutBounce, spring)
• Matematisk beskrivning av kurvan
• Visuell beskrivning av rörelsekänslan
• Rekommenderade användningsfall
• CSS-ekvivalent (där det är tillämpligt)

Konfigurera AI-integration

Att ansluta Rendervid till ditt AI-verktyg kräver att du lägger till MCP-servern i ditt verktygs konfiguration. Konfigurationsprocessen varierar något mellan verktyg, men kärnkonceptet är detsamma: peka ditt AI-verktyg mot Rendervids MCP-serveringångspunkt.

Förutsättningar

Innan du konfigurerar något AI-verktyg, se till att du har:

1. Node.js 18+ installerat på ditt system
2. Rendervid klonat och byggt från GitHub-repositoriet :

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

3. FFmpeg installerat (krävs för videoutdata):

# macOS
brew install ffmpeg

# Ubuntu/Debian
sudo apt install ffmpeg

# Windows (med Chocolatey)
choco install ffmpeg

Claude Desktop / Claude Code

Lägg till Rendervid MCP-servern i din Claude Desktop-konfigurationsfil.

Konfigurationsfilens plats:

• 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": {}
    }
  }
}

Ersätt /path/to/rendervid med den faktiska sökvägen till din Rendervid-installation.

För Claude Code (CLI), lägg till samma konfiguration i ditt projekts .claude/mcp.json-fil eller dina globala Claude Code-inställningar. Claude Code kommer automatiskt att upptäcka MCP-servern och exponera alla 11 verktyg under dina kodningssessioner.

Efter att ha sparat konfigurationen, starta om Claude Desktop eller Claude Code. Du kan verifiera anslutningen genom att fråga Claude: “Vilka Rendervid-verktyg finns tillgängliga?” Claude bör lista alla 11 MCP-verktyg.

Cursor IDE

Lägg till Rendervid MCP-servern i Cursors MCP-konfiguration.

Konfigurationsfil: .cursor/mcp.json i din projektrot (eller globala Cursor-inställningar).

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

Efter att ha sparat, starta om Cursor. Rendervid-verktygen kommer att vara tillgängliga i Cursors AI-assistent, vilket gör att du kan generera videor direkt från din editor.

Windsurf IDE

Windsurf stöder MCP-servrar genom sin AI-konfiguration. Lägg till Rendervid-servern i dina Windsurf MCP-inställningar:

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

Konsultera Windsurfs dokumentation för den exakta platsen för konfigurationsfilen, eftersom den kan variera beroende på version och operativsystem.

Generisk MCP-konfiguration

Alla verktyg som implementerar MCP-klientspecifikationen kan ansluta till Rendervids MCP-server. Servern kommunicerar över stdio (standard input/output), vilket är standard MCP-transport.

För att integrera med en anpassad MCP-klient:

1. Starta MCP-serverprocessen:

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

2. Kommunicera över stdin/stdout med hjälp av MCP JSON-RPC-protokollet.
3. Anropa tools/list för att upptäcka tillgängliga verktyg.
4. Anropa tools/call med verktygsnamnet och argumenten för att köra vilket verktyg som helst.

MCP-servern är tillståndslös. Varje verktygsanrop är oberoende, och servern kan hantera samtidiga förfrågningar från flera klienter.

AI-arbetsflöde: Exempel från början till slut

Följande exempel visar hur AI-agenter använder Rendervids MCP-verktyg för att gå från ett naturligt språkkommando till en färdig video.

Exempel 1: Skapande av innehåll för sociala medier

Användarkommando: “Skapa en 10-sekunders Instagram story som marknadsför en sommarrea med animerad text och en gradientbakgrund”

AI-agentens arbetsflöde:

Steg 1 – Upptäck kapacitet:

Agenten anropar get_capabilities för att lära sig om tillgängliga lagertyper, animationsförinställningar och utdatabegränsningar. Den upptäcker att text- och shape-lager är tillgängliga, fadeInUp- och scaleIn-animationer existerar, och Instagram stories använder 1080x1920-upplösning.

Steg 2 – Hitta en startmall:

Agenten anropar list_examples med category: "social-media" och hittar en instagram-story-mall. Den anropar sedan get_example("instagram-story") för att ladda den fullständiga mall-JSON:en.

Steg 3 – Bygg mallen:

Med exemplet som referens konstruerar agenten en anpassad mall:

{
  "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": "SOMMARREA",
          "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 PÅ ALLT",
          "fontSize": 64,
          "fontFamily": "Montserrat",
          "color": "#FFE066",
          "position": { "x": 540, "y": 850 },
          "animations": [
            { "type": "fadeInUp", "duration": 0.8, "delay": 0.6 }
          ]
        },
        {
          "type": "text",
          "text": "Handla nu  →",
          "fontSize": 48,
          "fontFamily": "Montserrat",
          "color": "#FFFFFF",
          "position": { "x": 540, "y": 1200 },
          "animations": [
            { "type": "scaleIn", "duration": 0.6, "delay": 1.2 }
          ]
        }
      ]
    }
  ]
}

Steg 4 – Validera:

Agenten anropar validate_template med mall-JSON:en. Svaret kommer tillbaka som valid: true utan fel.

Steg 5 – Rendera:

Agenten anropar render_video med den validerade mallen och får en URL till den färdiga MP4-filen.

Exempel 2: Automatisering av marknadsföringsvideo

Användarkommando: “Generera en produktvisningsvideo för våra nya hörlurar. Använd denna produktbild: https://example.com/headphones.png . Produktnamnet är ‘SoundPro X1’ och priset är $299.”

AI-agentens arbetsflöde:

1. get_capabilities – Lär sig om bildlager, textstyling och animationsalternativ.
2. list_examples – Hittar en product-showcase-mall i kategorin e-commerce.
3. get_example("product-showcase") – Laddar den kompletta produktvisningsmallar, som använder mallvariabler för produktnamn, bild och pris.
4. Modifierar mallen – Uppdaterar inputs med användarens produktdata:

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

5. validate_template – Verifierar mallen och bekräftar att https://example.com/headphones.png är tillgänglig.
6. render_video – Producerar den slutliga produktvisningsvideon.

Detta arbetsflöde visar hur AI-agenter utnyttjar mallvariabler för att skapa personligt innehåll från återanvändbara mallar. Samma produktvisningsmall kan generera hundratals unika videor genom att byta ut indata.

Exempel 3: Generering av datavisualisering

Användarkommando: “Skapa ett animerat stapeldiagram som visar kvartalsintäkter: Q1: $1,2M, Q2: $1,8M, Q3: $2,1M, Q4: $2,7M”

AI-agentens arbetsflöde:

1. get_capabilities – Upptäcker custom-lagertypen och den inbyggda komponenten AnimatedLineChart.
2. get_component_docs("AnimatedLineChart") – Läser dokumentationen för diagramkomponenten och lär sig om dataformat, färgkonfiguration, axeletiketter och animationsalternativ.
3. get_component_defaults("AnimatedLineChart") – Får standardvärdena och JSON-schemat för att förstå den minsta nödvändiga konfigurationen.
4. Bygger en mall med ett anpassat komponentlager:

   {
     "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": "Kvartalsintäkter 2025",
       "yAxisLabel": "Intäkter (USD)",
       "animationDuration": 2
     }
   }
   

5. validate_template – Bekräftar att mallstrukturen är korrekt.
6. render_video – Genererar den animerade diagramvideon.

Självbeskrivande API: Hur kapacitet gör AI-agenter effektiva

Verktyget get_capabilities är hörnstenen i Rendervids AI-integration. Det implementerar ett självbeskrivande API-mönster, där systemet berättar för AI-agenter exakt vad det kan göra, vilka parametrar som krävs och vilka värden som är giltiga. Detta eliminerar behovet av att AI-modeller ska memorera eller tränas på Rendervids specifika API.

Vad capabilities-svaret innehåller

När en AI-agent anropar get_capabilities får den ett strukturerat svar som täcker varje aspekt av renderingssystemet:

Lagertyper med JSON-scheman:

{
  "layerTypes": {
    "text": {
      "description": "Renderar text med full stylingkontroll",
      "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": { "..." : "..." }
  }
}

Animationsförinställningar:

Capabilities-svaret listar varje animationsförinställning med dess kategori, konfigurerbara parametrar och beskrivning. En AI-agent som tar emot denna data vet att fadeInUp är en inträdesanimation med parametrarna duration, delay och easing, och att den flyttar elementet uppåt samtidigt som det tonar in det.

Easing-funktioner:

Alla 30+ easing-funktioner listas med beskrivningar, så AI-agenten kan välja rätt kurva för varje animation. Till exempel beskrivs easeOutBounce som att den simulerar en studseffekt i slutet av animationen, vilket agenten kan rekommendera för lekfullt eller uppmärksamhetsfångande innehåll.

Filter och effekter:

Visuella filter som blur, brightness, contrast, saturate, grayscale och sepia dokumenteras med sina parameterintervall, vilket låter AI-agenten tillämpa efterbehandlingseffekter på vilket lager som helst.

Varför självbeskrivande API:er är viktiga

Traditionella API:er kräver dokumentation som AI-modeller kanske eller kanske inte har sett under träningen. Ett självbeskrivande API tillhandahåller dokumentation vid körning, vilket säkerställer att AI-agenten alltid har aktuell, korrekt information. När Rendervid lägger till en ny animationsförinställning eller lagertyp ser varje ansluten AI-agent den omedelbart genom get_capabilities. Inga dokumentationsuppdateringar, ingen omträning, inga versionsmissanpassningar.

Bästa praxis för AI-videogenerering

Följ dessa riktlinjer för att få bästa resultat när du använder AI-agenter för att generera Rendervid-videor.

1. Validera alltid före rendering

Anropa validate_template före varje rendering. Rendering är beräkningsintensivt, och validering är nästan omedelbar. Valideringsverktyget fångar upp problem som skulle få en rendering att misslyckas eller producera oväntad utdata:

• Trasiga medie-URL:er (bilder, videor, ljudfiler som returnerar 404)
• Ogiltig JSON-struktur eller saknade obligatoriska fält
• Värden utanför intervallet för dimensioner, teckenstorlekar eller varaktigheter
• Okända animationsförinställningar eller lagertyper

Ett typiskt AI-arbetsflöde bör alltid inkludera validering som ett steg innan render_video eller render_image anropas.

2. Börja från exempel

Istället för att bygga mallar från grunden bör AI-agenter använda list_examples och get_example för att hitta en relevant startmall. Exempelmallar är testade och kända för att producera bra utdata. Att börja från ett exempel och modifiera det är snabbare och mindre felbenäget än att generera en helt ny mallstruktur.

Rekommenderad metod:

1. Anropa list_examples med en relevant kategori
2. Anropa get_example för den närmast matchande mallen
3. Modifiera mallen för att matcha användarens specifika krav
4. Validera och rendera

3. Använd beskrivande kommandon

När du begär videor från en AI-agent, var specifik om:

• Dimensioner och plattform – “1080x1920 Instagram story” är bättre än “en vertikal video”
• Varaktighet – “10-sekunders intro” är bättre än “en kort video”
• Stil och stämning – “mörk bakgrund med neontext och studsande animationer” ger AI-agenten tydlig riktning
• Innehållsstruktur – “Tre textrader som visas en efter en med fade-in-animationer” är mer handlingsbart än “lite animerad text”

4. Iterera på mallar

Videogenerering är iterativ. Efter den första renderingen, granska utdata och be AI-agenten att justera specifika element:

• “Gör titeltexten större och ändra färgen till guld”
• “Sakta ner inträdesanimationerna och lägg till en 0,5-sekunders fördröjning mellan varje rad”
• “Lägg till ett subtilt oskärpefilter på bakgrundsbilden”
• “Ändra easing från linjär till easeOutCubic för mjukare rörelse”

AI-agenten kan modifiera den befintliga mallen och återrendera utan att börja om, vilket gör iteration snabb och effektiv.

5. Utnyttja mallvariabler för batchproduktion

Om du behöver flera variationer av samma video (olika produkter, olika språk, olika data), be AI-agenten att skapa en mall med variabler . Detta låter dig rendera många videor från en enda mall genom att skicka olika inputs:

{
  "inputs": {
    "productName": "Löparskor Pro",
    "productImage": "https://example.com/shoes.png",
    "price": "$149",
    "tagline": "Spring snabbare, gå längre"
  }
}

6. Använd asynkron rendering för långa videor

För videor längre än 30 sekunder eller mallar med komplexa animationer, använd start_render_async istället för render_video. Detta förhindrar timeout och låter AI-agenten utföra andra uppgifter medan videon renderas i bakgrunden.

Mallupptäckt: Bläddra bland 100+ exempel

Rendervid inkluderar över 100 exempelmallar som spänner över 32 kategorier, vilket ger AI-agenter ett rikt bibliotek av startpunkter för alla videogenereringsuppgifter.

Hur AI-agenter upptäcker mallar

Mallupptäcktsarbetsflödet använder två verktyg i sekvens:

1. list_examples – Bläddra i katalogen med valfri kategorifiltrering för att hitta relevanta mallar.
2. get_example – Ladda den fullständiga JSON-mallen för ett specifikt exempel.

Mallkategorier

AI-agenter kan filtrera exempel efter kategori för att snabbt hitta relevanta startpunkter:

Mallupptäckt i praktiken

När en användare ber om “ett animerat diagram som visar försäljningsdata” gör AI-agenten:

1. Anropar list_examples(category: "data-visualization") och får en lista över diagramrelaterade mallar.
2. Identifierar animated-bar-chart som den bästa matchningen baserat på beskrivningen.
3. Anropar get_example("animated-bar-chart") för att ladda den kompletta mallen.
4. Undersöker mallstrukturen för att förstå hur data är formaterad.
5. Ersätter exempeldata med användarens faktiska försäljningssiffror.
6. Validerar och renderar.

Detta upptäckt-först-tillvägagångssätt innebär att AI-agenter konsekvent producerar välstrukturerade mallar eftersom de bygger på testade exempel snarare än att generera mall-JSON från grunden.

Utforska alla tillgängliga mallar

För att se varje tillgänglig mall kan en AI-agent anropa list_examples utan kategorifilter. Svaret inkluderar metadata för alla 100+ mallar, vilket gör att agenten kan söka över kategorier för den bästa matchningen. Varje post inkluderar mallnamn, kategori, beskrivning, dimensioner och varaktighet, vilket ger agenten tillräckligt med information för att göra ett informerat val.

Stödda AI-verktyg

Rendervids MCP-server fungerar med alla verktyg som implementerar Model Context Protocol-klientspecifikationen. Följande verktyg har testats och bekräftats fungera med Rendervid:

Eftersom MCP är en öppen standard kommer alla framtida verktyg som lägger till MCP-klientstöd automatiskt att vara kompatibla med Rendervids MCP-server. Inga ändringar av servern eller dess verktyg krävs.

Nästa steg

• Rendervid-översikt – Lär dig om alla Rendervid-funktioner, utdataformat och arkitektur.
• Mallsystem – Djupdykning i JSON-mallstruktur, variabler och indatasystemet.
• Komponentreferens – Dokumentation för alla lagertyper och anpassade React-komponenter.
• Distributionsguide – Distribuera Rendervid till AWS Lambda, Azure Functions, Google Cloud Run eller Docker för molnskalningsrendering.
• GitHub-repositorium – Källkod, problemspårare och gemenskapsbidrag.