commit

app.py

@@ -1,7 +1,11 @@
-# app.py – Prüfungsrechts-Chatbot (RAG + Sprache, UI kiểu ChatGPT)
-#
+# app.py – Prüfungsrechts-Chatbot (RAG + Sprache, UI kiểu ChatGPT + VAD)
+
+from __future__ import annotations
+
 import os
-from dataclasses import dataclass
+from dataclasses import dataclass, field
+from typing import Any, List
+
 import gradio as gr
 from gradio_pdf import PDF
 
@@ -13,7 +17,7 @@ from llm import load_llm
 from rag_pipeline import answer
 from speech_io import transcribe_audio, synthesize_speech
 
-ASR_LANGUAGE_HINT = os.getenv("ASR_LANGUAGE", "de")  # set to "auto" for detection, or e.g. "en"
+ASR_LANGUAGE_HINT = os.getenv("ASR_LANGUAGE", "de")  # "auto" = Auto-Detect
 
 # =====================================================
 # INITIALISIERUNG (global)
@@ -39,6 +43,7 @@ pdf_meta = next(d.metadata for d in docs if d.metadata.get("type") == "pdf")
 hg_meta = next(d.metadata for d in docs if d.metadata.get("type") == "hg")
 hg_url = hg_meta.get("viewer_url")
 
+
 # =====================================================
 # Quellen formatieren – Markdown für Chat
 # =====================================================
@@ -56,144 +61,221 @@ def format_sources(src):
 
     return "\n".join(out)
 
+
 # =====================================================
-# CORE CHAT-FUNKTION (Text + separates Mikro-Audio)
+# State Management (wie Gradio Guide)
 # =====================================================
 @dataclass
 class AppState:
-    conversation: list
-    recording_state: str
-    mode: str
-    last_record_path: str | None
-    status_text: str
+    conversation: list = field(default_factory=list)  # LLM-History (role/content)
+    stopped: bool = False
+    model_outs: Any = None
+
 
-def chat_fn(text_input, audio_path, history, state: AppState, lang_sel):
+# =====================================================
+# CORE CHAT-FUNKTION (Text + Mikro)
+# =====================================================
+def chat_fn(
+    text_input: str,
+    audio_path: str,
+    history: List[List[str]],
+    state: AppState,
+):
     """
-    text_input: Textbox-Inhalt (str)
-    audio_path: Pfad zu WAV/FLAC vom Mikro (gr.Audio, type="filepath")
-    history: Liste von OpenAI-ähnlichen Messages (role, content)
+    text_input: Textbox-Inhalt
+    audio_path: Pfad zur Audiodatei aus gr.Audio (type="filepath")
+    history: Chatbot-Verlauf [[user, bot], ...]
+    state: AppState (Gradio State)
     """
     text = (text_input or "").strip()
 
-    if (not text) and audio_path:
-        state.recording_state = "processing"
-        state.last_record_path = audio_path
-        spoken = transcribe_audio(audio_path, language=lang_sel)
-        text = spoken.strip()
-        state.status_text = "✅ Verarbeitung abgeschlossen"
+    # Nur Audio → erst transkribieren
+    if audio_path and not text:
+        spoken = transcribe_audio(audio_path, language=ASR_LANGUAGE_HINT)
+        text = (spoken or "").strip()
 
     if not text:
-        # Nichts zu tun
-        return history, "", None, "", "Bereit"
+        # nichts zu tun
+        return history, state, "", None
 
-    # 2) RAG-Antwort berechnen
+    # RAG-Antwort
     ans, sources = answer(text, retriever, llm)
     bot_msg = ans + format_sources(sources)
 
-    # 3) History aktualisieren (ChatGPT-Style)
-    history = history + [
-        {"role": "user", "content": text},
-        {"role": "assistant", "content": bot_msg},
-    ]
+    # State.conversation im LLM-Format (für spätere Erweiterungen)
+    state.conversation.append({"role": "user", "content": text})
+    state.conversation.append({"role": "assistant", "content": bot_msg})
+
+    # Chatbot-History im klassischen Gradio-Format
+    if history is None:
+        history = []
+    history = history + [[text, bot_msg]]
+
+    # Optional: hier könnte synthesize_speech(bot_msg) aufgerufen werden,
+    # wenn du die Antwort automatisch vorlesen lassen willst.
+    # tts_audio = synthesize_speech(bot_msg)
+
+    # Text- und Audioeingabe leeren
+    return history, state, "", None
 
-    state.conversation = history
-    state.status_text = "Bereit"
-    return history, "", None, text, state.status_text
 
 # =====================================================
 # LAST ANSWER → TTS (für Button "Antwort erneut vorlesen")
 # =====================================================
-def read_last_answer(history):
+def read_last_answer(history: List[List[str]]):
     if not history:
         return None
+    last_pair = history[-1]
+    if len(last_pair) < 2:
+        return None
+    bot_text = last_pair[1]
+    return synthesize_speech(bot_text)
 
-    for msg in reversed(history):
-        if msg.get("role") == "assistant":
-            return synthesize_speech(msg.get("content", ""))
-
-    return None
 
 # =====================================================
-# UI – GRADIO
+# CSS + JS (VAD) – nach Gradio Guide adaptiert
 # =====================================================
-with gr.Blocks(title="Prüfungsrechts-Chatbot (RAG + Sprache)") as demo:
-    # Leichtes Styling: zentriert, schmale Breite, kompakte Input-Zeile (ChatGPT-like)
-    gr.HTML(
-        """
-        <style>
-        html, body {height: auto !important; overflow-y: auto !important;}
-        .gradio-container {max-width: 960px; margin: 0 auto; padding: 12px;}
-        #chat-wrap {position: relative;}
-        #chat-input-row {transform: translateY(-28px); margin-bottom: -28px;}
-
-        /* ChatGPT-like Bottom Bar */
-        #chat-input-row {
-            align-items: center;
-            gap: 8px;
-            padding: 8px 12px;
-            border: 1px solid rgba(0,0,0,0.08);
-            border-radius: 9999px;
-            background: var(--background-primary);
-            box-shadow: 0 2px 6px rgba(0,0,0,0.06);
+CUSTOM_STYLE_AND_VAD = """
+<style>
+html, body {height: auto !important; overflow-y: auto !important;}
+.gradio-container {max-width: 960px; margin: 0 auto; padding: 12px;}
+#chat-wrap {position: relative;}
+#chat-input-row {transform: translateY(-28px); margin-bottom: -28px;}
+
+/* ChatGPT-like Bottom Bar */
+#chat-input-row {
+    align-items: center;
+    gap: 8px;
+    padding: 8px 12px;
+    border: 1px solid rgba(0,0,0,0.08);
+    border-radius: 9999px;
+    background: var(--background-primary);
+    box-shadow: 0 2px 6px rgba(0,0,0,0.06);
+}
+
+/* Textbox inside pill */
+#chat-textbox textarea {
+    min-height: 42px;
+    max-height: 120px;
+    border: none !important;
+    background: transparent !important;
+    box-shadow: none !important;
+    resize: none;
+    padding-left: 0;
+}
+
+/* Icon buttons (plus, mic, send) */
+.icon-btn, .compact-btn {
+    width: 32px;
+    height: 32px;
+    border-radius: 9999px !important;
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    border: 1px solid rgba(0,0,0,0.08) !important;
+    background: #f7f7f8 !important;
+    box-shadow: none !important;
+}
+.send-btn {
+    background: #111 !important;
+    color: #fff !important;
+    border-color: #111 !important;
+}
+
+/* Make audio mic compact and borderless */
+#chat-audio {min-width: 32px; border: none !important; background: transparent !important;}
+#chat-audio .wrap, #chat-audio .audio-wrap, #chat-audio .audio-controls {max-width: 32px;}
+#chat-textbox textarea {border: none !important; outline: none !important;}
+@media (max-width: 768px) { #chat-input-row {transform: none; margin-bottom: 0;} }
+</style>
+
+<script>
+/*
+ * Voice Activity Detection (VAD) nach Gradio Guide:
+ * Nutzt @ricky0123/vad-web, um automatisch auf die
+ * .record-button / .stop-button der Audio-Komponente zu klicken.
+ */
+async function init_vad() {
+  try {
+    const script1 = document.createElement("script");
+    script1.src = "https://cdn.jsdelivr.net/npm/onnxruntime-web@1.14.0/dist/ort.js";
+    document.head.appendChild(script1);
+
+    const script2 = document.createElement("script");
+    script2.onload = async () =>  {
+      console.log("VAD JS geladen");
+      const recordButton = document.querySelector('.record-button');
+      if (recordButton) {
+        recordButton.textContent = "Just start talking";
+      }
+      const myvad = await vad.MicVAD.new({
+        onSpeechStart: () => {
+          const record = document.querySelector('.record-button');
+          const player = document.querySelector('#streaming-out');
+          if (record && (!player || player.paused)) {
+            console.log("VAD: speech start → record.click()");
+            record.click();
+          }
+        },
+        onSpeechEnd: (audio) => {
+          const stop = document.querySelector('.stop-button');
+          if (stop) {
+            console.log("VAD: speech end → stop.click()");
+            stop.click();
+          }
         }
+      });
+      myvad.start();
+    };
+    script2.src = "https://cdn.jsdelivr.net/npm/@ricky0123/vad-web@0.0.7/dist/bundle.min.js";
+    document.head.appendChild(script2);
+  } catch (e) {
+    console.log("VAD init Fehler:", e);
+  }
+}
+if (typeof window !== "undefined") {
+  window.addEventListener("load", init_vad);
+}
+</script>
+"""
 
-        /* Textbox inside pill */
-        #chat-textbox textarea {
-            min-height: 42px;
-            max-height: 120px;
-            border: none !important;
-            background: transparent !important;
-            box-shadow: none !important;
-            resize: none;
-            padding-left: 0;
-        }
 
-        /* Icon buttons (plus, mic, send) */
-        .icon-btn, .compact-btn {
-            width: 32px;
-            height: 32px;
-            border-radius: 9999px !important;
-            display: inline-flex;
-            align-items: center;
-            justify-content: center;
-            border: 1px solid rgba(0,0,0,0.08) !important;
-            background: #f7f7f8 !important;
-            box-shadow: none !important;
-        }
-        .send-btn {
-            background: #111 !important;
-            color: #fff !important;
-            border-color: #111 !important;
-        }
-        /* Make audio mic compact and borderless */
-        #chat-audio {min-width: 32px; border: none !important; background: transparent !important;}
-        #chat-audio .wrap, #chat-audio .audio-wrap, #chat-audio .audio-controls {max-width: 32px;}
-        #chat-textbox textarea {border: none !important; outline: none !important;}
-        @media (max-width: 768px) { #chat-input-row {transform: none; margin-bottom: 0;} }
-        </style>
-        """
-    )
+# =====================================================
+# UI – GRADIO (ChatGPT-artig + VAD)
+# =====================================================
+with gr.Blocks(title="Prüfungsrechts-Chatbot (RAG + Sprache)") as demo:
+    gr.HTML(CUSTOM_STYLE_AND_VAD)
+
     gr.Markdown("# 🧑‍⚖️ Prüfungsrechts-Chatbot")
     gr.Markdown(
         "Dieser Chatbot beantwortet Fragen **ausschließlich** aus der "
         "Prüfungsordnung (PDF) und dem Hochschulgesetz NRW. "
-        "Du kannst Text eingeben oder direkt ins Mikrofon sprechen."
+        "Du kannst Text eingeben oder einfach anfangen zu sprechen – "
+        "die Aufnahme startet/stopt automatisch (Voice Activity Detection)."
     )
 
-    # Einspaltiges Layout, alles untereinander (verhindert abgeschnittene Bereiche)
     with gr.Column(elem_id="chat-wrap"):
         chatbot = gr.Chatbot(
             label="Chat",
-            height=280,
+            height=380,
         )
 
+        # globaler State für Konversation usw.
+        state = gr.State(value=AppState())
+
         # Eingabezeile à la ChatGPT: Plus + Text + Mikro + Senden
         with gr.Row(elem_id="chat-input-row"):
-            attach_btn = gr.UploadButton("＋", file_types=["file"], file_count="multiple", elem_classes=["icon-btn"], scale=1)
+            attach_btn = gr.UploadButton(
+                "＋",
+                file_types=["file"],
+                file_count="multiple",
+                elem_classes=["icon-btn"],
+                scale=1,
+            )
             chat_text = gr.Textbox(
                 elem_id="chat-textbox",
                 label=None,
-                placeholder="Stelle irgendeine Frage",
+                placeholder="Stelle irgendeine Frage oder sprich einfach los …",
                 lines=1,
                 max_lines=6,
                 autofocus=True,
@@ -205,35 +287,43 @@ with gr.Blocks(title="Prüfungsrechts-Chatbot (RAG + Sprache)") as demo:
                 sources=["microphone"],
                 type="filepath",
                 format="wav",
-                streaming=True,
+                streaming=False,  # wichtig: record/stop Buttons für VAD
                 interactive=True,
                 scale=1,
                 show_label=False,
             )
-            send_btn = gr.Button("➤", elem_classes=["compact-btn", "send-btn"], scale=1)
+            send_btn = gr.Button(
+                "➤",
+                elem_classes=["compact-btn", "send-btn"],
+                scale=1,
+            )
 
-        # Senden bei Enter
+        # Senden bei Enter (Text)
         chat_text.submit(
             chat_fn,
-            [chat_text, chat_audio, chatbot],
-            [chatbot, chat_text, chat_audio],
+            [chat_text, chat_audio, chatbot, state],
+            [chatbot, state, chat_text, chat_audio],
         )
-        def transcribe_to_textbox(audio_path):
-            return transcribe_audio(audio_path, language=ASR_LANGUAGE_HINT)
+        # Audio-Stop (manuell oder durch VAD) → ganze Pipeline
         chat_audio.change(
-            transcribe_to_textbox,
-            [chat_audio],
-            [chat_text],
-        )
-        chat_audio.stream(
-            transcribe_to_textbox,
-            [chat_audio],
-            [chat_text],
+            chat_fn,
+            [chat_text, chat_audio, chatbot, state],
+            [chatbot, state, chat_text, chat_audio],
         )
+        # Senden-Button
         send_btn.click(
             chat_fn,
-            [chat_text, chat_audio, chatbot],
-            [chatbot, chat_text, chat_audio],
+            [chat_text, chat_audio, chatbot, state],
+            [chatbot, state, chat_text, chat_audio],
+        )
+
+        # Optional: Button "Antwort erneut vorlesen"
+        voice_out = gr.Audio(label="Vorgelesene Antwort", type="numpy", interactive=False, elem_id="streaming-out")
+        read_btn = gr.Button("🔁 Antwort erneut vorlesen")
+        read_btn.click(
+            read_last_answer,
+            [chatbot],
+            [voice_out],
         )
 
         # Quellen & Dokumente kompakt unterhalb

speech_io.py

@@ -2,14 +2,20 @@
 speech_io.py
 
 Sprachbasierte Ein-/Ausgabe:
-- Speech-to-Text (STT) mit Whisper (transformers.pipeline)
+- Speech-to-Text (STT) mit Whisper:
+    * lokal über transformers.pipeline
+    * optional über Groq Whisper (whisper-large-v3[-turbo])
 - Text-to-Speech (TTS) mit MMS-TTS Deutsch
 
-Dieses File ist 100% stabil für HuggingFace Spaces.
+Dieses File ist stabil für HuggingFace Spaces.
 """
 
+from __future__ import annotations
+
 import os
-from typing import Optional, Tuple
+import time
+from typing import Optional, Tuple, List, Dict, Any
+
 import numpy as np
 import soundfile as sf
 from scipy.signal import butter, filtfilt, resample
@@ -17,26 +23,43 @@ from transformers import pipeline
 import re
 import difflib
 
-# Modelle (per ENV konfigurierbar)
-# Standard jetzt "tiny" für schnellere Verarbeitung; setze ASR_MODEL_ID env auf small/base/medium für mehr Genauigkeit
+# Groq ist optional: nur genutzt, wenn installiert + API-Key gesetzt
+try:
+    from groq import Groq  # type: ignore
+except Exception:  # Modul evtl. nicht installiert
+    Groq = None  # type: ignore
+
+# ============================
+#  Konfiguration über ENV
+# ============================
+
+# Lokales Whisper (transformers) – Standard tiny für Geschwindigkeit.
 ASR_MODEL_ID = os.getenv("ASR_MODEL_ID", "openai/whisper-tiny")
+
+# Optional: Groq Whisper Backend
+USE_GROQ_WHISPER = os.getenv("USE_GROQ_WHISPER", "0").lower() in ("1", "true", "yes")
+GROQ_WHISPER_MODEL = os.getenv("GROQ_WHISPER_MODEL", "whisper-large-v3-turbo")
+
 TTS_MODEL_ID = os.getenv("TTS_MODEL_ID", "facebook/mms-tts-deu")
-ASR_DEFAULT_LANGUAGE = os.getenv("ASR_LANGUAGE", "de")  # "auto" um Auto-Detect zu erzwingen
+ASR_DEFAULT_LANGUAGE = os.getenv("ASR_LANGUAGE", "de")  # "auto" → Auto-Detekt
 TTS_ENABLED = os.getenv("TTS_ENABLED", "1").lower() not in ("0", "false", "no")
 ASR_PROMPT = os.getenv("ASR_PROMPT", "Dies ist ein Diktat in deutscher Sprache.")
 ASR_MAX_DURATION_S = int(os.getenv("ASR_MAX_DURATION_S", "30"))
 
 _asr = None
 _tts = None
+_groq_client = None
+
 
 # ========================================================
-# STT PIPELINE
+#  PIPELINES
 # ========================================================
 
 def get_asr_pipeline():
+    """Lokales Whisper-Pipeline (transformers)."""
     global _asr
     if _asr is None:
-        print(f">>> Lade ASR Modell: {ASR_MODEL_ID}")
+        print(f">>> Lade lokales ASR Modell: {ASR_MODEL_ID}")
         _asr = pipeline(
             task="automatic-speech-recognition",
             model=ASR_MODEL_ID,
@@ -47,9 +70,6 @@ def get_asr_pipeline():
         )
     return _asr
 
-# ========================================================
-# TTS PIPELINE
-# ========================================================
 
 def get_tts_pipeline():
     global _tts
@@ -61,8 +81,26 @@ def get_tts_pipeline():
         )
     return _tts
 
+
+def get_groq_client():
+    """Lazy Init des Groq-Clients – nur wenn USE_GROQ_WHISPER aktiv ist."""
+    global _groq_client
+    if _groq_client is None:
+        if Groq is None:
+            raise RuntimeError(
+                "Groq Python-Client nicht installiert. "
+                "Bitte `pip install groq` und USE_GROQ_WHISPER=1 setzen."
+            )
+        api_key = os.getenv("GROQ_API_KEY")
+        if not api_key:
+            raise RuntimeError("GROQ_API_KEY ist nicht gesetzt.")
+        _groq_client = Groq(api_key=api_key)  # type: ignore
+        print(">>> Groq-Client initialisiert.")
+    return _groq_client
+
+
 # ========================================================
-# AUDIO FILTER – Noise Reduction + Highpass
+#  AUDIO FILTER – Noise Reduction + Highpass
 # ========================================================
 
 def butter_highpass_filter(data, cutoff=60, fs=16000, order=4):
@@ -71,6 +109,7 @@ def butter_highpass_filter(data, cutoff=60, fs=16000, order=4):
     b, a = butter(order, norm_cutoff, btype="high")
     return filtfilt(b, a, data)
 
+
 def apply_fade(audio, sr, duration_ms=10):
     fade_samples = int(sr * duration_ms / 1000)
 
@@ -85,22 +124,90 @@ def apply_fade(audio, sr, duration_ms=10):
 
     return audio
 
+
 # ========================================================
-# SPEECH-TO-TEXT (STT)
+#  GROQ-WHISPER HELFER
 # ========================================================
 
-def transcribe_audio(audio_path: str, language: Optional[str] = None, max_duration_s: int = ASR_MAX_DURATION_S) -> str:
+def _process_groq_whisper_response(completion: Any) -> str:
     """
-    audio_path: path zu WAV-Datei (von gr.Audio type="filepath")
-    language: Optional Sprachcode (z.B. "de", "en"); None = Auto-Detect
-    max_duration_s: begrenzt Audiolänge für schnellere Verarbeitung
+    Auswertung der Groq Whisper-Antwort (verbose_json) analog zum Gradio-Guide:
+    - nutzt no_speech_prob, um reines Rauschen zu filtern
     """
+    # completion kann ein Pydantic-Objekt oder ein dict sein
+    segments = None
+    text = getattr(completion, "text", None)
+    if hasattr(completion, "segments"):
+        segments = completion.segments
+    elif isinstance(completion, dict):
+        segments = completion.get("segments", [])
+        text = completion.get("text", "")
+
+    if not segments:
+        return ""
+
+    first = segments[0]
+    if isinstance(first, dict):
+        no_speech_prob = first.get("no_speech_prob", 0.0)
+    else:
+        no_speech_prob = getattr(first, "no_speech_prob", 0.0)
+
+    print("Groq Whisper no_speech_prob:", no_speech_prob)
+    if no_speech_prob > 0.7:
+        # wahrscheinlich nur Rauschen
+        return ""
+
+    if text is None:
+        return ""
+    return str(text).strip()
+
+
+def transcribe_with_groq(audio_path: str, language: Optional[str]) -> str:
+    """
+    STT über Groq Whisper (whisper-large-v3(-turbo)).
+    Erwartet eine Audiodatei (z.B. WAV) von gr.Audio (type='filepath').
+    """
+    client = get_groq_client()
+
+    if language:
+        lang_param = None if language.lower() == "auto" else language
+    else:
+        if ASR_DEFAULT_LANGUAGE and ASR_DEFAULT_LANGUAGE.lower() != "auto":
+            lang_param = ASR_DEFAULT_LANGUAGE
+        else:
+            lang_param = None
+
+    try:
+        with open(audio_path, "rb") as audio_file:
+            resp = client.audio.transcriptions.with_raw_response.create(
+                model=GROQ_WHISPER_MODEL,
+                file=("audio.wav", audio_file),
+                response_format="verbose_json",
+                language=lang_param,
+            )
+            completion = resp.parse()
+    except Exception as e:
+        print(f"Groq Whisper Fehler: {e}")
+        return ""
+
+    text = _process_groq_whisper_response(completion)
+    print("Groq ASR:", text)
+    return text
+
+
+# ========================================================
+#  SPEECH-TO-TEXT (lokal) – wie bisher
+# ========================================================
 
+def _transcribe_local_whisper(
+    audio_path: str,
+    language: Optional[str] = None,
+    max_duration_s: int = ASR_MAX_DURATION_S,
+) -> str:
     if audio_path is None or not os.path.exists(audio_path):
         print(">>> Kein Audio gefunden.")
         return ""
 
-    # WAV einlesen (soundfile garantiert PCM korrekt)
     data, sr = sf.read(audio_path, always_2d=False)
 
     if data is None or data.size == 0:
@@ -114,19 +221,18 @@ def transcribe_audio(audio_path: str, language: Optional[str] = None, max_durati
     data = np.clip(data, -1.0, 1.0)
     try:
         data = butter_highpass_filter(data, cutoff=60, fs=sr)
-    except:
+    except Exception:
         pass
+
     m = np.max(np.abs(data))
     if m > 0:
         data = data / m
 
-    # sehr leise Aufnahmen filtern, damit nicht nur Rauschen erkannt wird
     rms = float(np.sqrt(np.mean(data ** 2)))
     if rms < 5e-5:
         print(">>> Audio zu leise, breche ab.")
         return ""
 
-    # bei zu hoher Samplingrate auf 16 kHz runterskalieren (schneller, kleiner)
     TARGET_SR = 16000
     if sr != TARGET_SR:
         target_len = int(len(data) * TARGET_SR / sr)
@@ -135,15 +241,16 @@ def transcribe_audio(audio_path: str, language: Optional[str] = None, max_durati
 
     idx = np.where(np.abs(data) > 0.02)[0]
     if idx.size:
-        data = data[idx[0]:idx[-1]+1]
+        data = data[idx[0]: idx[-1] + 1]
 
-    # Stats zum Debuggen
     duration_s = len(data) / sr if sr else 0
     rms = float(np.sqrt(np.mean(data ** 2)))
     peak = float(np.max(np.abs(data))) if data.size else 0.0
-    print(f">>> Audio stats – sr: {sr}, len: {len(data)}, dur: {duration_s:.2f}s, rms: {rms:.6f}, peak: {peak:.6f}")
+    print(
+        f">>> Audio stats – sr: {sr}, len: {len(data)}, "
+        f"dur: {duration_s:.2f}s, rms: {rms:.6f}, peak: {peak:.6f}"
+    )
 
-    # sehr leise / sehr kurze Aufnahmen filtern, damit nicht nur Rauschen erkannt wird
     if duration_s < 0.3:
         print(">>> Audio zu kurz, breche ab.")
         return ""
@@ -151,22 +258,20 @@ def transcribe_audio(audio_path: str, language: Optional[str] = None, max_durati
         print(">>> Audio zu leise, breche ab.")
         return ""
 
-    # Whisper > max_duration_s vermeiden
     MAX_SAMPLES = sr * max_duration_s
     if len(data) > MAX_SAMPLES:
         data = data[:MAX_SAMPLES]
 
     asr = get_asr_pipeline()
 
-    print(">>> Transkribiere Audio...")
+    print(">>> Transkribiere Audio (lokal)...")
     lang = language
     if not lang and ASR_DEFAULT_LANGUAGE and ASR_DEFAULT_LANGUAGE.lower() != "auto":
         lang = ASR_DEFAULT_LANGUAGE
     if isinstance(lang, str) and lang.lower() == "auto":
         lang = None
 
-    call_kwargs = {}
-    # Dynamische Dekodier-Settings: kurze Clips -> kleinere Token-Budgets gegen Halluzination
+    call_kwargs: Dict[str, Any] = {}
     token_budget = 120
     if duration_s < 2.0:
         token_budget = 60
@@ -184,6 +289,7 @@ def transcribe_audio(audio_path: str, language: Optional[str] = None, max_durati
             "logprob_threshold": -1.0,
             "no_speech_threshold": 0.6,
             "no_repeat_ngram_size": 3,
+            "prompt": ASR_PROMPT,
         }
 
     result = asr({"array": data, "sampling_rate": sr}, **call_kwargs)
@@ -193,6 +299,7 @@ def transcribe_audio(audio_path: str, language: Optional[str] = None, max_durati
 
     text = result.get("text", "") if isinstance(result, dict) else str(result)
     text = text.strip()
+
     def _fix_domain_terms(s: str) -> str:
         pairs = [
             (r"\bbriefe\s*um\b", "prüfung"),
@@ -203,8 +310,15 @@ def transcribe_audio(audio_path: str, language: Optional[str] = None, max_durati
         for pat, rep in pairs:
             s = re.sub(pat, rep, s, flags=re.IGNORECASE)
         vocab = [
-            "prüfung","prüfungsordnung","hochschulgesetz","modul","klausur",
-            "immatrikulation","exmatrikulation","anmeldung","wiederholung"
+            "prüfung",
+            "prüfungsordnung",
+            "hochschulgesetz",
+            "modul",
+            "klausur",
+            "immatrikulation",
+            "exmatrikulation",
+            "anmeldung",
+            "wiederholung",
         ]
         tokens = s.split()
         fixed = []
@@ -212,12 +326,42 @@ def transcribe_audio(audio_path: str, language: Optional[str] = None, max_durati
             cand = difflib.get_close_matches(t.lower(), vocab, n=1, cutoff=0.82)
             fixed.append(cand[0] if cand else t)
         return " ".join(fixed)
+
     text = _fix_domain_terms(text)
-    print("ASR:", text)
+    print("ASR (lokal):", text)
     return text
 
+
 # ========================================================
-# TEXT-TO-SPEECH (TTS)
+#  Public STT-Funktion – wählt Backend (lokal vs Groq)
+# ========================================================
+
+def transcribe_audio(
+    audio_path: str,
+    language: Optional[str] = None,
+    max_duration_s: int = ASR_MAX_DURATION_S,
+) -> str:
+    """
+    High-Level STT-API:
+    - Wenn USE_GROQ_WHISPER=1 und GROQ_API_KEY gesetzt → Groq Whisper
+    - sonst lokales Whisper (transformers)
+    """
+
+    if not audio_path:
+        return ""
+
+    if USE_GROQ_WHISPER:
+        try:
+            return transcribe_with_groq(audio_path, language)
+        except Exception as e:
+            # Fallback auf lokales Modell, falls Groq fehlschlägt
+            print(f">>> Groq Whisper Fehler, fallback auf lokal: {e}")
+
+    return _transcribe_local_whisper(audio_path, language, max_duration_s)
+
+
+# ========================================================
+#  TEXT-TO-SPEECH (TTS)
 # ========================================================
 
 def synthesize_speech(text: str):
@@ -227,36 +371,88 @@ def synthesize_speech(text: str):
     tts = get_tts_pipeline()
     out = tts(text)
 
-    # rohes Audio from MMS (float32 [-1, 1])
     audio = np.array(out["audio"], dtype=np.float32)
     sr = out.get("sampling_rate", 16000)
 
-    # ===== FIX sample_rate =====
     if sr is None or sr <= 0 or sr > 65535:
         sr = 16000
 
-    # ===== Mono erzwingen =====
     if audio.ndim > 1:
         audio = audio.squeeze()
     if audio.ndim > 1:
         audio = audio[:, 0]
 
-    # ===== Noise reduction =====
     try:
         audio = butter_highpass_filter(audio, cutoff=60, fs=sr)
-    except:
+    except Exception:
         pass
 
-    # ===== Normalize =====
     max_val = np.max(np.abs(audio))
     if max_val > 0:
         audio = audio / max_val
 
-    # ===== Fade gegen pop =====
     audio = apply_fade(audio, sr)
 
-    # ===== int16 =====
     audio_int16 = np.clip(audio * 32767, -32768, 32767).astype(np.int16)
 
-    # Rückgabe: (sr, np.int16 array)
-    return (sr, audio_int16)
+    return sr, audio_int16
+
+
+# ========================================================
+#  SIMPLE BENCHMARK-FUNKTION FÜR WHISPER-MODELLE
+# ========================================================
+
+def benchmark_asr_models(
+    audio_path: str,
+    local_models: Optional[List[str]] = None,
+    groq_models: Optional[List[str]] = None,
+) -> Dict[str, Dict[str, Any]]:
+    """
+    Einfache Benchmark-Routine:
+    - misst Laufzeit und Textlänge für verschiedene Whisper-Modelle
+    - wird NICHT automatisch im Space ausgeführt, nur manuell aufrufbar.
+
+    Beispiel (lokal):
+        benchmark_asr_models("sample.wav",
+                             local_models=["openai/whisper-tiny","openai/whisper-small"])
+
+    Beispiel (Groq, falls GROQ_API_KEY vorhanden):
+        benchmark_asr_models("sample.wav",
+                             groq_models=["whisper-large-v3-turbo","whisper-large-v3"])
+    """
+    results: Dict[str, Dict[str, Any]] = {}
+
+    if local_models:
+        for mid in local_models:
+            t0 = time.perf_counter()
+            global _asr
+            _asr = None
+            os.environ["ASR_MODEL_ID"] = mid
+            text = _transcribe_local_whisper(audio_path, language=None)
+            dt = time.perf_counter() - t0
+            results[f"local::{mid}"] = {
+                "seconds": dt,
+                "chars": len(text),
+                "text_sample": text[:120],
+            }
+
+    if groq_models:
+        if Groq is None or not os.getenv("GROQ_API_KEY"):
+            print(">>> Groq Benchmark übersprungen (kein Client/API-Key).")
+        else:
+            for mid in groq_models:
+                t0 = time.perf_counter()
+                global GROQ_WHISPER_MODEL
+                GROQ_WHISPER_MODEL = mid
+                text = transcribe_with_groq(audio_path, language=None)
+                dt = time.perf_counter() - t0
+                results[f"groq::{mid}"] = {
+                    "seconds": dt,
+                    "chars": len(text),
+                    "text_sample": text[:120],
+                }
+
+    for name, info in results.items():
+        print(f"[{name}] {info['seconds']:.2f}s – {info['chars']} chars")
+
+    return results