Update app.py

app.py

@@ -3,69 +3,86 @@ import gradio as gr
 import requests
 import google.generativeai as genai
 
-from langchain_core.prompts import PromptTemplate
-from langchain_classic.memory import ConversationBufferMemory
-
-# ------------------------------------
+# -----------------------------
 # Load API keys from environment
-# ------------------------------------
+# -----------------------------
 GEMINI_API_KEY = os.environ.get("GEMINI_API_KEY")
 ELEVENLABS_API_KEY = os.environ.get("ELEVENLABS_API_KEY")
 ELEVENLABS_VOICE_ID = "21m00Tcm4TlvDq8ikWAM"
 
+# Safety: fail early if no keys
+if not GEMINI_API_KEY:
+    raise RuntimeError("Missing GEMINI_API_KEY in environment")
+if not ELEVENLABS_API_KEY:
+    # Not strictly fatal if you only want text, but warn:
+    print("Warning: ELEVENLABS_API_KEY not set — audio generation will fail.")
+
 # Configure Gemini
 genai.configure(api_key=GEMINI_API_KEY)
 
-# ------------------------------------
-# Prompt + Memory
-# ------------------------------------
-template = """You are a helpful assistant.
+# -----------------------------
+# Simple prompt template + memory (no LangChain)
+# -----------------------------
+PROMPT_TEMPLATE = """You are a helpful assistant.
 {chat_history}
 User: {user_message}
 Chatbot:"""
 
-prompt = PromptTemplate(
-    input_variables=["chat_history", "user_message"],
-    template=template
-)
+# Use a simple in-memory ring buffer for conversation (keeps last N messages)
+class SimpleMemory:
+    def __init__(self, max_messages=20):
+        self.max_messages = max_messages
+        self.history = []  # list of strings like "User: ...", "Chatbot: ..."
 
-memory = ConversationBufferMemory(memory_key="chat_history")
+    def add_user(self, text):
+        self.history.append(f"User: {text}")
+        self._trim()
 
-# ------------------------------------
-# Gemini Wrapper
-# ------------------------------------
-gemini_model = genai.GenerativeModel("gemini-2.5-flash")
+    def add_bot(self, text):
+        self.history.append(f"Chatbot: {text}")
+        self._trim()
 
-class GeminiLLM:
-    def __init__(self, model):
-        self.model = model
-        self.memory_history = []
+    def _trim(self):
+        if len(self.history) > self.max_messages:
+            self.history = self.history[-self.max_messages:]
 
-    def predict(self, user_message):
-        full_prompt = "You are a helpful assistant.\n"
-        for msg in self.memory_history:
-            full_prompt += msg + "\n"
-        full_prompt += f"User: {user_message}\nChatbot:"
+    def as_text(self):
+        return "\n".join(self.history)
 
-        response = self.model.generate_content(full_prompt)
-        answer = response.text
+memory = SimpleMemory(max_messages=20)
 
-        self.memory_history.append(f"User: {user_message}")
-        self.memory_history.append(f"Chatbot: {answer}")
-
-        if len(self.memory_history) > 20:
-            self.memory_history = self.memory_history[-20:]
+# -----------------------------
+# Gemini wrapper (simple)
+# -----------------------------
+# Keep a single model instance
+gemini_model = genai.GenerativeModel("gemini-2.5-flash")
 
-        return answer
+def generate_text_with_gemini(user_message):
+    # Build full prompt
+    chat_history = memory.as_text()
+    full_prompt = PROMPT_TEMPLATE.format(chat_history=chat_history, user_message=user_message)
 
-llm_chain = GeminiLLM(gemini_model)
+    # Use the SDK to generate
+    # NOTE: API may return a response object; using .generate_content as before
+    response = gemini_model.generate_content(full_prompt)
+    # response.text contains the assistant output
+    text = response.text if hasattr(response, "text") else str(response)
+    return text
 
-# ------------------------------------
-# ElevenLabs Audio (Hugging Face friendly)
-# ------------------------------------
+# -----------------------------
+# ElevenLabs audio generation (lazy import)
+# -----------------------------
 def generate_audio_elevenlabs(text):
-    from elevenlabs.client import ElevenLabs
-    from elevenlabs import save
+    """
+    Returns output_path on success, empty string on failure.
+    Uses /tmp directory (Hugging Face friendly).
+    """
+    try:
+        from elevenlabs.client import ElevenLabs
+        from elevenlabs import save
+    except Exception as e:
+        print("ElevenLabs import failed:", e)
+        return ""
 
     try:
         client = ElevenLabs(api_key=ELEVENLABS_API_KEY)
@@ -75,32 +92,52 @@ def generate_audio_elevenlabs(text):
             model="eleven_monolingual_v1"
         )
 
+        # Safe temp path for HF Spaces
         output_path = f"/tmp/audio_{abs(hash(text)) % 100000}.mp3"
         save(audio, output_path)
         return output_path
-
     except Exception as e:
-        print("Audio error:", e)
+        # log and return empty result so UI still shows text
+        print("ElevenLabs generation error:", e)
         return ""
 
-# ------------------------------------
+# -----------------------------
 # Combined response
-# ------------------------------------
-def get_response_and_audio(message):
-    text = llm_chain.predict(message)
-    audio_path = generate_audio_elevenlabs(text)
+# -----------------------------
+def get_text_and_audio(user_message):
+    # Text
+    text = generate_text_with_gemini(user_message)
+
+    # Update memory
+    memory.add_user(user_message)
+    memory.add_bot(text)
+
+    # Audio (non-blocking style: we still run it but return text even if audio fails)
+    audio_path = ""
+    if ELEVENLABS_API_KEY:
+        audio_path = generate_audio_elevenlabs(text)
+
     return text, audio_path
 
-# ------------------------------------
-# Gradio ChatHandler (UI unchanged)
-# ------------------------------------
+# -----------------------------
+# Chat handler used by Gradio UI (unchanged UI)
+# -----------------------------
 def chat_bot_response(message, history):
-    text, audio_path = get_response_and_audio(message)
+    """
+    Gradio ChatInterface function signature:
+    - message: new user message (string)
+    - history: prior messages (list) provided by Gradio (we don't need to rely on it)
+    Return: text response (Gradio ChatInterface will render it)
+    """
+    text, audio_path = get_text_and_audio(message)
+
+    # Optionally: attach audio playback by returning a dict or specific component.
+    # To keep the UI identical and simple, we return text only — same behavior as before.
     return text
 
-# ------------------------------------
-# UI (same as your original)
-# ------------------------------------
+# -----------------------------
+# UI (exact ChatInterface parameters preserved, including theme)
+# -----------------------------
 demo = gr.ChatInterface(
     fn=chat_bot_response,
     title="🤖 Gemini + ElevenLabs Chatbot",
@@ -112,7 +149,7 @@ demo = gr.ChatInterface(
         "What's the weather like today?",
         "Explain quantum computing in simple terms"
     ],
-    theme=gr.themes.Soft()
+    theme=gr.themes.Soft()   # keep theme — requirements pin ensures support
 )
 
 if __name__ == "__main__":