Update app.py

app.py

@@ -1,38 +1,57 @@
-import streamlit as st
 import os
-import google.generativeai as genai
 import io
-import soundfile as sf
+import streamlit as st
 from groq import Groq
+import soundfile as sf
+import google.generativeai as genai
 
-# Streamlit Seite konfigurieren
-st.set_page_config(
-    page_title="Gemini-2 Chatbot mit Spracheingabe",
-    page_icon="🤖"
-)
+# Umgebungsvariablen laden
+groq_api_key = os.getenv('groqwhisper')
+gemini_api_key = os.getenv('geminiapi')
 
-# Load environment variables for Groq
-api_key = os.getenv('groqwhisper')
-if api_key is None:
-    st.error("The 'groq_whisper' environment variable is not set. Please set it and restart the app.")
+if not groq_api_key or not gemini_api_key:
+    st.error("Bitte setze die Umgebungsvariablen 'groqwhisper' und 'geminiapi'")
     st.stop()
 
-# Initialize Groq client
-client = Groq(api_key=api_key)
+# Groq Client initialisieren
+groq_client = Groq(api_key=groq_api_key)
+
+# Gemini konfigurieren
+genai.configure(api_key=gemini_api_key)
+
+# Modellkonfiguration
+generation_config = {
+    "temperature": 0.4,
+    "top_p": 0.95,
+    "top_k": 40,
+    "max_output_tokens": 8192,
+    "response_mime_type": "text/plain",
+}
+
+model = genai.GenerativeModel(
+    model_name="gemini-2.0-flash-exp",
+    generation_config=generation_config,
+)
+
+# Session State für Chatverlauf
+if "chat_session" not in st.session_state:
+    st.session_state.chat_session = model.start_chat(history=[])
+
+if "display_history" not in st.session_state:
+    st.session_state.display_history = []
 
-# Funktion zur Verarbeitung von Audio
 def process_audio(audio_data):
-    """Process audio data and return transcription."""
+    """Verarbeitet Audiodaten und gibt Transkript zurück."""
     try:
         sample_rate, samples = audio_data
         
-        # Create in-memory WAV file
+        # WAV-Datei im Speicher erstellen
         with io.BytesIO() as wav_buffer:
             sf.write(wav_buffer, samples, sample_rate, format='WAV')
             wav_buffer.seek(0)
             
-            # Send to Groq for transcription
-            transcription = client.audio.transcriptions.create(
+            # Transkription mit Groq
+            transcription = groq_client.audio.transcriptions.create(
                 file=("recording.wav", wav_buffer.read(), "audio/wav"),
                 model="whisper-large-v3-turbo",
                 prompt="transcribe",
@@ -42,73 +61,52 @@ def process_audio(audio_data):
             )
         return transcription.text
     except Exception as e:
-        return f"An error occurred: {str(e)}"
-
-# Gemini API Konfiguration
-genai.configure(api_key=os.environ["geminiapi"])
+        return f"Fehler: {str(e)}"
 
-# Modell-Konfiguration
-generation_config = {
-    "temperature": 0.4,
-    "top_p": 0.95,
-    "top_k": 40,
-    "max_output_tokens": 8192,
-    "response_mime_type": "text/plain",
-}
-
-model = genai.GenerativeModel(
-    model_name="gemini-2.0-flash-exp",
-    generation_config=generation_config,
-    #grounding_config=grounding_config
+# Streamlit UI
+st.set_page_config(
+    page_title="Gemini Chatbot mit Spracheingabe",
+    page_icon="🤖"
 )
+st.title("Gemini Chatbot 🎤+📝")
 
-# Chat Session State initialisieren
-if "chat_session" not in st.session_state:
-    st.session_state.chat_session = model.start_chat(history=[])
-
-# UI Komponenten
-st.title("Gemini-2 Chatbot mit Spracheingabe")
-
-# Audio recorder component
-audio_bytes = st.audio_input("Klicke zum Aufnehmen", key="audio_input")
-
-# Chat Input
-user_input = st.text_input("Oder schreibe deine Frage:", key="text_input")
+# Chatverlauf anzeigen
+for role, text in st.session_state.display_history:
+    with st.chat_message(role):
+        st.markdown(text)
 
+# Spracheingabe verarbeiten
+audio_bytes = st.audio_input("Sprachnachricht aufnehmen")
 if audio_bytes:
-    # Extrahiere die Bytes aus dem UploadedFile-Objekt
-    audio_bytes_content = audio_bytes.getvalue()
-    
-    # Konvertiere die Bytes in ein numpy-Array mit soundfile
-    with io.BytesIO(audio_bytes_content) as wav_io:
-        samples, sample_rate = sf.read(wav_io)
-        
-        # Konvertiere Stereo in Mono, falls erforderlich
-        if len(samples.shape) > 1 and samples.shape[1] == 2:
-            samples = samples.mean(axis=1)
-        
-        # Verarbeite das Audio
-        with st.spinner("Transcribing..."):
-            transcription = process_audio((sample_rate, samples))
-        
-        # Verarbeitet die Transkription als Eingabe für den Chatbot
-        if transcription:
-           user_input = transcription
+    try:
+        audio_content = audio_bytes.getvalue()
+        with io.BytesIO(audio_content) as wav_io:
+            samples, sample_rate = sf.read(wav_io)
+            if len(samples.shape) > 1 and samples.shape[1] == 2:
+                samples = samples.mean(axis=1)
+                
+            with st.spinner("Transkription..."):
+                transcription = process_audio((sample_rate, samples))
+                
+            if transcription:
+                if transcription.startswith("Fehler:"):
+                    st.error(transcription)
+                else:
+                    st.session_state.display_history.append(("user", transcription))
+                    full_prompt = f"{transcription}\nAntworte immer auf Deutsch"
+                    response = st.session_state.chat_session.send_message(full_prompt)
+                    response_text = response.candidates[0].content.parts[0].text if response.candidates else "Keine Antwort"
+                    st.session_state.display_history.append(("assistant", response_text))
+                    st.rerun()
+    except Exception as e:
+        st.error(f"Audioprocessing fehlgeschlagen: {str(e)}")
 
+# Texteingabe verarbeiten
+user_input = st.text_input("Schreibe deine Frage:", key="user_input")
 if user_input:
-    messages = st.container()
-    # Prompt mit Sprachaufforderung kombinieren
+    st.session_state.display_history.append(("user", user_input))
     full_prompt = f"{user_input}\nAntworte immer auf Deutsch"
-    
-    # Antwort generieren
     response = st.session_state.chat_session.send_message(full_prompt)
-    
-    # Antwort extrahieren
-    if response.candidates:
-        response_text = response.candidates[0].content.parts[0].text
-    else:
-        response_text = "Keine Antwort erhalten"
-    
-    # Antwort anzeigen
-    messages.chat_message("user").write(f"{user_input}")
-    messages.chat_message("assistant").write(f"{response_text}")
+    response_text = response.candidates[0].content.parts[0].text if response.candidates else "Keine Antwort"
+    st.session_state.display_history.append(("assistant", response_text))
+    st.rerun()