Vollständig offline Sprachassistenten bauen 2026: Whisper + LLM + Piper (Schritt für Schritt)

Kurzfakten

• STT-Schicht: whisper.cpp (beste Wahl für Apple Silicon und Embedded-Hardware), faster-whisper (beste Wahl für NVIDIA-GPU-Python-Pipelines).
• LLM-Schicht: Ollama mit Llama 3.1 8B (empfohlen), Phi-4 (kleiner, gute Qualität) oder Mistral 7B (vergleichbare Qualität zu Llama 3.1 8B).
• TTS-Schicht: Piper (schnellste, nur CPU, Echtzeit auf Pi), Coqui TTS (bessere Qualität, benötigt GPU).
• Wake-Word-Optionen: OpenWakeWord (MIT, vollständig offline), Porcupine (kostenlose Stufe, 1 benutzerdefiniertes Wake-Word).
• Mindesthardware: Raspberry Pi 5 mit 8 GB RAM (ca. 90 €) für 5–8 Sekunden Latenz.
• Empfohlene Hardware: Mac Mini M5 24 GB (ca. 600 €) oder Desktop mit RTX 3060 12 GB (ca. 750 €) für 1–2 Sekunden Latenz.
• Sprachen: Whisper unterstützt 99 Sprachen. Piper unterstützt 20+ Sprachpakete. Die LLM-Performance variiert je nach Sprache.

Warum einen lokalen Sprachassistenten bauen?

• Datenschutz: Kein Audio verlässt das eigene Netzwerk. Kein Wake-Word-Audio in der Cloud gespeichert. Keine Gesprächshistorie auf Servern Dritter. Kritisch für Beschäftigte im Gesundheitswesen, Anwälte, Journalisten und alle mit vertraulicher Arbeit.
• Kosten: Kein Abonnement. Alexa+ kostet ca. 4,99 €/Monat. Google One kostet ca. 1,99–9,99 €/Monat. Ein lokaler Assistent ist eine einmalige Hardwareinvestition.
• Anpassbarkeit: Wake-Word, Persönlichkeit, System-Prompt und Funktionen selbst wählen. Eigene Befehle hinzufügen, lokale Hausautomationssysteme verbinden, lokale APIs integrieren.
• Offline-Betrieb: Funktioniert ohne Internet. Stromausfall (mit USV) + Internetausfall: Der lokale Assistent funktioniert weiterhin. Nützlich für Hütten, abgelegene Standorte und Notfallvorbereitung.
• Was Sie aufgeben: Websuche, Smart-Home-Integration mit proprietären Clouds, Kalendersynchronisierung mit Cloud-Diensten und die jahrelange RLHF-Optimierung, die Alexa/Siri bei Randfällen geschmeidig macht.

Die Drei-Schichten-Architektur

• Schicht 1 — STT (Spracherkennung): whisper.cpp oder faster-whisper. Konvertiert Mikrofon-Audio in Text. Läuft offline, ohne Netzwerkzugriff.
• Schicht 2 — LLM (Verarbeitung): Ollama mit Llama 3.1 8B, Phi-4 oder Mistral 7B. Nimmt den transkribierten Text + Gesprächshistorie + System-Prompt entgegen und generiert eine Antwort. Läuft offline, ohne Netzwerkzugriff.
• Schicht 3 — TTS (Text-to-Speech): Piper oder Coqui TTS. Konvertiert den LLM-Antworttext in Audio und gibt es über den Lautsprecher aus. Läuft offline, ohne Netzwerkzugriff.
• Orchestrator: Ein Python-Skript, das die drei Komponenten verbindet: Audio vom Mikrofon aufnehmen → an STT übergeben → Transkript an LLM übergeben → Antwort an TTS übergeben → Audio abspielen.
• Optionales Wake-Word: Ein leichtgewichtiger Dauerdetektor (OpenWakeWord, Porcupine), der die vollständige Pipeline nur auslöst, wenn die Wake-Phrase erkannt wird. Ohne ihn läuft whisper.cpp kontinuierlich – mit höherem CPU-Verbrauch und mehr Fehlauslösungen.

Hardwareanforderungen

Schritt 1: Spracherkennung einrichten

• whisper.cpp installieren: git clone https://github.com/ggerganov/whisper.cpp && cd whisper.cpp && make -j4
• Modell herunterladen: bash ./models/download-ggml-model.sh small (small = 3,4 % WER, gutes Gleichgewicht zwischen Geschwindigkeit und Genauigkeit)
• Transkription testen: ./main -m models/ggml-small.bin -f test.wav – sollte genauen Text ausgeben.
• Metal auf Mac aktivieren: make -j4 WHISPER_COREML=1 dann bash models/generate-coreml-model.sh small
• Whisper-Modellauswahl: base für Raspberry Pi (1 GB RAM, geringe Latenz), small für den besten Kompromiss (2 GB RAM, 3,4 % WER), large-v3 für höchste Genauigkeit (10 GB VRAM/RAM).
• Stille-Unterdrückung konfigurieren: Flags --no-speech-threshold 0.6 --suppress-blank hinzufügen, um zu vermeiden, dass Stille als halluzinierter Text transkribiert wird.
• Mit 10-Sekunden-Aufnahme testen: Einen Testsatz einsprechen und prüfen, ob Whisper ihn korrekt transkribiert. Sowohl unter Lärmbedingungen als auch bei leiser Sprache testen.

Schritt 2: Lokales LLM einrichten

• Ollama installieren: Von ollama.com herunterladen. Verfügbar für macOS, Linux und Windows. Installation in unter 2 Minuten.
• Modell herunterladen: ollama pull llama3.1:8b (empfohlen) oder ollama pull phi4 (leichter, gut für Systeme mit 16 GB RAM).
• Testen: ollama run llama3.1:8b "What is the capital of France?" – prüfen, ob die Antwort korrekt und schnell ist.
• System-Prompt für Sprache: Einen kurzen, direktiven System-Prompt verwenden: „You are a helpful voice assistant. Keep responses concise — 1–3 sentences maximum. Never use bullet points, markdown, or formatting. Speak naturally as if in conversation."
• Temperatur: Temperatur auf 0,3–0,5 setzen für vorhersehbarere, sachlichere Antworten. Niedrigere Temperatur reduziert Halluzinationen bei Sprachantworten.
• Maximale Token-Anzahl: Antwortlänge mit --num-predict 150 begrenzen – lange Antworten benötigen mehr TTS-Zeit und wirken bei Sprachinteraktion unnatürlich.

Schritt 3: Text-to-Speech einrichten

• Piper installieren: pip install piper-tts
• Stimme herunterladen: piper --download-dir voices --update-voices --voice en_US-lessac-medium (oder eine beliebige Stimme von der Piper-Stimmen-Seite auf Hugging Face).
• Testen: echo "Hello, how can I help you today?" | piper --model voices/en_US-lessac-medium.onnx --output-raw | aplay -r 22050 -f S16_LE -c 1
• Audio-Ausgabe: Piper gibt rohes PCM oder WAV aus. Mit aplay (Linux), afplay (Mac) weiterleiten oder die Python-Bibliothek sounddevice für plattformübergreifende Wiedergabe verwenden.
• Alternative (bessere Qualität): Coqui VITS-Backend – pip install TTS installieren, tts --model_name tts_models/en/vctk/vits verwenden. Benötigt ~2 GB VRAM; 2–3× langsamer als Piper, aber merklich natürlicher.
• Stimmauswahl: Für Sprachassistenten eine Stimme mittlerer Qualität statt hoher wählen – mittlere Stimmen sind schneller und der Unterschied über einen Lautsprecher kaum wahrnehmbar.

Schritt 4: Pipeline verbinden

#!/usr/bin/env python3
"""Minimal offline voice assistant: Whisper STT + Ollama LLM + Piper TTS."""

import subprocess
import tempfile
import sounddevice as sd
import soundfile as sf
import numpy as np
import requests
import json

SAMPLE_RATE = 16000
RECORD_SECONDS = 5
OLLAMA_URL = "http://localhost:11434/api/generate"
WHISPER_BIN = "./whisper.cpp/main"
WHISPER_MODEL = "./whisper.cpp/models/ggml-small.bin"
PIPER_BIN = "piper"
PIPER_VOICE = "voices/en_US-lessac-medium.onnx"
SYSTEM_PROMPT = (
    "You are a helpful voice assistant. Keep responses to 1-3 sentences. "
    "Never use markdown, bullet points, or formatting. Speak naturally."
)

conversation_history = []

def record_audio(seconds: int = RECORD_SECONDS) -> np.ndarray:
    print("Listening...")
    audio = sd.rec(int(seconds * SAMPLE_RATE), samplerate=SAMPLE_RATE, channels=1, dtype="int16")
    sd.wait()
    return audio

def transcribe(audio: np.ndarray) -> str:
    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
        sf.write(f.name, audio, SAMPLE_RATE)
        result = subprocess.run(
            [WHISPER_BIN, "-m", WHISPER_MODEL, "-f", f.name, "--no-timestamps", "--no-prints"],
            capture_output=True, text=True
        )
    return result.stdout.strip()

def ask_llm(text: str) -> str:
    conversation_history.append({"role": "user", "content": text})
    response = requests.post(OLLAMA_URL, json={
        "model": "llama3.1:8b",
        "system": SYSTEM_PROMPT,
        "messages": conversation_history,
        "stream": False,
    })
    reply = response.json()["message"]["content"]
    conversation_history.append({"role": "assistant", "content": reply})
    return reply

def speak(text: str) -> None:
    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
        subprocess.run(
            f'echo "{text}" | {PIPER_BIN} --model {PIPER_VOICE} --output_file {f.name}',
            shell=True, check=True
        )
        data, sr = sf.read(f.name)
        sd.play(data, sr)
        sd.wait()

def main():
    print("Voice assistant ready. Press Ctrl+C to stop.")
    while True:
        audio = record_audio()
        transcript = transcribe(audio)
        if not transcript or len(transcript) < 3:
            continue
        print(f"You: {transcript}")
        response = ask_llm(transcript)
        print(f"Assistant: {response}")
        speak(response)

if __name__ == "__main__":
    main()

Schritt 5: Wake-Word-Erkennung

• OpenWakeWord (MIT-Lizenz): Vollständig Open-Source, läuft auf CPU, unterstützt benutzerdefinierte Wake-Words durch Fine-Tuning auf eigene Phrasen. Installation: pip install openwakeword. Läuft auf Raspberry Pi. Beste Wahl für vollständig offline und Open-Source-Setups.
• Porcupine (Picovoice): Proprietär, aber mit kostenloser Stufe für den privaten Gebrauch. Vorgefertigte Wake-Words umfassen „Alexa", „Hey Siri", „Ok Google" und benutzerdefinierte Optionen wie „Hey Jarvis". Sehr genaue Erkennung mit geringer Fehlauslösungsrate. Installation: pip install pvporcupine.
• Integrationsmuster: OpenWakeWord/Porcupine in einer Schleife ausführen. Bei erkanntem Wake-Word einen „Ding"-Ton abspielen (Nutzer-Feedback), dann die Whisper + LLM + TTS-Pipeline für eine Anfrage auslösen. Nach der TTS-Wiedergabe zur Wake-Word-Erkennung zurückkehren.
• Dauerbetrieb: Die Wake-Word-Erkennung verbraucht ~2–5 % CPU auf dem Raspberry Pi 5 – vernachlässigbar. Der Assistent kann 24/7 mit minimalem Stromverbrauch laufen.
• Benutzerdefinierte Wake-Words (OpenWakeWord): 500 positive und 500 negative Audiobeispiele der eigenen Wake-Phrase per TTS generieren, dann OpenWakeWord in unter 30 Minuten auf CPU feinabstimmen. Genauigkeit vergleichbar mit Porcupine für geläufige englische Wörter.

Latenzoptimierung

• STT-Optimierung (~0,2–0,5 Sek.): Whisper small statt large-v3 verwenden. VAD einsetzen, um Stille vor der Übergabe an Whisper abzuschneiden – kürzeres Audio = schnellere Transkription.
• LLM-Optimierung (~0,5–1,5 Sek. First Token): Modell beim Start vorladen (Ollama erledigt dies automatisch). Q4_K_M-Quantisierung für das beste Geschwindigkeits-Qualitäts-Verhältnis verwenden. --num-predict 100–150 setzen, um die Antwortlänge zu begrenzen.
• LLM → TTS streamen: LLM-Ausgabe Token für Token streamen. TTS bei jedem vollständigen Satz starten (Satzende durch Punkt/Fragezeichen erkannt). Dies reduziert die wahrgenommene Latenz um 0,3–0,7 Sekunden – der Nutzer hört den Anfang der Antwort, während das LLM noch das Ende generiert.
• TTS-Optimierung (~0,1–0,3 Sek.): Piper generiert das erste Audio in 50 ms. Piper beim Start vorinitialisieren. --output-raw verwenden, um Audio beim Generieren zu streamen, statt auf eine vollständige Datei zu warten.
• Modelle im Speicher halten: Ollama hält Modelle automatisch im VRAM warm. whisper.cpp im Stream-Modus bleibt im Speicher. Modelle zwischen Anfragen nicht neu laden.
• Latenz-Ziele nach Hardware: Pi 5: 5–8 Sek. (akzeptabel für nicht-konversationelle Nutzung). Mini-PC CPU: 3–5 Sek. (grenzwertig konversationell). Desktop-GPU: 1–2 Sek. (natürlich). Mac M5: 1–1,5 Sek. (ausgezeichnet).

Datenschutz und Sicherheit

• Mit Wireshark überprüfen: Wireshark auf dem Netzwerkinterface während eines Gesprächs mit dem Assistenten ausführen. Es sollten keinerlei Pakete vom Assistenten-Prozess sichtbar sein. Unerwarteter Datenverkehr weist auf eine Fehlkonfiguration hin – prüfen, ob Ollamas externe API bei öffentlicher IP-Adresse deaktiviert ist.
• Kein Audio gespeichert: Weder whisper.cpp noch faster-whisper schreiben standardmäßig Audiodateien – sie verarbeiten im Arbeitsspeicher. Der Python-Orchestrator in diesem Leitfaden schreibt eine temporäre WAV-Datei für whisper.cpp, die nach der Transkription gelöscht wird.
• Keine Gesprächshistorie gespeichert: Die Gesprächshistorie im Beispielskript liegt nur im Arbeitsspeicher und wird beim Neustart zurückgesetzt. Für persistente Historie eine explizite Speicherung mit lokaler Datenbank und Verschlüsselung im Ruhezustand implementieren.
• DSGVO-Konformität: Da die gesamte Verarbeitung lokal erfolgt und keine Daten das eigene Netzwerk verlassen, erfordert ein lokaler Sprachassistent für den internen Gebrauch keinen Auftragsverarbeitungsvertrag nach Art. 28 DSGVO. Es besteht kein Auftraggeber-/Auftragnehmer-Verhältnis mit einem Dritten.
• Netzwerkisolierung: Für maximalen Datenschutz eine Firewall-Regel hinzufügen, die ausgehenden Datenverkehr vom Assistenten-Prozess blockiert. Ollama und whisper.cpp funktionieren normal – sie benötigen nach dem Modell-Download keinen Netzwerkzugriff.

Häufige Fragen

Quellen

• whisper.cpp auf GitHub — Quellcode, Build-Anleitungen, Stream-Modus-Dokumentation.
• Ollama auf ollama.com — Installation, Modell-Bibliothek, API-Referenz.
• Piper TTS auf GitHub — Quellcode, Stimmpaket-Downloads, Raspberry Pi Setup-Anleitung.
• OpenWakeWord auf GitHub — Quellcode, Anleitung zum Training benutzerdefinierter Wake-Words, unterstützte Architekturen.
• Porcupine von Picovoice — Wake-Word SDK, kostenlose Stufen-Bedingungen, Python SDK-Dokumentation.
• Picovoice Console — Kostenlosen API-Schlüssel für Porcupine (privater Gebrauch) erstellen.

Weiterführende Lektüre

• Lokale Spracherkennung 2026: Whisper.cpp vs. faster-whisper — Detailanalyse der STT-Schicht dieser Pipeline.
• Lokale TTS und Voice-Cloning 2026: Piper vs. Coqui vs. XTTS v2 — Detailanalyse der TTS-Schicht und Voice-Cloning-Optionen.
• Lokale multimodale KI-Pipeline 2026 — Sprachpipeline um Vision-Modell-Unterstützung erweitern.
• Ollama installieren — Ollama-Installation und Modellverwaltung.
• Lokale LLM-Hardware-Anleitung 2026 — Hardware-Auswahl für die vollständige Sprach- und LLM-Pipeline.
• Lokalen Sprachassistenten auf dem Smartphone bauen — Die mobile Version dieses Leitfadens (iPhone und Android).