Rendervid AI Integration - Generer Videoer med Claude Code, Cursor & MCP

Introduktion: AI-Drevet Videogenerering

At skabe videoer programmatisk har traditionelt krævet dyb viden om video-codecs, animationsrammer og rendering-pipelines. Rendervid eliminerer denne kompleksitet ved at acceptere JSON-skabeloner og outputte færdige videoer. Når du kombinerer dette med AI-agenter, der forstår naturligt sprog, får du noget kraftfuldt: evnen til at beskrive en video på almindeligt dansk og modtage en renderet MP4 til gengæld.

Rendervid bygger bro mellem AI-sprogmodeller og videoproduktion. I stedet for at skrive kode, designe keyframes eller lære et videoredigeringsprogram, fortæller du en AI-agent, hvad du ønsker. Agenten genererer en gyldig JSON-skabelon , validerer den og renderer det endelige output gennem Rendervids motor. Hele processen sker i en enkelt samtale.

Denne integration er bygget på Model Context Protocol (MCP), en åben standard, der gør det muligt for AI-værktøjer at interagere med eksterne tjenester gennem en struktureret grænseflade. Rendervids MCP-server eksponerer 11 værktøjer, der dækker rendering, validering, skabelon-opdagelse og dokumentation, hvilket giver AI-agenter alt, hvad de har brug for til at producere professionelt videoindhold autonomt.

Hvad er Model Context Protocol (MCP)?

Model Context Protocol er en åben standard udviklet til at give AI-assistenter struktureret adgang til eksterne værktøjer og datakilder. I stedet for at stole på, at AI-modeller gætter på API-formater eller genererer kode, der kalder REST-endpoints, leverer MCP en typet, opdagelig grænseflade, som AI-agenter kan forespørge ved runtime.

For videogenerering løser MCP et kritisk problem: AI-agenter skal vide, hvad der er muligt, før de kan generere gyldigt output. Uden MCP ville en AI-model skulle trænes på Rendervids specifikke skabelonformat, kende hver tilgængelig animationsforudindstilling og forstå begrænsningerne for hver lagtype. Med MCP kalder agenten simpelthen get_capabilities og modtager en komplet beskrivelse af systemet, inklusive JSON-skemaer for hver komponent.

Hvorfor MCP Betyder Noget for AI-Videogenerering

• Runtime-Opdagelse: AI-agenter lærer, hvad Rendervid kan gøre i det øjeblik, de forbinder, ikke på træningstidspunktet. Dette betyder, at nye funktioner er umiddelbart tilgængelige uden gentræning.
• Type-Sikkerhed: Hvert værktøj har et defineret input- og output-skema. AI-agenten ved præcis, hvilke parametre der er påkrævet, og hvilke typer de skal være.
• Validering Før Rendering: I stedet for at indsende en skabelon og håbe, at den virker, kan agenten validere skabelonen først og rette eventuelle problemer, før den bruger tid på rendering.
• Værktøjs-Komponerbarhed: AI-agenter kan kæde værktøjer sammen, kalde list_examples for at finde en startskabelon, modificere den, kalde validate_template for at kontrollere den og derefter kalde render_video for at producere outputtet. Alt i en enkelt samtale-tur.

MCP Server Værktøjsreference

Rendervids MCP-server eksponerer 11 værktøjer organiseret i tre kategorier: Rendering, Validering & Opdagelse og Dokumentation. Hvert værktøj er designet til at give AI-agenter maksimal autonomi ved generering af videoindhold.

Rendering-Værktøjer

Disse værktøjer håndterer den faktiske produktion af video- og billedoutput fra JSON-skabeloner.

render_video

Genererer en komplet videofil fra en JSON-skabelon. Dette er det primære rendering-værktøj til at producere MP4-, WebM- eller MOV-output.

Parametre:

• template (objekt, påkrævet) – Den komplette JSON-skabelon, der definerer scener, lag, animationer og outputindstillinger.
• inputs (objekt, valgfrit) – Nøgle-værdi-par til skabelonvariabel-substitution.
• output_format (streng, valgfrit) – Outputformat: mp4, webm eller mov. Standard er mp4.

Eksempel på brug af en AI-agent:

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

Returnerer: En URL eller filsti til den renderede videofil.

render_image

Genererer en enkelt ramme eller stillbillede fra en JSON-skabelon. Nyttigt til at skabe thumbnails, sociale medier-grafik, posterrammer og statiske marketingmaterialer.

Parametre:

• template (objekt, påkrævet) – JSON-skabelonen, der definerer billedkompositionen.
• inputs (objekt, valgfrit) – Skabelonvariabel-substitutionsværdier.
• output_format (streng, valgfrit) – Outputformat: png, jpeg eller webp. Standard er png.
• frame (nummer, valgfrit) – Hvilken ramme der skal renderes (til at udtrække et specifikt øjeblik fra en animeret skabelon).

Hvornår skal man bruge render_image vs render_video:

• Brug render_image til statisk output: thumbnails, bannere, sociale medier-opslag, præsentationsslides.
• Brug render_video til alt med bevægelse: animationer, overgange, lyd, videoklip.

start_render_async

Starter et asynkront rendering-job til videoer med lang varighed (typisk over 30 sekunder). I stedet for at vente på, at renderingen færdiggøres synkront, returnerer dette værktøj et job-ID, som du kan polle med check_render_status.

Parametre:

• template (objekt, påkrævet) – Den komplette JSON-skabelon.
• inputs (objekt, valgfrit) – Skabelonvariabelværdier.
• output_format (streng, valgfrit) – Ønsket outputformat.

Returnerer: En job_id-streng, der kan bruges med check_render_status og list_render_jobs.

Hvornår skal man bruge asynkron rendering:

• Videoer længere end 30 sekunder
• Skabeloner med mange scener eller komplekse animationer
• Batch-rendering-workflows, hvor du vil indsende flere jobs og indsamle resultater senere
• Cloud-rendering-miljøer, hvor langvarige synkrone anmodninger kan time out

check_render_status

Kontrollerer den aktuelle status for et asynkront rendering-job startet med start_render_async.

Parametre:

• job_id (streng, påkrævet) – Job-ID’et returneret af start_render_async.

Returnerer: Et objekt indeholdende:

• status – En af queued, rendering, completed eller failed.
• progress – En procentdel (0-100), der angiver rendering-fremskridt.
• output_url – URL’en til den færdige video (kun til stede, når status er completed).
• error – Fejlmeddelelse, hvis jobbet fejlede.

Eksempel på polling-workflow:

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

Lister alle asynkrone rendering-jobs, både aktive og færdiggjorte. Nyttigt til at overvåge batch-rendering-operationer eller gennemgå nyligt output.

Parametre:

• status_filter (streng, valgfrit) – Filtrer efter status: queued, rendering, completed, failed eller all. Standard er all.
• limit (nummer, valgfrit) – Maksimalt antal jobs, der skal returneres.

Returnerer: Et array af job-objekter, hver med job_id, status, progress, created_at og output_url (hvis færdiggjort).

Validerings- & Opdagelses-Værktøjer

Disse værktøjer hjælper AI-agenter med at forstå, hvad Rendervid kan gøre, og verificere, at skabeloner er korrekte før rendering.

validate_template

Validerer en JSON-skabelon før rendering. Dette værktøj kontrollerer skabelonstruktur, felttyper, værdibegrænsninger og verificerer endda, at medie-URL’er (billeder, videoer, lydfiler) er tilgængelige. At køre validering før rendering forhindrer spildt tid på skabeloner, der ville fejle under rendering-processen.

Parametre:

• template (objekt, påkrævet) – JSON-skabelonen, der skal valideres.
• check_urls (boolean, valgfrit) – Om medie-URL’er skal verificeres som tilgængelige. Standard er true.

Returnerer: Et objekt indeholdende:

• valid – Boolean, der angiver, om skabelonen er gyldig.
• errors – Array af fejlobjekter med path, message og severity for hvert fundne problem.
• warnings – Array af advarsels-objekter for ikke-kritiske problemer (f.eks. ubrugte variabler, meget store dimensioner).

Hvad validering fanger:

• Manglende påkrævede felter (f.eks. en scene uden duration)
• Ugyldige felttyper (f.eks. en streng, hvor et nummer forventes)
• Ukendte lagtyper eller animationsforudindstillinger
• Ødelagte eller utilgængelige medie-URL’er (billeder, videoer, lydfiler)
• Værdier uden for område (f.eks. negative dimensioner, fps over maksimum)
• Skabelonvariabel-syntaksfejl

Eksempel på valideringsrespons:

{
  "valid": false,
  "errors": [
    {
      "path": "scenes[0].layers[2].src",
      "message": "URL returnerede HTTP 404: https://example.com/missing-image.png",
      "severity": "error"
    },
    {
      "path": "scenes[1].duration",
      "message": "Scene-varighed skal være et positivt tal",
      "severity": "error"
    }
  ],
  "warnings": [
    {
      "path": "outputSettings.width",
      "message": "Bredde 7680 er meget stor og kan resultere i langsom rendering",
      "severity": "warning"
    }
  ]
}

get_capabilities

Returnerer en omfattende beskrivelse af alt, hvad Rendervid kan gøre. Dette er typisk det første værktøj, en AI-agent kalder, når den starter en videogenereringsopgave. Responsen inkluderer tilgængelige lagtyper, animationsforudindstillinger, easing-funktioner, filtre, outputformater og deres JSON-skemaer.

Parametre: Ingen.

Returnerer: Et struktureret objekt indeholdende:

• layerTypes – Alle tilgængelige lagtyper (text, image, video, shape, audio, group, lottie, custom) med deres JSON-skemaer og konfigurerbare egenskaber.
• animations – Alle animationsforudindstillinger grupperet efter kategori (entrance, exit, emphasis, keyframe) med beskrivelser og konfigurerbare parametre.
• easingFunctions – Alle 30+ easing-funktioner med beskrivelser og brugeksempler.
• filters – Tilgængelige visuelle filtre (blur, brightness, contrast, saturate, grayscale, sepia osv.) med parameterområder.
• outputFormats – Understøttede outputformater til video- og billedrendering med deres begrænsninger.
• inputTypes – Skabelonvariabeltyper og valideringsregler.
• sceneTransitions – Alle 17 scene-overgangstyper med deres parametre.

Hvorfor dette værktøj er kritisk for AI-agenter:

Capabilities-responsen er en selvbeskrivende API. En AI-agent behøver ikke at være præ-trænet på Rendervids skabelonformat. Den kan kalde get_capabilities ved runtime, modtage det komplette skema og generere gyldige skabeloner ved sit første forsøg. Når Rendervid tilføjer nye funktioner, animationer eller lagtyper, får alle tilsluttede AI-agenter automatisk adgang til dem gennem dette værktøj uden nogen kodeændringer.

get_example

Indlæser en specifik eksempelskabelon efter navn. AI-agenter bruger dette til at hente en fungerende skabelon som udgangspunkt og derefter modificere den for at matche brugerens krav.

Parametre:

• name (streng, påkrævet) – Eksempelskabelonnavnet (f.eks. instagram-story, product-showcase, animated-bar-chart).

Returnerer: Den komplette JSON-skabelon for det anmodede eksempel, klar til at rendere eller modificere.

Eksempel:

AI-Agent kalder: get_example("instagram-story")
Returnerer: Komplet 1080x1920 Instagram story-skabelon med tekstlag,
         baggrundsbillede og entrance-animationer

list_examples

Gennemser det fulde katalog af 50+ eksempelskabeloner organiseret efter kategori. AI-agenter bruger dette til at finde relevante startskabeloner til brugerens anmodning.

Parametre:

• category (streng, valgfrit) – Filtrer efter kategori (f.eks. social-media, marketing, data-visualization, typography, e-commerce).

Returnerer: Et array af eksempel-metadata-objekter, hver med:

• name – Skabelon-identifikator til brug med get_example.
• category – Skabelonkategori.
• description – Hvad skabelonen skaber.
• dimensions – Output-bredde og -højde.
• duration – Skabelonvarighed i sekunder.

Dokumentations-Værktøjer

Disse værktøjer leverer detaljeret referencedokumentation, som AI-agenter kan konsultere ved konstruktion af skabeloner.

get_component_docs

Returnerer detaljeret dokumentation for en specifik komponent eller lagtype . Inkluderer egenskabsbeskrivelser, påkrævede vs valgfrie felter, standardværdier og brugeksempler.

Parametre:

• component (streng, påkrævet) – Komponent/lagtype-navnet (f.eks. text, image, video, shape, audio, group, lottie, custom, AnimatedLineChart, TypewriterEffect).

Returnerer: Omfattende dokumentation inklusive:

• Egenskabstabel med typer, standarder og beskrivelser
• JSON-skema for komponenten
• Brugeksempler
• Noter om browser vs Node.js rendering-forskelle

get_animation_docs

Returnerer den komplette animationseffekt-reference, inklusive alle entrance-, exit-, emphasis- og keyframe-animationsforudindstillinger.

Parametre:

• animation (streng, valgfrit) – Specifikt animationsnavn for at få detaljerede dokumenter (f.eks. fadeInUp, bounceIn, slideOutLeft). Hvis udeladt, returneres det fulde animationskatalog.

Returnerer: Animationsdokumentation inklusive:

• Animationsnavn og kategori (entrance, exit, emphasis, keyframe)
• Beskrivelse af den visuelle effekt
• Konfigurerbare parametre (duration, delay, easing)
• Standardværdier
• Anbefalede anvendelsestilfælde

get_component_defaults

Returnerer standardværdierne og det fulde JSON-skema for en specifik komponenttype. AI-agenter bruger dette til at forstå, hvordan en minimal gyldig komponent ser ud, og hvilke egenskaber de kan overskrive.

Parametre:

• component (streng, påkrævet) – Komponent/lagtype-navnet.

Returnerer: Et JSON-objekt med:

• defaults – Komplette standardværdier for hver egenskab
• schema – JSON-skema, der definerer komponentens struktur, typer og begrænsninger
• required – Liste over påkrævede egenskaber

Eksempel på respons for et tekstlag:

{
  "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": "Tekstindholdet, der skal vises" },
      "fontSize": { "type": "number", "minimum": 1, "maximum": 500 },
      "fontFamily": { "type": "string", "description": "Google Font-navn eller systemfont" },
      "color": { "type": "string", "pattern": "^#[0-9a-fA-F]{6}$" }
    }
  }
}

get_easing_docs

Returnerer den komplette reference for alle tilgængelige easing-funktioner. Easing-funktioner styrer accelerationskurven for animationer og bestemmer, om de starter langsomt, slutter langsomt, hopper eller følger en elastisk kurve.

Parametre:

• easing (streng, valgfrit) – Specifikt easing-funktionsnavn for detaljeret dokumentation. Hvis udeladt, returneres den fulde liste.

Returnerer: Dokumentation for hver easing-funktion inklusive:

• Funktionsnavn (f.eks. easeInOutCubic, easeOutBounce, spring)
• Matematisk beskrivelse af kurven
• Visuel beskrivelse af bevægelsesfølelsen
• Anbefalede anvendelsestilfælde
• CSS-ækvivalent (hvor det er relevant)

Opsætning af AI-Integration

At forbinde Rendervid til dit AI-værktøj kræver, at du tilføjer MCP-serveren til dit værktøjs konfiguration. Opsætningsprocessen varierer lidt mellem værktøjer, men kerneidéen er den samme: peg dit AI-værktøj på Rendervids MCP-server entry point.

Forudsætninger

Før du konfigurerer et AI-værktøj, skal du sørge for at have:

1. Node.js 18+ installeret på dit system
2. Rendervid klonet og bygget fra GitHub-repositoriet :

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

3. FFmpeg installeret (påkrævet til video-output):

# macOS
brew install ffmpeg

# Ubuntu/Debian
sudo apt install ffmpeg

# Windows (med Chocolatey)
choco install ffmpeg

Claude Desktop / Claude Code

Tilføj Rendervid MCP-serveren til din Claude Desktop-konfigurationsfil.

Konfigurationsfilplacering:

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

Erstat /path/to/rendervid med den faktiske sti til din Rendervid-installation.

For Claude Code (CLI), tilføj den samme konfiguration til dit projekts .claude/mcp.json-fil eller dine globale Claude Code-indstillinger. Claude Code vil automatisk opdage MCP-serveren og eksponere alle 11 værktøjer under dine kodningssessioner.

Efter at have gemt konfigurationen, genstart Claude Desktop eller Claude Code. Du kan verificere forbindelsen ved at spørge Claude: “Hvilke Rendervid-værktøjer er tilgængelige?” Claude skulle liste alle 11 MCP-værktøjer.

Cursor IDE

Tilføj Rendervid MCP-serveren til Cursors MCP-konfiguration.

Konfigurationsfil: .cursor/mcp.json i din projektrod (eller globale Cursor-indstillinger).

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

Efter at have gemt, genstart Cursor. Rendervid-værktøjerne vil være tilgængelige i Cursors AI-assistent, hvilket gør det muligt for dig at generere videoer direkte fra din editor.

Windsurf IDE

Windsurf understøtter MCP-servere gennem sin AI-konfiguration. Tilføj Rendervid-serveren til dine Windsurf MCP-indstillinger:

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

Konsulter Windsurfs dokumentation for den nøjagtige konfigurationsfilplacering, da den kan variere efter version og operativsystem.

Generisk MCP-Opsætning

Ethvert værktøj, der implementerer MCP-klientspecifikationen, kan forbinde til Rendervids MCP-server. Serveren kommunikerer over stdio (standard input/output), som er standard MCP-transport.

For at integrere med en brugerdefineret MCP-klient:

1. Spawn MCP-serverprocessen:

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

2. Kommuniker over stdin/stdout ved hjælp af MCP JSON-RPC-protokollen.
3. Kald tools/list for at opdage tilgængelige værktøjer.
4. Kald tools/call med værktøjsnavnet og argumenter for at udføre et hvilket som helst værktøj.

MCP-serveren er tilstandsløs. Hvert værktøjskald er uafhængigt, og serveren kan håndtere samtidige anmodninger fra flere klienter.

AI-Workflow: End-to-End Eksempler

Følgende eksempler viser, hvordan AI-agenter bruger Rendervids MCP-værktøjer til at gå fra en naturlig sprog-prompt til en færdig video.

Eksempel 1: Sociale Medier Indhold-Skabelse

Bruger-prompt: “Opret en 10-sekunders Instagram story, der promoverer et sommerudsalg med animeret tekst og en gradient-baggrund”

AI-agent workflow:

Trin 1 – Opdag capabilities:

Agenten kalder get_capabilities for at lære om tilgængelige lagtyper, animationsforudindstillinger og output-begrænsninger. Den opdager, at text- og shape-lag er tilgængelige, fadeInUp- og scaleIn-animationer eksisterer, og Instagram stories bruger 1080x1920 opløsning.

Trin 2 – Find en startskabelon:

Agenten kalder list_examples med category: "social-media" og finder en instagram-story-skabelon. Den kalder derefter get_example("instagram-story") for at indlæse den fulde skabelon-JSON.

Trin 3 – Byg skabelonen:

Ved at bruge eksemplet som reference konstruerer agenten en brugerdefineret skabelon:

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

Trin 4 – Validér:

Agenten kalder validate_template med skabelon-JSON’en. Responsen kommer tilbage som valid: true uden fejl.

Trin 5 – Render:

Agenten kalder render_video med den validerede skabelon og modtager en URL til den færdige MP4-fil.

Eksempel 2: Marketing-Video Automatisering

Bruger-prompt: “Generer en produktpræsentations-video til vores nye hovedtelefoner. Brug dette produktbillede: https://example.com/headphones.png . Produktnavnet er ‘SoundPro X1’, og prisen er $299.”

AI-agent workflow:

1. get_capabilities – Lærer om billedlag, tekststyling og animationsmuligheder.
2. list_examples – Finder en product-showcase-skabelon i e-commerce-kategorien.
3. get_example("product-showcase") – Indlæser den komplette produktpræsentations-skabelon, som bruger skabelonvariabler til produktnavn, billede og pris.
4. Modificerer skabelonen – Opdaterer inputs med brugerens produktdata:

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

5. validate_template – Verificerer skabelonen og bekræfter, at https://example.com/headphones.png er tilgængelig.
6. render_video – Producerer den endelige produktpræsentations-video.

Dette workflow demonstrerer, hvordan AI-agenter udnytter skabelonvariabler til at skabe personaliseret indhold fra genanvendelige skabeloner. Den samme produktpræsentations-skabelon kan generere hundredvis af unikke videoer ved at bytte inputs.

Eksempel 3: Datavisualiseringsgenerering

Bruger-prompt: “Opret et animeret søjlediagram, der viser kvartalsvis omsætning: Q1: $1.2M, Q2: $1.8M, Q3: $2.1M, Q4: $2.7M”

AI-agent workflow:

1. get_capabilities – Opdager custom-lagtypen og den indbyggede AnimatedLineChart-komponent .
2. get_component_docs("AnimatedLineChart") – Læser dokumentationen for diagram-komponenten og lærer om dataformat, farvekonfiguration, aksemærkater og animationsmuligheder.
3. get_component_defaults("AnimatedLineChart") – Får standardværdierne og JSON-skemaet for at forstå den minimale påkrævede konfiguration.
4. Bygger en skabelon med et brugerdefineret komponentlag:

   {
     "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": "Kvartalsvis Omsætning 2025",
       "yAxisLabel": "Omsætning (USD)",
       "animationDuration": 2
     }
   }
   

5. validate_template – Bekræfter, at skabelonstrukturen er korrekt.
6. render_video – Genererer den animerede diagram-video.

Selvbeskrivende API: Hvordan Capabilities Gør AI-Agenter Effektive

get_capabilities-værktøjet er hjørnestenen i Rendervids AI-integration. Det implementerer et selvbeskrivende API-mønster, hvor systemet fortæller AI-agenter præcis, hvad det kan gøre, hvilke parametre der er påkrævet, og hvilke værdier der er gyldige. Dette eliminerer behovet for, at AI-modeller skal huske eller trænes på Rendervids specifikke API.

Hvad Capabilities-Responsen Indeholder

Når en AI-agent kalder get_capabilities, modtager den en struktureret respons, der dækker alle aspekter af rendering-systemet:

Lagtyper med JSON-Skemaer:

{
  "layerTypes": {
    "text": {
      "description": "Renderer tekst med fuld styling-kontrol",
      "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": { "..." : "..." }
  }
}

Animationsforudindstillinger:

Capabilities-responsen lister hver animationsforudindstilling med dens kategori, konfigurerbare parametre og beskrivelse. En AI-agent, der modtager disse data, ved, at fadeInUp er en entrance-animation med duration-, delay- og easing-parametre, og at den flytter elementet opad, mens den fader det ind.

Easing-Funktioner:

Alle 30+ easing-funktioner er listet med beskrivelser, så AI-agenten kan vælge den rigtige kurve for hver animation. For eksempel beskrives easeOutBounce som simulering af en hoppende effekt i slutningen af animationen, som agenten kan anbefale til legende eller opmærksomhedsfangende indhold.

Filtre og Effekter:

Visuelle filtre som blur, brightness, contrast, saturate, grayscale og sepia er dokumenteret med deres parameterområder, hvilket lader AI-agenten anvende efterbehandlingseffekter på et hvilket som helst lag.

Hvorfor Selvbeskrivende API’er Betyder Noget

Traditionelle API’er kræver dokumentation, som AI-modeller måske eller måske ikke har set under træning. En selvbeskrivende API leverer dokumentation ved runtime, hvilket sikrer, at AI-agenten altid har aktuel, nøjagtig information. Når Rendervid tilføjer en ny animationsforudindstilling eller lagtype, ser hver tilsluttet AI-agent den umiddelbart gennem get_capabilities. Ingen dokumentationsopdateringer, ingen gentræning, ingen versionsmismatch.

Best Practices for AI-Videogenerering

Følg disse retningslinjer for at få de bedste resultater, når du bruger AI-agenter til at generere Rendervid-videoer.

1. Validér Altid Før Rendering

Kald validate_template før hver rendering. Rendering er beregningsmæssigt dyrt, og validering er næsten øjeblikkelig. Valideringsværktøjet fanger problemer, der ville få en rendering til at fejle eller producere uventet output:

• Ødelagte medie-URL’er (billeder, videoer, lydfiler, der returnerer 404)
• Ugyldig JSON-struktur eller manglende påkrævede felter
• Værdier uden for område for dimensioner, skriftstørrelser eller varigheder
• Ukendte animationsforudindstillinger eller lagtyper

Et typisk AI-workflow bør altid inkludere validering som et trin før kald af render_video eller render_image.

2. Start fra Eksempler

I stedet for at bygge skabeloner fra bunden bør AI-agenter bruge list_examples og get_example til at finde en relevant startskabelon. Eksempelskabeloner er testet og kendt for at producere godt output. At starte fra et eksempel og modificere det er hurtigere og mindre fejlbehæftet end at generere en helt ny skabelonstruktur.

Anbefalet tilgang:

1. Kald list_examples med en relevant kategori
2. Kald get_example for den tættest matchende skabelon
3. Modificer skabelonen for at matche brugerens specifikke krav
4. Validér og render

3. Brug Beskrivende Prompts

Når du anmoder om videoer fra en AI-agent, vær specifik om:

• Dimensioner og platform – “1080x1920 Instagram story” er bedre end “en lodret video”
• Varighed – “10-sekunders intro” er bedre end “en kort video”
• Stil og stemning – “mørk baggrund med neon-tekst og hoppende animationer” giver AI-agenten klar retning
• Indholdsstruktur – “Tre tekstlinjer, der vises en efter en med fade-in-animationer” er mere handlingsrettet end “noget animeret tekst”

4. Iterér på Skabeloner

Videogenerering er iterativ. Efter den første rendering, gennemgå outputtet og bed AI-agenten om at justere specifikke elementer:

• “Gør titelteksten større og skift farven til guld”
• “Sænk farten på entrance-animationerne og tilføj en 0,5-sekunders forsinkelse mellem hver linje”
• “Tilføj et subtilt blur-filter til baggrundsbilledet”
• “Skift easing fra linear til easeOutCubic for glattere bevægelse”

AI-agenten kan modificere den eksisterende skabelon og re-rendere uden at starte forfra, hvilket gør iteration hurtig og effektiv.

5. Udnyt Skabelonvariabler til Batch-Produktion

Hvis du har brug for flere variationer af den samme video (forskellige produkter, forskellige sprog, forskellige data), bed AI-agenten om at oprette en skabelon med variabler . Dette lader dig rendere mange videoer fra en enkelt skabelon ved at sende forskellige inputs:

{
  "inputs": {
    "productName": "Løbesko Pro",
    "productImage": "https://example.com/shoes.png",
    "price": "$149",
    "tagline": "Løb Hurtigere, Kom Længere"
  }
}

6. Brug Asynkron Rendering til Lange Videoer

For videoer længere end 30 sekunder eller skabeloner med komplekse animationer, brug start_render_async i stedet for render_video. Dette forhindrer timeouts og tillader AI-agenten at udføre andre opgaver, mens videoen renderes i baggrunden.

Skabelon-Opdagelse: Gennemse 100+ Eksempler

Rendervid inkluderer over 100 eksempelskabeloner, der spænder over 32 kategorier, hvilket giver AI-agenter et rigt bibliotek af udgangspunkter til enhver videogenereringsopgave.

Hvordan AI-Agenter Opdager Skabeloner

Skabelon-opdagelses-workflowet bruger to værktøjer i sekvens:

1. list_examples – Gennemse kataloget med valgfri kategorifiltrering for at finde relevante skabeloner.
2. get_example – Indlæs den fulde JSON-skabelon for et specifikt eksempel.

Skabelonkategorier

AI-agenter kan filtrere eksempler efter kategori for hurtigt at finde relevante udgangspunkter:

Skabelon-Opdagelse i Praksis

Når en bruger beder om “et animeret diagram, der viser salgsdata,” gør AI-agenten:

1. Kalder list_examples(category: "data-visualization") og modtager en liste over diagram-relaterede skabeloner.
2. Identificerer animated-bar-chart som det bedste match baseret på beskrivelsen.
3. Kalder get_example("animated-bar-chart") for at indlæse den komplette skabelon.
4. Undersøger skabelonstrukturen for at forstå, hvordan data er formateret.
5. Erstatter eksempeldata med brugerens faktiske salgstal.
6. Validerer og renderer.

Denne opdagelses-først tilgang betyder, at AI-agenter konsekvent producerer velstrukturerede skabeloner, fordi de bygger på testede eksempler i stedet for at generere skabelon-JSON fra bunden.

Udforsk Alle Tilgængelige Skabeloner

For at se hver tilgængelig skabelon kan en AI-agent kalde list_examples uden et kategorifilter. Responsen inkluderer metadata for alle 100+ skabeloner, hvilket tillader agenten at søge på tværs af kategorier for det bedste match. Hver post inkluderer skabelonnavnet, kategorien, beskrivelsen, dimensionerne og varigheden, hvilket giver agenten nok information til at træffe et informeret valg.

Understøttede AI-Værktøjer

Rendervids MCP-server fungerer med ethvert værktøj, der implementerer Model Context Protocol-klientspecifikationen. Følgende værktøjer er blevet testet og bekræftet at fungere med Rendervid:

Fordi MCP er en åben standard, vil ethvert fremtidigt værktøj, der tilføjer MCP-klientsupport, automatisk være kompatibelt med Rendervids MCP-server. Ingen ændringer til serveren eller dens værktøjer er påkrævet.

Næste Skridt

• Rendervid Oversigt – Lær om alle Rendervid-funktioner, outputformater og arkitektur.
• Skabelonsystem – Dybt dyk i JSON-skabelonstruktur, variabler og inputsystemet.
• Komponent-Reference – Dokumentation for alle lagtyper og brugerdefinerede React-komponenter.
• Implementeringsguide – Implementer Rendervid til AWS Lambda, Azure Functions, Google Cloud Run eller Docker til cloud-skala rendering.
• GitHub-Repository – Kildekode, issue tracker og fællesskabsbidrag.