Update app.py

app.py

@@ -1,100 +1,129 @@
 import gradio as gr
-import requests
-import os
-from dotenv import load_dotenv
+from huggingface_hub import InferenceClient
 import speech_recognition as sr
 import pyttsx3
+import os
+import requests
+
+# Load API Key securely
+API_KEY = "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"  # Replace with your actual API key
+MODEL_NAME = "mistralai/mistral-7b-instruct"  # Ensure this model is accessible
+
+# Check if API key is set
+if not API_KEY:
+    raise ValueError("Error: Hugging Face API key is missing. Set HF_API_KEY as an environment variable.")
 
-# Load environment variables (assuming Gemini API key is stored in a .env file)
-load_dotenv()
+# Verify API Key
+headers = {"Authorization": f"Bearer {API_KEY}"}
+response = requests.get("https://huggingface.co/api/whoami-v2", headers=headers)
 
-# Replace this with the actual API URL for Gemini
-GEMINI_API_URL = "https://api.gemini.com/v1/query"  # You need to replace this URL
+if response.status_code != 200:
+    raise ValueError(f"Invalid API Key! Error: {response.json()}")
 
-# Retrieve your API key securely from environment variables
-API_KEY = os.getenv("GEMINI_API_KEY")
+print("API Key is valid!")
 
-# Function to send messages to Gemini API
-def call_gemini_api(messages):
-    headers = {
-        "Authorization": f"Bearer {API_KEY}",
-        "Content-Type": "application/json",
-    }
+# Initialize the InferenceClient
+client = InferenceClient(model=MODEL_NAME, token=API_KEY)
 
-    # Create the request body based on your messages (adjust format as per Gemini's API)
-    data = {
-        "messages": messages,
-        "max_tokens": 512,  # Adjust token length as needed
-    }
+# System message for the chatbot
+system_message = "You are a friendly and helpful chatbot."
 
+# Function to process chat input
+def respond(message, history=None, audio_input=None):
     try:
-        # Making the POST request to the Gemini API URL
-        response = requests.post(GEMINI_API_URL, headers=headers, json=data)
-        response.raise_for_status()
-        return response.json()  # Assuming Gemini returns JSON response
-    except requests.exceptions.RequestException as e:
-        print(f"Error calling Gemini API: {e}")
-        return {"error": str(e)}
-
-# Define the respond function
-def respond(message, history: list[tuple[str, str]], audio_input=None):
-    # If audio input is provided, convert it to text
-    if audio_input:
-        message = voice_to_text(audio_input)
-    
-    # Prepare the messages for the Gemini API
-    messages = [{"role": "system", "content": "You are a friendly and helpful chatbot."}]
-    
-    # Add history to the messages list
-    for val in history:
-        if val[0]:  # Check if user message exists
-            messages.append({"role": "user", "content": val[0]})
-        if val[1]:  # Check if assistant message exists
-            messages.append({"role": "assistant", "content": val[1]})
-
-    # Append the current user message
-    messages.append({"role": "user", "content": message})
-
-    # Get the Gemini API response
-    response_data = call_gemini_api(messages)
-
-    # Assuming Gemini API returns a 'content' key in the response
-    response = response_data.get("content", "Sorry, I could not process your request.")
-    
-    return response
-
-# Convert voice input (audio) to text
-def voice_to_text(audio):
+        # 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})
+
+        # Log input messages for debugging
+        print("Sending messages:", messages)
+
+        # Get response from Hugging Face API
+        chat_response = client.post_json(
+            repo_id=MODEL_NAME,
+            payload={"inputs": message, "parameters": {"max_new_tokens": 512}},
+        )
+
+        # Log API response for debugging
+        print("Raw API Response:", chat_response)
+
+        # Validate API Response
+        if chat_response is None or "error" in chat_response:
+            return "Error: No response from API. Check API key and model permissions.", None
+
+        # Extract chatbot response
+        response = chat_response.get("generated_text", "").strip()
+
+        if not response:
+            response = "Error: Model returned an empty response."
+
+    except Exception as e:
+        response = f"Error: {str(e)}"
+        print("Exception Occurred:", e)
+
+    # Convert response to speech
+    audio_output = text_to_voice(response)
+    return response, audio_output
+
+
+# Convert audio to text
+def voice_to_text(audio_path):
     recognizer = sr.Recognizer()
-    with sr.AudioFile(audio.name) as source:
-        audio_data = recognizer.record(source)
-        try:
-            text = recognizer.recognize_google(audio_data)  # Convert to text using Google's speech recognition
-        except sr.UnknownValueError:
-            text = "Sorry, I could not understand the audio."
-        except sr.RequestError:
-            text = "Could not request results from Google Speech Recognition service."
+    try:
+        with sr.AudioFile(audio_path) as source:
+            audio_data = recognizer.record(source)
+            text = recognizer.recognize_google(audio_data)
+    except sr.UnknownValueError:
+        text = "Sorry, I could not understand the audio."
+    except sr.RequestError:
+        text = "Could not connect to the recognition service."
+    except Exception as e:
+        text = f"Audio Processing Error: {str(e)}"
     return text
 
-# Convert text to speech (voice output)
+
+# Convert text to speech
 def text_to_voice(text):
-    engine = pyttsx3.init()
-    engine.save_to_file(text, 'response.mp3')
-    engine.runAndWait()
-    return 'response.mp3'
+    try:
+        audio_filename = "response.mp3"
+        engine = pyttsx3.init()
+        engine.save_to_file(text, audio_filename)
+        engine.runAndWait()
+        return audio_filename
+    except Exception as e:
+        print(f"TTS Error: {e}")
+        return None
+
 
-# Create the Gradio interface
+# Gradio UI
 demo = gr.Interface(
     fn=respond,
     inputs=[
-        gr.Textbox(label="Text Input (or leave blank to use audio input)", placeholder="Enter your message here..."),  # Text input
-        gr.Audio(type="filepath", label="Audio Input (or leave blank to use text input)"),  # Audio input
+        gr.Textbox(label="Text Input", placeholder="Enter your message..."),
+        gr.Audio(type="filepath", label="Audio Input (optional)"),  # Audio input field
     ],
     outputs=[
-        gr.Textbox(label="Text Output"),  # Text output
-        gr.Audio(label="Voice Output")  # Voice output
-    ]
+        gr.Textbox(label="Chatbot Response"),  # Text output field
+        gr.Audio(label="Voice Output")  # Voice output field
+    ],
 )
 
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch(debug=True)  # Enable debug mode for troubleshooting