Communitygithub.com

ComeOnOliver/skillshub

Veja, entenda e atue em vídeo e áudio: ingestão de arquivos, URLs, feeds ao vivo e captura de tela; indexação visual, semântica e temporal; transcodificação e edição de linha do tempo; alertas em tempo real.

O que é skillshub?

Este skill capacita agentes de IA a perceber, compreender e agir sobre conteúdo de vídeo e áudio de forma abrangente. Ele suporta a ingestão de vídeos de diversas fontes – arquivos locais, URLs públicas, feeds RTSP/ao vivo e captura de tela do desktop – e retorna tanto contexto em tempo real quanto links de streaming reproduzíveis. Para compreensão, o skill constrói índices visuais, semânticos e temporais, permitindo a busca por momentos exatos com timestamps e a geração automática de clipes. Na camada de ação, ele permite transcodificar e normalizar vídeos (codec, resolução, taxa de quadros, proporção), realizar edições na linha do tempo (legendas, sobreposições de texto/imagem, marca d'água, dublagem, tradução) e gerar novos ativos de mídia (imagens, áudio, vídeo). Além disso, o skill oferece monitoramento contínuo de feeds ao vivo e sessões de desktop, emitindo alertas em tempo real com base em eventos visuais ou falados. Projetado para ser usado com o SDK Python do VideoDB, ele abstrai operações complexas de processamento de vídeo para o servidor, eliminando a necessidade de ferramentas locais como ffmpeg na maioria dos casos.

Funciona com✓Claude Code~Codex CLI~Cursor
npx skills add https://github.com/ComeOnOliver/skillshub/tree/HEAD/skills/affaan-m/everything-claude-code/videodb

Perguntar na sua IA favorita

Abre um novo chat com esta habilidade de agente já pré-carregada.

Documentação

Skill VideoDB

Percepção + memória + ações para vídeo, streams ao vivo e sessões de desktop.

Quando usar

Percepção de Desktop

  • Iniciar/parar uma sessão de desktop capturando tela, microfone e áudio do sistema
  • Transmitir contexto ao vivo e armazenar memória episódica da sessão
  • Executar alertas/gatilhos em tempo real sobre o que é falado e o que está acontecendo na tela
  • Produzir resumos de sessão, uma linha do tempo pesquisável e links de evidência reproduzíveis

Ingestão de vídeo + stream

  • Ingerir um arquivo ou URL e retornar um link de stream web reproduzível
  • Transcodificar/normalizar: codec, bitrate, fps, resolução, proporção de aspecto

Indexar + pesquisar (timestamps + evidência)

  • Construir índices visuais, falados e de palavras-chave
  • Pesquisar e retornar momentos exatos com timestamps e evidência reproduzível
  • Criar clipes automaticamente a partir dos resultados da pesquisa

Edição e geração de linha do tempo

  • Legendas: gerar, traduzir, incorporar
  • Sobreposições: texto/imagem/marca, legendas animadas
  • Áudio: música de fundo, narração, dublagem
  • Composição programática e exportações via operações de linha do tempo

Streams ao vivo (RTSP) + monitoramento

  • Conectar feeds RTSP/ao vivo
  • Executar compreensão visual e falada em tempo real e emitir eventos/alertas para workflows de monitoramento

Como funciona

Entradas comuns

  • Caminho de arquivo local, URL pública ou URL RTSP
  • Solicitação de captura de desktop: iniciar / parar / resumir sessão
  • Operações desejadas: obter contexto para compreensão, especificação de transcodificação, especificação de índice, consulta de pesquisa, intervalos de clipe, edições de linha do tempo, regras de alerta

Saídas comuns

  • URL de stream
  • Resultados de pesquisa com timestamps e links de evidência
  • Ativos gerados: legendas, áudio, imagens, clipes
  • Payloads de eventos/alertas para streams ao vivo
  • Resumos de sessão de desktop e entradas de memória

Executando código Python

Antes de executar qualquer código VideoDB, mude para o diretório do projeto e carregue as variáveis de ambiente:

from dotenv import load_dotenv
load_dotenv(".env")

import videodb
conn = videodb.connect()

Isso lê VIDEO_DB_API_KEY de:

  1. Ambiente (se já exportado)
  2. Arquivo .env do projeto no diretório atual

Se a chave estiver faltando, videodb.connect() levanta AuthenticationError automaticamente.

NÃO escreva um arquivo de script quando um comando inline curto funcionar.

Ao escrever Python inline (python -c "..."), use sempre código formatado corretamente — use ponto e vírgula para separar instruções e mantenha legível. Para qualquer coisa com mais de ~3 instruções, use um heredoc:

python << 'EOF'
from dotenv import load_dotenv
load_dotenv(".env")

import videodb
conn = videodb.connect()
coll = conn.get_collection()
print(f"Vídeos: {len(coll.get_videos())}")
EOF

Configuração

Quando o usuário pedir para "configurar videodb" ou similar:

1. Instalar SDK

pip install "videodb[capture]" python-dotenv

Se videodb[capture] falhar no Linux, instale sem o extra capture:

pip install videodb python-dotenv

2. Configurar chave de API

O usuário deve definir VIDEO_DB_API_KEY usando qualquer método:

  • Exportar no terminal (antes de iniciar o Claude): export VIDEO_DB_API_KEY=sua-chave
  • Arquivo .env do projeto: Salve VIDEO_DB_API_KEY=sua-chave no arquivo .env do projeto

Obtenha uma chave de API gratuita em console.videodb.io (50 uploads gratuitos, sem cartão de crédito).

NÃO leia, escreva ou manipule a chave de API você mesmo. Sempre deixe o usuário defini-la.

Referência Rápida

Upload de mídia

# URL
video = coll.upload(url="https://exemplo.com/video.mp4")

# YouTube
video = coll.upload(url="https://www.youtube.com/watch?v=VIDEO_ID")

# Arquivo local
video = coll.upload(file_path="/caminho/para/video.mp4")

Transcrição + legenda

# force=True pula o erro se o vídeo já estiver indexado
video.index_spoken_words(force=True)
texto = video.get_transcript_text()
stream_url = video.add_subtitle()

Pesquisar dentro de vídeos

from videodb.exceptions import InvalidRequestError

video.index_spoken_words(force=True)

# search() levanta InvalidRequestError quando nenhum resultado é encontrado.
# Sempre envolva em try/except e trate "Nenhum resultado encontrado" como vazio.
try:
    resultados = video.search("demonstração do produto")
    shots = resultados.get_shots()
    stream_url = resultados.compile()
except InvalidRequestError as e:
    if "No results found" in str(e):
        shots = []
    else:
        raise

Pesquisa de cena

import re
from videodb import SearchType, IndexType, SceneExtractionType
from videodb.exceptions import InvalidRequestError

# index_scenes() não tem parâmetro force — ele levanta um erro se um índice
# de cena já existir. Extraia o ID do índice existente do erro.
try:
    scene_index_id = video.index_scenes(
        extraction_type=SceneExtractionType.shot_based,
        prompt="Descreva o conteúdo visual desta cena.",
    )
except Exception as e:
    match = re.search(r"id\s+([a-f0-9]+)", str(e))
    if match:
        scene_index_id = match.group(1)
    else:
        raise

# Use score_threshold para filtrar ruído de baixa relevância (recomendado: 0.3+)
try:
    resultados = video.search(
        query="pessoa escrevendo em um quadro branco",
        search_type=SearchType.semantic,
        index_type=IndexType.scene,
        scene_index_id=scene_index_id,
        score_threshold=0.3,
    )
    shots = resultados.get_shots()
    stream_url = resultados.compile()
except InvalidRequestError as e:
    if "No results found" in str(e):
        shots = []
    else:
        raise

Edição de linha do tempo

Importante: Sempre valide timestamps antes de construir uma linha do tempo:

  • start deve ser >= 0 (valores negativos são aceitos silenciosamente, mas produzem saída quebrada)
  • start deve ser < end
  • end deve ser <= video.length
from videodb.timeline import Timeline
from videodb.asset import VideoAsset, TextAsset, TextStyle

timeline = Timeline(conn)
timeline.add_inline(VideoAsset(asset_id=video.id, start=10, end=30))
timeline.add_overlay(0, TextAsset(text="O Fim", duration=3, style=TextStyle(fontsize=36)))
stream_url = timeline.generate_stream()

Transcodificar vídeo (mudança de resolução/qualidade)

from videodb import TranscodeMode, VideoConfig, AudioConfig

# Altere resolução, qualidade ou proporção de aspecto no servidor
job_id = conn.transcode(
    source="https://exemplo.com/video.mp4",
    callback_url="https://exemplo.com/webhook",
    mode=TranscodeMode.economy,
    video_config=VideoConfig(resolution=720, quality=23, aspect_ratio="16:9"),
    audio_config=AudioConfig(mute=False),
)

Reenquadrar proporção de aspecto (para plataformas sociais)

Aviso: reframe() é uma operação lenta no servidor. Para vídeos longos, pode levar vários minutos e pode expirar. Melhores práticas:

  • Sempre limite a um segmento curto usando start/end quando possível
  • Para vídeos completos, use callback_url para processamento assíncrono
  • Corte o vídeo em uma Timeline primeiro, depois reenquadre o resultado mais curto
from videodb import ReframeMode

# Sempre prefira reenquadrar um segmento curto:
reframed = video.reframe(start=0, end=60, target="vertical", mode=ReframeMode.smart)

# Reenquadramento assíncrono para vídeos completos (retorna None, resultado via webhook):
video.reframe(target="vertical", callback_url="https://exemplo.com/webhook")

# Predefinições: "vertical" (9:16), "square" (1:1), "landscape" (16:9)
reframed = video.reframe(start=0, end=60, target="square")

# Dimensões personalizadas
reframed = video.reframe(start=0, end=60, target={"width": 1280, "height": 720})

Mídia generativa

imagem = coll.generate_image(
    prompt="um pôr do sol sobre montanhas",
    aspect_ratio="16:9",
)

Tratamento de erros

from videodb.exceptions import AuthenticationError, InvalidRequestError

try:
    conn = videodb.connect()
except AuthenticationError:
    print("Verifique sua VIDEO_DB_API_KEY")

try:
    video = coll.upload(url="https://exemplo.com/video.mp4")
except InvalidRequestError as e:
    print(f"Falha no upload: {e}")

Armadilhas comuns

CenárioMensagem de erroSolução
Indexar um vídeo já indexadoÍndice de palavra falada para o vídeo já existeUse video.index_spoken_words(force=True) para pular se já indexado
Índice de cena já existeÍndice de cena com id XXXX já existeExtraia o scene_index_id existente do erro com re.search(r"id\s+([a-f0-9]+)", str(e))
Pesquisa não encontra correspondênciasInvalidRequestError: Nenhum resultado encontradoCapture a exceção e trate como resultados vazios (shots = [])
Reenquadramento expiraBloqueia indefinidamente em vídeos longosUse start/end para limitar o segmento, ou passe callback_url para assíncrono
Timestamps negativos na TimelineProduz silenciosamente um stream quebradoSempre valide start >= 0 antes de criar VideoAsset
generate_video() / create_collection() falhaOperação não permitida ou limite máximoRecursos limitados por plano — informe o usuário sobre os limites do plano

Exemplos

Prompts canônicos

  • "Inicie a captura de desktop e alerte quando um campo de senha aparecer."
  • "Grave minha sessão e produza um resumo acionável quando terminar."
  • "Ingira este arquivo e retorne um link de stream reproduzível."
  • "Indexe esta pasta e encontre todas as cenas com pessoas, retorne timestamps."
  • "Gere legendas, incorpore-as e adicione música de fundo suave."
  • "Conecte esta URL RTSP e alerte quando uma pessoa entrar na zona."

Gravação de Tela (Captura de Desktop)

Use ws_listener.py para capturar eventos WebSocket durante sessões de gravação. A captura de desktop suporta apenas macOS.

Início Rápido

  1. Escolha o diretório de estado: STATE_DIR="${VIDEODB_EVENTS_DIR:-$HOME/.local/state/videodb}"
  2. Inicie o listener: VIDEODB_EVENTS_DIR="$STATE_DIR" python scripts/ws_listener.py --clear "$STATE_DIR" &
  3. Obtenha o ID WebSocket: cat "$STATE_DIR/videodb_ws_id"
  4. Execute o código de captura (consulte reference/capture.md para o fluxo completo)
  5. Eventos escritos em: $STATE_DIR/videodb_events.jsonl

Use --clear sempre que iniciar uma nova execução de captura para que eventos de transcrição e visuais antigos não vazem para a nova sessão.

Consultar Eventos

import json
import os
import time
from pathlib import Path

events_dir = Path(os.environ.get("VIDEODB_EVENTS_DIR", Path.home() / ".local" / "state" / "videodb"))
events_file = events_dir / "videodb_events.jsonl"
eventos = []

if events_file.exists():
    with events_file.open(encoding="utf-8") as handle:
        for linha in handle:
            try:
                eventos.append(json.loads(linha))
            except json.JSONDecodeError:
                continue

transcricoes = [e["data"]["text"] for e in eventos if e.get("channel") == "transcript"]
corte = time.time() - 300
recentes_visual = [
    e for e in eventos
    if e.get("channel") == "visual_index" and e["unix_ts"] > corte
]

Documentação adicional

A documentação de referência está no diretório reference/ adjacente a este arquivo SKILL.md. Use a ferramenta Glob para localizá-la, se necessário.

Não use ffmpeg, moviepy ou ferramentas de codificação locais quando o VideoDB suportar a operação. As seguintes operações são todas tratadas no servidor pelo VideoDB: corte, combinação de clipes, sobreposição de áudio ou música, adição de legendas, sobreposições de texto/imagem, transcodificação, alterações de resolução, conversão de proporção de aspecto, redimensionamento para requisitos de plataforma, transcrição e geração de mídia. Use ferramentas locais apenas para operações listadas em Limitações em reference/editor.md (transições, alterações de velocidade, corte/zoom, gradagem de cor, mixagem de volume).

Quando usar o quê

ProblemaSolução VideoDB
Plataforma rejeita proporção de aspecto ou resolução do vídeovideo.reframe() ou conn.transcode() com VideoConfig
Precisa redimensionar vídeo para Twitter/Instagram/TikTokvideo.reframe(target="vertical") ou target="square"
Precisa alterar resolução (ex. 1080p → 720p)conn.transcode() com VideoConfig(resolution=720)
Precisa sobrepor áudio/música no vídeoAudioAsset em uma Timeline
Precisa adicionar legendasvideo.add_subtitle() ou CaptionAsset
Precisa combinar/cortar clipesVideoAsset em uma Timeline
Precisa gerar narração, música ou SFXcoll.generate_voice(), generate_music(), generate_sound_effect()

Procedência

O material de referência para este skill é distribuído localmente em skills/videodb/reference/. Use as cópias locais acima em vez de seguir links de repositórios externos em tempo de execução.

Individual skills in this repo

This repo contains 20 individual skills — each has its own dedicated page.

ComeOnOliver/skillshub

Create stunning, animation-rich HTML presentations from scratch or by converting PowerPoint files. Use when the user wants to build a presentation, convert a PPT/PPTX to web, or create slides for a talk/pitch. Helps non-designers discover their aesthetic through visual exploration rather than abstract choices.

ComeOnOliver/skillshub

Next.js 16+ 和 Turbopack — 增量打包、文件系统缓存、开发速度,以及何时使用 Turbopack 与 webpack。

ComeOnOliver/skillshub

SwiftUI architecture patterns, state management with @Observable, view composition, navigation, performance optimization, and modern iOS/macOS UI best practices.

ComeOnOliver/skillshub

AI-assisted video editing workflows for cutting, structuring, and augmenting real footage. Covers the full pipeline from raw capture through FFmpeg, Remotion, ElevenLabs, fal.ai, and final polish in Descript or CapCut. Use when the user wants to edit video, cut footage, create vlogs, or build video content.

ComeOnOliver/skillshub

Next.js 15 애플리케이션을 위한 프론트엔드 개발 가이드라인. React 19, TypeScript, Shadcn/ui, Tailwind CSS를 사용한 모던 패턴. Server Components, Client Components, App Router, 파일 구조, Shadcn/ui 컴포넌트, 성능 최적화, TypeScript 모범 사례 포함. 컴포넌트, 페이지, 기능 생성, 데이터 페칭, 스타일링, 라우팅, 프론트엔드 코드 작업 시 사용.

ComeOnOliver/skillshub

Provides Tamagui patterns for config v4, compiler optimization, styled context, and cross-platform styling. Must use when working with Tamagui projects (tamagui.config.ts, @tamagui imports).

ComeOnOliver/skillshub

Create distinctive, production-grade frontend interfaces with high design quality. Use this skill when the user asks to build web components, pages, or applications. Generates creative, polished code that avoids generic AI aesthetics.

ComeOnOliver/skillshub

Create high-converting, visually distinctive landing pages. Use when building marketing pages, product launches, SaaS homepages, or any single-page conversion-focused website. Guides section-by-section composition with anti-AI-slop principles.

ComeOnOliver/skillshub

Auto-loaded context for Portfolio Buddy 2 development. Use for ANY task involving: React 19 development, TypeScript, portfolio analysis features, metrics calculations, trading strategy comparison, or working with the Portfolio Buddy 2 codebase. Contains tech stack, known issues, and architectural constraints.

ComeOnOliver/skillshub

Next.js development tooling via MCP. Inspect routes, components, build info, and debug Next.js apps. Use when working on Next.js applications, debugging routing, or inspecting app structure. NOT for general React or non-Next.js projects.

ComeOnOliver/skillshub

Implement UI using Shadcn MCP (atoms/theme) and 21st.dev MCP (complex sections). Use when adding buttons, layouts, or generating landing pages.

ComeOnOliver/skillshub

A conceptual skill for building an API client in Next.js that handles JWT tokens

ComeOnOliver/skillshub

Best practices and patterns for Next.js App Router, Server Actions, and Routing in this project.

ComeOnOliver/skillshub

The Design System, Theme, and UX rules for the Physical AI Hub.

ComeOnOliver/skillshub

Comprehensive frontend development skill for building modern, performant web applications using ReactJS, NextJS, TypeScript, Tailwind CSS. Includes component scaffolding, performance optimization, bundle analysis, and UI best practices. Use when developing frontend features, optimizing performance, implementing UI/UX designs, managing state, or reviewing frontend code.

ComeOnOliver/skillshub

This document captures learnings from fixing keyboard navigation issues when floating components (Select, DropdownMenu, Popover) have CSS open/close animations.

ComeOnOliver/skillshub

Build Next.js 16 applications with correct patterns and distinctive design. Use when creating pages, layouts, dynamic routes, upgrading from Next.js 15, or implementing proxy.ts. Covers breaking changes (async params/searchParams, Turbopack, cacheComponents) and frontend aesthetics. NOT when building non-React or backend-only applications.

ComeOnOliver/skillshub

Comprehensive Framer Motion animation library for React. Covers motion components, variants, gestures, page transitions, and scroll animations. Use when adding animations to React/Next.js applications.

ComeOnOliver/skillshub

Next.js 16+ uses App Router with Server Components by default. Client Components are only used when interactivity is needed (hooks, event handlers, browser APIs).

ComeOnOliver/skillshub

Build interfaces that resonate, not just render. This skill enforces bold, intentional

Habilidades Relacionadas