Intégration IA Rendervid - Générer des vidéos avec Claude Code, Cursor & MCP

Introduction : Génération vidéo pilotée par l’IA

Créer des vidéos de manière programmatique a traditionnellement nécessité une connaissance approfondie des codecs vidéo, des frameworks d’animation et des pipelines de rendu. Rendervid élimine cette complexité en acceptant des modèles JSON et en produisant des vidéos finies. Lorsque vous combinez cela avec des agents IA qui comprennent le langage naturel, vous obtenez quelque chose de puissant : la capacité de décrire une vidéo en anglais simple et de recevoir un MP4 rendu en retour.

Rendervid comble le fossé entre les modèles de langage IA et la production vidéo. Au lieu d’écrire du code, de concevoir des images clés ou d’apprendre un éditeur vidéo, vous dites à un agent IA ce que vous voulez. L’agent génère un modèle JSON valide, le valide et effectue le rendu de la sortie finale via le moteur de Rendervid. L’ensemble du processus se déroule en une seule conversation.

Cette intégration est construite sur le Model Context Protocol (MCP), un standard ouvert qui permet aux outils IA d’interagir avec des services externes via une interface structurée. Le serveur MCP de Rendervid expose 11 outils couvrant le rendu, la validation, la découverte de modèles et la documentation, donnant aux agents IA tout ce dont ils ont besoin pour produire du contenu vidéo professionnel de manière autonome.

Qu’est-ce que le Model Context Protocol (MCP) ?

Le Model Context Protocol est un standard ouvert développé pour donner aux assistants IA un accès structuré à des outils et sources de données externes. Plutôt que de compter sur les modèles IA pour deviner les formats d’API ou générer du code qui appelle des points de terminaison REST, MCP fournit une interface typée et découvrable que les agents IA peuvent interroger à l’exécution.

Pour la génération vidéo, MCP résout un problème critique : les agents IA doivent savoir ce qui est possible avant de pouvoir générer une sortie valide. Sans MCP, un modèle IA devrait être entraîné sur le format de modèle spécifique de Rendervid, connaître chaque préréglage d’animation disponible et comprendre les contraintes de chaque type de calque. Avec MCP, l’agent appelle simplement get_capabilities et reçoit une description complète du système, incluant les schémas JSON pour chaque composant.

Pourquoi MCP est important pour la génération vidéo IA

• Découverte à l’exécution : Les agents IA apprennent ce que Rendervid peut faire au moment où ils se connectent, pas au moment de l’entraînement. Cela signifie que les nouvelles fonctionnalités sont immédiatement disponibles sans réentraînement.
• Sécurité des types : Chaque outil a un schéma d’entrée et de sortie défini. L’agent IA sait exactement quels paramètres sont requis et quels types ils doivent être.
• Validation avant le rendu : Au lieu de soumettre un modèle en espérant qu’il fonctionne, l’agent peut valider le modèle d’abord et corriger tout problème avant de consacrer du temps au rendu.
• Composabilité des outils : Les agents IA peuvent enchaîner les outils, appelant list_examples pour trouver un modèle de départ, le modifier, appeler validate_template pour le vérifier, puis appeler render_video pour produire la sortie. Tout cela en un seul tour de conversation.

Référence des outils du serveur MCP

Le serveur MCP de Rendervid expose 11 outils organisés en trois catégories : Rendu, Validation et découverte, et Documentation. Chaque outil est conçu pour donner aux agents IA une autonomie maximale lors de la génération de contenu vidéo.

Outils de rendu

Ces outils gèrent la production réelle de sorties vidéo et image à partir de modèles JSON.

render_video

Génère un fichier vidéo complet à partir d’un modèle JSON. C’est l’outil de rendu principal pour produire des sorties MP4, WebM ou MOV.

Paramètres :

• template (objet, requis) – Le modèle JSON complet définissant les scènes, calques, animations et paramètres de sortie.
• inputs (objet, optionnel) – Paires clé-valeur pour la substitution de variables de modèle.
• output_format (chaîne, optionnel) – Format de sortie : mp4, webm ou mov. Par défaut mp4.

Exemple d’utilisation par un agent IA :

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

Retourne : Une URL ou un chemin de fichier vers le fichier vidéo rendu.

render_image

Génère une seule image ou image fixe à partir d’un modèle JSON. Utile pour créer des miniatures, des graphiques pour réseaux sociaux, des affiches et des supports marketing statiques.

Paramètres :

• template (objet, requis) – Le modèle JSON définissant la composition de l’image.
• inputs (objet, optionnel) – Valeurs de substitution de variables de modèle.
• output_format (chaîne, optionnel) – Format de sortie : png, jpeg ou webp. Par défaut png.
• frame (nombre, optionnel) – Quelle image rendre (pour extraire un moment spécifique d’un modèle animé).

Quand utiliser render_image vs render_video :

• Utilisez render_image pour une sortie statique : miniatures, bannières, publications sur réseaux sociaux, diapositives de présentation.
• Utilisez render_video pour tout ce qui comporte du mouvement : animations, transitions, audio, clips vidéo.

start_render_async

Démarre un travail de rendu asynchrone pour les vidéos de longue durée (généralement plus de 30 secondes). Au lieu d’attendre que le rendu se termine de manière synchrone, cet outil retourne un ID de travail que vous pouvez interroger avec check_render_status.

Paramètres :

• template (objet, requis) – Le modèle JSON complet.
• inputs (objet, optionnel) – Valeurs de variables de modèle.
• output_format (chaîne, optionnel) – Format de sortie souhaité.

Retourne : Une chaîne job_id qui peut être utilisée avec check_render_status et list_render_jobs.

Quand utiliser le rendu asynchrone :

• Vidéos de plus de 30 secondes
• Modèles avec de nombreuses scènes ou animations complexes
• Flux de travail de rendu par lots où vous souhaitez soumettre plusieurs travaux et collecter les résultats plus tard
• Environnements de rendu cloud où les requêtes synchrones de longue durée peuvent expirer

check_render_status

Vérifie le statut actuel d’un travail de rendu asynchrone démarré avec start_render_async.

Paramètres :

• job_id (chaîne, requis) – L’ID de travail retourné par start_render_async.

Retourne : Un objet contenant :

• status – Un parmi queued, rendering, completed ou failed.
• progress – Un pourcentage (0-100) indiquant la progression du rendu.
• output_url – L’URL de la vidéo terminée (présente uniquement lorsque status est completed).
• error – Message d’erreur si le travail a échoué.

Exemple de flux d’interrogation :

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

Liste tous les travaux de rendu asynchrones, à la fois actifs et terminés. Utile pour surveiller les opérations de rendu par lots ou examiner les sorties récentes.

Paramètres :

• status_filter (chaîne, optionnel) – Filtrer par statut : queued, rendering, completed, failed ou all. Par défaut all.
• limit (nombre, optionnel) – Nombre maximum de travaux à retourner.

Retourne : Un tableau d’objets de travaux, chacun avec job_id, status, progress, created_at et output_url (si terminé).

Outils de validation et découverte

Ces outils aident les agents IA à comprendre ce que Rendervid peut faire et à vérifier que les modèles sont corrects avant le rendu.

validate_template

Valide un modèle JSON avant le rendu. Cet outil vérifie la structure du modèle, les types de champs, les contraintes de valeur, et vérifie même que les URL de médias (images, vidéos, fichiers audio) sont accessibles. Exécuter la validation avant le rendu évite de perdre du temps sur des modèles qui échoueraient pendant le processus de rendu.

Paramètres :

• template (objet, requis) – Le modèle JSON à valider.
• check_urls (booléen, optionnel) – S’il faut vérifier que les URL de médias sont accessibles. Par défaut true.

Retourne : Un objet contenant :

• valid – Booléen indiquant si le modèle est valide.
• errors – Tableau d’objets d’erreur avec path, message et severity pour chaque problème trouvé.
• warnings – Tableau d’objets d’avertissement pour les problèmes non critiques (par ex., variables inutilisées, dimensions très grandes).

Ce que la validation détecte :

• Champs requis manquants (par ex., une scène sans duration)
• Types de champs invalides (par ex., une chaîne là où un nombre est attendu)
• Types de calques ou préréglages d’animation inconnus
• URL de médias cassées ou inaccessibles (images, vidéos, fichiers audio)
• Valeurs hors limites (par ex., dimensions négatives, fps au-dessus du maximum)
• Erreurs de syntaxe de variables de modèle

Exemple de réponse de validation :

{
  "valid": false,
  "errors": [
    {
      "path": "scenes[0].layers[2].src",
      "message": "L'URL a retourné HTTP 404 : https://example.com/missing-image.png",
      "severity": "error"
    },
    {
      "path": "scenes[1].duration",
      "message": "La durée de la scène doit être un nombre positif",
      "severity": "error"
    }
  ],
  "warnings": [
    {
      "path": "outputSettings.width",
      "message": "La largeur 7680 est très grande et peut entraîner un rendu lent",
      "severity": "warning"
    }
  ]
}

get_capabilities

Retourne une description complète de tout ce que Rendervid peut faire. C’est généralement le premier outil qu’un agent IA appelle lors du démarrage d’une tâche de génération vidéo. La réponse inclut les types de calques disponibles, les préréglages d’animation, les fonctions d’accélération, les filtres, les formats de sortie et leurs schémas JSON.

Paramètres : Aucun.

Retourne : Un objet structuré contenant :

• layerTypes – Tous les types de calques disponibles (text, image, video, shape, audio, group, lottie, custom) avec leurs schémas JSON et propriétés configurables.
• animations – Tous les préréglages d’animation groupés par catégorie (entrance, exit, emphasis, keyframe) avec descriptions et paramètres configurables.
• easingFunctions – Toutes les 30+ fonctions d’accélération avec descriptions et exemples d’utilisation.
• filters – Filtres visuels disponibles (blur, brightness, contrast, saturate, grayscale, sepia, etc.) avec plages de paramètres.
• outputFormats – Formats de sortie pris en charge pour le rendu vidéo et image avec leurs contraintes.
• inputTypes – Types de variables de modèle et règles de validation.
• sceneTransitions – Tous les 17 types de transitions de scène avec leurs paramètres.

Pourquoi cet outil est critique pour les agents IA :

La réponse des capacités est une API auto-descriptive. Un agent IA n’a pas besoin d’être pré-entraîné sur le format de modèle de Rendervid. Il peut appeler get_capabilities à l’exécution, recevoir le schéma complet et générer des modèles valides dès sa première tentative. Lorsque Rendervid ajoute de nouveaux préréglages d’animation ou types de calques, tous les agents IA connectés y ont automatiquement accès via cet outil sans aucun changement de code.

get_example

Charge un modèle d’exemple spécifique par nom. Les agents IA utilisent cela pour récupérer un modèle fonctionnel comme point de départ, puis le modifier pour correspondre aux exigences de l’utilisateur.

Paramètres :

• name (chaîne, requis) – Le nom du modèle d’exemple (par ex., instagram-story, product-showcase, animated-bar-chart).

Retourne : Le modèle JSON complet pour l’exemple demandé, prêt à être rendu ou modifié.

Exemple :

L'agent IA appelle : get_example("instagram-story")
Retourne : Modèle complet de story Instagram 1080x1920 avec calques de texte,
         image de fond et animations d'entrée

list_examples

Parcourt le catalogue complet de plus de 50 modèles d’exemple organisés par catégorie. Les agents IA utilisent cela pour trouver des modèles de départ pertinents pour la demande de l’utilisateur.

Paramètres :

• category (chaîne, optionnel) – Filtrer par catégorie (par ex., social-media, marketing, data-visualization, typography, e-commerce).

Retourne : Un tableau d’objets de métadonnées d’exemple, chacun avec :

• name – Identifiant de modèle à utiliser avec get_example.
• category – Catégorie du modèle.
• description – Ce que le modèle crée.
• dimensions – Largeur et hauteur de sortie.
• duration – Durée du modèle en secondes.

Outils de documentation

Ces outils fournissent une documentation de référence détaillée que les agents IA peuvent consulter lors de la construction de modèles.

get_component_docs

Retourne une documentation détaillée pour un composant ou type de calque spécifique. Inclut les descriptions de propriétés, les champs requis vs optionnels, les valeurs par défaut et les exemples d’utilisation.

Paramètres :

• component (chaîne, requis) – Le nom du composant/type de calque (par ex., text, image, video, shape, audio, group, lottie, custom, AnimatedLineChart, TypewriterEffect).

Retourne : Documentation complète incluant :

• Tableau de propriétés avec types, valeurs par défaut et descriptions
• Schéma JSON pour le composant
• Exemples d’utilisation
• Notes sur les différences de rendu navigateur vs Node.js

get_animation_docs

Retourne la référence complète des effets d’animation, incluant tous les préréglages d’animation d’entrée, de sortie, d’emphase et d’images clés.

Paramètres :

• animation (chaîne, optionnel) – Nom d’animation spécifique pour obtenir une documentation détaillée (par ex., fadeInUp, bounceIn, slideOutLeft). Si omis, retourne le catalogue complet d’animations.

Retourne : Documentation d’animation incluant :

• Nom de l’animation et catégorie (entrance, exit, emphasis, keyframe)
• Description de l’effet visuel
• Paramètres configurables (duration, delay, easing)
• Valeurs par défaut
• Cas d’utilisation recommandés

get_component_defaults

Retourne les valeurs par défaut et le schéma JSON complet pour un type de composant spécifique. Les agents IA utilisent cela pour comprendre à quoi ressemble un composant valide minimal et quelles propriétés ils peuvent remplacer.

Paramètres :

• component (chaîne, requis) – Le nom du composant/type de calque.

Retourne : Un objet JSON avec :

• defaults – Valeurs par défaut complètes pour chaque propriété
• schema – Schéma JSON définissant la structure, les types et les contraintes du composant
• required – Liste des propriétés requises

Exemple de réponse pour un calque de texte :

{
  "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": "Le contenu textuel à afficher" },
      "fontSize": { "type": "number", "minimum": 1, "maximum": 500 },
      "fontFamily": { "type": "string", "description": "Nom de police Google ou police système" },
      "color": { "type": "string", "pattern": "^#[0-9a-fA-F]{6}$" }
    }
  }
}

get_easing_docs

Retourne la référence complète pour toutes les fonctions d’accélération disponibles. Les fonctions d’accélération contrôlent la courbe d’accélération des animations, déterminant si elles commencent lentement, se terminent lentement, rebondissent ou suivent une courbe élastique.

Paramètres :

• easing (chaîne, optionnel) – Nom de fonction d’accélération spécifique pour une documentation détaillée. Si omis, retourne la liste complète.

Retourne : Documentation pour chaque fonction d’accélération incluant :

• Nom de la fonction (par ex., easeInOutCubic, easeOutBounce, spring)
• Description mathématique de la courbe
• Description visuelle de la sensation de mouvement
• Cas d’utilisation recommandés
• Équivalent CSS (le cas échéant)

Configuration de l’intégration IA

Connecter Rendervid à votre outil IA nécessite d’ajouter le serveur MCP à la configuration de votre outil. Le processus de configuration varie légèrement entre les outils, mais le concept de base est le même : pointer votre outil IA vers le point d’entrée du serveur MCP de Rendervid.

Prérequis

Avant de configurer un outil IA, assurez-vous d’avoir :

1. Node.js 18+ installé sur votre système
2. Rendervid cloné et compilé depuis le dépôt GitHub :

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

3. FFmpeg installé (requis pour la sortie vidéo) :

# macOS
brew install ffmpeg

# Ubuntu/Debian
sudo apt install ffmpeg

# Windows (avec Chocolatey)
choco install ffmpeg

Claude Desktop / Claude Code

Ajoutez le serveur MCP Rendervid à votre fichier de configuration Claude Desktop.

Emplacement du fichier de configuration :

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

Configuration :

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

Remplacez /path/to/rendervid par le chemin réel vers votre installation Rendervid.

Pour Claude Code (CLI), ajoutez la même configuration à votre fichier .claude/mcp.json du projet ou à vos paramètres globaux Claude Code. Claude Code détectera automatiquement le serveur MCP et exposera les 11 outils pendant vos sessions de codage.

Après avoir enregistré la configuration, redémarrez Claude Desktop ou Claude Code. Vous pouvez vérifier la connexion en demandant à Claude : “Quels outils Rendervid sont disponibles ?” Claude devrait lister les 11 outils MCP.

Cursor IDE

Ajoutez le serveur MCP Rendervid à la configuration MCP de Cursor.

Fichier de configuration : .cursor/mcp.json à la racine de votre projet (ou paramètres globaux Cursor).

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

Après avoir enregistré, redémarrez Cursor. Les outils Rendervid seront disponibles dans l’assistant IA de Cursor, vous permettant de générer des vidéos directement depuis votre éditeur.

Windsurf IDE

Windsurf prend en charge les serveurs MCP via sa configuration IA. Ajoutez le serveur Rendervid à vos paramètres MCP Windsurf :

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

Consultez la documentation de Windsurf pour l’emplacement exact du fichier de configuration, car il peut varier selon la version et le système d’exploitation.

Configuration MCP générique

Tout outil qui implémente la spécification client MCP peut se connecter au serveur MCP de Rendervid. Le serveur communique via stdio (entrée/sortie standard), qui est le transport MCP par défaut.

Pour intégrer avec un client MCP personnalisé :

1. Lancez le processus du serveur MCP :

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

2. Communiquez via stdin/stdout en utilisant le protocole JSON-RPC MCP.
3. Appelez tools/list pour découvrir les outils disponibles.
4. Appelez tools/call avec le nom de l’outil et les arguments pour exécuter n’importe quel outil.

Le serveur MCP est sans état. Chaque appel d’outil est indépendant, et le serveur peut gérer des requêtes simultanées de plusieurs clients.

Flux de travail IA : Exemples de bout en bout

Les exemples suivants montrent comment les agents IA utilisent les outils MCP de Rendervid pour passer d’une commande en langage naturel à une vidéo terminée.

Exemple 1 : Création de contenu pour réseaux sociaux

Commande utilisateur : “Créer une story Instagram de 10 secondes faisant la promotion de soldes d’été avec du texte animé et un fond dégradé”

Flux de travail de l’agent IA :

Étape 1 – Découvrir les capacités :

L’agent appelle get_capabilities pour en savoir plus sur les types de calques disponibles, les préréglages d’animation et les contraintes de sortie. Il découvre que les calques text et shape sont disponibles, que les animations fadeInUp et scaleIn existent, et que les stories Instagram utilisent une résolution de 1080x1920.

Étape 2 – Trouver un modèle de départ :

L’agent appelle list_examples avec category: "social-media" et trouve un modèle instagram-story. Il appelle ensuite get_example("instagram-story") pour charger le JSON complet du modèle.

Étape 3 – Construire le modèle :

En utilisant l’exemple comme référence, l’agent construit un modèle personnalisé :

{
  "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": "SOLDES D'ÉTÉ",
          "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% DE RÉDUCTION SUR TOUT",
          "fontSize": 64,
          "fontFamily": "Montserrat",
          "color": "#FFE066",
          "position": { "x": 540, "y": 850 },
          "animations": [
            { "type": "fadeInUp", "duration": 0.8, "delay": 0.6 }
          ]
        },
        {
          "type": "text",
          "text": "Acheter maintenant  →",
          "fontSize": 48,
          "fontFamily": "Montserrat",
          "color": "#FFFFFF",
          "position": { "x": 540, "y": 1200 },
          "animations": [
            { "type": "scaleIn", "duration": 0.6, "delay": 1.2 }
          ]
        }
      ]
    }
  ]
}

Étape 4 – Valider :

L’agent appelle validate_template avec le JSON du modèle. La réponse revient comme valid: true sans erreurs.

Étape 5 – Rendre :

L’agent appelle render_video avec le modèle validé et reçoit une URL vers le fichier MP4 terminé.

Exemple 2 : Automatisation de vidéo marketing

Commande utilisateur : “Générer une vidéo de présentation de produit pour nos nouveaux écouteurs. Utiliser cette image de produit : https://example.com/headphones.png . Le nom du produit est ‘SoundPro X1’ et le prix est 299 $.”

Flux de travail de l’agent IA :

1. get_capabilities – Apprend sur les calques d’image, le style de texte et les options d’animation.
2. list_examples – Trouve un modèle product-showcase dans la catégorie e-commerce.
3. get_example("product-showcase") – Charge le modèle complet de présentation de produit, qui utilise des variables de modèle pour le nom du produit, l’image et le prix.
4. Modifie le modèle – Met à jour les inputs avec les données de produit de l’utilisateur :

   {
     "inputs": {
       "productName": "SoundPro X1",
       "productImage": "https://example.com/headphones.png",
       "price": "299 $",
       "tagline": "Son premium, redéfini"
     }
   }
   

5. validate_template – Vérifie le modèle et confirme que https://example.com/headphones.png est accessible.
6. render_video – Produit la vidéo finale de présentation de produit.

Ce flux de travail démontre comment les agents IA exploitent les variables de modèle pour créer du contenu personnalisé à partir de modèles réutilisables. Le même modèle de présentation de produit peut générer des centaines de vidéos uniques en changeant simplement les entrées.

Exemple 3 : Génération de visualisation de données

Commande utilisateur : “Créer un graphique à barres animé montrant les revenus trimestriels : T1 : 1,2 M$, T2 : 1,8 M$, T3 : 2,1 M$, T4 : 2,7 M$”

Flux de travail de l’agent IA :

1. get_capabilities – Découvre le type de calque custom et le composant intégré AnimatedLineChart.
2. get_component_docs("AnimatedLineChart") – Lit la documentation du composant graphique, apprenant sur le format de données, la configuration des couleurs, les étiquettes d’axe et les options d’animation.
3. get_component_defaults("AnimatedLineChart") – Obtient les valeurs par défaut et le schéma JSON pour comprendre la configuration minimale requise.
4. Construit un modèle avec un calque de composant personnalisé :

   {
     "type": "custom",
     "component": "AnimatedLineChart",
     "props": {
       "data": [
         { "label": "T1", "value": 1200000 },
         { "label": "T2", "value": 1800000 },
         { "label": "T3", "value": 2100000 },
         { "label": "T4", "value": 2700000 }
       ],
       "colors": ["#4361EE", "#3A0CA3", "#7209B7", "#F72585"],
       "title": "Revenus trimestriels 2025",
       "yAxisLabel": "Revenus (USD)",
       "animationDuration": 2
     }
   }
   

5. validate_template – Confirme que la structure du modèle est correcte.
6. render_video – Génère la vidéo de graphique animé.

API auto-descriptive : Comment les capacités rendent les agents IA efficaces

L’outil get_capabilities est la pierre angulaire de l’intégration IA de Rendervid. Il implémente un modèle d’API auto-descriptive, où le système indique aux agents IA exactement ce qu’il peut faire, quels paramètres sont requis et quelles valeurs sont valides. Cela élimine le besoin pour les modèles IA de mémoriser ou d’être entraînés sur l’API spécifique de Rendervid.

Ce que contient la réponse des capacités

Lorsqu’un agent IA appelle get_capabilities, il reçoit une réponse structurée couvrant chaque aspect du système de rendu :

Types de calques avec schémas JSON :

{
  "layerTypes": {
    "text": {
      "description": "Rend du texte avec un contrôle complet du style",
      "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": { "..." : "..." }
  }
}

Préréglages d’animation :

La réponse des capacités liste chaque préréglage d’animation avec sa catégorie, ses paramètres configurables et sa description. Un agent IA recevant ces données sait que fadeInUp est une animation d’entrée avec des paramètres duration, delay et easing, et qu’elle déplace l’élément vers le haut tout en le faisant apparaître en fondu.

Fonctions d’accélération :

Toutes les 30+ fonctions d’accélération sont listées avec des descriptions, afin que l’agent IA puisse sélectionner la bonne courbe pour chaque animation. Par exemple, easeOutBounce est décrit comme simulant un effet de rebond à la fin de l’animation, que l’agent peut recommander pour du contenu ludique ou accrocheur.

Filtres et effets :

Les filtres visuels comme blur, brightness, contrast, saturate, grayscale et sepia sont documentés avec leurs plages de paramètres, permettant à l’agent IA d’appliquer des effets de post-traitement à n’importe quel calque.

Pourquoi les API auto-descriptives sont importantes

Les API traditionnelles nécessitent une documentation que les modèles IA peuvent ou non avoir vue pendant l’entraînement. Une API auto-descriptive fournit la documentation à l’exécution, garantissant que l’agent IA dispose toujours d’informations actuelles et précises. Lorsque Rendervid ajoute un nouveau préréglage d’animation ou type de calque, chaque agent IA connecté le voit immédiatement via get_capabilities. Pas de mises à jour de documentation, pas de réentraînement, pas de désaccords de version.

Meilleures pratiques pour la génération vidéo IA

Suivez ces directives pour obtenir les meilleurs résultats lors de l’utilisation d’agents IA pour générer des vidéos Rendervid.

1. Toujours valider avant le rendu

Appelez validate_template avant chaque rendu. Le rendu est coûteux en calcul, et la validation est presque instantanée. L’outil de validation détecte les problèmes qui causeraient l’échec d’un rendu ou produiraient une sortie inattendue :

• URL de médias cassées (images, vidéos, fichiers audio qui retournent 404)
• Structure JSON invalide ou champs requis manquants
• Valeurs hors limites pour les dimensions, tailles de police ou durées
• Préréglages d’animation ou types de calques inconnus

Un flux de travail IA typique devrait toujours inclure la validation comme étape avant d’appeler render_video ou render_image.

2. Partir d’exemples

Au lieu de construire des modèles à partir de zéro, les agents IA devraient utiliser list_examples et get_example pour trouver un modèle de départ pertinent. Les modèles d’exemple sont testés et connus pour produire une bonne sortie. Partir d’un exemple et le modifier est plus rapide et moins sujet aux erreurs que de générer une structure de modèle entièrement nouvelle.

Approche recommandée :

1. Appelez list_examples avec une catégorie pertinente
2. Appelez get_example pour le modèle le plus proche
3. Modifiez le modèle pour correspondre aux exigences spécifiques de l’utilisateur
4. Validez et rendez

3. Utiliser des commandes descriptives

Lors de la demande de vidéos à un agent IA, soyez précis sur :

• Dimensions et plateforme – “Story Instagram 1080x1920” est mieux que “une vidéo verticale”
• Durée – “Introduction de 10 secondes” est mieux que “une courte vidéo”
• Style et ambiance – “fond sombre avec texte néon et animations rebondissantes” donne à l’agent IA une direction claire
• Structure du contenu – “Trois lignes de texte apparaissant l’une après l’autre avec des animations de fondu” est plus actionnable que “du texte animé”

4. Itérer sur les modèles

La génération vidéo est itérative. Après le premier rendu, examinez la sortie et demandez à l’agent IA d’ajuster des éléments spécifiques :

• “Agrandir le texte du titre et changer la couleur en or”
• “Ralentir les animations d’entrée et ajouter un délai de 0,5 seconde entre chaque ligne”
• “Ajouter un filtre de flou subtil à l’image de fond”
• “Changer l’accélération de linéaire à easeOutCubic pour un mouvement plus fluide”

L’agent IA peut modifier le modèle existant et effectuer un nouveau rendu sans recommencer, rendant l’itération rapide et efficace.

5. Exploiter les variables de modèle pour la production par lots

Si vous avez besoin de plusieurs variations de la même vidéo (produits différents, langues différentes, données différentes), demandez à l’agent IA de créer un modèle avec des variables . Cela vous permet de rendre de nombreuses vidéos à partir d’un seul modèle en passant différents inputs :

{
  "inputs": {
    "productName": "Chaussures de course Pro",
    "productImage": "https://example.com/shoes.png",
    "price": "149 $",
    "tagline": "Courir plus vite, aller plus loin"
  }
}

6. Utiliser le rendu asynchrone pour les vidéos longues

Pour les vidéos de plus de 30 secondes ou les modèles avec des animations complexes, utilisez start_render_async au lieu de render_video. Cela évite les expirations de délai et permet à l’agent IA d’effectuer d’autres tâches pendant que la vidéo est rendue en arrière-plan.

Découverte de modèles : Parcourir plus de 100 exemples

Rendervid inclut plus de 100 modèles d’exemple couvrant 32 catégories, donnant aux agents IA une riche bibliothèque de points de départ pour toute tâche de génération vidéo.

Comment les agents IA découvrent les modèles

Le flux de travail de découverte de modèles utilise deux outils en séquence :

1. list_examples – Parcourir le catalogue avec filtrage optionnel par catégorie pour trouver des modèles pertinents.
2. get_example – Charger le modèle JSON complet pour un exemple spécifique.

Catégories de modèles

Les agents IA peuvent filtrer les exemples par catégorie pour trouver rapidement des points de départ pertinents :

Découverte de modèles en pratique

Lorsqu’un utilisateur demande “un graphique animé montrant des données de ventes”, l’agent IA :

1. Appelle list_examples(category: "data-visualization") et reçoit une liste de modèles liés aux graphiques.
2. Identifie animated-bar-chart comme la meilleure correspondance basée sur la description.
3. Appelle get_example("animated-bar-chart") pour charger le modèle complet.
4. Examine la structure du modèle pour comprendre comment les données sont formatées.
5. Remplace les données d’exemple par les chiffres de ventes réels de l’utilisateur.
6. Valide et rend.

Cette approche axée sur la découverte signifie que les agents IA produisent systématiquement des modèles bien structurés car ils s’appuient sur des exemples testés plutôt que de générer du JSON de modèle à partir de zéro.

Explorer tous les modèles disponibles

Pour voir tous les modèles disponibles, un agent IA peut appeler list_examples sans filtre de catégorie. La réponse inclut des métadonnées pour tous les 100+ modèles, permettant à l’agent de rechercher dans toutes les catégories la meilleure correspondance. Chaque entrée inclut le nom du modèle, la catégorie, la description, les dimensions et la durée, donnant à l’agent suffisamment d’informations pour faire une sélection éclairée.

Outils IA pris en charge

Le serveur MCP de Rendervid fonctionne avec tout outil qui implémente la spécification client du Model Context Protocol. Les outils suivants ont été testés et confirmés pour fonctionner avec Rendervid :

Parce que MCP est un standard ouvert, tout futur outil qui ajoute le support client MCP sera automatiquement compatible avec le serveur MCP de Rendervid. Aucun changement au serveur ou à ses outils n’est requis.

Prochaines étapes

• Aperçu de Rendervid – Découvrez toutes les fonctionnalités de Rendervid, les formats de sortie et l’architecture.
• Système de modèles – Plongée profonde dans la structure des modèles JSON, les variables et le système d’entrée.
• Référence des composants – Documentation pour tous les types de calques et composants React personnalisés.
• Guide de déploiement – Déployez Rendervid sur AWS Lambda, Azure Functions, Google Cloud Run ou Docker pour un rendu à l’échelle du cloud.
• Dépôt GitHub – Code source, suivi des problèmes et contributions de la communauté.