Communitygithub.com

ASoudy/AGS (Audio-zu-Markdown-Transkription)

Wandelt Audioaufnahmen mit intelligenter LLM-Integration in professionelle Markdown-Dokumentation um.

Was ist AGS (Audio-zu-Markdown-Transkription)?

Dieses Skill automatisiert die Audio-zu-Text-Transkription mit professionellem Markdown-Output. Es extrahiert umfangreiche technische Metadaten (Sprecher, Zeitstempel, Sprache, Dateigröße, Dauer) und generiert strukturierte Besprechungsprotokolle sowie zusammenfassende Executive Summaries. Das Skill nutzt Faster-Whisper oder Whisper ohne Konfigurationsaufwand und funktioniert projektübergreifend ohne fest kodierte Pfade oder API-Schlüssel. Es eignet sich ideal für Meetings, Interviews, Vorlesungen und die Inhaltsanalyse und wird von Tools wie Claude Code, Cursor und anderen KI-Agenten-Plattformen unterstützt.

Funktioniert mit✓Claude Code✓Codex CLI~Cursor
npx skills add https://github.com/ASoudy/AGS/tree/HEAD/claude_skills_libraries/landing-page-mastery/skills/audio-transcriber

In Ihrer bevorzugten KI fragen

Öffnet einen neuen Chat, in dem dieser Agent-Skill bereits geladen ist.

Dokumentation

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:

  1. Dateipfad oder URL vom Benutzer akzeptieren:

    • Lokale Datei: meeting.mp3
    • URL: https://example.com/audio.mp3 (in temporäres Verzeichnis herunterladen)
  2. Überprüfen, ob Datei existiert:

if [[ ! -f "$AUDIO_FILE" ]]; then
    echo "❌ Datei nicht gefunden: $AUDIO_FILE"
    exit 1
fi
  1. 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")
  1. 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
  1. 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:

  1. Prompt des Benutzers anzeigen:

    📝 Vom Benutzer bereitgestellter Prompt:
    ┌──────────────────────────────────┐
    │ [Vorschau des Benutzer-Prompts]  │
    └──────────────────────────────────┘
    
  2. Automatisch mit Prompt-Engineer verbessern (falls verfügbar):

    🔧 Verbessere Prompt mit Prompt-Engineer...
    [Aufruf: gh copilot -p "verbessern Sie diesen Prompt: {user_prompt}"]
    
  3. Beide Versionen anzeigen:

    ✨ Verbesserte Version:
    ┌──────────────────────────────────┐
    │ Rolle: Sie sind ein Dokumentator... │
    │ Anweisungen: Wandeln Sie...      │
    │ Schritte: 1) ... 2) ...          │
    │ Endziel: ...                     │
    └──────────────────────────────────┘
    
    📝 Originalversion:
    ┌──────────────────────────────────┐
    [Ursprünglicher Prompt des Benutzers]
    └──────────────────────────────────┘
    
  4. Fragen, welche verwendet werden soll:

    💡 Verbesserte Version verwenden? [j/n] (Standard: j):
    
  5. 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

Individual skills in this repo

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

ASoudy/AGS

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

ASoudy/AGS

Astropy is the core Python package for astronomy, providing essential functionality for astronomical research and data analysis.

ASoudy/AGS

Build content-focused websites with Astro — zero JS by default, islands architecture, multi-framework components, and Markdown/MDX support.

ASoudy/AGS

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

ASoudy/AGS

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.

ASoudy/AGS

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

ASoudy/AGS

Pull a YouTube video transcript into a queryable markdown vault with yt-dlp subtitle discovery, VTT cleanup, metadata frontmatter, and capture-seed stubs.

ASoudy/AGS

Expert in building portfolios that actually land jobs and clients - not just showing work, but creating memorable experiences. Covers developer portfolios, designer portfolios, creative portfolios, and portfolios that convert visitors into opportunities.

ASoudy/AGS

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.

ASoudy/AGS

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

ASoudy/AGS

CRITICAL: Use for Makepad animation system. Triggers on: makepad animation, makepad animator, makepad hover, makepad state, makepad transition, "from: { all: Forward", makepad pressed, makepad 动画, makepad 状态, makepad 过渡, makepad 悬停效果

ASoudy/AGS

Comprehensive patterns for Next.js 14+ App Router architecture, Server Components, and modern full-stack React development.

ASoudy/AGS

Next.js App Router principles. Server Components, data fetching, routing patterns.

ASoudy/AGS

Expert integration of Supabase Auth with Next.js App Router

ASoudy/AGS

React and Next.js 14+ application development with App Router, Server Components, TypeScript, Tailwind CSS, and modern frontend patterns.

ASoudy/AGS

Best practices for Remotion - Video creation in React

ASoudy/AGS

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

ASoudy/AGS

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

ASoudy/AGS

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.

ASoudy/AGS

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

Verwandte Skills