Zweck
Dieses Skill automatisiert die Audio-zu-Text-Transkription mit professionellem Markdown-Output, extrahiert umfangreiche technische Metadaten (Sprecher, Zeitstempel, Sprache, Dateigröße, Dauer) und generiert strukturierte Besprechungsprotokolle und Executive Summaries. Es verwendet Faster-Whisper oder Whisper ohne Konfiguration und funktioniert universell in allen Projekten ohne feste Pfade oder API-Schlüssel.
Inspiriert von Tools wie Plaud verwandelt dieses Skill rohe Audioaufnahmen in verwertbare Dokumentation und ist ideal für Meetings, Interviews, Vorlesungen und Inhaltsanalysen.
Wann verwenden
Verwenden Sie dieses Skill, wenn:
- Der Benutzer Audio-/Videodateien in Text transkribieren muss
- Der Benutzer automatisch Besprechungsprotokolle aus Aufnahmen generieren möchte
- Der Benutzer Sprecheridentifikation (Diarisierung) in Gesprächen benötigt
- Der Benutzer Untertitel/Beschriftungen (SRT-, VTT-Formate) benötigt
- Der Benutzer Executive Summaries von langen Audioinhalten wünscht
- Der Benutzer nach Variationen von "dieses Audio transkribieren", "Audio in Text umwandeln", "Besprechungsnotizen aus Aufnahme generieren" fragt
- Der Benutzer Audiodateien in gängigen Formaten (MP3, WAV, M4A, OGG, FLAC, WEBM) hat
Arbeitsablauf
Schritt 0: Erkennung (Auto-Erkennung von Transkriptionswerkzeugen)
Ziel: Verfügbare Transkriptions-Engines ohne Benutzerkonfiguration identifizieren.
Aktionen:
Erkennungsbefehle ausführen, um installierte Werkzeuge zu finden:
# Prüfen auf Faster-Whisper (bevorzugt - 4-5x schneller)
if python3 -c "import faster_whisper" 2>/dev/null; then
TRANSCRIBER="faster-whisper"
echo "✅ Faster-Whisper erkannt (optimiert)"
# Fallback auf ursprüngliches Whisper
elif python3 -c "import whisper" 2>/dev/null; then
TRANSCRIBER="whisper"
echo "✅ OpenAI Whisper erkannt"
else
TRANSCRIBER="keins"
echo "⚠️ Kein Transkriptionswerkzeug gefunden"
fi
# Prüfen auf ffmpeg (Audiokonvertierung)
if command -v ffmpeg &>/dev/null; then
echo "✅ ffmpeg verfügbar (Formatkonvertierung aktiviert)"
else
echo "ℹ️ ffmpeg nicht gefunden (eingeschränkte Formatunterstützung)"
fi
Wenn kein Transkriptionswerkzeug gefunden wurde:
Automatische Installation mit dem bereitgestellten Skript anbieten:
echo "⚠️ Kein Transkriptionswerkzeug gefunden"
echo ""
echo "🔧 Abhängigkeiten automatisch installieren? (Empfohlen)"
read -p "Installationsskript ausführen? [J/n]: " AUTO_INSTALL
if [[ ! "$AUTO_INSTALL" =~ ^[Nn] ]]; then
# Skill-Verzeichnis ermitteln (funktioniert für Repository- und Symlink-Installationen)
SKILL_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
# Installationsskript ausführen
if [[ -f "$SKILL_DIR/scripts/install-requirements.sh" ]]; then
bash "$SKILL_DIR/scripts/install-requirements.sh"
else
echo "❌ Installationsskript nicht gefunden"
echo ""
echo "📦 Manuelle Installation:"
echo " pip install faster-whisper # Empfohlen"
echo " pip install openai-whisper # Alternative"
echo " brew install ffmpeg # Optional (macOS)"
exit 1
fi
# Überprüfen, ob die Installation erfolgreich war
if python3 -c "import faster_whisper" 2>/dev/null || python3 -c "import whisper" 2>/dev/null; then
echo "✅ Installation erfolgreich! Fahre mit Transkription fort..."
else
echo "❌ Installation fehlgeschlagen. Bitte manuell installieren."
exit 1
fi
else
echo ""
echo "📦 Manuelle Installation erforderlich:"
echo ""
echo "Empfohlen (am schnellsten):"
echo " pip install faster-whisper"
echo ""
echo "Alternative (Original):"
echo " pip install openai-whisper"
echo ""
echo "Optional (Formatkonvertierung):"
echo " brew install ffmpeg # macOS"
echo " apt install ffmpeg # Linux"
echo ""
exit 1
fi
Dadurch können Benutzer Abhängigkeiten mit einer Bestätigung installieren oder sich für die manuelle Installation entscheiden.
Wenn Transkriptionswerkzeug gefunden wurde:
Fahren Sie mit Schritt 0b (CLI-Erkennung) fort.
Schritt 1: Audiodatei validieren
Ziel: Überprüfen, ob die Datei existiert, Format prüfen und Metadaten extrahieren.
Aktionen:
-
Dateipfad oder URL vom Benutzer akzeptieren:
- Lokale Datei:
meeting.mp3 - URL:
https://example.com/audio.mp3(in temporäres Verzeichnis herunterladen)
- Lokale Datei:
-
Überprüfen, ob Datei existiert:
if [[ ! -f "$AUDIO_FILE" ]]; then
echo "❌ Datei nicht gefunden: $AUDIO_FILE"
exit 1
fi
- Metadaten extrahieren mit ffprobe oder Dateiwerkzeugen:
# Dateigröße ermitteln
FILE_SIZE=$(du -h "$AUDIO_FILE" | cut -f1)
# Dauer und Format mit ffprobe ermitteln
DURATION=$(ffprobe -v error -show_entries format=duration \
-of default=noprint_wrappers=1:nokey=1 "$AUDIO_FILE" 2>/dev/null)
FORMAT=$(ffprobe -v error -select_streams a:0 -show_entries \
stream=codec_name -of default=noprint_wrappers=1:nokey=1 "$AUDIO_FILE" 2>/dev/null)
# Dauer in HH:MM:SS umwandeln
DURATION_HMS=$(date -u -r "$DURATION" +%H:%M:%S 2>/dev/null || echo "Unbekannt")
- Dateigröße prüfen (Warnung bei großen Dateien für Cloud-APIs):
SIZE_MB=$(du -m "$AUDIO_FILE" | cut -f1)
if [[ $SIZE_MB -gt 25 ]]; then
echo "⚠️ Große Datei ($FILE_SIZE) - Verarbeitung kann mehrere Minuten dauern"
fi
- Format validieren (unterstützt: MP3, WAV, M4A, OGG, FLAC, WEBM):
EXTENSION="${AUDIO_FILE##*.}"
SUPPORTED_FORMATS=("mp3" "wav" "m4a" "ogg" "flac" "webm" "mp4")
if [[ ! " ${SUPPORTED_FORMATS[@]} " =~ " ${EXTENSION,,} " ]]; then
echo "⚠️ Nicht unterstütztes Format: $EXTENSION"
if command -v ffmpeg &>/dev/null; then
echo "🔄 Konvertiere in WAV..."
ffmpeg -i "$AUDIO_FILE" -ar 16000 "${AUDIO_FILE%.*}.wav" -y
AUDIO_FILE="${AUDIO_FILE%.*}.wav"
else
echo "❌ Installieren Sie ffmpeg zur Formatkonvertierung: brew install ffmpeg"
exit 1
fi
fi
Schritt 3: Markdown-Output generieren
Ziel: Strukturiertes Markdown mit Metadaten, Transkription, Besprechungsprotokoll und Zusammenfassung erstellen.
Output-Vorlage:
# Audio-Transkriptionsbericht
## 📊 Metadaten
| Feld | Wert |
|-------|-------|
| **Dateiname** | {filename} |
| **Dateigröße** | {file_size} |
| **Dauer** | {duration_hms} |
| **Sprache** | {language} ({language_code}) |
| **Verarbeitungsdatum** | {process_date} |
| **Identifizierte Sprecher** | {num_speakers} |
| **Transkriptions-Engine** | {engine} (Modell: {model}) |
## 📋 Besprechungsprotokoll
### Teilnehmer
- {speaker_1}
- {speaker_2}
- ...
### Besprochene Themen
1. **{topic_1}** ({timestamp})
- {key_point_1}
- {key_point_2}
2. **{topic_2}** ({timestamp})
- {key_point_1}
### Getroffene Entscheidungen
- ✅ {decision_1}
- ✅ {decision_2}
### Aktionspunkte
- [ ] **{action_1}** - Zuständig: {speaker} - Fällig: {date_if_mentioned}
- [ ] **{action_2}** - Zuständig: {speaker}
*Generiert von Audio-Transkriptions-Skill v1.0.0*
*Transkriptions-Engine: {engine} | Verarbeitungszeit: {elapsed_time}s*
Implementierung:
Python oder Bash mit KI-Modell (Claude/GPT) zur intelligenten Zusammenfassung verwenden:
def generate_meeting_minutes(segments):
"""Themen, Entscheidungen, Aktionspunkte aus Transkription extrahieren."""
# Segmente nach Thema gruppieren (einfaches Clustering nach Zeitstempeln)
topics = cluster_by_topic(segments)
# Aktionspunkte identifizieren (Schlüsselwörter: "sollte", "wird", "muss", "Aktion")
action_items = extract_action_items(segments)
# Entscheidungen identifizieren (Schlüsselwörter: "entschieden", "vereinbart", "genehmigt")
decisions = extract_decisions(segments)
return {
"topics": topics,
"decisions": decisions,
"action_items": action_items
}
def generate_summary(segments, max_paragraphs=5):
"""Executive Summary mit KI erstellen (Claude/GPT über API oder lokales Modell)."""
full_text = " ".join([s["text"] for s in segments])
# Chain-of-Density-Ansatz verwenden (aus Prompt-Engineer-Frameworks)
summary_prompt = f"""
Fassen Sie die folgende Transkription in {max_paragraphs} prägnanten Absätzen zusammen.
Konzentrieren Sie sich auf wichtige Themen, Entscheidungen und Aktionspunkte.
Transkription:
{full_text}
"""
# KI-Modell aufrufen (Platzhalter - Benutzer kann Claude-API integrieren oder lokales Modell verwenden)
summary = call_ai_model(summary_prompt)
return summary
Benennung der Ausgabedatei:
# v1.1.0: Zeitstempel verwenden, um Überschreiben zu vermeiden
TIMESTAMP=$(date +%Y%m%d-%H%M%S)
TRANSCRIPT_FILE="transkript-${TIMESTAMP}.md"
ATA_FILE="protokoll-${TIMESTAMP}.md"
echo "$TRANSCRIPT_CONTENT" > "$TRANSCRIPT_FILE"
echo "✅ Transkript gespeichert: $TRANSCRIPT_FILE"
if [[ -n "$ATA_CONTENT" ]]; then
echo "$ATA_CONTENT" > "$ATA_FILE"
echo "✅ Protokoll gespeichert: $ATA_FILE"
fi
SZENARIO A: Benutzer hat benutzerdefinierten Prompt angegeben
Arbeitsablauf:
-
Prompt des Benutzers anzeigen:
📝 Vom Benutzer bereitgestellter Prompt: ┌──────────────────────────────────┐ │ [Vorschau des Benutzer-Prompts] │ └──────────────────────────────────┘ -
Automatisch mit Prompt-Engineer verbessern (falls verfügbar):
🔧 Verbessere Prompt mit Prompt-Engineer... [Aufruf: gh copilot -p "verbessern Sie diesen Prompt: {user_prompt}"] -
Beide Versionen anzeigen:
✨ Verbesserte Version: ┌──────────────────────────────────┐ │ Rolle: Sie sind ein Dokumentator... │ │ Anweisungen: Wandeln Sie... │ │ Schritte: 1) ... 2) ... │ │ Endziel: ... │ └──────────────────────────────────┘ 📝 Originalversion: ┌──────────────────────────────────┐ [Ursprünglicher Prompt des Benutzers] └──────────────────────────────────┘ -
Fragen, welche verwendet werden soll:
💡 Verbesserte Version verwenden? [j/n] (Standard: j): -
Mit ausgewähltem Prompt verarbeiten:
- Wenn "j": verbesserte Version verwenden
- Wenn "n": Originalversion verwenden
LLM-Verarbeitung (Beide Szenarien)
Sobald der Prompt endgültig ist:
from rich.progress import Progress, SpinnerColumn, TextColumn
def process_with_llm(transcript, prompt, cli_tool='claude'):
full_prompt = f"{prompt}\n\n---\n\nTranskription:\n\n{transcript}"
with Progress(
SpinnerColumn(),
TextColumn("[progress.description]{task.description}"),
transient=True
) as progress:
progress.add_task(
description=f"🤖 Verarbeite mit {cli_tool}...",
total=None
)
if cli_tool == 'claude':
result = subprocess.run(
['claude', '-'],
input=full_prompt,
capture_output=True,
text=True,
timeout=300 # 5 Minuten
)
elif cli_tool == 'gh-copilot':
result = subprocess.run(
['gh', 'copilot', 'suggest', '-t', 'shell', full_prompt],
capture_output=True,
text=True,
timeout=300
)
if result.returncode == 0:
return result.stdout.strip()
else:
return None
Fortschrittsausgabe:
🤖 Verarbeite mit claude... ⠋
[Nach Abschluss:]
✅ Protokoll erfolgreich generiert!
Endgültige Ausgabe
Erfolg (beide Dateien):
💾 Speichere Dateien...
✅ Dateien erstellt:
- transkript-20260203-023045.md (reines Transkript)
- protokoll-20260203-023045.md (mit LLM verarbeitet)
🧹 Temporäre Dateien entfernt: metadata.json, transcription.json
✅ Abgeschlossen! Gesamtzeit: 3m 45s
Nur Transkript (Benutzer hat LLM abgelehnt):
💾 Speichere Dateien...
✅ Datei erstellt:
- transkript-20260203-023045.md
ℹ️ Protokoll nicht generiert (LLM-Verarbeitung vom Benutzer abgelehnt)
🧹 Temporäre Dateien entfernt: metadata.json, transcription.json
✅ Abgeschlossen!
Schritt 5: Ergebnisse zusammenfassen
Ziel: Abschlussstatus und nächste Schritte anzeigen.
Ausgabe:
echo ""
echo "✅ Transkription abgeschlossen!"
echo ""
echo "📊 Ergebnisse:"
echo " Datei: $OUTPUT_FILE"
echo " Sprache: $LANGUAGE"
echo " Dauer: $DURATION_HMS"
echo " Sprecher: $NUM_SPEAKERS"
echo " Wörter: $WORD_COUNT"
echo " Verarbeitungszeit: ${ELAPSED_TIME}s"
echo ""
echo "📝 Generiert:"
echo " - $OUTPUT_FILE (Markdown-Bericht)"
[wenn alternative Formate:]
echo " - ${OUTPUT_FILE%.*}.srt (Untertitel)"
echo " - ${OUTPUT_FILE%.*}.json (Strukturierte Daten)"
echo ""
echo "🎯 Nächste Schritte:"
echo " 1. Besprechungsprotokoll und Aktionspunkte überprüfen"
echo " 2. Bericht mit Teilnehmern teilen"
echo " 3. Aktionspunkte bis zur Erledigung verfolgen"
Beispielverwendung
Beispiel 1: Einfache Transkription
Benutzereingabe:
copilot> transkribiere audio zu markdown: meeting-2026-02-02.mp3
Skill-Ausgabe:
✅ Faster-Whisper erkannt (optimiert)
✅ ffmpeg verfügbar (Formatkonvertierung aktiviert)
📂 Datei: meeting-2026-02-02.mp3
📊 Größe: 12.3 MB
⏱️ Dauer: 00:45:32
🎙️ Verarbeite...
[████████████████████] 100%
✅ Sprache erkannt: Portugiesisch (pt-BR)
👥 Sprecher identifiziert: 4
📝 Generiere Markdown-Output...
✅ Transkription abgeschlossen!
📊 Ergebnisse:
Datei: meeting-2026-02-02.md
Sprache: pt-BR
Dauer: 00:45:32
Sprecher: 4
Wörter: 6.842
Verarbeitungszeit: 127s
📝 Generiert:
- meeting-2026-02-02.md (Markdown-Bericht)
🎯 Nächste Schritte:
1. Besprechungsprotokoll und Aktionspunkte überprüfen
2. Bericht mit Teilnehmern teilen
3. Aktionspunkte bis zur Erledigung verfolgen
Beispiel 3: Batch-Verarbeitung
Benutzereingabe:
copilot> transkribiere diese audios: recordings/*.mp3
Skill-Ausgabe:
📦 Batch-Modus: 5 Dateien gefunden
1. team-standup.mp3
2. client-call.mp3
3. brainstorm-session.mp3
4. product-demo.mp3
5. retrospective.mp3
🎙️ Verarbeite Batch...
[1/5] team-standup.mp3 ✅ (2m 34s)
[2/5] client-call.mp3 ✅ (15m 12s)
[3/5] brainstorm-session.mp3 ✅ (8m 47s)
[4/5] product-demo.mp3 ✅ (22m 03s)
[5/5] retrospective.mp3 ✅ (11m 28s)
✅ Batch abgeschlossen!
📝 5 Markdown-Berichte generiert
⏱️ Gesamtverarbeitungszeit: 6m 15s
Beispiel 5: Warnung bei großen Dateien
Benutzereingabe:
copilot> transkribiere audio zu markdown: conference-keynote.mp3
Skill-Ausgabe:
✅ Faster-Whisper erkannt (optimiert)
📂 Datei: conference-keynote.mp3
📊 Größe: 87.2 MB
⏱️ Dauer: 02:15:47
⚠️ Große Datei (87.2 MB) - Verarbeitung kann mehrere Minuten dauern
Fortfahren? [J/n]:
Benutzer: J
🎙️ Verarbeite... (dies kann 10-15 Minuten dauern)
[████░░░░░░░░░░░░░░░░] 20% - Geschätzte verbleibende Zeit: 12m