Communitygithub.com

503496348-ops/mischief-production

Compétence VideoDB : voir, comprendre et agir sur la vidéo et l'audio – ingestion depuis des fichiers, URLs, flux RTSP ou capture d'écran ; indexation, recherche et édition de timeline ; transcodage et génération de médias.

Qu'est-ce que mischief-production ?

Cette compétence permet à un agent IA d'interagir avec la plateforme VideoDB pour effectuer des opérations avancées sur la vidéo et l'audio. Elle couvre l'ingestion depuis des fichiers locaux, des URLs, des vidéos YouTube, des flux RTSP en direct ou la capture d'écran d'un poste de travail. L'agent peut ensuite indexer le contenu visuel et audio, construire des index sémantiques et temporels, et rechercher des moments précis avec des horodatages et des clips automatiques. La compétence permet également de transcoder des vidéos (modification du codec, du débit, de la résolution, du rapport hauteur/largeur), d'éditer la timeline (ajout de sous-titres, d'overlays texte/image, de marques audio, doublage et traduction), de générer des médias (images, audio, vidéo) et de mettre en place des alertes en temps réel sur les flux en direct ou les sessions de capture d'écran. Elle est conçue pour être utilisée avec l'API Python de VideoDB, en évitant les outils locaux comme ffmpeg ou moviepy pour les opérations prises en charge. La configuration nécessite une clé API VideoDB, mais l'agent ne doit jamais manipuler cette clé directement – l'utilisateur doit la fournir via l'environnement ou un fichier `.env`.

Compatible avec✓Claude Code~Codex CLI~Cursor
npx skills add https://github.com/503496348-ops/mischief-production/tree/HEAD/skills/ecc-videodb

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

Compétence VideoDB

Perception + mémoire + actions pour la vidéo, les flux en direct et les sessions de bureau.

Quand l'utiliser

Perception de bureau

  • Démarrer/arrêter une session de bureau capturant l'écran, le micro et l'audio système
  • Diffuser un contexte en direct et stocker une mémoire de session épisodique
  • Exécuter des alertes/déclencheurs en temps réel sur ce qui est dit et ce qui se passe à l'écran
  • Produire des résumés de session, une timeline consultable et des liens de preuve lisibles

Ingestion vidéo + flux

  • Ingérer un fichier ou une URL et renvoyer un lien de flux web lisible
  • Transcoder/normaliser : codec, débit, fps, résolution, rapport hauteur/largeur

Indexation + recherche (horodatages + preuves)

  • Construire des index visuels, vocaux et par mots-clés
  • Rechercher et retourner des moments précis avec horodatages et preuves lisibles
  • Créer automatiquement des clips à partir des résultats de recherche

Édition de timeline + génération

  • Sous-titres : générer, traduire, incruster
  • Superpositions : texte/image/marque, légendes animées
  • Audio : musique de fond, voix off, doublage
  • Composition programmatique et exportations via opérations de timeline

Flux en direct (RTSP) + surveillance

  • Connecter des flux RTSP/en direct
  • Exécuter une compréhension visuelle et vocale en temps réel et émettre des événements/alertes pour les workflows de surveillance

Comment ça fonctionne

Entrées courantes

  • Chemin de fichier local, URL publique ou URL RTSP
  • Demande de capture de bureau : démarrer / arrêter / résumer la session
  • Opérations souhaitées : obtenir un contexte de compréhension, spécification de transcodage, spécification d'index, requête de recherche, plages de clip, éditions de timeline, règles d'alerte

Sorties courantes

  • URL du flux
  • Résultats de recherche avec horodatages et liens de preuve
  • Actifs générés : sous-titres, audio, images, clips
  • Charges d'événements/alertes pour les flux en direct
  • Résumés de session de bureau et entrées mémoire

Exécution de code Python

Avant d'exécuter tout code VideoDB, placez-vous dans le répertoire du projet et chargez les variables d'environnement :

from dotenv import load_dotenv
load_dotenv(".env")

import videodb
conn = videodb.connect()

Ceci lit VIDEO_DB_API_KEY depuis :

  1. L'environnement (si déjà exporté)
  2. Le fichier .env du projet dans le répertoire courant

Si la clé est manquante, videodb.connect() lève automatiquement AuthenticationError.

N'ÉCRIVEZ PAS de fichier script quand une courte commande en ligne suffit.

Quand vous écrivez du Python en ligne (python -c "..."), utilisez toujours du code correctement formaté – utilisez des points-virgules pour séparer les instructions et gardez-le lisible. Pour tout ce qui dépasse environ 3 instructions, utilisez plutôt un heredoc :

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

import videodb
conn = videodb.connect()
coll = conn.get_collection()
print(f"Vidéos : {len(coll.get_videos())}")
EOF

Configuration

Quand l'utilisateur demande de « configurer videodb » ou similaire :

1. Installer le SDK

pip install "videodb[capture]" python-dotenv

Si videodb[capture] échoue sous Linux, installez sans l'extension capture :

pip install videodb python-dotenv

2. Configurer la clé API

L'utilisateur doit définir VIDEO_DB_API_KEY en utilisant l'une ou l'autre méthode :

  • Export dans le terminal (avant de lancer Claude) : export VIDEO_DB_API_KEY=votre-clé
  • Fichier .env du projet : Enregistrez VIDEO_DB_API_KEY=votre-clé dans le fichier .env du projet

Obtenez une clé API gratuite sur console.videodb.io (50 téléversements gratuits, sans carte de crédit).

Ne lisez PAS, n'écrivez PAS et ne gérez PAS la clé API vous-même. Laissez toujours l'utilisateur la définir.

Référence rapide

Téléverser un 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")

# Fichier local
video = coll.upload(file_path="/chemin/vers/video.mp4")

Transcription + sous-titres

# force=True ignore l'erreur si la vidéo est déjà indexée
video.index_spoken_words(force=True)
text = video.get_transcript_text()
stream_url = video.add_subtitle()

Rechercher dans les vidéos

from videodb.exceptions import InvalidRequestError

video.index_spoken_words(force=True)

# search() lève InvalidRequestError quand aucun résultat n'est trouvé.
# Toujours englober dans try/except et traiter "Aucun résultat trouvé" comme vide.
try:
    results = video.search("demo produit")
    shots = results.get_shots()
    stream_url = results.compile()
except InvalidRequestError as e:
    if "No results found" in str(e):
        shots = []
    else:
        raise

Recherche par scène

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

# index_scenes() n'a pas de paramètre force — il lève une erreur si un index
# de scène existe déjà. Extrayez l'ID de l'index existant depuis l'erreur.
try:
    scene_index_id = video.index_scenes(
        extraction_type=SceneExtractionType.shot_based,
        prompt="Décrivez le contenu visuel de cette scène.",
    )
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

# Utilisez score_threshold pour filtrer le bruit à faible pertinence (recommandé : 0,3+)
try:
    results = video.search(
        query="personne écrivant sur un tableau blanc",
        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 "No results found" in str(e):
        shots = []
    else:
        raise

Édition de timeline

Important : Validez toujours les horodatages avant de construire une timeline :

  • start doit être >= 0 (les valeurs négatives sont acceptées silencieusement mais produisent un résultat cassé)
  • start doit être < end
  • end doit être <= 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="The End", duration=3, style=TextStyle(fontsize=36)))
stream_url = timeline.generate_stream()

Transcodage vidéo (changement de résolution / qualité)

from videodb import TranscodeMode, VideoConfig, AudioConfig

# Changer la résolution, la qualité ou le rapport hauteur/largeur côté serveur
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),
)

Recadrer le rapport hauteur/largeur (pour les réseaux sociaux)

Attention : reframe() est une opération serveur lente. Pour les longues vidéos, cela peut prendre plusieurs minutes et peut expirer. Bonnes pratiques :

  • Limitez-vous toujours à un court segment avec start/end quand c'est possible
  • Pour les vidéos de longue durée, utilisez callback_url pour un traitement asynchrone
  • Rognez d'abord la vidéo sur une Timeline, puis recadrez le résultat plus court
from videodb import ReframeMode

# Préférez toujours recadrer un court segment :
reframed = video.reframe(start=0, end=60, target="vertical", mode=ReframeMode.smart)

# Recadrage asynchrone pour les vidéos de longue durée (retourne None, résultat via webhook) :
video.reframe(target="vertical", callback_url="https://example.com/webhook")

# Préréglages : "vertical" (9:16), "square" (1:1), "landscape" (16:9)
reframed = video.reframe(start=0, end=60, target="square")

# Dimensions personnalisées
reframed = video.reframe(start=0, end=60, target={"width": 1280, "height": 720})

Médias génératifs

image = coll.generate_image(
    prompt="un coucher de soleil sur les montagnes",
    aspect_ratio="16:9",
)

Gestion des erreurs

from videodb.exceptions import AuthenticationError, InvalidRequestError

try:
    conn = videodb.connect()
except AuthenticationError:
    print("Vérifiez votre VIDEO_DB_API_KEY")

try:
    video = coll.upload(url="https://example.com/video.mp4")
except InvalidRequestError as e:
    print(f"Échec du téléversement : {e}")

Pièges courants

ScénarioMessage d'erreurSolution
Indexer une vidéo déjà indexéeSpoken word index for video already existsUtilisez video.index_spoken_words(force=True) pour ignorer si déjà indexé
L'index de scène existe déjàScene index with id XXXX already existsExtrayez le scene_index_id existant depuis l'erreur avec re.search(r"id\s+([a-f0-9]+)", str(e))
La recherche ne trouve aucune correspondanceInvalidRequestError: No results foundAttrapez l'exception et traitez comme résultats vides (shots = [])
Le recadrage expireBloque indéfiniment sur les longues vidéosUtilisez start/end pour limiter le segment, ou passez callback_url pour l'asynchrone
Horodatages négatifs sur la TimelineProduit silencieusement un flux casséValidez toujours start >= 0 avant de créer un VideoAsset
generate_video() / create_collection() échoueOperation not allowed ou maximum limitFonctionnalités limitées par le plan – informez l'utilisateur des limites du plan

Exemples

Prompts canoniques

  • « Démarre la capture de bureau et alerte quand un champ de mot de passe apparaît. »
  • « Enregistre ma session et produis un résumé exploitable quand elle se termine. »
  • « Ingère ce fichier et retourne un lien de flux lisible. »
  • « Indexe ce dossier et trouve toutes les scènes avec des personnes, retourne les horodatages. »
  • « Génère des sous-titres, incruste-les et ajoute une musique de fond légère. »
  • « Connecte cette URL RTSP et alerte quand une personne entre dans la zone. »

Enregistrement d'écran (Capture de bureau)

Utilisez ws_listener.py pour capturer les événements WebSocket pendant les sessions d'enregistrement. La capture de bureau prend en charge macOS uniquement.

Démarrage rapide

  1. Choisir le répertoire d'état : STATE_DIR="${VIDEODB_EVENTS_DIR:-$HOME/.local/state/videodb}"
  2. Démarrer le listener : VIDEODB_EVENTS_DIR="$STATE_DIR" python scripts/ws_listener.py --clear "$STATE_DIR" &
  3. Obtenir l'ID WebSocket : cat "$STATE_DIR/videodb_ws_id"
  4. Exécuter le code de capture (voir reference/capture.md pour le workflow complet)
  5. Événements écrits dans : $STATE_DIR/videodb_events.jsonl

Utilisez --clear chaque fois que vous démarrez une nouvelle session de capture, afin que les événements transcript et visuels obsolètes ne s'infiltrent pas dans la nouvelle session.

Interroger les événements

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"
events = []

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

transcripts = [e["data"]["text"] for e in events if e.get("channel") == "transcript"]
cutoff = time.time() - 300
recent_visual = [
    e for e in events
    if e.get("channel") == "visual_index" and e["unix_ts"] > cutoff
]

Documentation supplémentaire

La documentation de référence se trouve dans le répertoire reference/ adjacent à ce fichier SKILL.md. Utilisez l'outil Glob pour le localiser si nécessaire.

N'utilisez pas ffmpeg, moviepy ou des outils d'encodage locaux quand VideoDB prend en charge l'opération. Les opérations suivantes sont toutes traitées côté serveur par VideoDB : rogner, combiner des clips, superposer de l'audio ou de la musique, ajouter des sous-titres, des superpositions texte/image, transcoder, changer la résolution, convertir le rapport hauteur/largeur, redimensionner selon les exigences de la plateforme, transcrire et générer des médias. Revenez aux outils locaux uniquement pour les opérations listées dans Limitations dans reference/editor.md (transitions, changements de vitesse, recadrage/zoom, étalonnage des couleurs, mixage du volume).

Quand utiliser quoi

ProblèmeSolution VideoDB
La plateforme rejette le rapport hauteur/largeur ou la résolution de la vidéovideo.reframe() ou conn.transcode() avec VideoConfig
Besoin de redimensionner une vidéo pour Twitter/Instagram/TikTokvideo.reframe(target="vertical") ou target="square"
Besoin de changer la résolution (ex. 1080p → 720p)conn.transcode() avec VideoConfig(resolution=720)
Besoin de superposer de l'audio/de la musique sur une vidéoAudioAsset sur une Timeline
Besoin d'ajouter des sous-titresvideo.add_subtitle() ou CaptionAsset
Besoin de combiner/rogner des clipsVideoAsset sur une Timeline
Besoin de générer une voix off, de la musique ou des effets sonorescoll.generate_voice(), generate_music(), generate_sound_effect()

Provenance

Le matériel de référence pour cette compétence est fourni localement sous skills/videodb/reference/. Utilisez les copies locales ci-dessus plutôt que de suivre des liens vers des dépôts externes au moment de l'exécution.

Individual skills in this repo

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

503496348-ops/mischief-production

Use this skill when inspecting Blender characters, rigs, poses, animation retargeting, ground contact, facing direction, or model-vs-motion alignment where screenshots alone are not enough.

503496348-ops/mischief-production

Build reusable Manim explainers for technical concepts, graphs, system diagrams, and product walkthroughs, then hand off to the wider HCP video stack if needed. Use when the user wants a clean animated explainer rather than a generic talking-head script.

503496348-ops/mischief-production

Advanced motion patterns for React / Next.js — drag & drop, gestures, text animations, SVG path drawing, custom hooks, imperative sequences (useAnimate), loaders, and the full API decision tree. Requires motion-foundations.

503496348-ops/mischief-production

Motion tokens, spring presets, performance rules, device adaptation, accessibility enforcement, and SSR safety for React / Next.js using motion/react. Foundation layer — all other motion skills depend on this.

503496348-ops/mischief-production

Production-ready animation patterns for React / Next.js — button, modal, toast, stagger, page transitions, exit animations, scroll, and layout — built on motion-foundations tokens and springs.

503496348-ops/mischief-production

Production-ready UI motion system for React/Next.js. Use when implementing animations, transitions, or motion patterns.

503496348-ops/mischief-production

Best practices for Remotion - Video creation in React. 29 domain-specific rules covering 3D, animations, audio, captions, charts, transitions, and more.

Skills associés