Eigener KI-Sprachassistent mit Whisper + Piper TTS — Komplett offline

Unser Sprachassistent besteht aus vier Komponenten, die wie eine Pipeline zusammenarbeiten:

???? Mikrofon → [Whisper STT] → Text → [Ollama LLM] → Antwort → [Piper TTS] → ???? Lautsprecher

Die Komponenten im Detail:

Gesamter Ablauf:

1. Du sprichst ins Mikrofon 2. Whisper erkennt deine Worte und wandelt sie in Text um 3. Der Text geht an Ollama (lokales LLM), das eine Antwort generiert 4. Piper TTS wandelt die Antwort in gesprochenes Deutsch um 5. Die Antwort wird über den Lautsprecher ausgegeben

Was du brauchst:

• Einen PC, Laptop oder Raspberry Pi
• Ein USB-Mikrofon (oder eingebautes Laptop-Mikrofon)
• Lautsprecher oder Kopfhörer
• Python 3.10+
• Optional: NVIDIA GPU (für schnellere Spracherkennung)

Setup-Varianten und Hardware-Anforderungen:

Whisper-Modelle — Genauigkeit vs. Geschwindigkeit:

WER = Word Error Rate (niedrigerer Wert = besser). X× Echtzeit = ein 10-Sekunden-Audio braucht X×10 Sekunden.

Piper TTS — Läuft überall:

Piper ist extrem leichtgewichtig:

• RAM: ~50 MB
• CPU: Selbst ein Raspberry Pi Zero schafft Echtzeit
• GPU: Nicht nötig
• Latenz: <100ms für einen Satz

Du hast zwei Optionen: Das Original von OpenAI oder die schnellere Alternative faster-whisper.

Option A: OpenAI Whisper (Original)

# Systemabhängigkeiten (Linux):
sudo apt install ffmpeg
# macOS:
brew install ffmpeg
# Windows: Lade ffmpeg von https://ffmpeg.org/download.html
# Whisper installieren:
pip install openai-whisper

Option B: faster-whisper (empfohlen — bis zu 4× schneller!)

pip install faster-whisper

faster-whisper nutzt CTranslate2 und ist deutlich schneller bei gleicher Qualität. FFmpeg wird nicht benötigt.

Installation prüfen:

# Teste in Python:
python3 -c "
from faster_whisper import WhisperModel
# Modell laden (wird beim ersten Mal heruntergeladen)
model = WhisperModel('base', device='cpu', compute_type='int8')
print('faster-whisper erfolgreich installiert!')
print('Modell geladen: base')
"

Modell vorab herunterladen:

# Lade das gewünschte Modell vorab herunter:
python3 -c "
from faster_whisper import WhisperModel
# Für CPU:
model = WhisperModel('small', device='cpu', compute_type='int8')
# Für GPU:
# model = WhisperModel('large-v3', device='cuda', compute_type='float16')
print('Modell heruntergeladen und bereit!')
"

GPU-Unterstützung aktivieren (NVIDIA):

# Stelle sicher, dass CUDA installiert ist:
nvidia-smi
# faster-whisper nutzt CUDA automatisch wenn verfügbar
# Für GPU-Nutzung setze device='cuda':
# model = WhisperModel('large-v3', device='cuda', compute_type='float16')

Jetzt testen wir die Spracherkennung mit einer Audio-Datei und live vom Mikrofon.

Test 1: Audio-Datei transkribieren

Erstelle eine Test-Datei oder nutze eine vorhandene WAV/MP3:

#!/usr/bin/env python3
"""test_whisper.py — Whisper Spracherkennung testen"""
from faster_whisper import WhisperModel
# Modell laden (small = gute Balance)
model = WhisperModel("small", device="cpu", compute_type="int8")
# Audio-Datei transkribieren
segments, info = model.transcribe("test_audio.wav", language="de")
print(f"Erkannte Sprache: {info.language} (Konfidenz: {info.language_probability:.2%})")
print(f"Dauer: {info.duration:.1f} Sekunden")
print()
print("Transkription:")
for segment in segments:
    print(f"[{segment.start:.1f}s - {segment.end:.1f}s] {segment.text}")

Test 2: Live vom Mikrofon aufnehmen

# Zuerst: Audio-Bibliothek installieren
pip install sounddevice numpy scipy

#!/usr/bin/env python3
"""live_whisper.py — Live-Spracherkennung vom Mikrofon"""
import sounddevice as sd
import numpy as np
from scipy.io.wavfile import write
from faster_whisper import WhisperModel
import tempfile
import os
# Modell laden
print("Lade Whisper-Modell...")
model = WhisperModel("small", device="cpu", compute_type="int8")
print("Modell geladen!")
SAMPLE_RATE = 16000  # Whisper erwartet 16 kHz
while True:
    input("
Drücke ENTER und sprich (5 Sekunden)...")
    # 5 Sekunden aufnehmen
    print("???? Aufnahme läuft...")
    audio = sd.rec(int(5 * SAMPLE_RATE), samplerate=SAMPLE_RATE,
                   channels=1, dtype='float32')
    sd.wait()
    print("Aufnahme beendet. Transkribiere...")
    # Als temporäre WAV speichern
    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
        write(f.name, SAMPLE_RATE, (audio * 32767).astype(np.int16))
        # Transkribieren
        segments, info = model.transcribe(f.name, language="de")
        text = " ".join([s.text for s in segments]).strip()
        print(f"
Du hast gesagt: {text}")
        os.unlink(f.name)
    if text.lower() in ["stop", "stopp", "beenden", "ende"]:
        print("Auf Wiedersehen!")
        break

Skript ausführen:

python3 live_whisper.py

Piper ist ein ultraschnelles Text-to-Speech-System, das komplett offline läuft — sogar auf einem Raspberry Pi.

Installation via pip:

pip install piper-tts

Deutsche Stimme herunterladen:

Die beste deutsche Stimme ist Thorsten — kostenlos, Open Source und erstaunlich natürlich klingend.

# Erstelle einen Ordner für die Stimmen:
mkdir -p ~/piper-voices
# Thorsten High-Quality herunterladen:
cd ~/piper-voices
# Modell-Datei:
wget https://huggingface.co/rhasspy/piper-voices/resolve/main/de/de_DE/thorsten/high/de_DE-thorsten-high.onnx
# Konfigurations-Datei:
wget https://huggingface.co/rhasspy/piper-voices/resolve/main/de/de_DE/thorsten/high/de_DE-thorsten-high.onnx.json

Weitere deutsche Stimmen:

# Kerstin (weibliche Stimme):
wget https://huggingface.co/rhasspy/piper-voices/resolve/main/de/de_DE/kerstin/low/de_DE-kerstin-low.onnx
wget https://huggingface.co/rhasspy/piper-voices/resolve/main/de/de_DE/kerstin/low/de_DE-kerstin-low.onnx.json

Piper testen (Kommandozeile):

# Text zu Sprache — Ausgabe als WAV-Datei:
echo "Hallo, ich bin dein lokaler Sprachassistent. Ich laufe komplett auf deinem Computer und sende keine Daten ins Internet." | \
  piper --model ~/piper-voices/de_DE-thorsten-high.onnx \
  --output_file ~/test_sprache.wav
# Anhören (Linux):
aplay ~/test_sprache.wav
# Anhören (macOS):
afplay ~/test_sprache.wav

Direkte Ausgabe über Lautsprecher (Linux):

echo "Dies ist ein Test der Sprachausgabe." | \
  piper --model ~/piper-voices/de_DE-thorsten-high.onnx \
  --output-raw | \
  aplay -r 22050 -f S16_LE -t raw -c 1

Für die Integration in unseren Sprachassistenten nutzen wir Piper direkt aus Python:

#!/usr/bin/env python3
"""test_piper.py — Piper TTS in Python testen"""
import subprocess
import tempfile
import os
def speak(text, model_path="~/piper-voices/de_DE-thorsten-high.onnx"):
    """Text mit Piper vorlesen."""
    model_path = os.path.expanduser(model_path)
    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
        # Piper aufrufen
        process = subprocess.run(
            ["piper", "--model", model_path, "--output_file", f.name],
            input=text,
            capture_output=True,
            text=True
        )
        if process.returncode != 0:
            print(f"Fehler: {process.stderr}")
            return
        # Audio abspielen (Linux)
        subprocess.run(["aplay", f.name], capture_output=True)
        # macOS: subprocess.run(["afplay", f.name])
        os.unlink(f.name)
# Test:
speak("Hallo! Ich bin dein persönlicher KI-Assistent.")
speak("Wie kann ich dir heute helfen?")
speak("Ich kann Fragen beantworten, Texte zusammenfassen und vieles mehr.")

Alternative: Piper Python-Paket direkt nutzen:

#!/usr/bin/env python3
"""test_piper_native.py — Piper nativ in Python"""
import wave
import subprocess
import tempfile
from piper import PiperVoice
# Stimme laden
voice = PiperVoice.load(
    os.path.expanduser("~/piper-voices/de_DE-thorsten-high.onnx"),
    os.path.expanduser("~/piper-voices/de_DE-thorsten-high.onnx.json")
)
# Text synthetisieren
with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
    with wave.open(f.name, "w") as wav_file:
        voice.synthesize("Dies ist ein Test der nativen Piper-Integration.", wav_file)
    # Abspielen
    subprocess.run(["aplay", f.name], capture_output=True)
    os.unlink(f.name)

Sprechgeschwindigkeit und Tonhöhe anpassen:

# Langsamer sprechen (length_scale > 1.0):
echo "Langsam und deutlich." | \
  piper --model ~/piper-voices/de_DE-thorsten-high.onnx \
  --length-scale 1.3 \
  --output_file langsam.wav
# Schneller sprechen (length_scale < 1.0):
echo "Schnell und energisch!" | \
  piper --model ~/piper-voices/de_DE-thorsten-high.onnx \
  --length-scale 0.8 \
  --output_file schnell.wav

Jetzt verbinden wir alle Komponenten zu einem funktionierenden Sprachassistenten. Stelle sicher, dass Ollama läuft (ollama serve bzw. der systemd-Service).

#!/usr/bin/env python3
"""sprachassistent.py — Kompletter offline Sprachassistent"""
import sounddevice as sd
import numpy as np
from scipy.io.wavfile import write
from faster_whisper import WhisperModel
import subprocess
import tempfile
import os
import json
import urllib.request
# === KONFIGURATION ===
WHISPER_MODEL = "small"       # tiny/base/small/medium/large-v3
WHISPER_DEVICE = "cpu"        # cpu oder cuda
OLLAMA_MODEL = "llama3.1:8b"  # Ollama-Modell
PIPER_MODEL = os.path.expanduser("~/piper-voices/de_DE-thorsten-high.onnx")
SAMPLE_RATE = 16000
RECORD_SECONDS = 5
SYSTEM_PROMPT = "Du bist ein hilfreicher deutscher Sprachassistent. Antworte kurz und präzise in 1-3 Sätzen. Antworte immer auf Deutsch."
# === WHISPER LADEN ===
print("Lade Whisper-Modell...")
whisper = WhisperModel(WHISPER_MODEL, device=WHISPER_DEVICE, compute_type="int8")
print("Whisper bereit!")
def record_audio():
    """Nimmt Audio vom Mikrofon auf."""
    print("
???? Ich höre zu... (sprich jetzt)")
    audio = sd.rec(int(RECORD_SECONDS * SAMPLE_RATE),
                   samplerate=SAMPLE_RATE, channels=1, dtype='float32')
    sd.wait()
    return audio
def transcribe(audio):
    """Wandelt Audio in Text um (Whisper)."""
    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
        write(f.name, SAMPLE_RATE, (audio * 32767).astype(np.int16))
        segments, info = whisper.transcribe(f.name, language="de")
        text = " ".join([s.text for s in segments]).strip()
        os.unlink(f.name)
        return text
def ask_ollama(prompt):
    """Sendet Prompt an Ollama und bekommt Antwort."""
    data = json.dumps({
        "model": OLLAMA_MODEL,
        "prompt": prompt,
        "system": SYSTEM_PROMPT,
        "stream": False
    }).encode()
    req = urllib.request.Request(
        "http://localhost:11434/api/generate",
        data=data,
        headers={"Content-Type": "application/json"}
    )
    with urllib.request.urlopen(req, timeout=30) as resp:
        result = json.loads(resp.read())
        return result["response"]
def speak(text):
    """Spricht Text über Piper TTS aus."""
    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
        subprocess.run(
            ["piper", "--model", PIPER_MODEL, "--output_file", f.name],
            input=text, capture_output=True, text=True
        )
        # Linux:
        subprocess.run(["aplay", f.name], capture_output=True)
        # macOS: subprocess.run(["afplay", f.name])
        os.unlink(f.name)
# === HAUPTSCHLEIFE ===
print("
=== SPRACHASSISTENT BEREIT ===")
print("Drücke ENTER zum Sprechen, 'q' zum Beenden
")
while True:
    cmd = input("▶ ENTER zum Sprechen: ")
    if cmd.lower() == 'q':
        speak("Auf Wiedersehen!")
        break
    # 1. Audio aufnehmen
    audio = record_audio()
    # 2. Sprache -> Text
    user_text = transcribe(audio)
    print(f"Du: {user_text}")
    if not user_text.strip():
        print("(Nichts erkannt, versuche es nochmal)")
        continue
    # 3. Text -> KI-Antwort
    print("Denke nach...")
    response = ask_ollama(user_text)
    print(f"KI: {response}")
    # 4. Antwort -> Sprache
    speak(response)

Starten:

# Stelle sicher, dass Ollama läuft:
ollama serve &  # oder: sudo systemctl start ollama
# Sprachassistent starten:
python3 sprachassistent.py

Damit der Sprachassistent automatisch startet und als Hintergrund-Dienst läuft:

systemd-Service erstellen (Linux):

sudo tee /etc/systemd/system/sprachassistent.service << 'EOF'
[Unit]
Description=KI-Sprachassistent (Whisper + Piper)
After=network.target ollama.service
Wants=ollama.service
[Service]
Type=simple
User=pi
WorkingDirectory=/home/pi
ExecStart=/usr/bin/python3 /home/pi/sprachassistent.py --daemon
Restart=always
RestartSec=5
Environment=HOME=/home/pi
Environment=DISPLAY=:0
Environment=PULSE_SERVER=unix:/run/user/1000/pulse/native
[Install]
WantedBy=multi-user.target
EOF
sudo systemctl daemon-reload
sudo systemctl enable --now sprachassistent

Daemon-Modus mit Hotword-Detection:

Statt ENTER zu drücken, kannst du ein Aktivierungswort nutzen. Installation:

pip install pvporcupine sounddevice

Erweitere das Skript um Wake-Word-Erkennung:

#!/usr/bin/env python3
"""sprachassistent_daemon.py — Mit Wake-Word 'Computer'"""
import pvporcupine
import struct
import sounddevice as sd
import numpy as np
# Porcupine Wake-Word (kostenloser API-Key von picovoice.ai)
porcupine = pvporcupine.create(
    access_key="DEIN_PICOVOICE_KEY",  # Kostenlos auf picovoice.ai
    keywords=["computer"]  # Oder: "jarvis", "alexa", "ok google"
)
FRAME_LENGTH = porcupine.frame_length
SAMPLE_RATE = porcupine.sample_rate
print("Sage 'Computer' um mich zu aktivieren...")
def audio_callback(indata, frames, time, status):
    """Wird bei jedem Audio-Frame aufgerufen."""
    pcm = struct.pack('h' * len(indata[:, 0]),
                      [int(s  32767) for s in indata[:, 0]])
    pcm_unpacked = struct.unpack_from("h" * FRAME_LENGTH, pcm)
    keyword_index = porcupine.process(pcm_unpacked)
    if keyword_index >= 0:
        print("
Aktivierungswort erkannt!")
        # Hier: Audio aufnehmen, transkribieren, antworten
        # (wie im vorherigen Schritt)
with sd.InputStream(
    samplerate=SAMPLE_RATE,
    channels=1,
    dtype='int16',
    blocksize=FRAME_LENGTH,
    callback=audio_callback
):
    while True:
        sd.sleep(100)

Autostart auf dem Raspberry Pi:

# Zum rc.local hinzufügen (Alternative zu systemd):
sudo nano /etc/rc.local
# Vor "exit 0" einfügen:
# su - pi -c "python3 /home/pi/sprachassistent.py --daemon &"

Ein Raspberry Pi 5 ist perfekt für einen Sprachassistenten im Dauerbetrieb — sparsam, leise und kompakt.

Einkaufsliste:

Raspberry Pi OS installieren:

1. Lade den Raspberry Pi Imager herunter 2. Wähle Raspberry Pi OS (64-bit) — die Lite-Version reicht 3. Flashe auf die microSD-Karte 4. Beim ersten Start: WiFi und SSH einrichten

Software installieren:

# System aktualisieren:
sudo apt update && sudo apt upgrade -y
# Abhängigkeiten:
sudo apt install python3-pip python3-venv portaudio19-dev -y
# Virtuelle Umgebung:
python3 -m venv ~/assistant-env
source ~/assistant-env/bin/activate
# Pakete installieren:
pip install faster-whisper piper-tts sounddevice numpy scipy
# Ollama installieren:
curl -fsSL https://ollama.com/install.sh | sh
# Kleines Modell für den Pi:
ollama pull llama3.2:1b

Performance auf dem Raspberry Pi 5:

Optimierungen für den Pi:

# In sprachassistent.py anpassen:
WHISPER_MODEL = "tiny"         # Kleinstes Modell
OLLAMA_MODEL = "llama3.2:1b"   # Kleinstes LLM
RECORD_SECONDS = 5             # Kurze Aufnahmen
# Swap erhöhen (empfohlen):
sudo dphys-swapfile swapoff
sudo sed -i 's/CONF_SWAPSIZE=.*/CONF_SWAPSIZE=2048/' /etc/dphys-swapfile
sudo dphys-swapfile setup
sudo dphys-swapfile swapon

Home Assistant Integration:

Whisper und Piper sind nativ in Home Assistant integriert! So steuerst du dein Smart Home per Sprache — komplett lokal.

# In configuration.yaml von Home Assistant:
# Whisper Speech-to-Text:
stt:
  - platform: faster_whisper
    model: small
    language: de
# Piper Text-to-Speech:
tts:
  - platform: piper
    voice: de_DE-thorsten-high
# Assist Pipeline (verbindet STT + LLM + TTS):
assist_pipeline:

Installiere die Whisper und Piper Add-ons über den Home Assistant Add-on Store.

Eigene Skills programmieren:

Erweitere deinen Assistenten mit benutzerdefinierten Funktionen:

# skills.py — Eigene Fähigkeiten
import datetime
import urllib.request
import json
def get_time():
    """Aktuelle Uhrzeit ansagen."""
    now = datetime.datetime.now()
    return f"Es ist {now.strftime('%H Uhr %M')}."
def get_date():
    """Aktuelles Datum ansagen."""
    now = datetime.datetime.now()
    tage = ["Montag","Dienstag","Mittwoch","Donnerstag","Freitag","Samstag","Sonntag"]
    monate = ["Januar","Februar","März","April","Mai","Juni",
              "Juli","August","September","Oktober","November","Dezember"]
    return f"Heute ist {tage[now.weekday()]}, der {now.day}. {monate[now.month-1]} {now.year}."
def set_timer(seconds):
    """Timer setzen."""
    import threading
    def timer_done():
        speak(f"Dein Timer von {seconds} Sekunden ist abgelaufen!")
    threading.Timer(seconds, timer_done).start()
    return f"Timer auf {seconds} Sekunden gestellt."
# Im Hauptskript: Prüfe ob die Frage ein Skill-Trigger ist
SKILL_TRIGGERS = {
    "uhrzeit": get_time,
    "wie spät": get_time,
    "welches datum": get_date,
    "welcher tag": get_date,
}
def check_skills(text):
    """Prüft ob ein lokaler Skill die Frage beantworten kann."""
    text_lower = text.lower()
    for trigger, func in SKILL_TRIGGERS.items():
        if trigger in text_lower:
            return func()
    return None  # Kein Skill, an Ollama weiterleiten

Kosten-Vergleich: Selbst gebaut vs. Alexa/Google: