Rendervid AI-integrasjon - Generer videoer med Claude Code, Cursor & MCP

Introduksjon: AI-drevet videogenerering

Å lage videoer programmatisk har tradisjonelt krevd dyp kunnskap om videokodeker, animasjonsrammeverk og renderingspipelines. Rendervid eliminerer denne kompleksiteten ved å akseptere JSON-maler og produsere ferdige videoer. Når du kombinerer dette med AI-agenter som forstår naturlig språk, får du noe kraftig: muligheten til å beskrive en video på vanlig norsk og motta en rendret MP4 i retur.

Rendervid bygger bro mellom AI-språkmodeller og videoproduksjon. I stedet for å skrive kode, designe nøkkelbilder eller lære et videoredigeringsprogram, forteller du en AI-agent hva du vil ha. Agenten genererer en gyldig JSON-mal , validerer den og rendrer det endelige resultatet gjennom Renderivds motor. Hele prosessen skjer i én enkelt samtale.

Denne integrasjonen er bygget på Model Context Protocol (MCP), en åpen standard som lar AI-verktøy samhandle med eksterne tjenester gjennom et strukturert grensesnitt. Rendervids MCP-server eksponerer 11 verktøy som dekker rendering, validering, maloppdagelse og dokumentasjon, og gir AI-agenter alt de trenger for å produsere profesjonelt videoinnhold autonomt.

Hva er Model Context Protocol (MCP)?

Model Context Protocol er en åpen standard utviklet for å gi AI-assistenter strukturert tilgang til eksterne verktøy og datakilder. I stedet for å stole på at AI-modeller gjetter API-formater eller genererer kode som kaller REST-endepunkter, tilbyr MCP et typet, oppdagbart grensesnitt som AI-agenter kan spørre ved kjøretid.

For videogenerering løser MCP et kritisk problem: AI-agenter trenger å vite hva som er mulig før de kan generere gyldig output. Uten MCP ville en AI-modell måtte bli trent på Rendervids spesifikke malformat, kjenne til alle tilgjengelige animasjonsforhåndsinnstillinger og forstå begrensningene til hver lagtype. Med MCP kaller agenten ganske enkelt get_capabilities og mottar en fullstendig beskrivelse av systemet, inkludert JSON-skjemaer for hver komponent.

Hvorfor MCP er viktig for AI-videogenerering

• Oppdagelse ved kjøretid: AI-agenter lærer hva Rendervid kan gjøre i det øyeblikket de kobler til, ikke ved treningstidspunktet. Dette betyr at nye funksjoner er umiddelbart tilgjengelige uten ny trening.
• Typesikkerhet: Hvert verktøy har et definert inngangs- og utgangsskjema. AI-agenten vet nøyaktig hvilke parametere som kreves og hvilke typer de må være.
• Validering før rendering: I stedet for å sende inn en mal og håpe den fungerer, kan agenten validere malen først og fikse eventuelle problemer før den bruker tid på rendering.
• Verktøykomponerbarhet: AI-agenter kan kjede verktøy sammen, kalle list_examples for å finne en startmal, modifisere den, kalle validate_template for å sjekke den, og deretter kalle render_video for å produsere outputen. Alt i en enkelt samtaleomgang.

MCP-serververktøy - referanse

Rendervids MCP-server eksponerer 11 verktøy organisert i tre kategorier: Rendering, Validering & Oppdagelse, og Dokumentasjon. Hvert verktøy er designet for å gi AI-agenter maksimal autonomi når de genererer videoinnhold.

Renderingsverktøy

Disse verktøyene håndterer den faktiske produksjonen av video- og bildeutdata fra JSON-maler.

render_video

Genererer en komplett videofil fra en JSON-mal. Dette er det primære renderingsverktøyet for å produsere MP4-, WebM- eller MOV-output.

Parametere:

• template (objekt, påkrevd) – Den komplette JSON-malen som definerer scener, lag, animasjoner og utgangsinnstillinger.
• inputs (objekt, valgfritt) – Nøkkel-verdi-par for malvariabelsubstitusjon.
• output_format (streng, valgfritt) – Utgangsformat: mp4, webm eller mov. Standard er mp4.

Eksempel på bruk 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": "Sommersalg - 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"
  }
}

Returnerer: En URL eller filsti til den rendrede videofilen.

render_image

Genererer en enkelt ramme eller stillbilde fra en JSON-mal. Nyttig for å lage miniatyrbilder, grafikk til sosiale medier, plakater og statisk markedsføringsmateriell.

Parametere:

• template (objekt, påkrevd) – JSON-malen som definerer bildekomposisjonen.
• inputs (objekt, valgfritt) – Malvariabelsubstitusjonsverdier.
• output_format (streng, valgfritt) – Utgangsformat: png, jpeg eller webp. Standard er png.
• frame (tall, valgfritt) – Hvilken ramme som skal rendres (for å trekke ut et spesifikt øyeblikk fra en animert mal).

Når skal man bruke render_image vs render_video:

• Bruk render_image for statisk output: miniatyrbilder, bannere, innlegg på sosiale medier, presentasjonsbilder.
• Bruk render_video for alt med bevegelse: animasjoner, overganger, lyd, videoklipp.

start_render_async

Starter en asynkron renderingsjobb for videoer med lang varighet (typisk over 30 sekunder). I stedet for å vente på at renderingen fullføres synkront, returnerer dette verktøyet en jobb-ID som du kan spørre med check_render_status.

Parametere:

• template (objekt, påkrevd) – Den komplette JSON-malen.
• inputs (objekt, valgfritt) – Malvariabelverdier.
• output_format (streng, valgfritt) – Ønsket utgangsformat.

Returnerer: En job_id-streng som kan brukes med check_render_status og list_render_jobs.

Når skal man bruke asynkron rendering:

• Videoer lengre enn 30 sekunder
• Maler med mange scener eller komplekse animasjoner
• Batchrenderingsarbeidsflyter hvor du vil sende inn flere jobber og samle resultater senere
• Skyrenderingsmiljøer hvor langvarige synkrone forespørsler kan time ut

check_render_status

Sjekker gjeldende status for en asynkron renderingsjobb startet med start_render_async.

Parametere:

• job_id (streng, påkrevd) – Jobb-IDen returnert av start_render_async.

Returnerer: Et objekt som inneholder:

• status – En av queued, rendering, completed eller failed.
• progress – En prosentandel (0-100) som indikerer renderingsfremgang.
• output_url – URLen til den ferdige videoen (kun tilstede når status er completed).
• error – Feilmelding hvis jobben mislyktes.

Eksempel på polling-arbeidsflyt:

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 renderingsjobber, både aktive og fullførte. Nyttig for å overvåke batchrenderingsoperasjoner eller gjennomgå nylig output.

Parametere:

• status_filter (streng, valgfritt) – Filtrer etter status: queued, rendering, completed, failed eller all. Standard er all.
• limit (tall, valgfritt) – Maksimalt antall jobber som skal returneres.

Returnerer: En matrise med jobbobjekter, hver med job_id, status, progress, created_at og output_url (hvis fullført).

Validerings- og oppdagelsesverktøy

Disse verktøyene hjelper AI-agenter med å forstå hva Rendervid kan gjøre og verifisere at maler er korrekte før rendering.

validate_template

Validerer en JSON-mal før rendering. Dette verktøyet sjekker malstruktur, felttyper, verdibegrensninger og verifiserer til og med at medie-URLer (bilder, videoer, lydfiler) er tilgjengelige. Å kjøre validering før rendering forhindrer bortkastet tid på maler som ville mislykkes under renderingsprosessen.

Parametere:

• template (objekt, påkrevd) – JSON-malen som skal valideres.
• check_urls (boolsk, valgfritt) – Om medie-URLer skal verifiseres som tilgjengelige. Standard er true.

Returnerer: Et objekt som inneholder:

• valid – Boolsk verdi som indikerer om malen er gyldig.
• errors – Matrise med feilobjekter med path, message og severity for hvert problem som blir funnet.
• warnings – Matrise med advarsler for ikke-kritiske problemer (f.eks. ubrukte variabler, svært store dimensjoner).

Hva validering fanger opp:

• Manglende obligatoriske felt (f.eks. en scene uten duration)
• Ugyldige felttyper (f.eks. en streng hvor et tall forventes)
• Ukjente lagtyper eller animasjonsforhåndsinnstillinger
• Ødelagte eller utilgjengelige medie-URLer (bilder, videoer, lydfiler)
• Verdier utenfor området (f.eks. negative dimensjoner, fps over maksimum)
• Syntaksfeil i malvariabler

Eksempel på valideringsrespons:

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

get_capabilities

Returnerer en omfattende beskrivelse av alt Rendervid kan gjøre. Dette er typisk det første verktøyet en AI-agent kaller når den starter en videogenereringsoppgave. Responsen inkluderer tilgjengelige lagtyper, animasjonsforhåndsinnstillinger, easing-funksjoner, filtre, utgangsformater og deres JSON-skjemaer.

Parametere: Ingen.

Returnerer: Et strukturert objekt som inneholder:

• layerTypes – Alle tilgjengelige lagtyper (text, image, video, shape, audio, group, lottie, custom) med deres JSON-skjemaer og konfigurerbare egenskaper.
• animations – Alle animasjonsforhåndsinnstillinger gruppert etter kategori (entrance, exit, emphasis, keyframe) med beskrivelser og konfigurerbare parametere.
• easingFunctions – Alle 30+ easing-funksjoner med beskrivelser og brukseksempler.
• filters – Tilgjengelige visuelle filtre (blur, brightness, contrast, saturate, grayscale, sepia, etc.) med parameterområder.
• outputFormats – Støttede utgangsformater for video- og bilderendering med deres begrensninger.
• inputTypes – Malvariabeltyper og valideringsregler.
• sceneTransitions – Alle 17 sceneovergangstyper med deres parametere.

Hvorfor dette verktøyet er kritisk for AI-agenter:

Capabilities-responsen er et selvbeskrivende API. En AI-agent trenger ikke å være forhåndstrent på Rendervids malformat. Den kan kalle get_capabilities ved kjøretid, motta det komplette skjemaet og generere gyldige maler ved første forsøk. Når Rendervid legger til nye funksjoner, animasjoner eller lagtyper, får AI-agenter automatisk tilgang til dem gjennom dette verktøyet uten noen kodeendringer.

get_example

Laster en spesifikk eksempelmal etter navn. AI-agenter bruker dette for å hente en fungerende mal som utgangspunkt, og deretter modifisere den for å matche brukerens krav.

Parametere:

• name (streng, påkrevd) – Eksempelmalnavn (f.eks. instagram-story, product-showcase, animated-bar-chart).

Returnerer: Den komplette JSON-malen for det forespurte eksemplet, klar til å rendres eller modifiseres.

Eksempel:

AI-agent kaller: get_example("instagram-story")
Returnerer: Komplett 1080x1920 Instagram-historiemal med tekstlag,
         bakgrunnsbilde og inngangsanimasjoner

list_examples

Blar gjennom hele katalogen med 50+ eksempelmaler organisert etter kategori. AI-agenter bruker dette for å finne relevante startmaler for brukerens forespørsel.

Parametere:

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

Returnerer: En matrise med eksempelmetadataobjekter, hver med:

• name – Malidentifikator for bruk med get_example.
• category – Malkategori.
• description – Hva malen lager.
• dimensions – Utgangsbredde og -høyde.
• duration – Malvarighet i sekunder.

Dokumentasjonsverktøy

Disse verktøyene gir detaljert referansedokumentasjon som AI-agenter kan konsultere når de konstruerer maler.

get_component_docs

Returnerer detaljert dokumentasjon for en spesifikk komponent eller lagtype . Inkluderer egenskapsbeskrivelser, obligatoriske vs valgfrie felt, standardverdier og brukseksempler.

Parametere:

• component (streng, påkrevd) – Komponent-/lagtypenavn (f.eks. text, image, video, shape, audio, group, lottie, custom, AnimatedLineChart, TypewriterEffect).

Returnerer: Omfattende dokumentasjon inkludert:

• Egenskapstabell med typer, standardverdier og beskrivelser
• JSON-skjema for komponenten
• Brukseksempler
• Merknader om forskjeller mellom nettleser- og Node.js-rendering

get_animation_docs

Returnerer den komplette animasjonseffektreferansen, inkludert alle inngangs-, utgangs-, vektleggings- og nøkkelbildeanimasjonsforhåndsinnstillinger.

Parametere:

• animation (streng, valgfritt) – Spesifikt animasjonsnavn for å få detaljert dokumentasjon for (f.eks. fadeInUp, bounceIn, slideOutLeft). Hvis utelatt, returneres hele animasjonskatalogen.

Returnerer: Animasjonsdokumentasjon inkludert:

• Animasjonsnavn og kategori (entrance, exit, emphasis, keyframe)
• Beskrivelse av den visuelle effekten
• Konfigurerbare parametere (duration, delay, easing)
• Standardverdier
• Anbefalte brukstilfeller

get_component_defaults

Returnerer standardverdiene og det fullstendige JSON-skjemaet for en spesifikk komponenttype. AI-agenter bruker dette for å forstå hvordan en minimal gyldig komponent ser ut og hvilke egenskaper de kan overstyre.

Parametere:

• component (streng, påkrevd) – Komponent-/lagtypenavn.

Returnerer: Et JSON-objekt med:

• defaults – Komplette standardverdier for hver egenskap
• schema – JSON-skjema som definerer komponentens struktur, typer og begrensninger
• required – Liste over obligatoriske egenskaper

Eksempelrespons 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": "Tekstinnholdet som 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 referansen for alle tilgjengelige easing-funksjoner. Easing-funksjoner kontrollerer akselerasjonskurven til animasjoner, og bestemmer om de starter sakte, slutter sakte, spretter eller følger en elastisk kurve.

Parametere:

• easing (streng, valgfritt) – Spesifikt easing-funksjonsnavn for detaljert dokumentasjon. Hvis utelatt, returneres hele listen.

Returnerer: Dokumentasjon for hver easing-funksjon inkludert:

• Funksjonsnavn (f.eks. easeInOutCubic, easeOutBounce, spring)
• Matematisk beskrivelse av kurven
• Visuell beskrivelse av bevegelsesførelsen
• Anbefalte brukstilfeller
• CSS-ekvivalent (der det er aktuelt)

Oppsett av AI-integrasjon

Å koble Rendervid til ditt AI-verktøy krever at du legger til MCP-serveren i verktøyets konfigurasjon. Oppsettprosessen varierer litt mellom verktøy, men kjernekonseptet er det samme: pek ditt AI-verktøy på Rendervids MCP-serverinngang.

Forutsetninger

Før du konfigurerer noe AI-verktøy, sørg for at du har:

1. Node.js 18+ installert på systemet ditt
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 installert (påkrevd for videoutgang):

# macOS
brew install ffmpeg

# Ubuntu/Debian
sudo apt install ffmpeg

# Windows (med Chocolatey)
choco install ffmpeg

Claude Desktop / Claude Code

Legg til Rendervid MCP-serveren i Claude Desktop-konfigurasjonsfilen din.

Konfigurasjonsfil plassering:

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

Konfigurasjon:

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

Erstatt /path/to/rendervid med den faktiske stien til Rendervid-installasjonen din.

For Claude Code (CLI), legg til samme konfigurasjon i prosjektets .claude/mcp.json-fil eller dine globale Claude Code-innstillinger. Claude Code vil automatisk oppdage MCP-serveren og eksponere alle 11 verktøy under kodeøktene dine.

Etter at du har lagret konfigurasjonen, start Claude Desktop eller Claude Code på nytt. Du kan verifisere tilkoblingen ved å spørre Claude: “Hvilke Rendervid-verktøy er tilgjengelige?” Claude bør liste alle 11 MCP-verktøy.

Cursor IDE

Legg til Rendervid MCP-serveren i Cursors MCP-konfigurasjon.

Konfigurasjonsfil: .cursor/mcp.json i prosjektroten din (eller globale Cursor-innstillinger).

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

Etter lagring, start Cursor på nytt. Rendervid-verktøyene vil være tilgjengelige i Cursors AI-assistent, slik at du kan generere videoer direkte fra editoren din.

Windsurf IDE

Windsurf støtter MCP-servere gjennom sin AI-konfigurasjon. Legg til Rendervid-serveren i dine Windsurf MCP-innstillinger:

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

Konsulter Windsurfs dokumentasjon for nøyaktig konfigurasjonsfil plassering, da den kan variere etter versjon og operativsystem.

Generisk MCP-oppsett

Ethvert verktøy som implementerer MCP-klientspesifikasjonen kan koble til Rendervids MCP-server. Serveren kommuniserer over stdio (standard inngang/utgang), som er standard MCP-transport.

For å integrere med en tilpasset MCP-klient:

1. Start MCP-serverprosessen:

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

2. Kommuniser over stdin/stdout ved hjelp av MCP JSON-RPC-protokollen.
3. Kall tools/list for å oppdage tilgjengelige verktøy.
4. Kall tools/call med verktøynavnet og argumentene for å utføre et hvilket som helst verktøy.

MCP-serveren er tilstandsløs. Hvert verktøykall er uavhengig, og serveren kan håndtere samtidige forespørsler fra flere klienter.

AI-arbeidsflyt: Ende-til-ende-eksempler

Følgende eksempler viser hvordan AI-agenter bruker Rendervids MCP-verktøy for å gå fra en naturlig språkkommando til en ferdig video.

Eksempel 1: Innholdsproduksjon for sosiale medier

Brukerkommando: “Lag en 10-sekunders Instagram-historie som promoterer et sommersalg med animert tekst og en gradientbakgrunn”

AI-agent arbeidsflyt:

Steg 1 – Oppdag funksjoner:

Agenten kaller get_capabilities for å lære om tilgjengelige lagtyper, animasjonsforhåndsinnstillinger og utgangsbegrensninger. Den oppdager at text- og shape-lag er tilgjengelige, fadeInUp- og scaleIn-animasjoner eksisterer, og Instagram-historier bruker 1080x1920 oppløsning.

Steg 2 – Finn en startmal:

Agenten kaller list_examples med category: "social-media" og finner en instagram-story-mal. Den kaller deretter get_example("instagram-story") for å laste hele mal-JSONen.

Steg 3 – Bygg malen:

Ved å bruke eksemplet som referanse, konstruerer agenten en tilpasset mal:

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

Steg 4 – Valider:

Agenten kaller validate_template med mal-JSONen. Responsen kommer tilbake som valid: true uten feil.

Steg 5 – Render:

Agenten kaller render_video med den validerte malen og mottar en URL til den ferdige MP4-filen.

Eksempel 2: Automatisering av markedsføringsvideo

Brukerkommando: “Generer en produktvisningsvideo for våre nye hodetelefoner. Bruk dette produktbildet: https://example.com/headphones.png . Produktnavnet er ‘SoundPro X1’ og prisen er $299.”

AI-agent arbeidsflyt:

1. get_capabilities – Lærer om bildelag, tekststyling og animasjonsalternativer.
2. list_examples – Finner en product-showcase-mal i e-commerce-kategorien.
3. get_example("product-showcase") – Laster den komplette produktvisningssmalen, som bruker malvariabler for produktnavn, bilde og pris.
4. Modifiserer malen – Oppdaterer inputs med brukerens produktdata:

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

5. validate_template – Verifiserer malen og bekrefter at https://example.com/headphones.png er tilgjengelig.
6. render_video – Produserer den endelige produktvisningsvideoen.

Denne arbeidsflyten demonstrerer hvordan AI-agenter utnytter malvariabler for å lage personlig tilpasset innhold fra gjenbrukbare maler. Den samme produktvisningsmalen kan generere hundrevis av unike videoer ved å bytte ut inngangene.

Eksempel 3: Generering av datavisualisering

Brukerkommando: “Lag et animert stolpediagram som viser kvartalsvis inntekt: Q1: $1.2M, Q2: $1.8M, Q3: $2.1M, Q4: $2.7M”

AI-agent arbeidsflyt:

1. get_capabilities – Oppdager custom-lagtypen og den innebygde AnimatedLineChart-komponenten .
2. get_component_docs("AnimatedLineChart") – Leser dokumentasjonen for diagramkomponenten, lærer om dataformat, fargekonfigurasjon, akseetiketter og animasjonsalternativer.
3. get_component_defaults("AnimatedLineChart") – Får standardverdiene og JSON-skjemaet for å forstå minimumskonfigurasjonen som kreves.
4. Bygger en mal med et tilpasset 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 inntekt 2025",
       "yAxisLabel": "Inntekt (USD)",
       "animationDuration": 2
     }
   }
   

5. validate_template – Bekrefter at malstrukturen er korrekt.
6. render_video – Genererer den animerte diagramvideoen.

Selvbeskrivende API: Hvordan funksjoner gjør AI-agenter effektive

get_capabilities-verktøyet er hjørnesteinen i Rendervids AI-integrasjon. Det implementerer et selvbeskrivende API-mønster, hvor systemet forteller AI-agenter nøyaktig hva det kan gjøre, hvilke parametere som kreves og hvilke verdier som er gyldige. Dette eliminerer behovet for at AI-modeller skal memorere eller bli trent på Rendervids spesifikke API.

Hva capabilities-responsen inneholder

Når en AI-agent kaller get_capabilities, mottar den en strukturert respons som dekker hvert aspekt av renderingssystemet:

Lagtyper med JSON-skjemaer:

{
  "layerTypes": {
    "text": {
      "description": "Rendrer tekst med full stylingskontroll",
      "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": { "..." : "..." }
  }
}

Animasjonsforhåndsinnstillinger:

Capabilities-responsen lister hver animasjonsforhåndsinnstilling med kategori, konfigurerbare parametere og beskrivelse. En AI-agent som mottar disse dataene vet at fadeInUp er en inngangsanimasjon med duration-, delay- og easing-parametere, og at den beveger elementet oppover mens den fader det inn.

Easing-funksjoner:

Alle 30+ easing-funksjoner er listet med beskrivelser, slik at AI-agenten kan velge riktig kurve for hver animasjon. For eksempel er easeOutBounce beskrevet som å simulere en spretteffekt på slutten av animasjonen, som agenten kan anbefale for lekent eller oppmerksomhetsfangende innhold.

Filtre og effekter:

Visuelle filtre som blur, brightness, contrast, saturate, grayscale og sepia er dokumentert med parameterområdene sine, slik at AI-agenten kan anvende etterbehandlingseffekter på ethvert lag.

Hvorfor selvbeskrivende APIer er viktige

Tradisjonelle APIer krever dokumentasjon som AI-modeller kanskje eller kanskje ikke har sett under trening. Et selvbeskrivende API gir dokumentasjon ved kjøretid, og sikrer at AI-agenten alltid har aktuell, nøyaktig informasjon. Når Rendervid legger til en ny animasjonsforhåndsinnstilling eller lagtype, ser hver tilkoblede AI-agent den umiddelbart gjennom get_capabilities. Ingen dokumentasjonsoppdateringer, ingen ny trening, ingen versjonsforskjeller.

Beste praksis for AI-videogenerering

Følg disse retningslinjene for å få de beste resultatene når du bruker AI-agenter til å generere Rendervid-videoer.

1. Valider alltid før rendering

Kall validate_template før hver rendering. Rendering er beregningsmessig kostbart, og validering er nesten øyeblikkelig. Valideringsverktøyet fanger opp problemer som ville få en rendering til å mislykkes eller produsere uventet output:

• Ødelagte medie-URLer (bilder, videoer, lydfiler som returnerer 404)
• Ugyldig JSON-struktur eller manglende obligatoriske felt
• Verdier utenfor området for dimensjoner, fontstørrelser eller varigheter
• Ukjente animasjonsforhåndsinnstillinger eller lagtyper

En typisk AI-arbeidsflyt bør alltid inkludere validering som et trinn før render_video eller render_image kalles.

2. Start fra eksempler

I stedet for å bygge maler fra bunnen av, bør AI-agenter bruke list_examples og get_example for å finne en relevant startmal. Eksempelmaler er testet og kjent for å produsere godt output. Å starte fra et eksempel og modifisere det er raskere og mindre feilutsatt enn å generere en helt ny malstruktur.

Anbefalt tilnærming:

1. Kall list_examples med en relevant kategori
2. Kall get_example for den nærmeste matchende malen
3. Modifiser malen for å matche brukerens spesifikke krav
4. Valider og render

3. Bruk beskrivende kommandoer

Når du ber om videoer fra en AI-agent, vær spesifikk om:

• Dimensjoner og plattform – “1080x1920 Instagram-historie” er bedre enn “en vertikal video”
• Varighet – “10-sekunders intro” er bedre enn “en kort video”
• Stil og stemning – “mørk bakgrunn med neontekst og sprettende animasjoner” gir AI-agenten klar retning
• Innholdsstruktur – “Tre tekstlinjer som vises én etter én med fade-in-animasjoner” er mer handlingsrettet enn “noe animert tekst”

4. Iterer på maler

Videogenerering er iterativ. Etter første rendering, gjennomgå outputen og be AI-agenten justere spesifikke elementer:

• “Gjør tittelteksten større og endre fargen til gull”
• “Senk hastigheten på inngangsanimasjonene og legg til en 0,5-sekunders forsinkelse mellom hver linje”
• “Legg til et subtilt uskarpfilter på bakgrunnsbildet”
• “Endre easing fra linear til easeOutCubic for jevnere bevegelse”

AI-agenten kan modifisere den eksisterende malen og rendre på nytt uten å starte på nytt, noe som gjør iterasjon rask og effektiv.

5. Utnytt malvariabler for batchproduksjon

Hvis du trenger flere variasjoner av samme video (forskjellige produkter, forskjellige språk, forskjellige data), be AI-agenten om å lage en mal med variabler . Dette lar deg rendre mange videoer fra en enkelt mal ved å sende forskjellige inputs:

{
  "inputs": {
    "productName": "Løpesko Pro",
    "productImage": "https://example.com/shoes.png",
    "price": "$149",
    "tagline": "Løp raskere, gå lenger"
  }
}

6. Bruk asynkron rendering for lange videoer

For videoer lengre enn 30 sekunder eller maler med komplekse animasjoner, bruk start_render_async i stedet for render_video. Dette forhindrer timeouts og lar AI-agenten utføre andre oppgaver mens videoen rendres i bakgrunnen.

Maloppdagelse: Bla gjennom 100+ eksempler

Rendervid inkluderer over 100 eksempelmaler som spenner over 32 kategorier, og gir AI-agenter et rikt bibliotek med utgangspunkter for enhver videogenereringsoppgave.

Hvordan AI-agenter oppdager maler

Maloppdagelsesarbeidsflyten bruker to verktøy i sekvens:

1. list_examples – Bla gjennom katalogen med valgfri kategorifiltrering for å finne relevante maler.
2. get_example – Last hele JSON-malen for et spesifikt eksempel.

Malkategorier

AI-agenter kan filtrere eksempler etter kategori for raskt å finne relevante utgangspunkter:

Maloppdagelse i praksis

Når en bruker ber om “et animert diagram som viser salgsdata,” AI-agenten:

1. Kaller list_examples(category: "data-visualization") og mottar en liste over diagramrelaterte maler.
2. Identifiserer animated-bar-chart som den beste matchen basert på beskrivelsen.
3. Kaller get_example("animated-bar-chart") for å laste den komplette malen.
4. Undersøker malstrukturen for å forstå hvordan data er formatert.
5. Erstatter eksempeldataene med brukerens faktiske salgstall.
6. Validerer og rendrer.

Denne oppdagelse-først-tilnærmingen betyr at AI-agenter konsekvent produserer godt strukturerte maler fordi de bygger på testede eksempler i stedet for å generere mal-JSON fra bunnen av.

Utforske alle tilgjengelige maler

For å se hver tilgjengelige mal kan en AI-agent kalle list_examples uten kategorifilter. Responsen inkluderer metadata for alle 100+ maler, slik at agenten kan søke på tvers av kategorier for den beste matchen. Hver oppføring inkluderer malnavn, kategori, beskrivelse, dimensjoner og varighet, og gir agenten nok informasjon til å ta et informert valg.

Støttede AI-verktøy

Rendervids MCP-server fungerer med ethvert verktøy som implementerer Model Context Protocol-klientspesifikasjonen. Følgende verktøy har blitt testet og bekreftet å fungere med Rendervid:

Fordi MCP er en åpen standard, vil ethvert fremtidig verktøy som legger til MCP-klientstøtte automatisk være kompatibelt med Rendervids MCP-server. Ingen endringer i serveren eller dens verktøy er nødvendig.

Neste steg

• Rendervid-oversikt – Lær om alle Rendervid-funksjoner, utgangsformater og arkitektur.
• Malsystem – Dypdykk i JSON-malstruktur, variabler og inngangssystemet.
• Komponentreferanse – Dokumentasjon for alle lagtyper og tilpassede React-komponenter.
• Distribusjonsveiledning – Distribuer Rendervid til AWS Lambda, Azure Functions, Google Cloud Run eller Docker for skyskala-rendering.
• GitHub-repositorium – Kildekode, problemsporer og fellesskapsbidrag.