Integración de IA de Rendervid - Genera Videos con Claude Code, Cursor y MCP

Introducción: Generación de Video Impulsada por IA

Crear videos programáticamente ha requerido tradicionalmente un conocimiento profundo de códecs de video, frameworks de animación y pipelines de renderizado. Rendervid elimina esta complejidad al aceptar plantillas JSON y generar videos terminados. Cuando combinas esto con agentes de IA que entienden lenguaje natural, obtienes algo poderoso: la capacidad de describir un video en inglés simple y recibir un MP4 renderizado a cambio.

Rendervid cierra la brecha entre los modelos de lenguaje de IA y la producción de video. En lugar de escribir código, diseñar fotogramas clave o aprender un editor de video, le dices a un agente de IA lo que quieres. El agente genera una plantilla JSON válida, la valida y renderiza la salida final a través del motor de Rendervid. Todo el proceso ocurre en una sola conversación.

Esta integración está construida sobre el Model Context Protocol (MCP), un estándar abierto que permite a las herramientas de IA interactuar con servicios externos a través de una interfaz estructurada. El servidor MCP de Rendervid expone 11 herramientas que cubren renderizado, validación, descubrimiento de plantillas y documentación, dando a los agentes de IA todo lo que necesitan para producir contenido de video profesional de forma autónoma.

¿Qué es el Model Context Protocol (MCP)?

El Model Context Protocol es un estándar abierto desarrollado para dar a los asistentes de IA acceso estructurado a herramientas externas y fuentes de datos. En lugar de depender de que los modelos de IA adivinen formatos de API o generen código que llame a endpoints REST, MCP proporciona una interfaz tipada y descubrible que los agentes de IA pueden consultar en tiempo de ejecución.

Para la generación de video, MCP resuelve un problema crítico: los agentes de IA necesitan saber qué es posible antes de poder generar una salida válida. Sin MCP, un modelo de IA necesitaría ser entrenado en el formato de plantilla específico de Rendervid, conocer cada preset de animación disponible y entender las restricciones de cada tipo de capa. Con MCP, el agente simplemente llama a get_capabilities y recibe una descripción completa del sistema, incluyendo esquemas JSON para cada componente.

Por qué MCP Importa para la Generación de Video con IA

• Descubrimiento en Tiempo de Ejecución: Los agentes de IA aprenden lo que Rendervid puede hacer en el momento en que se conectan, no en el momento del entrenamiento. Esto significa que las nuevas características están disponibles inmediatamente sin reentrenamiento.
• Seguridad de Tipos: Cada herramienta tiene un esquema de entrada y salida definido. El agente de IA sabe exactamente qué parámetros son requeridos y qué tipos deben ser.
• Validación Antes del Renderizado: En lugar de enviar una plantilla y esperar que funcione, el agente puede validar la plantilla primero y corregir cualquier problema antes de gastar tiempo en el renderizado.
• Composabilidad de Herramientas: Los agentes de IA pueden encadenar herramientas, llamando a list_examples para encontrar una plantilla inicial, modificándola, llamando a validate_template para verificarla y luego llamando a render_video para producir la salida. Todo en un solo turno de conversación.

Referencia de Herramientas del Servidor MCP

El servidor MCP de Rendervid expone 11 herramientas organizadas en tres categorías: Renderizado, Validación y Descubrimiento, y Documentación. Cada herramienta está diseñada para dar a los agentes de IA máxima autonomía al generar contenido de video.

Herramientas de Renderizado

Estas herramientas manejan la producción real de salida de video e imagen desde plantillas JSON.

render_video

Genera un archivo de video completo desde una plantilla JSON. Esta es la herramienta principal de renderizado para producir salida MP4, WebM o MOV.

Parámetros:

• template (objeto, requerido) – La plantilla JSON completa que define escenas, capas, animaciones y configuraciones de salida.
• inputs (objeto, opcional) – Pares clave-valor para la sustitución de variables de plantilla.
• output_format (cadena, opcional) – Formato de salida: mp4, webm o mov. Por defecto mp4.

Ejemplo de uso por un agente de IA:

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

Devuelve: Una URL o ruta de archivo al archivo de video renderizado.

render_image

Genera un solo fotograma o imagen estática desde una plantilla JSON. Útil para crear miniaturas, gráficos de redes sociales, fotogramas de póster y materiales de marketing estáticos.

Parámetros:

• template (objeto, requerido) – La plantilla JSON que define la composición de la imagen.
• inputs (objeto, opcional) – Valores de sustitución de variables de plantilla.
• output_format (cadena, opcional) – Formato de salida: png, jpeg o webp. Por defecto png.
• frame (número, opcional) – Qué fotograma renderizar (para extraer un momento específico de una plantilla animada).

Cuándo usar render_image vs render_video:

• Usa render_image para salida estática: miniaturas, banners, publicaciones de redes sociales, diapositivas de presentación.
• Usa render_video para cualquier cosa con movimiento: animaciones, transiciones, audio, clips de video.

start_render_async

Inicia un trabajo de renderizado asíncrono para videos de larga duración (típicamente más de 30 segundos). En lugar de esperar a que el renderizado se complete sincrónicamente, esta herramienta devuelve un ID de trabajo que puedes consultar con check_render_status.

Parámetros:

• template (objeto, requerido) – La plantilla JSON completa.
• inputs (objeto, opcional) – Valores de variables de plantilla.
• output_format (cadena, opcional) – Formato de salida deseado.

Devuelve: Una cadena job_id que puede ser usada con check_render_status y list_render_jobs.

Cuándo usar renderizado asíncrono:

• Videos de más de 30 segundos
• Plantillas con muchas escenas o animaciones complejas
• Flujos de trabajo de renderizado por lotes donde quieres enviar múltiples trabajos y recoger resultados después
• Entornos de renderizado en la nube donde las solicitudes sincrónicas de larga duración pueden agotar el tiempo de espera

check_render_status

Verifica el estado actual de un trabajo de renderizado asíncrono iniciado con start_render_async.

Parámetros:

• job_id (cadena, requerido) – El ID de trabajo devuelto por start_render_async.

Devuelve: Un objeto que contiene:

• status – Uno de queued, rendering, completed o failed.
• progress – Un porcentaje (0-100) indicando el progreso del renderizado.
• output_url – La URL del video terminado (solo presente cuando status es completed).
• error – Mensaje de error si el trabajo falló.

Ejemplo de flujo de trabajo de consulta:

Agente de 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

Lista todos los trabajos de renderizado asíncronos, tanto activos como completados. Útil para monitorear operaciones de renderizado por lotes o revisar salidas recientes.

Parámetros:

• status_filter (cadena, opcional) – Filtrar por estado: queued, rendering, completed, failed o all. Por defecto all.
• limit (número, opcional) – Número máximo de trabajos a devolver.

Devuelve: Un arreglo de objetos de trabajo, cada uno con job_id, status, progress, created_at y output_url (si está completado).

Herramientas de Validación y Descubrimiento

Estas herramientas ayudan a los agentes de IA a entender lo que Rendervid puede hacer y verificar que las plantillas sean correctas antes del renderizado.

validate_template

Valida una plantilla JSON antes del renderizado. Esta herramienta verifica la estructura de la plantilla, tipos de campo, restricciones de valores e incluso verifica que las URLs de medios (imágenes, videos, archivos de audio) sean accesibles. Ejecutar la validación antes del renderizado previene tiempo desperdiciado en plantillas que fallarían durante el proceso de renderizado.

Parámetros:

• template (objeto, requerido) – La plantilla JSON a validar.
• check_urls (booleano, opcional) – Si se debe verificar que las URLs de medios sean accesibles. Por defecto true.

Devuelve: Un objeto que contiene:

• valid – Booleano indicando si la plantilla es válida.
• errors – Arreglo de objetos de error con path, message y severity para cada problema encontrado.
• warnings – Arreglo de objetos de advertencia para problemas no críticos (ej., variables sin usar, dimensiones muy grandes).

Lo que la validación detecta:

• Campos requeridos faltantes (ej., una escena sin duration)
• Tipos de campo inválidos (ej., una cadena donde se espera un número)
• Tipos de capa o presets de animación desconocidos
• URLs de medios rotas o inaccesibles (imágenes, videos, archivos de audio)
• Valores fuera de rango (ej., dimensiones negativas, fps por encima del máximo)
• Errores de sintaxis de variables de plantilla

Ejemplo de respuesta de validación:

{
  "valid": false,
  "errors": [
    {
      "path": "scenes[0].layers[2].src",
      "message": "La URL devolvió HTTP 404: https://example.com/missing-image.png",
      "severity": "error"
    },
    {
      "path": "scenes[1].duration",
      "message": "La duración de la escena debe ser un número positivo",
      "severity": "error"
    }
  ],
  "warnings": [
    {
      "path": "outputSettings.width",
      "message": "El ancho 7680 es muy grande y puede resultar en renderizado lento",
      "severity": "warning"
    }
  ]
}

get_capabilities

Devuelve una descripción completa de todo lo que Rendervid puede hacer. Esta es típicamente la primera herramienta que un agente de IA llama al iniciar una tarea de generación de video. La respuesta incluye tipos de capas disponibles, presets de animación, funciones de easing, filtros, formatos de salida y sus esquemas JSON.

Parámetros: Ninguno.

Devuelve: Un objeto estructurado que contiene:

• layerTypes – Todos los tipos de capas disponibles (texto, imagen, video, forma, audio, grupo, lottie, personalizado) con sus esquemas JSON y propiedades configurables.
• animations – Todos los presets de animación agrupados por categoría (entrada, salida, énfasis, fotograma clave) con descripciones y parámetros configurables.
• easingFunctions – Todas las 30+ funciones de easing con descripciones y ejemplos de uso.
• filters – Filtros visuales disponibles (desenfoque, brillo, contraste, saturar, escala de grises, sepia, etc.) con rangos de parámetros.
• outputFormats – Formatos de salida soportados para renderizado de video e imagen con sus restricciones.
• inputTypes – Tipos de variables de plantilla y reglas de validación.
• sceneTransitions – Los 17 tipos de transiciones de escena con sus parámetros.

Por qué esta herramienta es crítica para los agentes de IA:

La respuesta de capacidades es una API autodescriptiva. Un agente de IA no necesita ser pre-entrenado en el formato de plantilla de Rendervid. Puede llamar a get_capabilities en tiempo de ejecución, recibir el esquema completo y generar plantillas válidas en su primer intento. Cuando Rendervid agrega nuevas características, animaciones o tipos de capas, los agentes de IA automáticamente obtienen acceso a ellas a través de esta herramienta sin ningún cambio de código.

get_example

Carga una plantilla de ejemplo específica por nombre. Los agentes de IA usan esto para recuperar una plantilla funcional como punto de partida, luego la modifican para coincidir con los requisitos del usuario.

Parámetros:

• name (cadena, requerido) – El nombre de la plantilla de ejemplo (ej., instagram-story, product-showcase, animated-bar-chart).

Devuelve: La plantilla JSON completa para el ejemplo solicitado, lista para renderizar o modificar.

Ejemplo:

El agente de IA llama: get_example("instagram-story")
Devuelve: Plantilla completa de historia de Instagram 1080x1920 con capas de texto,
         imagen de fondo y animaciones de entrada

list_examples

Explora el catálogo completo de más de 50 plantillas de ejemplo organizadas por categoría. Los agentes de IA usan esto para encontrar plantillas iniciales relevantes para la solicitud del usuario.

Parámetros:

• category (cadena, opcional) – Filtrar por categoría (ej., social-media, marketing, data-visualization, typography, e-commerce).

Devuelve: Un arreglo de objetos de metadatos de ejemplo, cada uno con:

• name – Identificador de plantilla para usar con get_example.
• category – Categoría de plantilla.
• description – Lo que la plantilla crea.
• dimensions – Ancho y alto de salida.
• duration – Duración de plantilla en segundos.

Herramientas de Documentación

Estas herramientas proporcionan documentación de referencia detallada que los agentes de IA pueden consultar al construir plantillas.

get_component_docs

Devuelve documentación detallada para un componente o tipo de capa específico. Incluye descripciones de propiedades, campos requeridos vs opcionales, valores por defecto y ejemplos de uso.

Parámetros:

• component (cadena, requerido) – El nombre del tipo de componente/capa (ej., text, image, video, shape, audio, group, lottie, custom, AnimatedLineChart, TypewriterEffect).

Devuelve: Documentación completa que incluye:

• Tabla de propiedades con tipos, valores por defecto y descripciones
• Esquema JSON para el componente
• Ejemplos de uso
• Notas sobre diferencias de renderizado en navegador vs Node.js

get_animation_docs

Devuelve la referencia completa de efectos de animación, incluyendo todos los presets de animación de entrada, salida, énfasis y fotogramas clave.

Parámetros:

• animation (cadena, opcional) – Nombre de animación específico para obtener documentación detallada (ej., fadeInUp, bounceIn, slideOutLeft). Si se omite, devuelve el catálogo completo de animaciones.

Devuelve: Documentación de animación que incluye:

• Nombre de animación y categoría (entrada, salida, énfasis, fotograma clave)
• Descripción del efecto visual
• Parámetros configurables (duración, retraso, easing)
• Valores por defecto
• Casos de uso recomendados

get_component_defaults

Devuelve los valores por defecto y el esquema JSON completo para un tipo de componente específico. Los agentes de IA usan esto para entender cómo se ve un componente válido mínimo y qué propiedades pueden sobrescribir.

Parámetros:

• component (cadena, requerido) – El nombre del tipo de componente/capa.

Devuelve: Un objeto JSON con:

• defaults – Valores por defecto completos para cada propiedad
• schema – Esquema JSON que define la estructura, tipos y restricciones del componente
• required – Lista de propiedades requeridas

Ejemplo de respuesta para una capa de texto:

{
  "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": "El contenido de texto a mostrar" },
      "fontSize": { "type": "number", "minimum": 1, "maximum": 500 },
      "fontFamily": { "type": "string", "description": "Nombre de fuente de Google o fuente del sistema" },
      "color": { "type": "string", "pattern": "^#[0-9a-fA-F]{6}$" }
    }
  }
}

get_easing_docs

Devuelve la referencia completa para todas las funciones de easing disponibles. Las funciones de easing controlan la curva de aceleración de las animaciones, determinando si comienzan lento, terminan lento, rebotan o siguen una curva elástica.

Parámetros:

• easing (cadena, opcional) – Nombre de función de easing específico para documentación detallada. Si se omite, devuelve la lista completa.

Devuelve: Documentación para cada función de easing que incluye:

• Nombre de función (ej., easeInOutCubic, easeOutBounce, spring)
• Descripción matemática de la curva
• Descripción visual de la sensación del movimiento
• Casos de uso recomendados
• Equivalente CSS (donde aplique)

Configuración de la Integración de IA

Conectar Rendervid a tu herramienta de IA requiere agregar el servidor MCP a la configuración de tu herramienta. El proceso de configuración varía ligeramente entre herramientas, pero el concepto central es el mismo: apunta tu herramienta de IA al punto de entrada del servidor MCP de Rendervid.

Requisitos Previos

Antes de configurar cualquier herramienta de IA, asegúrate de tener:

1. Node.js 18+ instalado en tu sistema
2. Rendervid clonado y construido desde el repositorio de GitHub :

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

3. FFmpeg instalado (requerido para salida de video):

# macOS
brew install ffmpeg

# Ubuntu/Debian
sudo apt install ffmpeg

# Windows (con Chocolatey)
choco install ffmpeg

Claude Desktop / Claude Code

Agrega el servidor MCP de Rendervid a tu archivo de configuración de Claude Desktop.

Ubicación del archivo de configuración:

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

Configuración:

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

Reemplaza /path/to/rendervid con la ruta real a tu instalación de Rendervid.

Para Claude Code (CLI), agrega la misma configuración al archivo .claude/mcp.json de tu proyecto o a tu configuración global de Claude Code. Claude Code detectará automáticamente el servidor MCP y expondrá las 11 herramientas durante tus sesiones de codificación.

Después de guardar la configuración, reinicia Claude Desktop o Claude Code. Puedes verificar la conexión preguntando a Claude: “¿Qué herramientas de Rendervid están disponibles?” Claude debería listar las 11 herramientas MCP.

Cursor IDE

Agrega el servidor MCP de Rendervid a la configuración MCP de Cursor.

Archivo de configuración: .cursor/mcp.json en la raíz de tu proyecto (o configuración global de Cursor).

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

Después de guardar, reinicia Cursor. Las herramientas de Rendervid estarán disponibles en el asistente de IA de Cursor, permitiéndote generar videos directamente desde tu editor.

Windsurf IDE

Windsurf soporta servidores MCP a través de su configuración de IA. Agrega el servidor de Rendervid a tu configuración MCP de Windsurf:

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

Consulta la documentación de Windsurf para la ubicación exacta del archivo de configuración, ya que puede variar según la versión y el sistema operativo.

Configuración MCP Genérica

Cualquier herramienta que implemente la especificación de cliente MCP puede conectarse al servidor MCP de Rendervid. El servidor se comunica a través de stdio (entrada/salida estándar), que es el transporte MCP por defecto.

Para integrar con un cliente MCP personalizado:

1. Genera el proceso del servidor MCP:

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

2. Comunícate a través de stdin/stdout usando el protocolo JSON-RPC de MCP.
3. Llama a tools/list para descubrir herramientas disponibles.
4. Llama a tools/call con el nombre de la herramienta y argumentos para ejecutar cualquier herramienta.

El servidor MCP no tiene estado. Cada llamada de herramienta es independiente, y el servidor puede manejar solicitudes concurrentes de múltiples clientes.

Flujo de Trabajo de IA: Ejemplos de Extremo a Extremo

Los siguientes ejemplos muestran cómo los agentes de IA usan las herramientas MCP de Rendervid para ir desde un comando en lenguaje natural hasta un video terminado.

Ejemplo 1: Creación de Contenido para Redes Sociales

Comando del usuario: “Crea una historia de Instagram de 10 segundos promocionando una venta de verano con texto animado y un fondo degradado”

Flujo de trabajo del agente de IA:

Paso 1 – Descubrir capacidades:

El agente llama a get_capabilities para aprender sobre tipos de capas disponibles, presets de animación y restricciones de salida. Descubre que las capas text y shape están disponibles, las animaciones fadeInUp y scaleIn existen, y las historias de Instagram usan resolución 1080x1920.

Paso 2 – Encontrar una plantilla inicial:

El agente llama a list_examples con category: "social-media" y encuentra una plantilla instagram-story. Luego llama a get_example("instagram-story") para cargar el JSON completo de la plantilla.

Paso 3 – Construir la plantilla:

Usando el ejemplo como referencia, el agente construye una plantilla personalizada:

{
  "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": "VENTA DE VERANO",
          "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 DESCUENTO EN TODO",
          "fontSize": 64,
          "fontFamily": "Montserrat",
          "color": "#FFE066",
          "position": { "x": 540, "y": 850 },
          "animations": [
            { "type": "fadeInUp", "duration": 0.8, "delay": 0.6 }
          ]
        },
        {
          "type": "text",
          "text": "Compra Ahora  →",
          "fontSize": 48,
          "fontFamily": "Montserrat",
          "color": "#FFFFFF",
          "position": { "x": 540, "y": 1200 },
          "animations": [
            { "type": "scaleIn", "duration": 0.6, "delay": 1.2 }
          ]
        }
      ]
    }
  ]
}

Paso 4 – Validar:

El agente llama a validate_template con el JSON de la plantilla. La respuesta vuelve como valid: true sin errores.

Paso 5 – Renderizar:

El agente llama a render_video con la plantilla validada y recibe una URL al archivo MP4 terminado.

Ejemplo 2: Automatización de Video de Marketing

Comando del usuario: “Genera un video de exhibición de producto para nuestros nuevos audífonos. Usa esta imagen del producto: https://example.com/headphones.png . El nombre del producto es ‘SoundPro X1’ y el precio es $299.”

Flujo de trabajo del agente de IA:

1. get_capabilities – Aprende sobre capas de imagen, estilos de texto y opciones de animación.
2. list_examples – Encuentra una plantilla product-showcase en la categoría e-commerce.
3. get_example("product-showcase") – Carga la plantilla completa de exhibición de producto, que usa variables de plantilla para nombre de producto, imagen y precio.
4. Modifica la plantilla – Actualiza los inputs con los datos del producto del usuario:

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

5. validate_template – Verifica la plantilla y confirma que https://example.com/headphones.png es accesible.
6. render_video – Produce el video final de exhibición de producto.

Este flujo de trabajo demuestra cómo los agentes de IA aprovechan las variables de plantilla para crear contenido personalizado desde plantillas reutilizables. La misma plantilla de exhibición de producto puede generar cientos de videos únicos intercambiando las entradas.

Ejemplo 3: Generación de Visualización de Datos

Comando del usuario: “Crea un gráfico de barras animado mostrando ingresos trimestrales: Q1: $1.2M, Q2: $1.8M, Q3: $2.1M, Q4: $2.7M”

Flujo de trabajo del agente de IA:

1. get_capabilities – Descubre el tipo de capa custom y el componente integrado AnimatedLineChart.
2. get_component_docs("AnimatedLineChart") – Lee la documentación del componente de gráfico, aprendiendo sobre formato de datos, configuración de color, etiquetas de ejes y opciones de animación.
3. get_component_defaults("AnimatedLineChart") – Obtiene los valores por defecto y el esquema JSON para entender la configuración mínima requerida.
4. Construye una plantilla con una capa de componente personalizado:

   {
     "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": "Ingresos Trimestrales 2025",
       "yAxisLabel": "Ingresos (USD)",
       "animationDuration": 2
     }
   }
   

5. validate_template – Confirma que la estructura de la plantilla es correcta.
6. render_video – Genera el video de gráfico animado.

API Autodescriptiva: Cómo las Capacidades Hacen Efectivos a los Agentes de IA

La herramienta get_capabilities es la piedra angular de la integración de IA de Rendervid. Implementa un patrón de API autodescriptiva, donde el sistema le dice a los agentes de IA exactamente lo que puede hacer, qué parámetros son requeridos y qué valores son válidos. Esto elimina la necesidad de que los modelos de IA memoricen o sean entrenados en la API específica de Rendervid.

Lo que Contiene la Respuesta de Capacidades

Cuando un agente de IA llama a get_capabilities, recibe una respuesta estructurada que cubre cada aspecto del sistema de renderizado:

Tipos de Capas con Esquemas JSON:

{
  "layerTypes": {
    "text": {
      "description": "Renderiza texto con control completo de estilo",
      "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": { "..." : "..." }
  }
}

Presets de Animación:

La respuesta de capacidades lista cada preset de animación con su categoría, parámetros configurables y descripción. Un agente de IA que recibe estos datos sabe que fadeInUp es una animación de entrada con parámetros duration, delay y easing, y que mueve el elemento hacia arriba mientras lo desvanece.

Funciones de Easing:

Todas las 30+ funciones de easing están listadas con descripciones, así que el agente de IA puede seleccionar la curva correcta para cada animación. Por ejemplo, easeOutBounce se describe como simulando un efecto de rebote al final de la animación, que el agente puede recomendar para contenido juguetón o que llame la atención.

Filtros y Efectos:

Los filtros visuales como blur, brightness, contrast, saturate, grayscale y sepia están documentados con sus rangos de parámetros, permitiendo al agente de IA aplicar efectos de postprocesamiento a cualquier capa.

Por qué las APIs Autodescriptivas Importan

Las APIs tradicionales requieren documentación que los modelos de IA pueden o no haber visto durante el entrenamiento. Una API autodescriptiva proporciona documentación en tiempo de ejecución, asegurando que el agente de IA siempre tenga información actual y precisa. Cuando Rendervid agrega un nuevo preset de animación o tipo de capa, cada agente de IA conectado lo ve inmediatamente a través de get_capabilities. Sin actualizaciones de documentación, sin reentrenamiento, sin desajustes de versión.

Mejores Prácticas para Generación de Video con IA

Sigue estas pautas para obtener los mejores resultados al usar agentes de IA para generar videos de Rendervid.

1. Siempre Valida Antes de Renderizar

Llama a validate_template antes de cada renderizado. El renderizado es computacionalmente costoso, y la validación es casi instantánea. La herramienta de validación detecta problemas que causarían que un renderizado falle o produzca salida inesperada:

• URLs de medios rotas (imágenes, videos, archivos de audio que devuelven 404)
• Estructura JSON inválida o campos requeridos faltantes
• Valores fuera de rango para dimensiones, tamaños de fuente o duraciones
• Presets de animación o tipos de capas desconocidos

Un flujo de trabajo típico de IA siempre debe incluir validación como un paso antes de llamar a render_video o render_image.

2. Comienza desde Ejemplos

En lugar de construir plantillas desde cero, los agentes de IA deberían usar list_examples y get_example para encontrar una plantilla inicial relevante. Las plantillas de ejemplo están probadas y se sabe que producen buena salida. Comenzar desde un ejemplo y modificarlo es más rápido y menos propenso a errores que generar una estructura de plantilla completamente nueva.

Enfoque recomendado:

1. Llama a list_examples con una categoría relevante
2. Llama a get_example para la plantilla que más coincida
3. Modifica la plantilla para coincidir con los requisitos específicos del usuario
4. Valida y renderiza

3. Usa Comandos Descriptivos

Al solicitar videos de un agente de IA, sé específico sobre:

• Dimensiones y plataforma – “historia de Instagram 1080x1920” es mejor que “un video vertical”
• Duración – “intro de 10 segundos” es mejor que “un video corto”
• Estilo y ambiente – “fondo oscuro con texto neón y animaciones de rebote” le da al agente de IA dirección clara
• Estructura de contenido – “Tres líneas de texto apareciendo una tras otra con animaciones de desvanecimiento” es más accionable que “algo de texto animado”

4. Itera en las Plantillas

La generación de video es iterativa. Después del primer renderizado, revisa la salida y pide al agente de IA que ajuste elementos específicos:

• “Haz el texto del título más grande y cambia el color a dorado”
• “Ralentiza las animaciones de entrada y agrega un retraso de 0.5 segundos entre cada línea”
• “Agrega un filtro de desenfoque sutil a la imagen de fondo”
• “Cambia el easing de lineal a easeOutCubic para un movimiento más suave”

El agente de IA puede modificar la plantilla existente y re-renderizar sin empezar de nuevo, haciendo la iteración rápida y eficiente.

5. Aprovecha las Variables de Plantilla para Producción por Lotes

Si necesitas múltiples variaciones del mismo video (diferentes productos, diferentes idiomas, diferentes datos), pide al agente de IA que cree una plantilla con variables . Esto te permite renderizar muchos videos desde una sola plantilla pasando diferentes inputs:

{
  "inputs": {
    "productName": "Zapatos para Correr Pro",
    "productImage": "https://example.com/shoes.png",
    "price": "$149",
    "tagline": "Corre Más Rápido, Ve Más Lejos"
  }
}

6. Usa Renderizado Asíncrono para Videos Largos

Para videos de más de 30 segundos o plantillas con animaciones complejas, usa start_render_async en lugar de render_video. Esto previene tiempos de espera agotados y permite al agente de IA realizar otras tareas mientras el video se renderiza en segundo plano.

Descubrimiento de Plantillas: Explorando Más de 100 Ejemplos

Rendervid incluye más de 100 plantillas de ejemplo que abarcan 32 categorías, dando a los agentes de IA una rica biblioteca de puntos de partida para cualquier tarea de generación de video.

Cómo los Agentes de IA Descubren Plantillas

El flujo de trabajo de descubrimiento de plantillas usa dos herramientas en secuencia:

1. list_examples – Explora el catálogo con filtrado opcional por categoría para encontrar plantillas relevantes.
2. get_example – Carga la plantilla JSON completa para un ejemplo específico.

Categorías de Plantillas

Los agentes de IA pueden filtrar ejemplos por categoría para encontrar rápidamente puntos de partida relevantes:

Descubrimiento de Plantillas en la Práctica

Cuando un usuario pide “un gráfico animado mostrando datos de ventas,” el agente de IA:

1. Llama a list_examples(category: "data-visualization") y recibe una lista de plantillas relacionadas con gráficos.
2. Identifica animated-bar-chart como la mejor coincidencia basado en la descripción.
3. Llama a get_example("animated-bar-chart") para cargar la plantilla completa.
4. Examina la estructura de la plantilla para entender cómo se formatean los datos.
5. Reemplaza los datos de ejemplo con las cifras de ventas reales del usuario.
6. Valida y renderiza.

Este enfoque de descubrimiento primero significa que los agentes de IA producen consistentemente plantillas bien estructuradas porque están construyendo sobre ejemplos probados en lugar de generar JSON de plantilla desde cero.

Explorando Todas las Plantillas Disponibles

Para ver cada plantilla disponible, un agente de IA puede llamar a list_examples sin un filtro de categoría. La respuesta incluye metadatos para todas las 100+ plantillas, permitiendo al agente buscar a través de categorías la mejor coincidencia. Cada entrada incluye el nombre de la plantilla, categoría, descripción, dimensiones y duración, dando al agente suficiente información para hacer una selección informada.

Herramientas de IA Soportadas

El servidor MCP de Rendervid funciona con cualquier herramienta que implemente la especificación de cliente del Model Context Protocol. Las siguientes herramientas han sido probadas y confirmadas para funcionar con Rendervid:

Debido a que MCP es un estándar abierto, cualquier herramienta futura que agregue soporte de cliente MCP será automáticamente compatible con el servidor MCP de Rendervid. No se requieren cambios al servidor o sus herramientas.

Próximos Pasos

• Descripción General de Rendervid – Aprende sobre todas las características de Rendervid, formatos de salida y arquitectura.
• Sistema de Plantillas – Inmersión profunda en la estructura de plantillas JSON, variables y el sistema de entrada.
• Referencia de Componentes – Documentación para todos los tipos de capas y componentes React personalizados.
• Guía de Implementación – Implementa Rendervid en AWS Lambda, Azure Functions, Google Cloud Run o Docker para renderizado a escala en la nube.
• Repositorio de GitHub – Código fuente, rastreador de problemas y contribuciones de la comunidad.