0Pricing
AI Agents · Lektion

Speech-to-Text mit Whisper und Deepgram

Echtzeit- und Batch-Transkription, Spracherkennung und Zeichensetzung.

Speech-to-Text mit Whisper und Deepgram ist eine kostenlose AI Agents-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des AI Agents-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der AI Agents-Kurs umfasst insgesamt 4 Lektionen.

Speech-to-Text in Sprachagenten

Ein Sprachagent muss gesprochene Audiodaten in Text umwandeln, bevor das LLM sie verarbeiten kann. Dieser Schritt wird als Speech-to-Text (STT) oder Automatic Speech Recognition (ASR) bezeichnet.

Zwei führende Optionen sind: OpenAI Whisper (dateibasiert, als Batch) und Deepgram (Streaming, Echtzeit, mit Sprecherdiarisierung und Wort-Zeitstempeln).

OpenAI Whisper: Grundlegende Transkription

Whisper transkribiert Audiodateien über die OpenAI API. Unterstützte Formate: mp3, mp4, wav, webm, m4a, flac. Maximale Dateigröße: 25 MB.

import openai
import os

client = openai.OpenAI(api_key=os.getenv('OPENAI_API_KEY'))

def transcribe_file(audio_path, language=None):
    with open(audio_path, 'rb') as audio_file:
        params = {
            'model': 'whisper-1',
            'file': audio_file,
            'response_format': 'json'  # or 'text', 'srt', 'vtt', 'verbose_json'
        }
        if language:
            params['language'] = language  # e.g., 'en', 'fr', 'de'

        transcript = client.audio.transcriptions.create(**params)

    return transcript.text

# Basic usage
text = transcribe_file('meeting_recording.mp3')
print('Transcribed:', text[:200])

Whisper mit Wort-Zeitstempeln

Verwenden Sie response_format='verbose_json', um Zeitstempel für jedes Wort und Segment zu erhalten. Das ist nützlich, um bestimmte Momente in Aufnahmen zu finden, eine Hervorhebung im Karaoke-Stil umzusetzen und Transkripte an die Audiowiedergabe anzugleichen.

import openai
import os

client = openai.OpenAI(api_key=os.getenv('OPENAI_API_KEY'))

def transcribe_with_timestamps(audio_path):
    with open(audio_path, 'rb') as f:
        result = client.audio.transcriptions.create(
            model='whisper-1',
            file=f,
            response_format='verbose_json',
            timestamp_granularities=['word', 'segment']  # get both word and segment times
        )

    segments = []
    for seg in result.segments:
        segments.append({
            'start': seg.start,
            'end':   seg.end,
            'text':  seg.text
        })

    words = []
    if hasattr(result, 'words'):
        for word in result.words:
            words.append({'word': word.word, 'start': word.start, 'end': word.end})

    return {'text': result.text, 'segments': segments, 'words': words}

Deepgram SDK: Asynchrones Streaming

Deepgram ist für die Transkription in Echtzeit-Streams optimiert. Audio wird während der Aufnahme in Chunks gesendet; partielle Transkripte werden zurückgegeben, bevor der Sprecher einen Satz beendet hat.

Installieren Sie es mit pip install deepgram-sdk.

import asyncio
import os
from deepgram import DeepgramClient, PrerecordedOptions

client = DeepgramClient(os.getenv('DEEPGRAM_API_KEY'))

async def transcribe_with_deepgram(audio_path):
    with open(audio_path, 'rb') as f:
        audio_data = f.read()

    options = PrerecordedOptions(
        model='nova-2',            # Deepgram's best accuracy model
        language='en',
        smart_format=True,         # auto-add punctuation and formatting
        utterances=True,           # segment by speaker turns
        punctuate=True,
        diarize=True               # speaker identification
    )

    response = await client.listen.asyncrest.v('1').transcribe_file(
        {'buffer': audio_data},
        options
    )

    return response.results.channels[0].alternatives[0].transcript

Sprecherdiarisierung

Die Diarisierung erkennt, wer wann spricht, und kennzeichnet Segmente als Sprecher 0, Sprecher 1 usw. Das ist für Besprechungstranskripte und Gespräche mit mehreren Teilnehmern von entscheidender Bedeutung.

async def transcribe_with_diarization(audio_path):
    from deepgram import DeepgramClient, PrerecordedOptions
    import os

    dg_client = DeepgramClient(os.getenv('DEEPGRAM_API_KEY'))

    options = PrerecordedOptions(
        model='nova-2',
        diarize=True,
        utterances=True,
        smart_format=True
    )

    with open(audio_path, 'rb') as f:
        audio_data = f.read()

    response = await dg_client.listen.asyncrest.v('1').transcribe_file(
        {'buffer': audio_data}, options
    )

    utterances = []
    for utt in response.results.utterances:
        utterances.append({
            'speaker': f'Speaker {utt.speaker}',
            'start':   round(utt.start, 2),
            'end':     round(utt.end, 2),
            'text':    utt.transcript
        })

    return utterances

# Output:
# [{'speaker': 'Speaker 0', 'start': 0.0, 'end': 3.2, 'text': 'Hello everyone.'},
#  {'speaker': 'Speaker 1', 'start': 3.5, 'end': 6.1, 'text': 'Good morning!'}]

Erkennung der gesprochenen Sprache

Wenn die Sprache des Benutzers unbekannt ist, können sowohl Whisper als auch Deepgram die gesprochene Sprache automatisch erkennen. Whisper erkennt die Sprache anhand der ersten 30 Sekunden der Audiodaten.

import openai
import os

client = openai.OpenAI(api_key=os.getenv('OPENAI_API_KEY'))

def detect_language(audio_path):
    with open(audio_path, 'rb') as f:
        # Use translations endpoint to get verbose JSON with language detection
        result = client.audio.transcriptions.create(
            model='whisper-1',
            file=f,
            response_format='verbose_json'
        )
    return {
        'detected_language': result.language,
        'text': result.text
    }

result = detect_language('user_audio.wav')
print(f"Language: {result['detected_language']}")
print(f"Text: {result['text'][:100]}")

# Deepgram: set language='auto' in options
from deepgram import PrerecordedOptions
options = PrerecordedOptions(model='nova-2', language='auto', detect_language=True)

Lange Audiodateien in Chunks aufteilen

Die 25-MB-Grenze von Whisper bedeutet, dass lange Aufnahmen (z. B. einstündige Besprechungen) in Chunks aufgeteilt werden müssen. Teilen Sie Audio anhand von Stille mit pydub auf, transkribieren Sie dann jeden Chunk und fügen Sie die Ergebnisse zusammen.

Installieren Sie es mit pip install pydub. ffmpeg ist erforderlich.

from pydub import AudioSegment
from pydub.silence import split_on_silence
import io

def transcribe_long_audio(audio_path, chunk_length_ms=60000):
    audio = AudioSegment.from_file(audio_path)

    # Split on silence
    chunks = split_on_silence(
        audio,
        min_silence_len=1000,   # 1 second of silence
        silence_thresh=-40,     # dBFS
        keep_silence=500        # keep 500ms at each end
    )

    # If no silence splitting worked, use fixed-length chunks
    if len(chunks) <= 1:
        chunks = [
            audio[i:i + chunk_length_ms]
            for i in range(0, len(audio), chunk_length_ms)
        ]

    full_transcript = []
    for i, chunk in enumerate(chunks):
        print(f'Transcribing chunk {i+1}/{len(chunks)}')
        buf = io.BytesIO()
        chunk.export(buf, format='mp3')
        buf.seek(0)
        buf.name = f'chunk_{i}.mp3'
        result = client.audio.transcriptions.create(model='whisper-1', file=buf)
        full_transcript.append(result.text)

    return ' '.join(full_transcript)

Deepgram-Live-Streaming

Verwenden Sie für Sprachgespräche in Echtzeit die WebSocket-Live-Streaming-API von Deepgram. Audio-Chunks werden während der Aufnahme gesendet; Zwischen- und finale Transkripte treffen innerhalb von Millisekunden ein.

import asyncio
import os
from deepgram import DeepgramClient, LiveTranscriptionEvents, LiveOptions

async def live_transcribe(on_transcript_callback):
    dg_client = DeepgramClient(os.getenv('DEEPGRAM_API_KEY'))

    connection = dg_client.listen.asynclive.v('1')

    async def on_message(self, result, **kwargs):
        sentence = result.channel.alternatives[0].transcript
        is_final = result.is_final
        if sentence:
            await on_transcript_callback(sentence, is_final)

    connection.on(LiveTranscriptionEvents.Transcript, on_message)

    options = LiveOptions(
        model='nova-2',
        language='en',
        smart_format=True,
        interim_results=True,  # get partial results before sentence ends
        endpointing=500        # ms of silence before finalizing
    )

    await connection.start(options)
    return connection  # caller sends audio chunks via connection.send(audio_chunk)

Fehlerbehandlung und Wiederholungsversuche

APIs zur Audiotranskription können aufgrund von Netzwerkproblemen, nicht unterstützten Formaten oder Rate Limits fehlschlagen. Implementieren Sie Wiederholungsversuche mit exponentiellem Backoff und überprüfen Sie Audiodaten, bevor Sie sie senden.

import time
import os

MAX_FILE_SIZE_BYTES = 25 * 1024 * 1024  # 25MB
SUPPORTED_FORMATS = ('.mp3', '.mp4', '.wav', '.webm', '.m4a', '.flac', '.ogg')

def validate_audio_file(audio_path):
    if not os.path.exists(audio_path):
        raise FileNotFoundError(f'Audio file not found: {audio_path}')
    size = os.path.getsize(audio_path)
    if size > MAX_FILE_SIZE_BYTES:
        raise ValueError(f'File too large: {size / 1024 / 1024:.1f}MB (max 25MB)')
    ext = os.path.splitext(audio_path)[1].lower()
    if ext not in SUPPORTED_FORMATS:
        raise ValueError(f'Unsupported format: {ext}. Supported: {SUPPORTED_FORMATS}')

def transcribe_with_retry(audio_path, max_retries=3):
    validate_audio_file(audio_path)
    for attempt in range(max_retries):
        try:
            return transcribe_file(audio_path)
        except Exception as e:
            if attempt < max_retries - 1:
                wait = 2 ** attempt
                print(f'Retry {attempt + 1} after error: {e}. Waiting {wait}s')
                time.sleep(wait)
            else:
                raise

Whisper oder Deepgram auswählen

Beide Tools eignen sich besonders für unterschiedliche Szenarien. Verwenden Sie diese Entscheidungsmatrix, um die passende Lösung für Ihren Sprachagenten auszuwählen.

COMPARISON = '''
Whisper (OpenAI API):
  - Best for: batch transcription, podcast processing, meeting notes
  - Latency: file upload latency + ~1-5 seconds processing
  - Strengths: excellent multilingual, high accuracy, cheap
  - Word timestamps: yes (verbose_json)
  - Diarization: NO (must use separate tool)
  - Use when: accuracy > speed, offline processing

DeeGram:
  - Best for: real-time voice agents, call center transcription
  - Latency: <300ms for streaming, ~1s for file upload
  - Strengths: streaming, diarization, custom vocabulary
  - Word timestamps: yes, with confidence scores
  - Diarization: YES (built-in, up to 10 speakers)
  - Use when: speed > accuracy, real-time required

Rule of thumb:
  Agent voice conversation -> Deepgram live streaming
  Batch audio files -> Whisper API
  Meeting transcripts with speakers -> Deepgram with diarize=True
'''
print(COMPARISON)

Konvertierung von Audioformaten

Whisper und Deepgram unterstützen gängige Audioformate, aber Benutzeraudio kann in ungewöhnlichen Formaten eintreffen (ogg, opus, webm aus Browsern, m4a von iOS). Konvertieren Sie es vor dem Senden an die API in standardmäßiges WAV oder MP3.

from pydub import AudioSegment
import os

SUPPORTED_FORMATS = {'.mp3', '.wav', '.flac', '.m4a', '.ogg', '.webm', '.opus'}

def convert_to_wav(input_path, output_path=None):
    ext = os.path.splitext(input_path)[1].lower()
    if ext not in SUPPORTED_FORMATS:
        raise ValueError(f'Unsupported audio format: {ext}')

    if output_path is None:
        output_path = input_path.rsplit('.', 1)[0] + '.wav'

    # pydub handles format detection automatically
    audio = AudioSegment.from_file(input_path)

    # Normalize to 16kHz mono (optimal for Whisper)
    audio = audio.set_frame_rate(16000).set_channels(1)

    audio.export(output_path, format='wav')
    print(f'Converted {input_path} -> {output_path} ({len(audio) / 1000:.1f}s)')
    return output_path

def ensure_compatible_audio(audio_path):
    ext = os.path.splitext(audio_path)[1].lower()
    if ext in {'.mp3', '.wav', '.m4a', '.flac'}:
        return audio_path  # already compatible
    return convert_to_wav(audio_path)

Wissensüberprüfung

Was versteht man im Kontext der Speech-to-Text-Transkription unter Sprecherdiarisierung?

Zusammenfassung: Speech-to-Text mit Whisper und Deepgram

Whisper (OpenAI API) eignet sich ideal für die Batch-Transkription: hohe Genauigkeit, Mehrsprachigkeit und Wort-Zeitstempel über verbose_json. Verwenden Sie es für dateibasierte Verarbeitung, bei der die Latenz nicht kritisch ist.

Deepgram ist für Echtzeit-Streaming ausgelegt: Live-WebSocket-Transkription mit Zwischenergebnissen, integrierter Sprecherdiarisierung und einer Latenz von unter 300 ms. Verwenden Sie es für interaktive Sprachagenten. Beide unterstützen die Spracherkennung und benötigen in Produktionsumgebungen eine Wiederholungslogik sowie eine Dateivalidierung.

Häufig gestellte Fragen

Ist die Lektion „Speech-to-Text mit Whisper und Deepgram“ kostenlos?

Ja — der vollständige Text von „Speech-to-Text mit Whisper und Deepgram“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des AI Agents-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der AI Agents-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Speech-to-Text mit Whisper und Deepgram“?

Echtzeit- und Batch-Transkription, Spracherkennung und Zeichensetzung. Du übst AI Agents mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um AI Agents zu starten?

Keine Vorkenntnisse erforderlich. AI Agents auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.

Wie lange dauert die Lektion „Speech-to-Text mit Whisper und Deepgram“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser AI Agents-Lektion Code schreiben und ausführen?

Ja. Jede AI Agents-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Speech-to-Text mit Whisper und Deepgram
  2. Text-to-Speech in Agentenantworten
  3. Eine Sprachkonversationsschleife erstellen
  4. Latenzoptimierung für Sprachagenten
← Zurück zu AI Agents