Skill de Resumo de Vídeo e Podcast
Envie um link de vídeo/podcast → receba transcrição completa + resumo estruturado
Plataformas Suportadas
| Plataforma | Tipo | Legendas | Transcrição Whisper |
|---|---|---|---|
| YouTube | Vídeo | ✅ | ✅ |
| Bilibili | Vídeo | ✅ | ✅ |
| X/Twitter | Vídeo | ❌ | ✅ |
| Xiaoyuzhou (小宇宙) | Podcast | ❌ | ✅ |
| Apple Podcasts | Podcast | ❌ | ✅ |
| Links diretos (mp3/mp4/m3u8) | Qualquer | ❌ | ✅ |
Gatilho
Acionado automaticamente quando uma URL de mídia é detectada:
- YouTube:
youtube.com,youtu.be - Bilibili:
bilibili.com,b23.tv - X/Twitter:
x.com,twitter.com(tweets com vídeo) - Xiaoyuzhou:
xiaoyuzhoufm.com - Apple Podcasts:
podcasts.apple.com - Direta:
.mp3,.mp4,.m3u8,.m4a,.webm
Pipeline
Etapa 0: Detectar Tipo de Mídia
| Padrão de URL | Tipo | Pipeline |
|---|---|---|
xiaoyuzhoufm.com/episode/ | Podcast | → Etapa 1b (Xiaoyuzhou) |
podcasts.apple.com | Podcast | → Etapa 1c (Apple) |
bilibili.com, b23.tv | Vídeo | → Etapa 1d (API do Bilibili) |
.mp3, .m4a link direto | Áudio | → Etapa 2b (download direto) |
| Outros | Vídeo | → Etapa 1a (extração de legendas) |
Etapa 1a: Vídeo — Extrair Legendas
# Limpar arquivos temporários
rm -f /tmp/media_sub*.vtt /tmp/media_audio.mp3 /tmp/media_transcript*.json /tmp/media_segment_*.mp3 2>/dev/null || true
# YouTube (preferir inglês, fallback chinês)
yt-dlp --skip-download --write-auto-sub --sub-lang "en,zh-Hans" -o "/tmp/media_sub" "VIDEO_URL"
# Bilibili
yt-dlp --skip-download --write-auto-sub --sub-lang "zh-Hans,zh" -o "/tmp/media_sub" "VIDEO_URL"
Verificar se há legendas:
ls /tmp/media_sub*.vtt 2>/dev/null
- Tem legendas → Ler conteúdo VTT, pular para Etapa 3
- Sem legendas → Etapa 2a (baixar áudio)
Etapa 1b: Xiaoyuzhou (小宇宙) — Extrair URL de Áudio
# Extrair link CDN direto de __NEXT_DATA__
# Xiaoyuzhou é um SPA Next.js, mas o HTML inicial contém URL de áudio em __NEXT_DATA__
AUDIO_URL=$(curl -sL -H "User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36" \
"EPISODE_URL" \
| grep -oE 'https://media\.xyzcdn\.net/[^"]+\.(m4a|mp3)' \
| head -1)
echo "Audio URL: $AUDIO_URL"
# Baixar áudio
curl -L -o /tmp/media_audio.mp3 "$AUDIO_URL"
Se a extração via curl estiver vazia (raro), fallback: usar Puppeteer/navegador para obter a página renderizada e extrair.
→ Etapa 2b (verificar tamanho e transcrever)
Etapa 1c: Apple Podcasts — via yt-dlp
yt-dlp -f "ba[ext=m4a]/ba/b" --extract-audio --audio-format mp3 --audio-quality 5 \
-o "/tmp/media_audio.%(ext)s" "APPLE_PODCAST_URL"
→ Etapa 2b (verificar tamanho e transcrever)
Etapa 1d: Bilibili — Stream de Áudio Direto por API
yt-dlp retorna 412 para o Bilibili mesmo com cookies. Use a API do Bilibili:
# 1. Extrair número BV da URL
BV="BV1xxxxx" # Substituir pelo número BV real
# 2. Obter informações do vídeo (título, duração, CID)
curl -s "https://api.bilibili.com/x/web-interface/view?bvid=$BV" \
-H "User-Agent: Mozilla/5.0" -H "Referer: https://www.bilibili.com/" \
| python3 -c "import json,sys; d=json.load(sys.stdin)['data']; print(f\"Title: {d['title']}\nDuration: {d['duration']}s\nCID: {d['cid']}\")"
# 3. Obter URL do stream de áudio
CID=<CID do passo anterior>
AUDIO_URL=$(curl -s "https://api.bilibili.com/x/player/playurl?bvid=$BV&cid=$CID&fnval=16&qn=64" \
-H "User-Agent: Mozilla/5.0" -H "Referer: https://www.bilibili.com/" \
| python3 -c "import json,sys; print(json.load(sys.stdin)['data']['dash']['audio'][0]['baseUrl'])")
# 4. Baixar áudio (cabeçalho Referer necessário, caso contrário 403)
curl -L -o /tmp/media_audio.m4s \
-H "User-Agent: Mozilla/5.0" -H "Referer: https://www.bilibili.com/" "$AUDIO_URL"
# 5. Converter para mp3
ffmpeg -y -i /tmp/media_audio.m4s -acodec libmp3lame -q:a 5 /tmp/media_audio.mp3
→ Etapa 2b (verificar tamanho e transcrever)
Etapa 2a: Vídeo — Baixar Áudio (quando não há legendas)
# YouTube pode precisar de --cookies-from-browser chrome para contornar detecção de bot
yt-dlp --cookies-from-browser chrome -f "ba[ext=m4a]/ba/b" --extract-audio --audio-format mp3 --audio-quality 5 \
-o "/tmp/media_audio.%(ext)s" "VIDEO_URL"
Etapa 2b: Verificar Tamanho do Áudio e Segmentar
FILE_SIZE=$(stat -f%z /tmp/media_audio.* 2>/dev/null || stat -c%s /tmp/media_audio.* 2>/dev/null)
echo "File size: $FILE_SIZE bytes"
- ≤ 25MB (25000000) → Etapa 2c (transcrever diretamente)
- > 25MB → Dividir primeiro, depois transcrever cada segmento
Dividir áudio grande (>25MB)):
# Obter duração total
DURATION=$(ffprobe -v error -show_entries format=duration -of csv=p=0 /tmp/media_audio.* | head -1)
# Dividir em segmentos de 10 minutos (mantém cada um abaixo de 25MB)
SEGMENT_SEC=600
SEGMENTS=$(python3 -c "import math; print(math.ceil(float('$DURATION')/$SEGMENT_SEC))")
# Cortar segmentos
for i in $(seq 0 $((SEGMENTS-1))); do
START=$((i * SEGMENT_SEC))
ffmpeg -y -i /tmp/media_audio.* -ss $START -t $SEGMENT_SEC -acodec libmp3lame -q:a 5 \
"/tmp/media_segment_${i}.mp3" 2>/dev/null
done
→ Chamar Etapa 2c para cada segmento sequencialmente (paralelo causa timeout 524 do Groq), concatenar resultados
Etapa 2c: Transcrição Whisper
Pré-requisito: Variável de ambiente GROQ_API_KEY
# Verificar chave de API
if [ -z "$GROQ_API_KEY" ]; then
echo "❌ GROQ_API_KEY não definida. Obtenha uma em: https://console.groq.com/keys"
exit 1
fi
# Transcrever arquivo único (substituir AUDIO_FILE pelo caminho real)
curl -s -X POST "https://api.groq.com/openai/v1/audio/transcriptions" \
-H "Authorization: Bearer $GROQ_API_KEY" \
-H "Content-Type: multipart/form-data" \
-F "file=@AUDIO_FILE" \
-F "model=whisper-large-v3-turbo" \
-F "response_format=verbose_json" \
-F "language=zh" \
> /tmp/media_transcript.json
# Extrair texto simples
python3 -c "import json; print(json.load(open('/tmp/media_transcript.json'))['text'])"
Opções do modelo Whisper:
| Modelo | Velocidade | Precisão | Caso de Uso |
|---|---|---|---|
whisper-large-v3-turbo | 10x tempo real | Alta | Escolha padrão |
whisper-large-v3 | 5x tempo real | Mais alta | Conteúdo profissional/ruidoso |
Parâmetro de idioma:
- Chinês:
language=zh - Inglês:
language=en - Detecção automática: omitir parâmetro language
Etapa 3: Resumo Estruturado
Escolher o formato de saída com base no tipo de mídia:
Vídeo (≤20 min):
- Visão Geral (1-2 frases)
- Pontos-Chave (3-5 marcadores)
- Citações Notáveis (se houver)
- Itens de Ação (se aplicável)
Podcast (>20 min):
- Visão Geral (2-3 frases: quem discutiu o quê)
- Resumo por Capítulo (segmentado por tópico, 2-3 frases cada)
- Pontos-Chave (5-8 marcadores)
- Citações Notáveis
- Itens de Ação (se aplicável)
Formato de Saída
Vídeo
## 📺 Resumo de Vídeo
**Título**: [Título do Vídeo]
**Duração**: [x minutos]
**Idioma**: [Chinês/Inglês]
### Visão Geral
[Resumo de 1-2 frases]
### Pontos-Chave
1. [Ponto 1]
2. [Ponto 2]
...
### Citações Notáveis
> "xxx" — [timestamp]
### Itens de Ação
- [se aplicável]
Podcast
## 🎙️ Resumo de Podcast
**Programa**: [Nome do Podcast]
**Episódio**: [Título do Episódio]
**Duração**: [x minutos]
**Convidados**: [se houver]
### Visão Geral
[2-3 frases: quem discutiu o quê, conclusões principais]
### Resumo por Capítulo
#### 1. [Tópico] (~xx:xx-xx:xx)
[2-3 frases do conteúdo central]
#### 2. [Tópico] (~xx:xx-xx:xx)
[2-3 frases do conteúdo central]
...
### Pontos-Chave
1. [Ponto 1]
2. [Ponto 2]
...
### Citações Notáveis
> "xxx"
### Itens de Ação
- [se aplicável]
Tratamento de Erros
| Situação | Ação |
|---|---|
| Sem legendas + sem GROQ_API_KEY | Solicitar ao usuário que defina a chave de API |
| Sem legendas + tem chave de API | Transcrição Whisper automática |
| Extração Xiaoyuzhou via curl vazia | Usar Puppeteer/navegador para obter HTML renderizado |
| Áudio >25MB | Segmentação com ffmpeg (10min/segmento), transcrever sequencialmente |
| Podcast >2 horas | Avisar o usuário sobre a duração, confirmar antes de prosseguir |
| Groq timeout 524 | NÃO paralelizar — transcrever sequencialmente, aguardar 5-8s entre segmentos |
| Groq limite de taxa 429 | Limite de 7200s/hora, aguardar cabeçalho retry-after e tentar novamente |
| yt-dlp Bilibili 412 | Usar API do Bilibili em vez disso (Etapa 1d) |
| yt-dlp detecção de bot no YouTube | Adicionar --cookies-from-browser chrome |
| Timeout de rede | Tentar novamente uma vez |
| Links do Spotify | Informar o usuário: não suportado (protegido por DRM) |
Limites do Groq Whisper
- Máximo 25MB por requisição
- Camada gratuita: 7200 segundos de áudio/hora (janela contínua), ~20 horas/dia
- Formatos suportados: mp3, mp4, mpeg, mpga, m4a, wav, webm
Dependências
yt-dlp: download de vídeo + extração de legendasffmpeg: conversão de áudio + segmentaçãocurl: download de áudio do Xiaoyuzhou, API do BilibiliGROQ_API_KEY: API de transcrição Whisper (gratuita em https://console.groq.com/keys)