Lokaler Sprachassistent

Das Experiment

Die Schnittstellenkarte hat die Kategorien erklärt: STT (Ohren), TTS (Stimme), Wake Word (Dauerlauscher). Dieses Labor baut daraus einen echten Assistenten — in der ehrlichsten Reihenfolge: zuerst die Kette Sprachmemo → Mitschrift → lokale KI → gesprochene Antwort, erst danach die Frage, ob du wirklich einen Dauerlauscher willst. Alles läuft lokal; keine Aufnahme verlässt deinen Rechner.

Die Bausteine (Stand Juli 2026)

Baustein	Werkzeug	Einordnung
Ohren (STT)	Whisper-Familie (Katalog)	offene Modelle von OpenAI, 99 Sprachen inkl. Deutsch, MIT-Lizenz
Ohren, schneller	faster-whisper	Neuimplementierung, laut Projekt bis 4× schneller bei gleicher Genauigkeit
Ohren, ohne Python	whisper.cpp	C/C++-Portierung, läuft ab Raspberry-Pi-Klasse auf reiner CPU
Stimme (TTS)	Windows-Sprachausgabe / Piper	sofort da (klassisch) / neuronal, deutsche Stimmen, heute im Repo OHF-Voice/piper1-gpl
Dauerlauscher	openWakeWord u. a.	eigene Mini-Modelle; für dieses Labor bewusst optional

Whisper gibt es in Grössen von tiny (39 Mio. Parameter, ~1 GB Speicher) über small (244 Mio., ~2 GB) bis large (1,55 Mrd., ~10 GB) — dazu turbo (809 Mio., ~6 GB) als schnelle Grosse (Zahlen laut offizieller Modellübersicht; anhand offizieller Doku geprüft). Für deutsche Sprachmemos ist small der bewährte Startpunkt: klein genug fürs Notebook, gross genug, dass Deutsch zuverlässig ankommt.

Teil 1: Die Ohren testen (ca. 25 Min.)

1. Aufnahme machen: Öffne die Windows-App Sprachrekorder und sprich einen Satz mit klarer Ansage, z. B. «Notiz: Am Samstag Druckerpapier kaufen.» Kopiere die Datei nach KI-Experimente\Sprachmemos (Ordnerstruktur wie in Mission 5).
2. faster-whisper installieren (PowerShell):

pip install faster-whisper

Was das tut: installiert die STT-Bibliothek samt Audio-Dekodierung. Rücksetzweg: pip uninstall faster-whisper; das beim ersten Lauf geladene Whisper-Modell liegt im Cache-Ordner %USERPROFILE%\.cache\huggingface und kann dort gelöscht werden. 3. Mitschrift-Skript als mitschrift.py in KI-Experimente speichern und mit python mitschrift.py starten:

# mitschrift.py — Labor 3, Teil 1: Whisper schreibt ein Sprachmemo mit.
# Beim ersten Lauf laedt faster-whisper das Modell herunter (einmalig online),
# danach funktioniert alles offline.
from pathlib import Path
from faster_whisper import WhisperModel

MEMOS = Path.home() / "KI-Experimente" / "Sprachmemos"
modell = WhisperModel("small", device="cpu", compute_type="int8")

for datei in sorted(MEMOS.glob("*.*")):
    if datei.suffix.lower() not in (".m4a", ".mp3", ".wav"):
        continue
    segmente, info = modell.transcribe(str(datei), language="de")
    text = " ".join(s.text.strip() for s in segmente)
    print(f"[GEHOERT] {datei.name}: {text}")

Erwartetes Ergebnis: dein Satz als Text — kleine Patzer bei Namen sind normal. Falls die Dekodierung an einer .m4a-Datei scheitert: einmal als .wav aufnehmen oder umwandeln; am Prinzip ändert sich nichts.

Teil 2: Der ganze Assistent (ca. 40 Min.)

Jetzt die volle Kette — nach dem Mission-5-Muster (Beobachtungsschleife, Protokoll, STOP.txt), erweitert um Stimme und eine ungefährliche Aktion: Memos, die mit «Notiz» beginnen, landen in einer Notizdatei statt bei der KI. Starte LM Studio mit laufendem Server (KM4), speichere das Skript als sprach-assistent.py und starte es mit python sprach-assistent.py.

# sprach-assistent.py — Labor 3: lokaler Diktat-Assistent.
# Sprachmemo in "Sprachmemos" legen -> Whisper schreibt mit -> lokale KI
# antwortet -> Antwort wird gespeichert und vorgelesen.
# Doppelter Not-Aus: Stoppwort "Stopp" sprechen ODER STOP.txt in den Ordner legen.
import json
import subprocess
import time
import urllib.request
from pathlib import Path
from faster_whisper import WhisperModel

BASIS = Path.home() / "KI-Experimente"
MEMOS = BASIS / "Sprachmemos"          # hier wird beobachtet (nur gelesen!)
ANTWORTEN = BASIS / "Antworten"        # Antworten als Textdateien
NOTIZEN = BASIS / "notizen.txt"        # die ungefaehrliche Aktion
PROTOKOLL = BASIS / "assistent-protokoll.txt"
NOT_AUS = MEMOS / "STOP.txt"
API = "http://localhost:1234/v1/chat/completions"   # deine lokale KI (KM4)
AUFTRAG = "Antworte kurz und freundlich auf Hochdeutsch, in hoechstens drei Saetzen."

def protokollieren(zeile: str) -> None:
    print(zeile)
    with PROTOKOLL.open("a", encoding="utf-8") as p:
        p.write(zeile + "\n")

def ki_antwort(frage: str) -> str:
    daten = json.dumps({"messages": [
        {"role": "system", "content": AUFTRAG},
        {"role": "user", "content": frage}]}).encode("utf-8")
    anfrage = urllib.request.Request(API, daten, {"Content-Type": "application/json"})
    with urllib.request.urlopen(anfrage, timeout=120) as antwort:
        return json.load(antwort)["choices"][0]["message"]["content"].strip()

def vorlesen(text: str) -> None:
    # Windows-Sprachausgabe (klassisch, offline). Apostrophe verdoppeln,
    # damit der PowerShell-Text gueltig bleibt; Laenge begrenzen.
    sicher = text.replace("'", "''")[:800]
    befehl = ("Add-Type -AssemblyName System.Speech; "
              f"(New-Object System.Speech.Synthesis.SpeechSynthesizer).Speak('{sicher}')")
    subprocess.run(["powershell", "-NoProfile", "-Command", befehl], check=False)

MEMOS.mkdir(parents=True, exist_ok=True)
ANTWORTEN.mkdir(parents=True, exist_ok=True)
modell = WhisperModel("small", device="cpu", compute_type="int8")
erledigt = set()
protokollieren("[START] Lausche auf neue Memos. Not-Aus: 'Stopp' sagen oder STOP.txt anlegen.")

while not NOT_AUS.exists():
    for datei in sorted(MEMOS.glob("*.*")):
        if datei in erledigt or datei.suffix.lower() not in (".m4a", ".mp3", ".wav"):
            continue
        erledigt.add(datei)
        protokollieren(f"[HOERE] {datei.name}")
        segmente, _ = modell.transcribe(str(datei), language="de")
        text = " ".join(s.text.strip() for s in segmente).strip()
        protokollieren(f"[GEHOERT] {text}")
        if text.lower().startswith("stopp"):
            protokollieren("[STOPP] Stoppwort erkannt — Assistent beendet sich.")
            raise SystemExit
        if text.lower().startswith("notiz"):
            with NOTIZEN.open("a", encoding="utf-8") as n:
                n.write(text + "\n")
            antwort = "Notiert."
        else:
            protokollieren("[DENKE] Frage geht an die lokale KI …")
            antwort = ki_antwort(text)
        (ANTWORTEN / (datei.stem + ".txt")).write_text(antwort, encoding="utf-8")
        protokollieren(f"[SPRECHE] {antwort}")
        vorlesen(antwort)
    time.sleep(5)
protokollieren("[STOPP] STOP.txt gefunden — Assistent beendet sich.")

So testest du sauber (Kontrollpunkte wie in Mission 5):

1. Notiz-Aktion: Memo «Notiz: Zahnarzttermin verschieben» einlegen → notizen.txt bekommt eine Zeile, die Stimme sagt «Notiert.» — die KI war nie beteiligt.
2. KI-Frage: Memo «Was ist ein Token, in einem Satz?» → Statuszeilen [HOERE], [GEHOERT], [DENKE], [SPRECHE] erscheinen, die Antwort liegt in Antworten\.
3. Stoppwort: Memo «Stopp» → der Assistent verabschiedet sich im Protokoll.
4. STOP.txt: wirkt zusätzlich, falls das Stoppwort einmal nicht verstanden wird.

Rücksetzweg: Skripte und Ordner Sprachmemos, Antworten löschen — dein System ist unverändert. (Skriptlogik reviewt; wie bei Mission 5 gilt der manuelle Prüfplan der Testdokumentation.)

Teil 3: Die Stimme aufwerten (ca. 10 Min.)

Die Windows-Sprachausgabe ist klassische Technik: zuverlässig, aber hörbar mechanisch. Die neuronale Alternative heisst Piper — schnelle lokale Sprachsynthese mit deutschen Stimmen, heute gepflegt von der Open Home Foundation im Repo OHF-Voice/piper1-gpl (GPL-Lizenz; das frühere Repo rhasspy/piper ist archiviert) (anhand offizieller Projektseiten geprüft, Stimmen nicht selbst getestet). Höre dir Beispielstimmen auf der Projektseite an, bevor du installierst — ob dir der Qualitätssprung den Zusatzaufwand wert ist, entscheidet dein Ohr.

Und der Dauerlauscher? (Einordnung, ca. 5 Min.)

Ein Wake Word («Hey Assistent …») macht aus dem Memo-Assistenten einen Immer-bereit-Assistenten — technisch: ein Mini-Modell lauscht pausenlos am Mikrofon und weckt erst bei Treffer die grosse Kette. Der Preis ist grundsätzlich: ein dauerhaft offenes Mikrofon in deiner Wohnung. Vor dem Bau drei Fakten (anhand offizieller Projektdoku geprüft):

• openWakeWord ist offen (Code Apache-2.0) und genügsam — ein Kern eines Raspberry Pi 3 schafft laut Projekt 15–20 Wake-Word-Modelle parallel. Aber: Die mitgelieferten Wake Words sind englisch («hey jarvis» u. a.) und nur für nicht-kommerzielle Nutzung lizenziert; ein deutsches Wake Word musst du selbst trainieren.
• Kommerzielle Alternativen wie Porcupine bieten laut Anbieter einen Gratis-Einstieg für Privatprojekte ‹PRÜFEN: Porcupine-Free-Tier-Konditionen (Limits, Kontopflicht) — picovoice.ai/pricing›.
• Den fertigen Weg gibt es auch: Home Assistant betreibt komplette lokale Sprach-Pipelines mit Whisper und Piper — «deine gesprochenen Befehle verlassen dein Zuhause nie» (sinngemäss die offizielle Doku); mehr dazu in Labor 6.

Vertiefung: Warum der Umweg über Dateien statt Live-Mikrofon?

Ein Live-Assistent braucht drei Dauerprozesse (Lauschen, Aufnahmeschnitt, Erkennung), die sauber zusammenspielen müssen — viel Technik, die vom Kern ablenkt. Der Datei-Weg hat dieselbe Lernkurve ohne diese Baustellen und ist nebenbei das ehrlichere Datenschutz-Setup: Das Mikrofon ist nur an, wenn du bewusst aufnimmst. Wenn dich das Live-Setup reizt: Genau das ist die Heimspiel-Disziplin von Home Assistant (Labor 6), dort mit fertig gelöster Aufnahmetechnik.

Risiken

• Dauerlauscher und Mitbewohner: Ein immer offenes Mikrofon erfasst alle im Raum — informiere Mitbewohnende und Gäste, auch wenn alles lokal bleibt. Persönlichkeitsrechte enden nicht an der Wohnungstür (das Kamera-Pendant vertieft Labor 4).
• Fehlerkennung → falsche Aktion: Aus «Notiz» wird «nutzlos», aus einer Frage ein Kommando. Deshalb führt der Assistent nur ungefährliche Aktionen aus (Notiz anhängen) und nie Löschungen oder Käufe — die KM7-Berechtigungsregel gilt auch für Ohren.
• Falsches Vertrauen in die Mitschrift: Whisper klingt auch dann flüssig, wenn es falsch gehört hat — bei wichtigen Inhalten (Namen, Zahlen, Termine) Mitschrift gegenlesen, bevor etwas darauf aufbaut.

Erweiterungen

• Routing einbauen: Lass das kleine Modell aus Labor 9 entscheiden, ob ein Memo EINFACH oder SCHWIERIG ist, bevor das grosse antwortet.
• Wochenzusammenfassung: Der Assistent fasst freitags alle notizen.txt-Einträge zusammen — die Mission-6-Statusmeldung, jetzt gesprochen.
• Piper statt Windows-Stimme: vorlesen() gegen einen Piper-Aufruf tauschen — der Rest des Skripts bleibt unverändert (saubere Bausteintrennung zahlt sich aus).

Kurz geprüft

3 Fragen zum Festigen — Feedback kommt sofort.

Warum ist STOP.txt zusätzlich zum Stoppwort nötig?

Das Stoppwort hängt von der Spracherkennung ab — der Not-Aus muss auch funktionieren, wenn genau diese versagt.Weil STOP.txt schneller ist.Tempo ist nicht der Punkt — Unabhängigkeit vom KI-Pfad ist es.Damit das Protokoll vollständig bleibt.Protokolliert wird bei beiden Wegen — entscheidend ist die Verlässlichkeit.

Die Spracherkennung ist schlecht. Der beste erste Schritt?

Mikrofon und Aufnahmesituation verbessern — sauberes Signal schlägt grösseres Modell.Sofort das large-Modell laden.Kostet ~10 GB Speicher und hilft wenig, wenn das Signal verrauscht ist.Die Aufnahmen in die Cloud schicken.Damit gibst du genau die Privatheit auf, für die dieses Labor gebaut ist.

Was ändert sich grundsätzlich, wenn aus dem Memo-Assistenten ein Wake-Word-Assistent wird?

Das Mikrofon ist dauerhaft offen — eine neue Datenschutz-Dimension für alle im Raum.Die KI wird intelligenter.Am Sprachmodell ändert sich nichts — nur am Aufnahmeweg davor.Nichts, es ist nur bequemer.Bequemer ja — aber der Dauerlauscher ist der eigentliche Preis.

Das kann ich jetzt

• Ich habe Whisper lokal Sprachmemos mitschreiben lassen und weiss, wovon die Erkennungsqualität wirklich abhängt (Signal vor Modellgrösse).
• Mein Diktat-Assistent verbindet STT, lokale KI, Sprachausgabe und eine ungefährliche Aktion — mit Statusanzeige, Protokoll und doppeltem Not-Aus.
• Ich kann begründen, wann ein Wake-Word-Dauerlauscher den Datenschutz-Preis wert ist — und kenne mit Home Assistant den fertigen Weg dorthin.