Communitygithub.com

sacredvoid/skillkit

Procesa grabaciones de video/audio (Zoom, reuniones, etc.) transcribiendo el audio con Whisper y extrayendo fotogramas visuales con ffmpeg. Detecta automáticamente tu hardware (Apple Silicon, NVIDIA, AMD, CPU) y elige el mejor modelo de transcripción. Multiplataforma: macOS, Linux, Windows.

¿Qué es skillkit?

Este skill de agente AI está diseñado para procesar grabaciones de video y audio (como reuniones de Zoom) y extraer transcripciones de texto y fotogramas visuales para su análisis. Detecta automáticamente el hardware del sistema (Apple Silicon MPS, GPU NVIDIA CUDA, AMD ROCm o CPU) y selecciona el motor de transcripción y el modelo óptimos: usa `faster-whisper` para sistemas con GPU CUDA (hasta 4x más rápido) y `openai-whisper` para MPS o CPU. El skill maneja todo el flujo de trabajo: identifica el archivo de grabación (incluyendo el chat de Zoom), instala dependencias como ffmpeg y PyTorch según la plataforma, extrae un fotograma por minuto con ffmpeg para contexto visual, y ejecuta la transcripción en segundo plano mientras revisa las imágenes. Finalmente, sintetiza la información combinando fotogramas, transcripción y chat para identificar participantes, decisiones, elementos de acción y citas clave. Soporta macOS, Linux y Windows, con instrucciones de instalación específicas para cada plataforma.

Compatible con~Claude Code✓Codex CLI~Cursor
npx skills add https://github.com/sacredvoid/skillkit/tree/HEAD/skills/video-audio-processor

Preguntar en tu IA favorita

Abre un nuevo chat con esta habilidad de agente ya precargada.

Documentación

Procesador de Video/Audio

Procesa grabaciones de video y audio en transcripciones de texto y capturas de fotogramas visuales para su análisis. Detecta automáticamente tu hardware y elige el modelo de transcripción, dispositivo y configuración óptimos.

Fase 0: Detectar Entorno de Cómputo

Ejecuta esto al inicio de cada invocación. Determina todo el flujo posterior.

python3 -c "
import platform, shutil, subprocess, json

info = {'os': platform.system(), 'arch': platform.machine(), 'ram_gb': 0, 'gpu': 'none', 'vram_gb': 0, 'device': 'cpu', 'dtype': 'float32'}

# RAM
try:
    if platform.system() == 'Darwin':
        import os; info['ram_gb'] = round(os.sysconf('SC_PAGE_SIZE') * os.sysconf('SC_PHYS_PAGES') / (1024**3))
    elif platform.system() == 'Linux':
        with open('/proc/meminfo') as f:
            for line in f:
                if line.startswith('MemTotal'):
                    info['ram_gb'] = round(int(line.split()[1]) / (1024**2))
                    break
    else:
        import ctypes
        mem = ctypes.c_ulonglong(0)
        ctypes.windll.kernel32.GetPhysicallyInstalledMemory(ctypes.byref(mem))
        info['ram_gb'] = round(mem.value / (1024**2))
except: pass

# Detección de GPU
try:
    import torch
    if torch.cuda.is_available():
        info['gpu'] = torch.cuda.get_device_name(0)
        info['vram_gb'] = round(torch.cuda.get_device_properties(0).total_mem / (1024**3))
        info['device'] = 'cuda'
        info['dtype'] = 'float16'
    elif hasattr(torch.backends, 'mps') and torch.backends.mps.is_available():
        info['gpu'] = 'Apple Silicon (MPS)'
        info['vram_gb'] = info['ram_gb']  # memoria unificada
        info['device'] = 'mps'
        info['dtype'] = 'float16'
    elif hasattr(torch, 'hip') or 'AMD' in str(getattr(torch, '_C', '')):
        info['gpu'] = 'AMD (ROCm)'
        info['device'] = 'cuda'  # ROCm usa la API de cuda
        info['dtype'] = 'float16'
except ImportError:
    pass

# Detección de ffmpeg
info['ffmpeg'] = shutil.which('ffmpeg') is not None
info['ffprobe'] = shutil.which('ffprobe') is not None

print(json.dumps(info))
"

Analiza la salida JSON y guárdala internamente como COMPUTE. Presenta los resultados al usuario:

Hardware detectado:

  • SO: {os} ({arch})
  • RAM: {ram_gb} GB
  • GPU: {gpu} ({vram_gb} GB VRAM)
  • Dispositivo de cómputo: {device}
  • ffmpeg: {instalado/falta}

Selección del Motor Whisper

Basado en el hardware, elige el motor de transcripción:

CondiciónMotorMotivo
GPU CUDA disponiblefaster-whisperCTranslate2 acelerado por GPU, 4x más rápido que Whisper estándar
MPS (Apple Silicon)openai-whisperWhisper estándar, usa aceleración MPS cuando está disponible
Solo CPUopenai-whisperWhisper estándar en CPU, respaldo confiable

Matriz de Selección de Modelo

Basado en el hardware y la duración de la grabación, recomienda un modelo:

CondiciónModelo RecomendadoVelocidad (1 hora de grabación)Precisión
CUDA >= 8 GB VRAMlarge-v3~5 minMejor
CUDA 4-7 GB VRAMmedium~8 minAlta
MPS (Apple Silicon, 16+ GB)medium~15 minAlta
MPS (Apple Silicon, 8 GB)small~10 minBuena
CPU + RAM >= 16 GBsmall~30 minBuena
CPU + RAM < 16 GBbase~15 minAdecuada

Presenta la recomendación y deja que el usuario elija:

AskUserQuestion: "¿Qué modelo de transcripción debería usar?"
Options:
- [Modelo recomendado] (Recomendado) - [motivo basado en su hardware]
- large-v3 - Mejor precisión, necesita 8+ GB VRAM o mucha RAM
- medium - Alta precisión, velocidad equilibrada
- small - Buena precisión, procesamiento más rápido
- base - Adecuado para la mayoría de reuniones, más rápido

Almacena el modelo elegido como WHISPER_MODEL y el motor como WHISPER_ENGINE.

Fase 1: Identificar la Grabación

Encuentra el archivo. Las grabaciones de Zoom suelen seguir el patrón:

  • GMT{date}-{time}_Recording_{resolution}.mp4 (video)
  • GMT{date}-{time}_Recording.m4a (solo audio)
  • GMT{date}-{time}_RecordingnewChat.txt (registro de chat)

Busca los tres artefactos. Lee primero el archivo de chat (es pequeño y da contexto inmediato).

Fase 2: Instalar Dependencias

Verifica e instala lo necesario según la plataforma.

ffmpeg

# Verificar si ffmpeg está disponible
ffmpeg -version 2>&1 | head -1
ffprobe -version 2>&1 | head -1

Si ffmpeg falta, instala según la plataforma:

PlataformaComando de instalación
macOS (Homebrew)brew install ffmpeg
macOS (sin Homebrew)Guía al usuario para instalar Homebrew primero, luego ffmpeg
Ubuntu/Debiansudo apt update && sudo apt install -y ffmpeg
Fedora/RHELsudo dnf install -y ffmpeg
Arch Linuxsudo pacman -S ffmpeg
Windows (winget)winget install Gyan.FFmpeg
Windows (choco)choco install ffmpeg
Windows (scoop)scoop install ffmpeg

Python + Whisper

python3 -c "import torch; print(torch.__version__)" 2>&1

Si torch falta, instala según la plataforma:

PlataformaComando de instalación
macOS (MPS)pip3 install torch torchvision torchaudio
Linux (CUDA)pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121
Linux (ROCm)pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/rocm6.0
Linux/Windows (CPU)pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cpu
Windows (CUDA)pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121

Luego instala el motor de transcripción:

# Para sistemas CUDA (faster-whisper con aceleración CTranslate2)
pip3 install faster-whisper

# Para sistemas MPS / CPU (OpenAI Whisper estándar)
pip3 install openai-whisper

Fase 3: Obtener Duración

Usa ffprobe (multiplataforma) para obtener la duración del archivo:

ffprobe -v quiet -show_entries format=duration -of csv=p=0 "/ruta/al/archivo"

Esto devuelve la duración en segundos. Conviértelo a formato legible y muéstralo al usuario. Úsalo para estimar el tiempo de transcripción basado en el modelo y hardware seleccionados.

Presenta el plan:

Plan de procesamiento:

  • Archivo: {nombre} ({duración})
  • Motor: {WHISPER_ENGINE} con modelo {WHISPER_MODEL} en {device}
  • Tiempo estimado de transcripción: {estimación}
  • Extracción de fotogramas: 1 por minuto ({cantidad_fotogramas} fotogramas)

¿Quieres ajustar algo antes de empezar?

Estimaciones de Tiempo

Dispositivobasesmallmediumlarge-v3
CUDA (RTX 3060+)~1 min/h~2 min/h~4 min/h~5 min/h
CUDA (faster-whisper)~30s/h~1 min/h~2 min/h~3 min/h
MPS (M1/M2/M3/M4)~3 min/h~6 min/h~15 min/h~25 min/h
CPU (16GB+ RAM)~8 min/h~15 min/h~30 min/h~60 min/h

Fase 4: Extraer Fotogramas Visuales

Extrae un fotograma por minuto para obtener contexto visual. Usa un directorio temporal multiplataforma:

# Crear directorio temporal (multiplataforma)
python3 -c "import tempfile, os; d = os.path.join(tempfile.gettempdir(), 'av-frames'); os.makedirs(d, exist_ok=True); print(d)"

Luego extrae los fotogramas:

ffmpeg -i "/ruta/al/video.mp4" \
  -vf "fps=1/60,scale=1280:-1" -q:v 3 {TEMP_DIR}/frame_%03d.jpg

Usa la herramienta de Lectura en cada fotograma para verlo. Los fotogramas muestran:

  • Comparticiones de pantalla (código, diapositivas, interfaces de usuario)
  • Nombres de participantes (en la esquina inferior izquierda de cada mosaico de video)
  • Marcas de tiempo (si son visibles en la compartición de pantalla)

Fase 5: Transcribir Audio

Ejecuta el motor de transcripción. Elige el código correcto según WHISPER_ENGINE:

faster-whisper (sistemas CUDA)

from faster_whisper import WhisperModel
import json

model = WhisperModel("{WHISPER_MODEL}", device="cuda", compute_type="float16")
segments, info = model.transcribe("/ruta/al/audio", beam_size=5, language="en")

results = []
for segment in segments:
    results.append({
        "start": segment.start,
        "end": segment.end,
        "text": segment.text.strip()
    })

# Guardar transcripción con marcas de tiempo
with open("{TEMP_DIR}/transcript.json", "w") as f:
    json.dump({"language": info.language, "segments": results}, f, indent=2)

with open("{TEMP_DIR}/transcript.txt", "w") as f:
    for seg in results:
        start = int(seg["start"])
        mins, secs = divmod(start, 60)
        f.write(f"[{mins:02d}:{secs:02d}] {seg['text']}\n")

print(f"Transcritos {len(results)} segmentos")

openai-whisper (sistemas MPS / CPU)

import whisper, json

model = whisper.load_model("{WHISPER_MODEL}")
result = model.transcribe("/ruta/al/audio", verbose=False)

# Guardar transcripción con marcas de tiempo
with open("{TEMP_DIR}/transcript.json", "w") as f:
    json.dump(result, f, indent=2)

with open("{TEMP_DIR}/transcript.txt", "w") as f:
    for seg in result["segments"]:
        start = int(seg["start"])
        mins, secs = divmod(start, 60)
        f.write(f"[{mins:02d}:{secs:02d}] {seg['text'].strip()}\n")

print(f"Transcritos {len(result['segments'])} segmentos")

Ejecuta la transcripción en segundo plano porque lleva un tiempo significativo. Mientras se ejecuta, revisa visualmente los fotogramas extraídos.

Fase 6: Sintetizar

Combina fotogramas visuales + transcripción + chat para construir una comprensión:

  • Quién: Identifica a los participantes a partir de las etiquetas de nombre en el video y la atribución de voz
  • Qué: Lo que se mostró en pantalla (demostraciones, diapositivas, código)
  • Dicho: Citas clave, decisiones, requisitos, retroalimentación
  • Elementos de acción: Compromisos explícitos y seguimientos

Referencia del Modelo

ModeloParámetrosVelocidadPrecisiónMejor Para
tiny39MMuy rápidaBajaEscaneo rápido, verificar si el audio es utilizable
base74MRápidaAdecuadaPredeterminado para reuniones cortas/claras
small244MModeradaBuenaReuniones generales con acentos
medium769MLentaAltaReuniones importantes, orientadas al cliente
large-v31.5BMuy lentaMejorGrabaciones críticas, mala calidad de audio

Consejos

  • Siempre ejecuta la transcripción en segundo plano mientras revisas los fotogramas visualmente
  • Lee los fotogramas en lotes de 8 (límite de paralelismo de la herramienta)
  • Whisper estándar usa FP32 en CPU y MPS; faster-whisper usa CTranslate2 con FP16 en CUDA
  • Para grabaciones muy largas (>1 hora), considera dividir el audio primero
  • Los archivos de chat de Zoom contienen marcas de tiempo y enlaces compartidos, léelos primero para contexto rápido
  • En Windows, usa barras diagonales o cadenas sin procesar para rutas de archivos en Python

Manejo de Errores

ErrorCausaSolución
ffmpeg: command not foundffmpeg no instaladoInstalar según la tabla de plataforma anterior
No module named 'whisper'Whisper no instaladopip3 install openai-whisper
No module named 'faster_whisper'faster-whisper no instaladopip3 install faster-whisper
CUDA out of memoryModelo demasiado grande para VRAMCambiar a un modelo más pequeño
RuntimeError: MPS backendProblema MPS en macOS antiguoActualizar macOS, o retroceder a CPU con PYTORCH_MPS_HIGH_WATERMARK_RATIO=0.0
torch not foundDependencias Python faltantesInstalar torch según la tabla de plataforma anterior
Transcripción confusaIdioma incorrecto o audio deficienteIntenta especificar language="es" o usa un modelo más grande
Transcripción muy lentaEjecutando modelo grande en CPUCambiar al modelo base o small

Skills relacionados