Integração de IA do Rendervid - Gere Vídeos com Claude Code, Cursor & MCP

Introdução: Geração de Vídeo Alimentada por IA

Criar vídeos programaticamente tem tradicionalmente exigido conhecimento profundo de codecs de vídeo, frameworks de animação e pipelines de renderização. O Rendervid elimina essa complexidade aceitando templates JSON e produzindo vídeos finalizados. Quando você combina isso com agentes de IA que entendem linguagem natural, você obtém algo poderoso: a capacidade de descrever um vídeo em inglês simples e receber um MP4 renderizado em retorno.

O Rendervid preenche a lacuna entre modelos de linguagem de IA e produção de vídeo. Em vez de escrever código, projetar keyframes ou aprender um editor de vídeo, você diz ao agente de IA o que deseja. O agente gera um template JSON válido, valida-o e renderiza a saída final através do motor do Rendervid. Todo o processo acontece em uma única conversa.

Esta integração é construída sobre o Model Context Protocol (MCP), um padrão aberto que permite que ferramentas de IA interajam com serviços externos através de uma interface estruturada. O servidor MCP do Rendervid expõe 11 ferramentas cobrindo renderização, validação, descoberta de templates e documentação, dando aos agentes de IA tudo o que precisam para produzir conteúdo de vídeo profissional de forma autônoma.

O Que É o Model Context Protocol (MCP)?

O Model Context Protocol é um padrão aberto desenvolvido para dar aos assistentes de IA acesso estruturado a ferramentas externas e fontes de dados. Em vez de confiar em modelos de IA para adivinhar formatos de API ou gerar código que chama endpoints REST, o MCP fornece uma interface tipada e descobrível que os agentes de IA podem consultar em tempo de execução.

Para geração de vídeo, o MCP resolve um problema crítico: os agentes de IA precisam saber o que é possível antes de poderem gerar saída válida. Sem o MCP, um modelo de IA precisaria ser treinado no formato específico de template do Rendervid, conhecer cada preset de animação disponível e entender as restrições de cada tipo de camada. Com o MCP, o agente simplesmente chama get_capabilities e recebe uma descrição completa do sistema, incluindo esquemas JSON para cada componente.

Por Que o MCP Importa para Geração de Vídeo por IA

• Descoberta em Tempo de Execução: Agentes de IA aprendem o que o Rendervid pode fazer no momento em que se conectam, não no momento do treinamento. Isso significa que novos recursos ficam imediatamente disponíveis sem retreinamento.
• Segurança de Tipo: Cada ferramenta tem um esquema de entrada e saída definido. O agente de IA sabe exatamente quais parâmetros são necessários e quais tipos eles devem ser.
• Validação Antes da Renderização: Em vez de submeter um template e esperar que funcione, o agente pode validar o template primeiro e corrigir quaisquer problemas antes de gastar tempo com renderização.
• Composabilidade de Ferramentas: Agentes de IA podem encadear ferramentas juntas, chamando list_examples para encontrar um template inicial, modificando-o, chamando validate_template para verificá-lo e então chamando render_video para produzir a saída. Tudo em um único turno de conversa.

Referência de Ferramentas do Servidor MCP

O servidor MCP do Rendervid expõe 11 ferramentas organizadas em três categorias: Renderização, Validação & Descoberta e Documentação. Cada ferramenta é projetada para dar aos agentes de IA máxima autonomia ao gerar conteúdo de vídeo.

Ferramentas de Renderização

Essas ferramentas lidam com a produção real de saída de vídeo e imagem a partir de templates JSON.

render_video

Gera um arquivo de vídeo completo a partir de um template JSON. Esta é a principal ferramenta de renderização para produzir saída MP4, WebM ou MOV.

Parâmetros:

• template (objeto, obrigatório) – O template JSON completo definindo cenas, camadas, animações e configurações de saída.
• inputs (objeto, opcional) – Pares chave-valor para substituição de variáveis do template.
• output_format (string, opcional) – Formato de saída: mp4, webm ou mov. Padrão é mp4.

Exemplo de uso por um agente de IA:

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

Retorna: Uma URL ou caminho de arquivo para o arquivo de vídeo renderizado.

render_image

Gera um único quadro ou imagem estática a partir de um template JSON. Útil para criar miniaturas, gráficos de redes sociais, quadros de pôster e materiais de marketing estáticos.

Parâmetros:

• template (objeto, obrigatório) – O template JSON definindo a composição da imagem.
• inputs (objeto, opcional) – Valores de substituição de variáveis do template.
• output_format (string, opcional) – Formato de saída: png, jpeg ou webp. Padrão é png.
• frame (número, opcional) – Qual quadro renderizar (para extrair um momento específico de um template animado).

Quando usar render_image vs render_video:

• Use render_image para saída estática: miniaturas, banners, posts de redes sociais, slides de apresentação.
• Use render_video para qualquer coisa com movimento: animações, transições, áudio, clipes de vídeo.

start_render_async

Inicia um trabalho de renderização assíncrona para vídeos de longa duração (tipicamente acima de 30 segundos). Em vez de esperar a renderização ser concluída de forma síncrona, esta ferramenta retorna um ID de trabalho que você pode consultar com check_render_status.

Parâmetros:

• template (objeto, obrigatório) – O template JSON completo.
• inputs (objeto, opcional) – Valores de variáveis do template.
• output_format (string, opcional) – Formato de saída desejado.

Retorna: Uma string job_id que pode ser usada com check_render_status e list_render_jobs.

Quando usar renderização assíncrona:

• Vídeos com mais de 30 segundos
• Templates com muitas cenas ou animações complexas
• Fluxos de trabalho de renderização em lote onde você deseja submeter múltiplos trabalhos e coletar resultados depois
• Ambientes de renderização em nuvem onde solicitações síncronas de longa duração podem expirar

check_render_status

Verifica o status atual de um trabalho de renderização assíncrona iniciado com start_render_async.

Parâmetros:

• job_id (string, obrigatório) – O ID do trabalho retornado por start_render_async.

Retorna: Um objeto contendo:

• status – Um de queued, rendering, completed ou failed.
• progress – Uma porcentagem (0-100) indicando o progresso da renderização.
• output_url – A URL do vídeo finalizado (presente apenas quando status é completed).
• error – Mensagem de erro se o trabalho falhou.

Exemplo de fluxo 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 os trabalhos de renderização assíncrona, tanto ativos quanto concluídos. Útil para monitorar operações de renderização em lote ou revisar saída recente.

Parâmetros:

• status_filter (string, opcional) – Filtrar por status: queued, rendering, completed, failed ou all. Padrão é all.
• limit (número, opcional) – Número máximo de trabalhos a retornar.

Retorna: Um array de objetos de trabalho, cada um com job_id, status, progress, created_at e output_url (se concluído).

Ferramentas de Validação & Descoberta

Essas ferramentas ajudam os agentes de IA a entender o que o Rendervid pode fazer e verificar se os templates estão corretos antes da renderização.

validate_template

Valida um template JSON antes da renderização. Esta ferramenta verifica a estrutura do template, tipos de campos, restrições de valores e até verifica se URLs de mídia (imagens, vídeos, arquivos de áudio) estão acessíveis. Executar a validação antes da renderização previne tempo desperdiçado em templates que falhariam durante o processo de renderização.

Parâmetros:

• template (objeto, obrigatório) – O template JSON a validar.
• check_urls (booleano, opcional) – Se deve verificar se URLs de mídia estão acessíveis. Padrão é true.

Retorna: Um objeto contendo:

• valid – Booleano indicando se o template é válido.
• errors – Array de objetos de erro com path, message e severity para cada problema encontrado.
• warnings – Array de objetos de aviso para problemas não críticos (por exemplo, variáveis não utilizadas, dimensões muito grandes).

O que a validação captura:

• Campos obrigatórios faltando (por exemplo, uma cena sem duration)
• Tipos de campos inválidos (por exemplo, uma string onde um número é esperado)
• Tipos de camada ou presets de animação desconhecidos
• URLs de mídia quebradas ou inacessíveis (imagens, vídeos, arquivos de áudio)
• Valores fora da faixa (por exemplo, dimensões negativas, fps acima do máximo)
• Erros de sintaxe de variáveis do template

Exemplo de resposta de validação:

{
  "valid": false,
  "errors": [
    {
      "path": "scenes[0].layers[2].src",
      "message": "URL retornou HTTP 404: https://example.com/missing-image.png",
      "severity": "error"
    },
    {
      "path": "scenes[1].duration",
      "message": "A duração da cena deve ser um número positivo",
      "severity": "error"
    }
  ],
  "warnings": [
    {
      "path": "outputSettings.width",
      "message": "Largura 7680 é muito grande e pode resultar em renderização lenta",
      "severity": "warning"
    }
  ]
}

get_capabilities

Retorna uma descrição abrangente de tudo o que o Rendervid pode fazer. Esta é tipicamente a primeira ferramenta que um agente de IA chama ao iniciar uma tarefa de geração de vídeo. A resposta inclui tipos de camadas disponíveis, presets de animação, funções de suavização, filtros, formatos de saída e seus esquemas JSON.

Parâmetros: Nenhum.

Retorna: Um objeto estruturado contendo:

• layerTypes – Todos os tipos de camadas disponíveis (text, image, video, shape, audio, group, lottie, custom) com seus esquemas JSON e propriedades configuráveis.
• animations – Todos os presets de animação agrupados por categoria (entrance, exit, emphasis, keyframe) com descrições e parâmetros configuráveis.
• easingFunctions – Todas as 30+ funções de suavização com descrições e exemplos de uso.
• filters – Filtros visuais disponíveis (blur, brightness, contrast, saturate, grayscale, sepia, etc.) com faixas de parâmetros.
• outputFormats – Formatos de saída suportados para renderização de vídeo e imagem com suas restrições.
• inputTypes – Tipos de variáveis do template e regras de validação.
• sceneTransitions – Todos os 17 tipos de transições de cena com seus parâmetros.

Por que esta ferramenta é crítica para agentes de IA:

A resposta de capacidades é uma API autodescritiva. Um agente de IA não precisa ser pré-treinado no formato de template do Rendervid. Ele pode chamar get_capabilities em tempo de execução, receber o esquema completo e gerar templates válidos em sua primeira tentativa. Quando o Rendervid adiciona novos recursos, animações ou tipos de camadas, os agentes de IA automaticamente ganham acesso a eles através desta ferramenta sem quaisquer mudanças de código.

get_example

Carrega um template de exemplo específico por nome. Agentes de IA usam isso para recuperar um template funcional como ponto de partida, então modificá-lo para corresponder aos requisitos do usuário.

Parâmetros:

• name (string, obrigatório) – O nome do template de exemplo (por exemplo, instagram-story, product-showcase, animated-bar-chart).

Retorna: O template JSON completo para o exemplo solicitado, pronto para renderizar ou modificar.

Exemplo:

Agente de IA chama: get_example("instagram-story")
Retorna: Template completo de story do Instagram 1080x1920 com camadas de texto,
         imagem de fundo e animações de entrada

list_examples

Navega pelo catálogo completo de mais de 50 templates de exemplo organizados por categoria. Agentes de IA usam isso para encontrar templates iniciais relevantes para a solicitação do usuário.

Parâmetros:

• category (string, opcional) – Filtrar por categoria (por exemplo, social-media, marketing, data-visualization, typography, e-commerce).

Retorna: Um array de objetos de metadados de exemplo, cada um com:

• name – Identificador do template para uso com get_example.
• category – Categoria do template.
• description – O que o template cria.
• dimensions – Largura e altura de saída.
• duration – Duração do template em segundos.

Ferramentas de Documentação

Essas ferramentas fornecem documentação de referência detalhada que os agentes de IA podem consultar ao construir templates.

get_component_docs

Retorna documentação detalhada para um componente ou tipo de camada específico. Inclui descrições de propriedades, campos obrigatórios vs opcionais, valores padrão e exemplos de uso.

Parâmetros:

• component (string, obrigatório) – O nome do tipo de componente/camada (por exemplo, text, image, video, shape, audio, group, lottie, custom, AnimatedLineChart, TypewriterEffect).

Retorna: Documentação abrangente incluindo:

• Tabela de propriedades com tipos, padrões e descrições
• Esquema JSON para o componente
• Exemplos de uso
• Notas sobre diferenças de renderização entre navegador e Node.js

get_animation_docs

Retorna a referência completa de efeitos de animação, incluindo todos os presets de animação de entrada, saída, ênfase e keyframe.

Parâmetros:

• animation (string, opcional) – Nome específico da animação para obter documentação detalhada (por exemplo, fadeInUp, bounceIn, slideOutLeft). Se omitido, retorna o catálogo completo de animações.

Retorna: Documentação de animação incluindo:

• Nome e categoria da animação (entrance, exit, emphasis, keyframe)
• Descrição do efeito visual
• Parâmetros configuráveis (duration, delay, easing)
• Valores padrão
• Casos de uso recomendados

get_component_defaults

Retorna os valores padrão e esquema JSON completo para um tipo de componente específico. Agentes de IA usam isso para entender como é um componente válido mínimo e quais propriedades eles podem sobrescrever.

Parâmetros:

• component (string, obrigatório) – O nome do tipo de componente/camada.

Retorna: Um objeto JSON com:

• defaults – Valores padrão completos para cada propriedade
• schema – JSON Schema definindo a estrutura, tipos e restrições do componente
• required – Lista de propriedades obrigatórias

Exemplo de resposta para uma camada 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": "O conteúdo de texto a exibir" },
      "fontSize": { "type": "number", "minimum": 1, "maximum": 500 },
      "fontFamily": { "type": "string", "description": "Nome de fonte do Google ou fonte do sistema" },
      "color": { "type": "string", "pattern": "^#[0-9a-fA-F]{6}$" }
    }
  }
}

get_easing_docs

Retorna a referência completa para todas as funções de suavização disponíveis. Funções de suavização controlam a curva de aceleração das animações, determinando se elas começam lentas, terminam lentas, saltam ou seguem uma curva elástica.

Parâmetros:

• easing (string, opcional) – Nome específico da função de suavização para documentação detalhada. Se omitido, retorna a lista completa.

Retorna: Documentação para cada função de suavização incluindo:

• Nome da função (por exemplo, easeInOutCubic, easeOutBounce, spring)
• Descrição matemática da curva
• Descrição visual da sensação do movimento
• Casos de uso recomendados
• Equivalente CSS (quando aplicável)

Configurando a Integração de IA

Conectar o Rendervid à sua ferramenta de IA requer adicionar o servidor MCP à configuração da sua ferramenta. O processo de configuração varia ligeiramente entre ferramentas, mas o conceito central é o mesmo: apontar sua ferramenta de IA para o ponto de entrada do servidor MCP do Rendervid.

Pré-requisitos

Antes de configurar qualquer ferramenta de IA, certifique-se de ter:

1. Node.js 18+ instalado no seu sistema
2. Rendervid clonado e construído do repositório GitHub :

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

3. FFmpeg instalado (necessário para saída de vídeo):

# macOS
brew install ffmpeg

# Ubuntu/Debian
sudo apt install ffmpeg

# Windows (com Chocolatey)
choco install ffmpeg

Claude Desktop / Claude Code

Adicione o servidor MCP do Rendervid ao seu arquivo de configuração do Claude Desktop.

Localização do arquivo de configuração:

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

Configuração:

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

Substitua /path/to/rendervid pelo caminho real para sua instalação do Rendervid.

Para Claude Code (CLI), adicione a mesma configuração ao arquivo .claude/mcp.json do seu projeto ou às suas configurações globais do Claude Code. O Claude Code detectará automaticamente o servidor MCP e exporá todas as 11 ferramentas durante suas sessões de codificação.

Após salvar a configuração, reinicie o Claude Desktop ou Claude Code. Você pode verificar a conexão perguntando ao Claude: “Quais ferramentas do Rendervid estão disponíveis?” O Claude deve listar todas as 11 ferramentas MCP.

Cursor IDE

Adicione o servidor MCP do Rendervid à configuração MCP do Cursor.

Arquivo de configuração: .cursor/mcp.json na raiz do seu projeto (ou configurações globais do Cursor).

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

Após salvar, reinicie o Cursor. As ferramentas do Rendervid estarão disponíveis no assistente de IA do Cursor, permitindo que você gere vídeos diretamente do seu editor.

Windsurf IDE

O Windsurf suporta servidores MCP através de sua configuração de IA. Adicione o servidor Rendervid às suas configurações MCP do Windsurf:

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

Consulte a documentação do Windsurf para a localização exata do arquivo de configuração, pois pode variar por versão e sistema operacional.

Configuração MCP Genérica

Qualquer ferramenta que implemente a especificação de cliente MCP pode se conectar ao servidor MCP do Rendervid. O servidor se comunica via stdio (entrada/saída padrão), que é o transporte MCP padrão.

Para integrar com um cliente MCP customizado:

1. Inicie o processo do servidor MCP:

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

2. Comunique-se via stdin/stdout usando o protocolo JSON-RPC do MCP.
3. Chame tools/list para descobrir ferramentas disponíveis.
4. Chame tools/call com o nome da ferramenta e argumentos para executar qualquer ferramenta.

O servidor MCP é sem estado. Cada chamada de ferramenta é independente, e o servidor pode lidar com solicitações concorrentes de múltiplos clientes.

Fluxo de Trabalho de IA: Exemplos Completos

Os exemplos a seguir mostram como agentes de IA usam as ferramentas MCP do Rendervid para ir de um prompt em linguagem natural para um vídeo finalizado.

Exemplo 1: Criação de Conteúdo para Redes Sociais

Prompt do usuário: “Crie um story de Instagram de 10 segundos promovendo uma liquidação de verão com texto animado e um fundo degradê”

Fluxo de trabalho do agente de IA:

Passo 1 – Descobrir capacidades:

O agente chama get_capabilities para aprender sobre tipos de camadas disponíveis, presets de animação e restrições de saída. Ele descobre que camadas text e shape estão disponíveis, animações fadeInUp e scaleIn existem, e stories do Instagram usam resolução 1080x1920.

Passo 2 – Encontrar um template inicial:

O agente chama list_examples com category: "social-media" e encontra um template instagram-story. Então chama get_example("instagram-story") para carregar o JSON completo do template.

Passo 3 – Construir o template:

Usando o exemplo como referência, o agente constrói um template customizado:

{
  "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": "LIQUIDAÇÃO DE VERÃO",
          "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 DESCONTO EM TUDO",
          "fontSize": 64,
          "fontFamily": "Montserrat",
          "color": "#FFE066",
          "position": { "x": 540, "y": 850 },
          "animations": [
            { "type": "fadeInUp", "duration": 0.8, "delay": 0.6 }
          ]
        },
        {
          "type": "text",
          "text": "Compre Agora  →",
          "fontSize": 48,
          "fontFamily": "Montserrat",
          "color": "#FFFFFF",
          "position": { "x": 540, "y": 1200 },
          "animations": [
            { "type": "scaleIn", "duration": 0.6, "delay": 1.2 }
          ]
        }
      ]
    }
  ]
}

Passo 4 – Validar:

O agente chama validate_template com o JSON do template. A resposta retorna como valid: true sem erros.

Passo 5 – Renderizar:

O agente chama render_video com o template validado e recebe uma URL para o arquivo MP4 finalizado.

Exemplo 2: Automação de Vídeo de Marketing

Prompt do usuário: “Gere um vídeo de vitrine de produto para nossos novos fones de ouvido. Use esta imagem do produto: https://example.com/headphones.png . O nome do produto é ‘SoundPro X1’ e o preço é $299.”

Fluxo de trabalho do agente de IA:

1. get_capabilities – Aprende sobre camadas de imagem, estilização de texto e opções de animação.
2. list_examples – Encontra um template product-showcase na categoria e-commerce.
3. get_example("product-showcase") – Carrega o template completo de vitrine de produto, que usa variáveis de template para nome do produto, imagem e preço.
4. Modifica o template – Atualiza os inputs com os dados do produto do usuário:

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

5. validate_template – Verifica o template e confirma que https://example.com/headphones.png está acessível.
6. render_video – Produz o vídeo final de vitrine do produto.

Este fluxo de trabalho demonstra como agentes de IA aproveitam variáveis de template para criar conteúdo personalizado a partir de templates reutilizáveis. O mesmo template de vitrine de produto pode gerar centenas de vídeos únicos trocando as entradas.

Exemplo 3: Geração de Visualização de Dados

Prompt do usuário: “Crie um gráfico de barras animado mostrando receita trimestral: Q1: $1.2M, Q2: $1.8M, Q3: $2.1M, Q4: $2.7M”

Fluxo de trabalho do agente de IA:

1. get_capabilities – Descobre o tipo de camada custom e o componente integrado AnimatedLineChart.
2. get_component_docs("AnimatedLineChart") – Lê a documentação para o componente de gráfico, aprendendo sobre formato de dados, configuração de cores, rótulos de eixos e opções de animação.
3. get_component_defaults("AnimatedLineChart") – Obtém os valores padrão e esquema JSON para entender a configuração mínima necessária.
4. Constrói um template com uma camada de componente customizado:

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

5. validate_template – Confirma que a estrutura do template está correta.
6. render_video – Gera o vídeo de gráfico animado.

API Autodescritiva: Como as Capacidades Tornam os Agentes de IA Eficazes

A ferramenta get_capabilities é a pedra angular da integração de IA do Rendervid. Ela implementa um padrão de API autodescritiva, onde o sistema diz aos agentes de IA exatamente o que pode fazer, quais parâmetros são necessários e quais valores são válidos. Isso elimina a necessidade de modelos de IA memorizarem ou serem treinados na API específica do Rendervid.

O Que a Resposta de Capacidades Contém

Quando um agente de IA chama get_capabilities, ele recebe uma resposta estruturada cobrindo todos os aspectos do sistema de renderização:

Tipos de Camadas com Esquemas JSON:

{
  "layerTypes": {
    "text": {
      "description": "Renderiza texto com controle completo de estilização",
      "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 Animação:

A resposta de capacidades lista cada preset de animação com sua categoria, parâmetros configuráveis e descrição. Um agente de IA recebendo esses dados sabe que fadeInUp é uma animação de entrada com parâmetros duration, delay e easing, e que move o elemento para cima enquanto o faz aparecer gradualmente.

Funções de Suavização:

Todas as 30+ funções de suavização são listadas com descrições, para que o agente de IA possa selecionar a curva certa para cada animação. Por exemplo, easeOutBounce é descrito como simulando um efeito de salto no final da animação, que o agente pode recomendar para conteúdo lúdico ou que chama atenção.

Filtros e Efeitos:

Filtros visuais como blur, brightness, contrast, saturate, grayscale e sepia são documentados com suas faixas de parâmetros, permitindo que o agente de IA aplique efeitos de pós-processamento a qualquer camada.

Por Que APIs Autodescritivas Importam

APIs tradicionais requerem documentação que modelos de IA podem ou não ter visto durante o treinamento. Uma API autodescritiva fornece documentação em tempo de execução, garantindo que o agente de IA sempre tenha informações atuais e precisas. Quando o Rendervid adiciona um novo preset de animação ou tipo de camada, cada agente de IA conectado imediatamente o vê através de get_capabilities. Sem atualizações de documentação, sem retreinamento, sem incompatibilidades de versão.

Melhores Práticas para Geração de Vídeo por IA

Siga estas diretrizes para obter os melhores resultados ao usar agentes de IA para gerar vídeos do Rendervid.

1. Sempre Valide Antes de Renderizar

Chame validate_template antes de cada renderização. A renderização é computacionalmente cara, e a validação é quase instantânea. A ferramenta de validação captura problemas que causariam falha na renderização ou produziriam saída inesperada:

• URLs de mídia quebradas (imagens, vídeos, arquivos de áudio que retornam 404)
• Estrutura JSON inválida ou campos obrigatórios faltando
• Valores fora da faixa para dimensões, tamanhos de fonte ou durações
• Presets de animação ou tipos de camadas desconhecidos

Um fluxo de trabalho típico de IA deve sempre incluir validação como um passo antes de chamar render_video ou render_image.

2. Comece a Partir de Exemplos

Em vez de construir templates do zero, agentes de IA devem usar list_examples e get_example para encontrar um template inicial relevante. Templates de exemplo são testados e sabidamente produzem boa saída. Começar de um exemplo e modificá-lo é mais rápido e menos propenso a erros do que gerar uma estrutura de template inteiramente nova.

Abordagem recomendada:

1. Chame list_examples com uma categoria relevante
2. Chame get_example para o template correspondente mais próximo
3. Modifique o template para corresponder aos requisitos específicos do usuário
4. Valide e renderize

3. Use Prompts Descritivos

Ao solicitar vídeos de um agente de IA, seja específico sobre:

• Dimensões e plataforma – “story do Instagram 1080x1920” é melhor que “um vídeo vertical”
• Duração – “introdução de 10 segundos” é melhor que “um vídeo curto”
• Estilo e atmosfera – “fundo escuro com texto neon e animações saltitantes” dá ao agente de IA direção clara
• Estrutura de conteúdo – “Três linhas de texto aparecendo uma após a outra com animações de fade-in” é mais acionável que “algum texto animado”

4. Itere em Templates

Geração de vídeo é iterativa. Após a primeira renderização, revise a saída e peça ao agente de IA para ajustar elementos específicos:

• “Torne o texto do título maior e mude a cor para dourado”
• “Desacelere as animações de entrada e adicione um atraso de 0.5 segundos entre cada linha”
• “Adicione um filtro de desfoque sutil à imagem de fundo”
• “Mude a suavização de linear para easeOutCubic para movimento mais suave”

O agente de IA pode modificar o template existente e re-renderizar sem começar do zero, tornando a iteração rápida e eficiente.

5. Aproveite Variáveis de Template para Produção em Lote

Se você precisa de múltiplas variações do mesmo vídeo (produtos diferentes, idiomas diferentes, dados diferentes), peça ao agente de IA para criar um template com variáveis . Isso permite que você renderize muitos vídeos de um único template passando diferentes inputs:

{
  "inputs": {
    "productName": "Tênis de Corrida Pro",
    "productImage": "https://example.com/shoes.png",
    "price": "$149",
    "tagline": "Corra Mais Rápido, Vá Mais Longe"
  }
}

6. Use Renderização Assíncrona para Vídeos Longos

Para vídeos com mais de 30 segundos ou templates com animações complexas, use start_render_async em vez de render_video. Isso previne timeouts e permite que o agente de IA execute outras tarefas enquanto o vídeo renderiza em segundo plano.

Descoberta de Templates: Navegando por Mais de 100 Exemplos

O Rendervid inclui mais de 100 templates de exemplo abrangendo 32 categorias, dando aos agentes de IA uma rica biblioteca de pontos de partida para qualquer tarefa de geração de vídeo.

Como Agentes de IA Descobrem Templates

O fluxo de trabalho de descoberta de templates usa duas ferramentas em sequência:

1. list_examples – Navegue pelo catálogo com filtragem opcional de categoria para encontrar templates relevantes.
2. get_example – Carregue o template JSON completo para um exemplo específico.

Categorias de Templates

Agentes de IA podem filtrar exemplos por categoria para encontrar rapidamente pontos de partida relevantes:

Descoberta de Templates na Prática

Quando um usuário pede “um gráfico animado mostrando dados de vendas”, o agente de IA:

1. Chama list_examples(category: "data-visualization") e recebe uma lista de templates relacionados a gráficos.
2. Identifica animated-bar-chart como a melhor correspondência baseada na descrição.
3. Chama get_example("animated-bar-chart") para carregar o template completo.
4. Examina a estrutura do template para entender como os dados são formatados.
5. Substitui os dados de exemplo pelos números reais de vendas do usuário.
6. Valida e renderiza.

Esta abordagem de descoberta primeiro significa que agentes de IA produzem consistentemente templates bem estruturados porque estão construindo sobre exemplos testados em vez de gerar JSON de template do zero.

Explorando Todos os Templates Disponíveis

Para ver todos os templates disponíveis, um agente de IA pode chamar list_examples sem um filtro de categoria. A resposta inclui metadados para todos os 100+ templates, permitindo que o agente pesquise entre categorias pela melhor correspondência. Cada entrada inclui o nome do template, categoria, descrição, dimensões e duração, dando ao agente informação suficiente para fazer uma seleção informada.

Ferramentas de IA Suportadas

O servidor MCP do Rendervid funciona com qualquer ferramenta que implemente a especificação de cliente do Model Context Protocol. As seguintes ferramentas foram testadas e confirmadas para funcionar com o Rendervid:

Como o MCP é um padrão aberto, qualquer ferramenta futura que adicione suporte ao cliente MCP será automaticamente compatível com o servidor MCP do Rendervid. Nenhuma mudança no servidor ou em suas ferramentas é necessária.

Próximos Passos

• Visão Geral do Rendervid – Aprenda sobre todos os recursos do Rendervid, formatos de saída e arquitetura.
• Sistema de Templates – Mergulho profundo na estrutura de templates JSON, variáveis e sistema de entrada.
• Referência de Componentes – Documentação para todos os tipos de camadas e componentes React customizados.
• Guia de Implantação – Implante o Rendervid no AWS Lambda, Azure Functions, Google Cloud Run ou Docker para renderização em escala de nuvem.
• Repositório GitHub – Código-fonte, rastreador de problemas e contribuições da comunidade.