Communitygithub.com

BEKO2210/Firstbrain

Percepção, indexação e edição de vídeo e áudio. Ingestão de arquivos/URLs/streams ao vivo, construção de índices visuais/falados, busca com timestamps, edição de timelines, adição de sobreposições/legendas, geração de mídia e criação de alertas em tempo real.

O que é Firstbrain?

O Firstbrain é uma skill avançada para agentes de IA, projetada para percepção, indexação e edição de vídeo e áudio em tempo real. Ela oferece suporte a ingestão de arquivos locais, URLs, streams ao vivo (RTSP) e captura de sessão de desktop (macOS), construindo índices visuais e de fala para busca semântica com timestamps precisos e links de evidência reproduzíveis. A skill permite recortes automáticos de cenas, edição programática de timelines com legendas, sobreposições de texto/imagem, áudio de fundo, narração e dublagem, além de geração de mídia (imagens, música, efeitos sonoros) via IA. Também suporta monitoramento em tempo real com alertas acionados por eventos visuais ou falados, transcodificação de vídeo e reframing para plataformas sociais. É especialmente útil para desenvolvedores que constroem agentes que precisam entender, pesquisar e modificar conteúdo audiovisual sem depender de ferramentas locais como ffmpeg — tudo é processado server-side pela SDK Python do VideoDB.

Funciona com✓Claude Code~Codex CLI~Cursor
npx skills add https://github.com/BEKO2210/Firstbrain/tree/HEAD/03%20-%20Resources/Skills/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.

Use esta skill quando precisar de:

Quando Usar

  • Você precisa de percepção de vídeo ou áudio, indexação, busca ou edição de timeline a partir de arquivos, URLs, sessões de desktop ou streams ao vivo.
  • A tarefa envolve timestamps, evidência pesquisável, legendas, clipes, sobreposições ou alertas de monitoramento em tempo real.
  • Você quer um único fluxo de trabalho que combine ingestão, compreensão, recuperação e ações de mídia.

1) 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 de sessão
  • Executar alertas/gatilhos em tempo real sobre o que é falado e o que acontece na tela
  • Produzir resumos de sessão, uma timeline pesquisável e links de evidência reproduzíveis

2) 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

3) Indexar + buscar (timestamps + evidência)

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

4) Edição de timeline + geração

  • Legendas: gerar, traduzir, queimar na tela
  • 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 timeline

5) Streams ao vivo (RTSP) + monitoramento

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

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 busca, intervalos de clipe, edições de timeline, regras de alerta

Saídas comuns

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

Prompts canônicos (exemplos)

  • "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 os timestamps."
  • "Gere legendas, queime-as na tela e adicione música de fundo suave."
  • "Conecte esta URL RTSP e alerte quando uma pessoa entrar na zona."

Executando código Python

Antes de executar qualquer código do 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á exportada)
  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 "..."), sempre use código formatado corretamente — use ponto e vírgula para separar instruções e mantenha a legibilidade. 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 da API

O usuário deve definir VIDEO_DB_API_KEY usando um dos métodos:

  • 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 https://console.videodb.io (50 uploads gratuitos, sem cartão de crédito).

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

Referência Rápida

Fazer upload de mídia

# URL
video = coll.upload(url="https://example.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)
text = 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:
    results = video.search("demonstração do produto")
    shots = results.get_shots()
    stream_url = results.compile()
except InvalidRequestError as e:
    if "Nenhum resultado encontrado" 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 nesta 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:
    results = 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 = results.get_shots()
    stream_url = results.compile()
except InvalidRequestError as e:
    if "Nenhum resultado encontrado" in str(e):
        shots = []
    else:
        raise

Edição de timeline

Importante: Sempre valide os timestamps antes de construir uma timeline:

  • 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="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

# Mude resolução, qualidade ou proporção de aspecto no servidor
job_id = conn.transcode(
    source="https://example.com/video.mp4",
    callback_url="https://example.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
  • Apare 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://example.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

image = 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://example.com/video.mp4")
except InvalidRequestError as e:
    print(f"Upload falhou: {e}")

Armadilhas comuns

CenárioMensagem de erroSolução
Indexar um vídeo já indexadoÍndice de palavras faladas 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))
Busca 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 async
Timestamps negativos na TimelineProduz silenciosamente 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 limites do plano

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.

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. Iniciar ouvinte: python scripts/ws_listener.py &
  2. Obter ID do WebSocket: cat /tmp/videodb_ws_id
  3. Executar código de captura (veja reference/capture.md para o fluxo completo)
  4. Eventos escritos em: /tmp/videodb_events.jsonl

Consultar eventos

import json
events = [json.loads(l) for l in open("/tmp/videodb_events.jsonl")]

# Obter todas as transcrições
transcripts = [e["data"]["text"] for e in events if e.get("channel") == "transcript"]

# Obter descrições visuais dos últimos 5 minutos
import time
cutoff = time.time() - 300
recent_visual = [e for e in events 
                 if e.get("channel") == "visual_index" and e["unix_ts"] > cutoff]

Scripts utilitários

Para o fluxo completo de captura, veja reference/capture.md.

Não use ffmpeg, moviepy ou ferramentas locais de codificação quando o VideoDB suportar a operação. As seguintes operações são todas tratadas no servidor pelo VideoDB — cortar, combinar clipes, sobrepor áudio ou música, adicionar legendas, sobreposições de texto/imagem, transcodificação, mudanças de resolução, conversão de proporção de aspecto, redimensionamento para requisitos de plataforma, transcrição e geração de mídia. Recorra a ferramentas locais apenas para operações listadas em Limitações em reference/editor.md (transições, mudanças de velocidade, corte/zoom, correção 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 mudar 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()

Repositório

https://github.com/video-db/skills

Mantido por: VideoDB

Conexões

  • Domínio: [[Design & Kreativitaet]]
  • Categoria: [[Video & Audio Produktion]]
  • Arquivos:
    • scripts/ws_listener.py
  • Navegação: [[Skills Uebersicht]], [[Home]]

Individual skills in this repo

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

BEKO2210/Firstbrain

Skill for discovering and researching autonomous AI agents, tools, and ecosystems using the AgentFolio directory.

BEKO2210/Firstbrain

Advanced JavaScript animation library skill for creating complex, high-performance web animations.

BEKO2210/Firstbrain

One sentence - what this skill does and when to invoke it

BEKO2210/Firstbrain

Audit and fix animation performance issues including layout thrashing, compositor properties, scroll-linked motion, and blur effects. Use when animations stutter, transitions jank, or reviewing CSS/JS animation performance.

BEKO2210/Firstbrain

Internationalization and localization patterns. Detecting hardcoded strings, managing translations, locale files, RTL support.

BEKO2210/Firstbrain

Expert in building portfolios that actually land jobs and clients -

BEKO2210/Firstbrain

Generates high-converting Next.js/React landing pages with Tailwind CSS. Uses PAS, AIDA, and BAB frameworks for optimized copy/components (Heroes, Features, Pricing). Focuses on Core Web Vitals/SEO.

BEKO2210/Firstbrain

AI-powered animation tool for creating motion in logos, UI, icons, and social media assets.

BEKO2210/Firstbrain

Best practices for Remotion - Video creation in React

BEKO2210/Firstbrain

Generate walkthrough videos from Stitch projects using Remotion with smooth transitions, zooming, and text overlays

BEKO2210/Firstbrain

Seek and analyze video content using Memories.ai Large Visual Memory Model for persistent video intelligence

BEKO2210/Firstbrain

Writes complete, structured landing pages optimized for SEO ranking, AEO citation, and visitor conversion. Activate when the user wants to write or generate a landing page for a product, service, or offer.

BEKO2210/Firstbrain

Three.js animation - keyframe animation, skeletal animation, morph targets, animation mixing. Use when animating objects, playing GLTF animations, creating procedural motion, or blending animations.

BEKO2210/Firstbrain

Automate TikTok tasks via Rube MCP (Composio): upload/publish videos, post photos, manage content, and view user profiles/stats. Always search tools first for current schemas.

BEKO2210/Firstbrain

Upload, stream, search, edit, transcribe, and generate AI video and audio using the VideoDB SDK.

BEKO2210/Firstbrain

One sentence - what this skill does and when to invoke it

BEKO2210/Firstbrain

Automate YouTube tasks via Rube MCP (Composio): upload videos, manage playlists, search content, get analytics, and handle comments. Always search tools first for current schemas.

BEKO2210/Firstbrain

Extract transcripts from YouTube videos and generate comprehensive, detailed summaries using intelligent analysis frameworks

Habilidades Relacionadas