Update app.py

app.py

@@ -1,63 +1,68 @@
 import gradio as gr
-import torch
-from transformers import AutoTokenizer, AutoModelForCausalLM
-import pyttsx3
+import requests
+import os
+from dotenv import load_dotenv
 import speech_recognition as sr
-from huggingface_hub import InferenceClient
+import pyttsx3
 
-# API Key for HuggingFace InferenceClient
-API_KEY = "AIzaSyBWBxsPBykuJ6z_kMYlAq9k9u3YU2Uy8Oc"
+# Load environment variables (assuming Gemini API key is stored in a .env file)
+load_dotenv()
 
-# Initialize the InferenceClient (replace with your model name if necessary)
-client = InferenceClient("HuggingFaceH4/zephyr-7b-beta", token=API_KEY)
+# Replace this with the actual API URL for Gemini
+GEMINI_API_URL = "https://api.gemini.com/v1/query"  # You need to replace this URL
 
-# Hardcoded system message
-system_message = "You are a friendly and helpful chatbot."
+# Retrieve your API key securely from environment variables
+API_KEY = os.getenv("GEMINI_API_KEY")
 
-# Load model with quantization and auto-device setup for faster loading
-device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
-model = AutoModelForCausalLM.from_pretrained(
-    "eurecom-ds/Phi-3-mini-4k-socratic",  # Replace with your model
-    torch_dtype=torch.bfloat16,
-    load_in_4bit=True,  # Enable 4-bit quantization for faster inference
-    device_map="auto",  # Automatically use GPU if available
-)
+# Function to send messages to Gemini API
+def call_gemini_api(messages):
+    headers = {
+        "Authorization": f"Bearer {API_KEY}",
+        "Content-Type": "application/json",
+    }
 
-# Tokenizer for the model
-tokenizer = AutoTokenizer.from_pretrained("eurecom-ds/Phi-3-mini-4k-socratic")
+    # 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
+    }
 
-# Function to handle text responses
-def respond(message, history: list, 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)
     
-    messages = [{"role": "system", "content": system_message}]
+    # 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]:
+        if val[0]:  # Check if user message exists
             messages.append({"role": "user", "content": val[0]})
-        if val[1]:
+        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})
 
-    response = ""  # Initialize response
-    
-    try:
-        for message_response in client.chat_completion(messages, max_tokens=150, stream=True):  # Reduce max tokens for faster response
-            if 'choices' in message_response and len(message_response['choices']) > 0:
-                delta_content = message_response['choices'][0].get('delta', {}).get('content', '')
-                if delta_content:
-                    response += delta_content
-            else:
-                print("Error: No valid content in response")
-                break
-    except Exception as e:
-        print(f"Error during API request: {e}")
+    # 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):
     recognizer = sr.Recognizer()
@@ -78,50 +83,18 @@ def text_to_voice(text):
     engine.runAndWait()
     return 'response.mp3'
 
+# Create the Gradio interface
+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
+    ],
+    outputs=[
+        gr.Textbox(label="Text Output"),  # Text output
+        gr.Audio(label="Voice Output")  # Voice output
+    ]
+)
 
-# Gradio Interface
-def create_interface():
-    with gr.Blocks() as demo:
-        chatbot = gr.Chatbot()
-        msg = gr.Textbox(label="Enter your message")
-        clear = gr.Button("Clear")
-
-        # Inputs and Outputs for Text and Audio
-        with gr.Row():
-            text_input = gr.Textbox(label="Text Input", placeholder="Enter your message...")
-            audio_input = gr.Audio(type="filepath", label="Audio Input (Optional)")
-
-        # Outputs for Text and Audio Response
-        with gr.Row():
-            text_output = gr.Textbox(label="Text Output")
-            audio_output = gr.Audio(label="Voice Output")
-        
-        # Interaction logic
-        def user(user_message, history):
-            return "", history + [[user_message, ""]]
-
-        def bot(history):
-            user_query = "".join(f"Student: {s}\nTeacher: {t}\n" for s, t in history[:-1])
-            last_query = history[-1][0]
-            user_query += f"Student: {last_query}"
-            response = respond(user_query, history)
-            history[-1][1] = response
-            return history, response  # Return updated history and response
-
-        # Submit text input
-        msg.submit(user, [msg, chatbot], [msg, chatbot]).then(bot, [chatbot], [chatbot, text_output])
-
-        # Submit audio input
-        audio_input.change(user, [audio_input, chatbot], [audio_input, chatbot]).then(bot, [chatbot], [chatbot, text_output])
-
-        # Clear button
-        clear.click(lambda: None, None, chatbot, queue=False)
-
-    return demo
-
-
-# Launch Gradio app
 if __name__ == "__main__":
-    demo = create_interface()
-    demo.queue()
-    demo.launch(server_name="0.0.0.0", server_port=2121)  # You can change port as needed
+    demo.launch()