Einen sprechenden Voice-Agent selbst bauen: Whisper + LLM + TTS in der Praxis

Artikel-Übersicht

In diesem Leitfaden bauen wir gemeinsam einen Voice-Agent, mit dem du dich tatsächlich unterhalten kannst – er hört zu, denkt nach und antwortet mit einer Stimme. Wir starten mit der großen Linie: Aus welchen sechs Bausteinen besteht so eine Pipeline überhaupt, und wie greifen sie ineinander? Danach gehen wir jeden Baustein einzeln durch. Du erfährst, wie du Mikrofon-Audio in Python einfängst, warum eine Voice Activity Detection (VAD) der heimliche Held jedes Sprachsystems ist und wie du mit Whisper bzw. dem schnelleren faster-whisper aus Audio sauberen Text machst. Wir wägen ehrlich ab, wann sich lokale Modelle lohnen und wann die Cloud die bessere Wahl ist – mit einem klaren Blick auf den Datenschutz. Anschließend kümmern wir uns um das LLM als „Gehirn" und um die Stimme: Wir vergleichen TTS-Engines von Piper über Kokoro und XTTS bis zu ElevenLabs und OpenAI. Ein eigener Abschnitt widmet sich dem Thema, das über Erfolg oder Frust entscheidet – Latenz, Streaming und Barge-in. Dann folgt das Herzstück: ein vollständiges, lauffähiges Python-Beispiel, das alle Teile verbindet. Zum Schluss schauen wir auf die modernen Speech-to-Speech-Ansätze von 2026 und sammeln die typischen Stolperfallen ein, besonders rund um die deutsche Sprache.

Einleitung: Warum einen eigenen Voice-Agent bauen?

Stell dir vor, du redest mit deinem Computer wie mit einem Kollegen – und er antwortet dir mit einer natürlichen Stimme, ohne dass deine Worte je das Haus verlassen. Genau das ist heute keine Science-Fiction mehr, sondern ein Wochenend-Projekt. Die Bausteine sind reif, quelloffen und erstaunlich gut: Spracherkennung auf menschlichem Niveau, Sprachmodelle, die wirklich verstehen, was du meinst, und Sprachsynthese, die kaum noch von echten Stimmen zu unterscheiden ist.

Warum solltest du das selbst bauen, wenn es fertige Assistenten gibt? Aus drei Gründen. Erstens Kontrolle: Du entscheidest, welches LLM antwortet, welche Tools es nutzen darf und wie der Agent klingt. Zweitens Datenschutz: Eine vollständig lokale Pipeline schickt kein einziges Audio-Byte in eine fremde Cloud – Gold wert für sensible Anwendungen in Kanzleien, Praxen oder Behörden. Drittens Verständnis: Wer die Pipeline einmal selbst zusammengesteckt hat, versteht plötzlich, warum Alexa manchmal mitten im Satz dazwischenredet und warum dein Agent eine Gedenksekunde braucht.

Ich verspreche dir: Wenn du diesen Artikel durchgearbeitet hast, hast du nicht nur einen funktionierenden Voice-Agent, sondern auch ein mentales Modell davon, an welcher Schraube du drehen musst, wenn etwas hakt. Legen wir los.

Die Pipeline im Überblick: Sechs Bausteine

Ein sprechender Voice-Agent ist im Kern eine Kette von sechs Stationen. Audio wandert von links nach rechts hindurch und kommt am Ende als gesprochene Antwort wieder heraus:

??? Mikrofon  ?  VAD  ?  Speech-to-Text  ?  LLM  ?  Text-to-Speech  ?  ?? Lautsprecher
  (Audio)    (Sprache?)   (Whisper)     (Antwort)    (Stimme)        (Audio)

Eine gute Analogie ist ein Dolmetscher-Team bei einer Konferenz. Das Mikrofon ist das Ohr. Die VAD ist die Person, die merkt: „Jetzt redet jemand, jetzt nicht mehr." Die Spracherkennung schreibt mit, was gesagt wurde. Das LLM ist der Experte, der die Frage beantwortet. Die Sprachsynthese spricht die Antwort aus. Und der Lautsprecher ist der Mund.

Das Entscheidende: Jede Station kostet Zeit, und die Zeiten addieren sich. Genau deshalb dreht sich später so viel um Streaming und Parallelisierung – wir wollen nicht warten, bis Station 3 komplett fertig ist, bevor Station 4 überhaupt anfängt. Doch zuerst verstehen wir jeden Baustein einzeln.

Schritt 1: Mikrofon-Audio einfangen

Alles beginnt mit rohem Audio. In Python ist sounddevice die angenehmste Bibliothek dafür – sie liefert dir die Mikrofon-Daten direkt als NumPy-Array. Whisper und die meisten VAD-Modelle erwarten 16 kHz Mono-PCM als Format, das merken wir uns als magische Zahl.

pip install sounddevice numpy

import sounddevice as sd
import numpy as np

SAMPLE_RATE = 16000  # 16 kHz – Standard für Whisper & VAD
BLOCK_SIZE = 512     # Anzahl Samples pro Audio-Block (~32 ms bei 16 kHz)

def audio_callback(indata, frames, time_info, status):
    # indata ist ein float32-Array mit Werten zwischen -1.0 und 1.0
    if status:
        print("Audio-Status:", status)
    # Hier würden wir den Block an die VAD weiterreichen
    lautstaerke = np.abs(indata).mean()
    print(f"Pegel: {lautstaerke:.4f}")

with sd.InputStream(samplerate=SAMPLE_RATE, channels=1,
                    blocksize=BLOCK_SIZE, dtype="float32",
                    callback=audio_callback):
    print("Höre zu … (Strg+C zum Beenden)")
    sd.sleep(10_000)  # 10 Sekunden lauschen

Wichtig ist das Konzept der Blöcke (auch „Chunks" oder „Frames"). Das Mikrofon liefert keinen kontinuierlichen Strom, sondern kleine Häppchen von z. B. 32 Millisekunden. Diese Häppchen sind die Währung, in der die ganze Pipeline rechnet – sie sind klein genug für niedrige Latenz und groß genug, dass die VAD etwas damit anfangen kann.

Schritt 2: Voice Activity Detection (VAD) – wann reden wir eigentlich?

Hier kommt der unterschätzte Star. Eine Voice Activity Detection beantwortet eine simple, aber folgenreiche Frage: Enthält dieser Audio-Block menschliche Sprache – oder nur Stille, Tastaturklappern und das Brummen der Klimaanlage?

Ohne VAD müsstest du Whisper auf den kompletten Audiostrom loslassen, also auch auf jede Sekunde Schweigen. Das ist teuer, langsam und produziert Halluzinationen (Whisper „erfindet" bei Stille gern Untertitel wie „Vielen Dank fürs Zuschauen"). Die VAD schneidet sauber heraus, wann gesprochen wird, und gibt nur diese Segmente an die Spracherkennung weiter.

Es gibt drei gängige Optionen, die 2026 den Markt dominieren:

VAD-Engine	Typ	Stärke	Schwäche
webrtcvad	klassisch (Google)	extrem schnell, winzig	ungenau bei Hintergrundgeräuschen
Silero VAD	Deep Learning (PyTorch)	sehr genau, läuft auf CPU	minimal mehr Overhead
Cobra (Picovoice)	Deep Learning, kommerziell	produktionsreif, robust	Lizenz/Account nötig

Für die allermeisten Projekte ist Silero VAD 2026 die richtige Wahl: Es ist quelloffen, deutlich genauer als das alte webrtcvad und so sparsam, dass es auf einer CPU im Hintergrund kaum auffällt (ein RTF von rund 0,004 – es braucht also nur etwa 0,4 % der Rechenzeit, um Audio in Echtzeit zu prüfen).

pip install silero-vad torch

import torch
from silero_vad import load_silero_vad

model = load_silero_vad()  # lädt das kleine ONNX/PyTorch-Modell

def ist_sprache(audio_block: np.ndarray, schwelle: float = 0.5) -> bool:
    tensor = torch.from_numpy(audio_block.flatten())
    wahrscheinlichkeit = model(tensor, SAMPLE_RATE).item()
    return wahrscheinlichkeit >= schwelle

Die VAD ist außerdem der Schlüssel zum sogenannten Endpointing – also dem Erkennen, dass der Nutzer mit dem Sprechen fertig ist. Die übliche Heuristik: Sobald nach erkannter Sprache eine kurze Stille von z. B. 500–800 ms folgt, gilt die Äußerung als abgeschlossen, und wir schicken sie an Whisper. Stell diese Pause zu kurz ein, fällt der Agent dir ins Wort, sobald du Luft holst. Stell sie zu lang ein, fühlt sich das Gespräch träge an. Dieser eine Parameter prägt das gefühlte Tempo enorm.

Schritt 3: Speech-to-Text mit Whisper und faster-whisper

Jetzt verwandeln wir Audio in Text. Der De-facto-Standard heißt nach wie vor Whisper von OpenAI – ein quelloffenes Spracherkennungsmodell, das in über 90 Sprachen transkribiert und Deutsch hervorragend beherrscht.

Die reine OpenAI-Referenzimplementierung ist allerdings nicht die schnellste. In der Praxis greift man 2026 fast immer zu faster-whisper, einer Reimplementierung auf Basis von CTranslate2. Sie ist bei identischer Genauigkeit um ein Vielfaches schneller und sparsamer im Speicher. Auf einer NVIDIA-GPU erreicht faster-whisper mit dem large-v3-Modell rund das 12-fache der Echtzeitgeschwindigkeit.

Bei den Modellgrößen lohnt sich ein genauer Blick, denn hier entscheidet sich der Kompromiss aus Genauigkeit, Tempo und Speicher:

Modell	Parameter	Genauigkeit (DE)	Tempo	Wann?
`tiny` / `base`	39–74 M	mäßig	sehr schnell	Tests, schwache Hardware
`small`	244 M	gut	schnell	Raspberry-Pi-Klasse
`medium`	769 M	sehr gut	mittel	guter Allrounder
`large-v3`	1,5 Mrd.	exzellent	langsamer	maximale Qualität
`large-v3-turbo`	809 M	nahe large-v3	~4–6× schneller	Empfehlung 2026
`distil-large-v3`	destilliert	sehr gut	sehr schnell	Streaming, niedrige Latenz

Der heimliche Gewinner ist large-v3-turbo: OpenAI hat dafür die Decoder-Schichten von 32 auf 4 reduziert, wodurch das Modell rund 6× schneller läuft als large-v3 und dabei bis auf 1–2 % an dessen Genauigkeit herankommt. Für die meisten Voice-Agents ist es der beste Startpunkt – es passt mit 8 GB RAM/VRAM bequem auf normale Hardware.

pip install faster-whisper

from faster_whisper import WhisperModel

# Lokal: läuft auf GPU ("cuda") oder CPU ("cpu")
# compute_type="int8" spart Speicher, "float16" ist genauer auf GPU
whisper = WhisperModel("large-v3-turbo", device="cuda", compute_type="float16")

def transkribiere(audio: np.ndarray) -> str:
    segmente, info = whisper.transcribe(
        audio,
        language="de",              # erzwingt Deutsch – verhindert Sprachwechsel!
        vad_filter=True,            # zusätzlicher VAD-Schutz gegen Halluzinationen
        beam_size=5,
    )
    return " ".join(seg.text for seg in segmente).strip()

Ein wichtiger Praxis-Tipp steckt schon im Code: Setze language="de" explizit. Whisper erkennt die Sprache zwar automatisch, liegt bei kurzen oder denglischen Äußerungen aber gern daneben und wechselt mitten im Satz ins Englische. Mehr dazu in den Stolperfallen.

Lokal oder Cloud? Die Datenschutz-Abwägung

Whisper kannst du lokal laufen lassen – oder du nutzt eine Cloud-API. Beide Wege haben ihre Berechtigung, und die Entscheidung ist nicht nur eine Frage des Geschmacks, sondern oft eine rechtliche.

Lokal bedeutet: Das Audio verlässt deinen Rechner nie. Für die DSGVO ist das der einfachste Fall – ohne Drittland-Datenübermittlung, ohne Auftragsverarbeitungsvertrag, ohne dass du dir Sorgen über den US Cloud Act machen musst. Der Preis ist Hardware: Für flüssige Latenz mit large-v3-turbo willst du eine GPU. Auf reiner CPU geht es auch, wird aber spürbar langsamer.

Cloud bedeutet: Du schickst das Audio an einen Dienst. OpenAI bietet dafür neben Whisper auch die schnelleren gpt-4o-transcribe-Modelle und seit 2026 ein dediziertes Streaming-Transkriptionsmodell (gpt-realtime-whisper) für besonders niedrige Latenz. Anbieter wie Deepgram oder Groq (das large-v3-turbo mit über 200× Echtzeit serviert) sind ebenfalls beliebt. Der Vorteil: keine eigene Hardware, top Tempo, immer aktuell. Der Nachteil: Datenschutz. Sobald personenbezogene oder vertrauliche Audiodaten das Haus verlassen, brauchst du eine saubere Rechtsgrundlage.

Kriterium	Lokal (faster-whisper)	Cloud (OpenAI, Deepgram, Groq …)
Datenschutz	? maximal, alles bleibt lokal	?? Drittland, AVV nötig
Latenz	abhängig von GPU	sehr niedrig, optimiert
Kosten	einmalig Hardware	pro Minute (z. B. ~0,006 $/min)
Wartung	du selbst	Anbieter
Offline-fähig	? ja	? nein

Meine Faustregel: Geht es um sensible Daten oder soll der Agent offline funktionieren, baust du lokal. Geht es um maximale Geschwindigkeit bei unkritischen Inhalten und du willst keine Hardware betreiben, ist die Cloud bequem. Übrigens gilt dieselbe Abwägung gleich dreimal – für STT, für das LLM und für die TTS.

Schritt 4: Das LLM – die Antwort generieren

Jetzt liegt der erkannte Text vor, und das „Gehirn" übernimmt. Hier kannst du jedes LLM einsetzen, das du magst: lokal über Ollama (z. B. ein Llama- oder Qwen-Modell), oder per API. Wenn du ohnehin schon Wert auf Datenschutz legst und STT lokal fährst, ist ein lokales LLM via Ollama der konsequente nächste Schritt.

Für einen Voice-Agent ist eine Sache besonders wichtig: Streaming. Das LLM soll seine Antwort nicht erst komplett fertig schreiben, bevor wir mit dem Vorlesen beginnen, sondern Token für Token liefern. So können wir den ersten Satz schon synthetisieren, während das Modell noch am zweiten arbeitet. Das halbiert gefühlt die Wartezeit.

import ollama  # pip install ollama

SYSTEM_PROMPT = (
    "Du bist ein freundlicher Sprachassistent. Antworte kurz, "
    "natürlich und auf Deutsch. Vermeide Aufzählungen und Sonderzeichen, "
    "denn deine Antwort wird vorgelesen."
)

def llm_antwort_stream(verlauf: list[dict]):
    """Liefert die Antwort des LLMs satzweise als Generator."""
    puffer = ""
    stream = ollama.chat(model="qwen3", messages=verlauf, stream=True)
    for chunk in stream:
        puffer += chunk["message"]["content"]
        # Sobald ein Satzende erreicht ist, geben wir den Satz zur TTS frei
        while any(p in puffer for p in ".!?"):
            for p in ".!?":
                if p in puffer:
                    satz, _, puffer = puffer.partition(p)
                    yield (satz + p).strip()
                    break
    if puffer.strip():
        yield puffer.strip()

Beachte den System-Prompt: Wir bitten das Modell ausdrücklich, vorlesbar zu antworten – kurze Sätze, keine Bullet-Points, keine Markdown-Sternchen. Nichts klingt absurder als ein Agent, der „Sternchen Sternchen wichtig Sternchen Sternchen" vorliest. Dieser kleine Hinweis erspart dir viel Frust.

Schritt 5: Text-to-Speech – dem Agenten eine Stimme geben

Der letzte inhaltliche Baustein verwandelt Text wieder in Klang. Die TTS-Landschaft 2026 ist üppig, und die Wahl hängt von drei Fragen ab: Wie natürlich? Wie schnell? Lokal oder Cloud?

Engine	Typ	Stärke	Deutsch
Piper	lokal, VITS/ONNX	winzig, läuft auf dem Raspberry Pi	? (z. B. Thorsten-Stimme)
Kokoro (82 M)	lokal	top Qualität pro Größe, Apache-2.0	?? via Community-ONNX-Modell
XTTS v2 (Coqui)	lokal	Voice-Cloning, 17 Sprachen	? nativ
Chatterbox	lokal, MIT	gewinnt Blindtests vs. ElevenLabs	(primär EN)
ElevenLabs	Cloud	sehr ausdrucksstark, 74 Sprachen	? exzellent
OpenAI (`gpt-4o-mini-tts`)	Cloud	günstig, steuerbar	? gut

Ein paar Worte zur Einordnung. Piper ist der Spatz in der Hand: ressourcenschonend, offline, blitzschnell – ideal, wenn du auf schwacher Hardware oder einem Raspberry Pi baust und mit einer soliden, etwas „synthetischen" Stimme leben kannst. Kokoro ist mit nur 82 Millionen Parametern erstaunlich gut und Apache-lizenziert; offiziell unterstützt es Deutsch zwar (noch) nicht, aber die Community stellt feinabgestimmte deutsche ONNX-Modelle bereit. XTTS v2 glänzt mit Voice-Cloning: Aus wenigen Sekunden Referenz-Audio erzeugt es eine erstaunlich treue Stimme in 17 Sprachen, Deutsch inklusive.

Auf der Cloud-Seite ist ElevenLabs (mit dem 2026 erschienenen Modell „Eleven v3", inklusive Audio-Tags und Mehrsprecher-Dialogen) der Maßstab für Ausdruck und erreicht mit „Flash v2.5" Latenzen um 75 ms. OpenAI kontert mit gpt-4o-mini-tts – günstig (rund 0,015 $/min), in 13 Stimmen und sogar per Anweisung steuerbar (du kannst sagen „sprich fröhlich und langsam").

Hier ein lokales Beispiel mit Piper und eines mit der OpenAI-Cloud:

# Variante A: lokal mit Piper (deutsche Thorsten-Stimme)
# pip install piper-tts  +  Modell-Download (.onnx) von huggingface
import subprocess, sounddevice as sd, numpy as np

def sprich_piper(text: str):
    proc = subprocess.run(
        ["piper", "--model", "de_DE-thorsten-medium.onnx", "--output_raw"],
        input=text.encode("utf-8"), capture_output=True,
    )
    audio = np.frombuffer(proc.stdout, dtype=np.int16)
    sd.play(audio, samplerate=22050)
    sd.wait()

# Variante B: Cloud mit OpenAI (gpt-4o-mini-tts), gestreamt
from openai import OpenAI
client = OpenAI()

def sprich_openai(text: str):
    with client.audio.speech.with_streaming_response.create(
        model="gpt-4o-mini-tts", voice="alloy",
        input=text, response_format="pcm",
        instructions="Sprich freundlich und natürlich auf Deutsch.",
    ) as antwort:
        for chunk in antwort.iter_bytes(4096):
            audio = np.frombuffer(chunk, dtype=np.int16)
            sd.play(audio, samplerate=24000)
            sd.wait()

Latenz und Echtzeit: Streaming, Barge-in und das gefühlte Tempo

Jetzt zum Thema, das über „Wow" oder „nervig" entscheidet. Die wichtigste Kennzahl ist die Time-to-first-audio: Wie lange dauert es vom Ende deiner Frage bis zum ersten gesprochenen Wort des Agenten? Liegt das unter ~800 ms, fühlt sich das Gespräch natürlich an. Über zwei Sekunden, und du hast das Gefühl, mit einer Behörde zu telefonieren.

Drei Techniken drücken die Latenz:

Streaming auf allen Ebenen. Wir warten nicht, bis das LLM fertig ist, sondern schicken den ersten fertigen Satz sofort an die TTS. Während Satz 1 vorgelesen wird, generiert das LLM Satz 2. Die Pipeline arbeitet wie ein Fließband, nicht wie eine Stafette mit Pausen.
Endpointing fein justieren. Die schon erwähnte Stille-Schwelle der VAD ist dein wichtigster Tuning-Regler. 500–700 ms sind ein guter Startwert für Deutsch.
Barge-in (Unterbrechen). In einem echten Gespräch fällst du dem anderen ins Wort, wenn er Unsinn redet. Ein guter Voice-Agent erlaubt das auch: Erkennt die VAD Sprache, während der Agent spricht, stoppt die Audio-Ausgabe sofort und das System hört wieder zu.

Barge-in hat eine fiese Tücke: das Echo-Problem. Wenn der Agent über den Lautsprecher spricht, hört das Mikrofon ihn ebenfalls – und die VAD denkt, du würdest reden, und unterbricht sich selbst. Die Lösung heißt Acoustic Echo Cancellation (AEC). Am sichersten arbeitest du mit Kopfhörern (dann gibt es kein Echo). Für Lautsprecher-Betrieb brauchst du AEC, idealerweise hardware- oder browserseitig (WebRTC), sodass nur sauberes, echobefreites Audio bei der VAD ankommt.

Das vollständige Python-Beispiel: alle Bausteine verbunden

Genug Theorie – hier ist eine lauffähige, lokale Pipeline, die alles verbindet: Mikrofon ? Silero VAD ? faster-whisper ? LLM (Ollama) ? Piper-TTS. Sie ist bewusst kompakt gehalten und gut kommentiert, damit du die Logik nachvollziehen kannst.

pip install sounddevice numpy silero-vad torch faster-whisper ollama piper-tts

import queue
import numpy as np
import sounddevice as sd
import torch
from silero_vad import load_silero_vad
from faster_whisper import WhisperModel
import ollama, subprocess

SAMPLE_RATE = 16000
BLOCK = 512                       # ~32 ms pro Block
STILLE_BLOECKE = 22              # ~700 ms Stille = Äußerung beendet

# --- Modelle laden ---
vad = load_silero_vad()
whisper = WhisperModel("large-v3-turbo", device="cuda", compute_type="float16")
verlauf = [{"role": "system", "content":
            "Du bist ein freundlicher deutscher Sprachassistent. "
            "Antworte kurz, natürlich und ohne Sonderzeichen oder Listen."}]

audio_q: queue.Queue = queue.Queue()

def callback(indata, frames, t, status):
    audio_q.put(indata.copy())

def aufnehmen() -> np.ndarray:
    """Sammelt Audio, bis nach erkannter Sprache eine Pause folgt."""
    puffer, gesprochen, stille = [], False, 0
    while True:
        block = audio_q.get().flatten()
        wahrsch = vad(torch.from_numpy(block), SAMPLE_RATE).item()
        if wahrsch >= 0.5:
            gesprochen, stille = True, 0
            puffer.append(block)
        elif gesprochen:
            stille += 1
            puffer.append(block)
            if stille >= STILLE_BLOECKE:
                break
    return np.concatenate(puffer)

def transkribieren(audio: np.ndarray) -> str:
    segs, _ = whisper.transcribe(audio, language="de", vad_filter=True)
    return " ".join(s.text for s in segs).strip()

def llm_saetze(text: str):
    verlauf.append({"role": "user", "content": text})
    antwort, puffer = "", ""
    for chunk in ollama.chat(model="qwen3", messages=verlauf, stream=True):
        puffer += chunk["message"]["content"]
        antwort += chunk["message"]["content"]
        while any(p in puffer for p in ".!?"):
            for p in ".!?":
                if p in puffer:
                    satz, _, puffer = puffer.partition(p)
                    yield (satz + p).strip()
                    break
    if puffer.strip():
        yield puffer.strip()
    verlauf.append({"role": "assistant", "content": antwort})

def sprich(text: str):
    proc = subprocess.run(
        ["piper", "--model", "de_DE-thorsten-medium.onnx", "--output_raw"],
        input=text.encode("utf-8"), capture_output=True)
    audio = np.frombuffer(proc.stdout, dtype=np.int16)
    sd.play(audio, samplerate=22050); sd.wait()

def main():
    with sd.InputStream(samplerate=SAMPLE_RATE, channels=1,
                        blocksize=BLOCK, dtype="float32", callback=callback):
        print("???  Sprich los … (Strg+C beendet)")
        while True:
            audio = aufnehmen()
            frage = transkribieren(audio)
            if not frage:
                continue
            print(f"?? Du: {frage}")
            print("?? Agent: ", end="", flush=True)
            for satz in llm_saetze(frage):   # Streaming Satz für Satz
                print(satz, end=" ", flush=True)
                sprich(satz)
            print()

if __name__ == "__main__":
    main()

Das ist ein vollständiger, lokaler Voice-Agent in unter 90 Zeilen. Willst du Datenschutz gegen Tempo tauschen, ersetzt du einfach einzelne Funktionen: transkribieren durch einen OpenAI-/Deepgram-Aufruf, sprich durch die ElevenLabs- oder OpenAI-TTS – die Architektur bleibt identisch. Genau das ist die Stärke der modularen Pipeline.

Wer es noch komfortabler mag, schaut sich die Bibliotheken RealtimeSTT und RealtimeTTS von KoljaB an. Sie kapseln VAD, Wake-Word-Erkennung (per Porcupine oder OpenWakeWord), Streaming-Transkription und Multi-Engine-TTS sauber weg. Das zugehörige Projekt RealtimeVoiceChat zeigt die komplette Schleife produktionsnah – ein hervorragender Startpunkt, wenn du nicht jedes Detail selbst verdrahten willst.

Der moderne Weg 2026: Speech-to-Speech-APIs

Unsere Pipeline hat sechs Stationen – und jeder Übergang kostet Zeit und Information. Tonfall, Betonung, Emotion gehen beim Schritt „Audio ? Text" verloren; der Agent weiß nicht, ob du genervt oder begeistert klangst. Genau hier setzt der moderne Speech-to-Speech-Ansatz an.

Modelle wie OpenAIs Realtime API (2026 mit gpt-realtime bzw. gpt-realtime-2, auf GPT-5-Klasse-Reasoning aufgebaut) verarbeiten Audio direkt zu Audio – ohne den Umweg über getrennte STT- und TTS-Schritte. Das Modell hört dich, „denkt" und antwortet in einem einzigen, durchgehenden Strom. Vorteile: dramatisch niedrigere Latenz (rund 200–300 ms), erhaltene Prosodie und natürliches, unterbrechbares Gesprächsverhalten samt eingebautem Barge-in und Tool-Calling. OpenAI hat 2026 zusätzlich gpt-realtime-translate (Live-Übersetzung, 70+ Eingabesprachen) und das erwähnte gpt-realtime-whisper für reine Transkription nachgelegt. Auf dem „Big Bench Audio"-Reasoning-Test erreicht gpt-realtime 82,8 % – ein riesiger Sprung gegenüber dem Vorgängermodell von Ende 2024 (65,6 %).

Wann nimmst du was?

Speech-to-Speech (Realtime API): wenn du maximale Natürlichkeit und niedrigste Latenz willst und Cloud-Nutzung in Ordnung ist. Du gibst dafür Kontrolle und lokale Ausführung auf.
Klassische Pipeline (unser Ansatz): wenn du Datenschutz, Offline-Betrieb, freie Modellwahl (eigenes lokales LLM, RAG, Tools) oder volle Transparenz über jeden Schritt brauchst.

Beide Welten verschmelzen zunehmend – aber die modulare Pipeline bleibt der flexible Allrounder, gerade im datensensiblen deutschen Umfeld.

Typische Stolperfallen – besonders auf Deutsch

Zum Schluss die Fallen, in die fast jeder einmal tappt. Wer sie kennt, spart sich Stunden.

Sprachwechsel mitten im Satz. Whisper erkennt Sprache automatisch und springt bei kurzen oder denglischen Sätzen gern ins Englische. Setze immer language="de" explizit. Das ist der häufigste Deutsch-Fehler überhaupt.
Halluzinationen bei Stille. Lässt du Whisper auf Schweigen los, „erfindet" es Untertitel-Floskeln. Vorgeschaltete VAD plus vad_filter=True lösen das zuverlässig.
Endpointing zu aggressiv. Im Deutschen gibt es längere Pausen (Komposita, nachdenkliches „ähm"). Eine zu kurze Stille-Schwelle schneidet dir das Wort ab. Starte bei ~700 ms und taste dich heran.
Zahlen, Abkürzungen und Umlaute in der TTS. Manche Engines lesen „z. B." als „z Punkt b Punkt" oder verschlucken Umlaute. Normalisiere kritischen Text vorab (ausschreiben statt abkürzen) und teste deutsche Stimmen explizit.
Markdown im LLM-Output. Sternchen, Bindestriche und Aufzählungen klingen vorgelesen schrecklich. Weise das LLM per System-Prompt an, in Fließtext zu antworten.
Echo ohne AEC. Im Lautsprecher-Betrieb hört sich der Agent selbst und unterbricht sich. Kopfhörer oder Acoustic Echo Cancellation sind Pflicht für Barge-in.
Audioformat-Mismatch. 16 kHz für STT/VAD, aber oft 22–24 kHz für die TTS-Ausgabe. Verwechselst du die Sampleraten, klingt die Stimme zu hoch oder zu tief – ein Klassiker.
Latenz-Falle „erst fertig, dann sprechen". Wer nicht streamt, wartet auf die komplette LLM-Antwort, bevor das erste Wort fällt. Immer satzweise pipen.

Zusammenfassung und praktische Tipps

Ein sprechender Voice-Agent ist 2026 absolut machbar – und du hast jetzt das komplette Bauplan-Wissen dafür. Die Kette aus Mikrofon, VAD, Speech-to-Text, LLM, Text-to-Speech und Lautsprecher ist modular: Jeden Baustein kannst du lokal oder cloud-basiert betreiben und nach Bedarf austauschen, ohne das Ganze umzuwerfen.

Die wichtigsten Mitnahmen:

Starte modular und lokal. Silero VAD + faster-whisper (large-v3-turbo) + ein lokales LLM via Ollama + Piper ergeben eine vollständig private, offline-fähige Pipeline.
Setze language="de" und einen vorlese-freundlichen System-Prompt – das löst zwei der häufigsten Deutsch-Probleme auf einen Schlag.
Streame alles. Satzweises Pipen vom LLM zur TTS ist der größte Hebel für gefühlte Geschwindigkeit.
Justiere das Endpointing (Stille-Schwelle der VAD) als wichtigsten Tuning-Regler; ~700 ms sind ein guter Start für Deutsch.
Denke an Barge-in und AEC, sobald du über Lautsprecher statt Kopfhörer arbeitest.
Wäge Datenschutz bewusst ab. Für sensible Inhalte: lokal. Für maximales Tempo bei unkritischen Daten: Cloud – dann aber mit sauberer Rechtsgrundlage.
Behalte Speech-to-Speech im Blick. Für höchste Natürlichkeit ist OpenAIs Realtime API beeindruckend; für Kontrolle, Offline-Betrieb und Datenschutz bleibt die klassische Pipeline ungeschlagen.

Mein Rat: Bau erst die einfache, lokale Version aus dem Beispiel oben, rede ein paar Minuten mit ihr und spüre selbst, wo es hakt. Dann optimierst du gezielt – mal die Latenz, mal die Stimme, mal das Modell. Genau dieses Tüfteln ist das Schöne daran. Viel Spaß beim Bauen deines Gesprächspartners!

Einen sprechenden Voice-Agent selbst bauen: Whisper + LLM + TTS in der Praxis

Einen sprechenden Voice-Agent selbst bauen: Whisper + LLM + TTS in der Praxis

Artikel-Übersicht

Einleitung: Warum einen eigenen Voice-Agent bauen?

Die Pipeline im Überblick: Sechs Bausteine

Schritt 1: Mikrofon-Audio einfangen

Schritt 2: Voice Activity Detection (VAD) – wann reden wir eigentlich?

Schritt 3: Speech-to-Text mit Whisper und faster-whisper

Lokal oder Cloud? Die Datenschutz-Abwägung

Schritt 4: Das LLM – die Antwort generieren

Schritt 5: Text-to-Speech – dem Agenten eine Stimme geben

Latenz und Echtzeit: Streaming, Barge-in und das gefühlte Tempo

Das vollständige Python-Beispiel: alle Bausteine verbunden

Der moderne Weg 2026: Speech-to-Speech-APIs

Typische Stolperfallen – besonders auf Deutsch

Zusammenfassung und praktische Tipps

Ressourcen