Update app.py

app.py

@@ -1,89 +1,76 @@
 import gradio as gr
+import requests
 import speech_recognition as sr
 import pyttsx3
-import requests
-
-# Load Groq API Key securely
-API_KEY = "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"  # Replace with your actual Groq API key
-MODEL_NAME = "groq-model-id"  # Ensure this model is accessible on Groq Cloud
 
-# Check if API key is set
-if not API_KEY:
-    raise ValueError("Error: Groq API key is missing. Set the API key.")
+# Define the Groq Cloud API key and model name
+API_KEY = "YOUR_GROQ_API_KEY"  # Replace with your Groq Cloud API Key
+MODEL_NAME = "groq-model-id"  # Replace with the actual model ID from Groq Cloud
 
-# Headers for authorization
-headers = {
-    "Authorization": f"Bearer {API_KEY}",
-    "Content-Type": "application/json"
-}
+# Groq Cloud API endpoint
+API_URL = f"https://api.groq.ai/v1/models/{MODEL_NAME}/predict"
 
-# URL for Groq Cloud model endpoint (example URL, replace with actual Groq Cloud endpoint)
-url = f"https://api.groq.ai/v1/models/{MODEL_NAME}/predict"
+# Verify API Key with Groq Cloud
+headers = {"Authorization": f"Bearer {API_KEY}"}
+response = requests.get("https://api.groq.ai/v1/whoami", headers=headers)
 
-# System message for the chatbot
-system_message = "You are a friendly and helpful chatbot."
+# Check if API Key is valid
+if response.status_code != 200:
+    raise ValueError(f"Invalid API Key! Error: {response.json()}")
+else:
+    print("API Key is valid!")
 
-# Function to process chat input
+# Function to process the chat input
 def respond(message, history=None, audio_input=None):
+    if history is None:
+        history = []
+
+    # If audio input is provided, convert it to text
+    if audio_input:
+        message = voice_to_text(audio_input)
+
+    # Prepare message history for context
+    messages = [{"role": "system", "content": "You are a friendly chatbot."}]
+    for user_msg, bot_msg in history:
+        if user_msg:
+            messages.append({"role": "user", "content": user_msg})
+        if bot_msg:
+            messages.append({"role": "assistant", "content": bot_msg})
+    messages.append({"role": "user", "content": message})
+
+    # Send message to Groq Cloud API
     try:
-        # If history is None, initialize it as an empty list
-        if history is None:
-            history = []
-
-        # If audio input is provided, convert it to text
-        if audio_input:
-            message = voice_to_text(audio_input)
-
-        # Ensure message is not empty
-        if not message or message.strip() == "":
-            return "Error: No input provided.", None
-
-        # Prepare message history
-        messages = [{"role": "system", "content": system_message}]
-        for user_msg, bot_msg in history:
-            if user_msg:
-                messages.append({"role": "user", "content": user_msg})
-            if bot_msg:
-                messages.append({"role": "assistant", "content": bot_msg})
-        messages.append({"role": "user", "content": message})
-
-        # Prepare the payload for Groq Cloud
+        # API request payload
         payload = {
             "inputs": message,
-            "parameters": {"max_new_tokens": 512}  # Optional parameters like max tokens
+            "parameters": {"max_new_tokens": 512}
         }
 
-        # Send the request to Groq Cloud API
-        response = requests.post(url, json=payload, headers=headers)
+        # Send POST request to the Groq Cloud API
+        response = requests.post(API_URL, headers=headers, json=payload)
 
-        # Validate API Response
-        if response.status_code != 200:
-            return f"Error: No response from API. Check API key and model permissions. Status: {response.status_code}", None
-
-        # Extract chatbot response
-        chat_response = response.json()
-
-        if "generated_text" in chat_response:
-            response_text = chat_response["generated_text"].strip()
+        if response.status_code == 200:
+            # Get the chatbot's response from the API
+            chat_response = response.json()
+            chatbot_reply = chat_response.get("generated_text", "")
         else:
-            response_text = "Error: Model returned an empty response."
+            raise ValueError(f"API Error: {response.status_code}, {response.text}")
 
     except Exception as e:
-        response_text = f"Error: {str(e)}"
-        print("Exception Occurred:", e)
+        chatbot_reply = f"Error: {str(e)}"
 
-    # Convert response to speech
-    audio_output = text_to_voice(response_text)
-    return response_text, audio_output
+    # Convert text response to speech
+    audio_output = text_to_voice(chatbot_reply)
+    return chatbot_reply, audio_output
 
 
-# Convert audio to text
+# Convert voice input (audio) to text
 def voice_to_text(audio_path):
     recognizer = sr.Recognizer()
     try:
         with sr.AudioFile(audio_path) as source:
             audio_data = recognizer.record(source)
-            text = recognizer.recognize_google(audio_data)
+            text = recognizer.recognize_google(audio_data)  # Using Google's speech recognition
     except sr.UnknownValueError:
         text = "Sorry, I could not understand the audio."
     except sr.RequestError:
@@ -93,7 +80,7 @@ def voice_to_text(audio_path):
     return text
 
 
-# Convert text to speech
+# Convert text to speech (voice output)
 def text_to_voice(text):
     try:
         audio_filename = "response.mp3"
@@ -102,11 +89,11 @@ def text_to_voice(text):
         engine.runAndWait()
         return audio_filename
     except Exception as e:
-        print(f"TTS Error: {e}")
+        print(f"Error converting text to speech: {e}")
         return None
 
 
-# Gradio UI
+# Create the Gradio interface
 demo = gr.Interface(
     fn=respond,
     inputs=[
@@ -116,8 +103,8 @@ demo = gr.Interface(
     outputs=[
         gr.Textbox(label="Chatbot Response"),
         gr.Audio(label="Voice Output")
-    ],
+    ]
 )
 
 if __name__ == "__main__":
-    demo.launch(debug=True)  # Enable debug mode for troubleshooting
+    demo.launch(debug=True)