KI-Sprachassistent: Hören. Verstehen. Antworten. Alles lokal.

💰 Warum ein lokaler Sprachassistent einen echten Unterschied macht

Alexa, Siri & Co. senden jedes gesprochene Wort an Cloud-Server. Für Arztpraxen, Anwaltskanzleien und Unternehmen mit sensiblen Daten ist das undenkbar. KIAgent_redet beweist: Hochwertige Sprachinteraktion funktioniert komplett lokal — in Echtzeit, ohne Datenabfluss.

💻 Code-Einblicke

Ein Blick unter die Haube — so funktioniert die Echtzeit-Sprachpipeline:

🎙️ Echtzeit-Audioaufnahme mit sounddevice

Kontinuierliche Mikrofon-Aufnahme mit Callback-basierter Chunk-Verarbeitung:

import sounddevice as sd
import numpy as np
import queue

# Konfiguration für 16kHz Mono-Audio
SAMPLE_RATE = 16000
CHANNELS = 1
CHUNK_DURATION = 3  # Sekunden pro Aufnahmechunk
CHUNK_SIZE = int(SAMPLE_RATE * CHUNK_DURATION)

audio_queue = queue.Queue()

def audio_callback(indata, frames, time, status):
    """Callback-Funktion für die Audioaufnahme"""
    if status:
        print(f"Status: {status}")
    audio_queue.put(indata.copy())

# Starte Audioaufnahme
with sd.InputStream(callback=audio_callback,
                  channels=CHANNELS,
                  samplerate=SAMPLE_RATE,
                  dtype=np.float32):
    while True:
        time.sleep(0.1)

🤖 Whisper-Transkription mit GPU-Unterstützung

Automatische CUDA-Erkennung und Konfidenz-basierte Validierung der Transkription:

import whisper
import torch

MIN_CONFIDENCE = 0.1
MIN_TEXT_LENGTH = 1

def print_gpu_info():
    """Gibt Informationen über die GPU-Nutzung aus"""
    if torch.cuda.is_available():
        print(f"CUDA verfügbar: Ja")
        print(f"Aktuelle GPU: {torch.cuda.get_device_name(0)}")
    else:
        print("CUDA nicht verfügbar - CPU wird verwendet")

def is_valid_transcription(text, confidence):
    """Überprüft, ob die Transkription gültig ist"""
    text = text.strip()
    # Überprüfe, ob der Text nur aus Zahlen besteht
    if text.replace(" ", "").isdigit():
        return False
    word_count = len(text.split())
    return confidence >= MIN_CONFIDENCE and word_count >= MIN_TEXT_LENGTH

# Whisper-Modell laden und transkribieren
device = "cuda" if torch.cuda.is_available() else "cpu"
model = whisper.load_model("base").to(device)
result = model.transcribe("audio.wav")
text = result['text'].strip()
confidence = result.get('confidence', 0.0)

if is_valid_transcription(text, confidence):
    print(f"✓ Gültige Transkription: {text}")

🔄 Parallele Verarbeitung mit Threading

Audioaufnahme und Transkription laufen in getrennten Threads für maximale Performance:

import threading
import wave

def process_audio():
    """Verarbeitet die Audiochunks und transkribiert sie"""
    device = "cuda" if torch.cuda.is_available() else "cpu"
    model = whisper.load_model("base").to(device)
    
    file_counter = 0
    while True:
        # Sammle Audiochunks für CHUNK_DURATION Sekunden
        audio_chunks = []
        start_time = time.time()
        while time.time() - start_time < CHUNK_DURATION:
            try:
                chunk = audio_queue.get(timeout=0.1)
                audio_chunks.append(chunk)
            except queue.Empty:
                continue
        
        if not audio_chunks:
            continue
            
        # Kombiniere und speichere als WAV
        audio_data = np.concatenate(audio_chunks)
        file_counter += 1
        wav_filename = f"temp_{file_counter}.wav"
        with wave.open(wav_filename, 'wb') as wf:
            wf.setnchannels(1)
            wf.setsampwidth(2)
            wf.setframerate(16000)
            wf.writeframes((audio_data * 32767).astype(np.int16).tobytes())
        
        # Transkribiere und validiere
        result = model.transcribe(wav_filename)
        text = result['text'].strip()
        if is_valid_transcription(text, result.get('confidence', 0.0)):
            print(f"✓ {text}")
        
        # Cleanup
        os.remove(wav_filename)

# Starte Verarbeitung in separatem Thread
process_thread = threading.Thread(target=process_audio, daemon=True)
process_thread.start()

⚙️ So funktioniert's

Die dreistufige Pipeline: Sprechen → Verstehen → Antworten — vollständig lokal.

🔧 Technische Umsetzung

KIAgent_redet kombiniert drei bewährte Open-Source-Komponenten zu einer nahtlosen Sprachpipeline. Der gesamte Stack läuft lokal — keine API-Keys, keine Cloud-Kosten, keine Latenz.

🏗️ Architektur-Komponenten

📸 Screenshot

📊 Projekt-Status

🚀 Gebaut mit Vibecoding — in Tagen statt Wochen

🗣️ Der System-Prompt hinter diesem Projekt

Der Prompt, der aus drei Einzelteilen einen sprechenden KI-Assistenten machte:

Du bist ein Experte für Sprachverarbeitungs-Pipelines in Python.

Aufgabe: Erstelle einen sprachgesteuerten KI-Assistenten, der komplett 
lokal läuft — ohne Cloud-Dienste.

Pipeline:
1. Mikrofon-Aufnahme → Whisper STT (Transkription)
2. Transkribierter Text → Lokales LLM (Ollama) zur Verarbeitung
3. LLM-Antwort → TTS-Engine (Sprachausgabe)

Technische Anforderungen:
- Whisper (OpenAI) lokal für Speech-to-Text
- Ollama für lokales LLM-Hosting
- Edge-TTS oder Piper TTS für deutsche Sprachausgabe
- Endlosschleife: Zuhören → Verstehen → Antworten → Zuhören
- Error-Handling für Mikrofon-Fehler, leere Aufnahmen

Wichtig:
- Alles lokal — kein gesprochenes Wort verlässt den Rechner
- Deutsche Sprache priorisieren (Whisper language=de)
- Kontext über mehrere Runden erhalten
- Ressourcen-Management (GPU-Speicher für Whisper + LLM)

🎯 Strategische Erkenntnisse aus diesem Projekt

Sprachinteraktion ist die natürlichste Mensch-Maschine-Schnittstelle. Diese Erkenntnisse sind richtungsweisend für jede sprachbasierte KI-Anwendung.