Update app.py

app.py

@@ -21,23 +21,38 @@ from langchain_google_genai import ChatGoogleGenerativeAI
 logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
 logger = logging.getLogger(__name__)
 
-# === HARD-CODED API KEY (for testing only) ===
-google_api_key = "AIzaSyCZtDtt7K6g3IgR0GsQ2pil4xsu7Jrt_lk"
-genai.configure(api_key="AIzaSyCZtDtt7K6g3IgR0GsQ2pil4xsu7Jrt_lk")
+# === API Key Configuration ===
+# Get API key from Hugging Face secrets (environment variable)
+GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
+if not GEMINI_API_KEY:
+    raise ValueError("GEMINI_API_KEY not found in environment variables. Please set it in Hugging Face secrets.")
+
+try:
+    genai.configure(api_key=GEMINI_API_KEY)
+except Exception as e:
+    logger.error(f"Failed to configure Gemini API: {e}")
+    raise
 
 # === Chat Storage ===
 HISTORY_FILE = "chat_history.json"
 
 def load_all_sessions():
-    if os.path.exists(HISTORY_FILE):
-        with open(HISTORY_FILE, "r", encoding="utf-8") as f:
-            return json.load(f)
+    try:
+        if os.path.exists(HISTORY_FILE):
+            with open(HISTORY_FILE, "r", encoding="utf-8") as f:
+                return json.load(f)
+    except Exception as e:
+        logger.error(f"Error loading sessions: {e}")
     return {}
 
 def save_all_sessions(sessions):
-    with open(HISTORY_FILE, "w", encoding="utf-8") as f:
-        json.dump(sessions, f, indent=2)
+    try:
+        with open(HISTORY_FILE, "w", encoding="utf-8") as f:
+            json.dump(sessions, f, indent=2)
+    except Exception as e:
+        logger.error(f"Error saving sessions: {e}")
 
+# Initialize sessions
 sessions = load_all_sessions()
 
 # === Gemini Chatbot ===
@@ -58,20 +73,31 @@ class GeminiChatbot:
             HumanMessagePromptTemplate.from_template("{input}")
         ])
 
-        self.model = ChatGoogleGenerativeAI(
-            model="gemini-2.0-flash",
-            temperature=0.7,
-            top_p=0.95,
-            google_api_key="AIzaSyCZtDtt7K6g3IgR0GsQ2pil4xsu7Jrt_lk",
-            convert_system_message_to_human=True
-        )
+        try:
+            self.model = ChatGoogleGenerativeAI(
+                model="gemini-1.5-flash",  # Updated to more stable model
+                temperature=0.7,
+                top_p=0.95,
+                google_api_key=GEMINI_API_KEY,
+                convert_system_message_to_human=True
+            )
+        except Exception as e:
+            logger.error(f"Failed to initialize Gemini model: {e}")
+            raise
 
         def call_model(state: MessagesState):
-            chat_history = state["messages"][:-1]
-            user_input = state["messages"][-1].content
-            formatted_messages = self.prompt.format_messages(chat_history=chat_history, input=user_input)
-            response = self.model.invoke(formatted_messages)
-            return {"messages": response}
+            try:
+                chat_history = state["messages"][:-1]
+                user_input = state["messages"][-1].content
+                formatted_messages = self.prompt.format_messages(
+                    chat_history=chat_history,
+                    input=user_input
+                )
+                response = self.model.invoke(formatted_messages)
+                return {"messages": response}
+            except Exception as e:
+                logger.error(f"Model invocation error: {e}")
+                raise
 
         workflow = StateGraph(state_schema=MessagesState)
         workflow.add_node("model", call_model)
@@ -94,6 +120,7 @@ class GeminiChatbot:
             response = self.app.invoke({"messages": full_history}, config)
             full_text = response["messages"][-1].content
 
+            # Stream response character by character
             full_response = ""
             for char in full_text:
                 full_response += char
@@ -102,106 +129,151 @@ class GeminiChatbot:
 
         except Exception as e:
             logger.error(f"Response error: {e}")
-            yield f"⚠ Hello Error: {type(e).__name__} — {str(e)}"
+            yield f"⚠ Error: {type(e).__name__} — {str(e)}"
 
-chatbot = GeminiChatbot()
+# Initialize chatbot
+try:
+    chatbot = GeminiChatbot()
+except Exception as e:
+    logger.critical(f"Failed to initialize chatbot: {e}")
+    raise
 
 # === Gradio UI ===
 def launch_interface():
     with gr.Blocks(
         theme=gr.themes.Base(),
         css="""
-        body { background-color: black; }
-        .gr-textbox textarea { background-color: #2f2f2f; color: white; }
-        .gr-chatbot { background-color: #2f2f2f; color: white; }
-        .gr-button, .gr-dropdown {
-            margin: 5px auto;
-            display: block;
-            width: 50%;
+        body { background-color: #f0f2f6; }
+        .gr-block { background-color: white; }
+        .gr-textbox textarea { background-color: white; }
+        .gr-chatbot { background-color: white; border-radius: 10px; }
+        .gr-button {
+            margin: 5px;
+            border-radius: 5px;
         }
-        .gr-markdown h2 { text-align: center; color: white; }
+        .gr-markdown h2 { text-align: center; }
         """
     ) as demo:
         demo.title = "LangChain Powered ChatBot"
         gr.Markdown("## LangChain Powered ChatBot")
 
+        # Initialize session state
         current_thread_id = gr.State()
-        session_names = gr.State()
         history = gr.State([])
-
+        
+        # Initialize or load sessions
         if not sessions:
             new_id = str(uuid.uuid4())
             sessions[new_id] = []
             save_all_sessions(sessions)
             current_thread_id.value = new_id
-            session_names.value = [f"NEW: {new_id}"]
         else:
             current_thread_id.value = next(iter(sessions))
-            session_names.value = [f"PREVIOUS: {k}" for k in sessions if sessions[k]]
 
         def get_dropdown_choices():
-            return [f"PREVIOUS: {k}" for k in sessions if sessions[k]] + [f"NEW: {current_thread_id.value}"]
-
-        new_chat_btn = gr.Button("New Chat", variant="primary")
-        session_selector = gr.Dropdown(
-            label="Chats",
-            choices=get_dropdown_choices(),
-            value=f"NEW: {current_thread_id.value}",
-            interactive=True
-        )
+            choices = []
+            for session_id in sessions:
+                if sessions[session_id]:  # Only show non-empty sessions
+                    first_msg = sessions[session_id][0][0][:20]  # First message snippet
+                    choices.append((f"Chat: {first_msg}...", session_id))
+            choices.append(("+ New Chat", current_thread_id.value))
+            return choices
+
+        # UI Components
+        with gr.Row():
+            new_chat_btn = gr.Button("+ New Chat", variant="primary")
+            session_selector = gr.Dropdown(
+                label="Your Chats",
+                choices=get_dropdown_choices(),
+                value=current_thread_id.value,
+                interactive=True
+            )
 
-        chatbot_ui = gr.Chatbot(label="Conversation", height=350)
+        chatbot_ui = gr.Chatbot(label="Conversation", height=400)
 
         with gr.Row():
-            msg = gr.Textbox(placeholder="Ask a question...", container=False, scale=9)
-            send = gr.Button("Send", variant="primary", scale=1)
+            msg = gr.Textbox(placeholder="Type your message...", container=False, scale=9)
+            send_btn = gr.Button("Send", variant="primary", scale=1)
 
-        clear = gr.Button("Clear Current Chat")
+        clear_btn = gr.Button("Clear Current Chat")
 
         def start_new_chat():
             new_id = str(uuid.uuid4())
             sessions[new_id] = []
             save_all_sessions(sessions)
-            display = f"NEW: {new_id}"
-            updated = [f"PREVIOUS: {k}" for k in sessions if sessions[k]] + [display]
-            return new_id, [], gr.update(choices=updated, value=display), display
+            current_thread_id.value = new_id
+            return [], gr.Dropdown.update(choices=get_dropdown_choices(), value=new_id)
 
-        def switch_chat(display_id):
-            true_id = display_id.split(": ", 1)[-1]
-            return true_id, sessions.get(true_id, []), display_id
+        def switch_chat(session_id):
+            if session_id == current_thread_id.value:
+                return current_thread_id.value, sessions.get(session_id, [])
+            current_thread_id.value = session_id
+            return session_id, sessions.get(session_id, [])
 
-        def respond(message, history, thread_id):
+        def respond(message, chat_history, thread_id):
             if not message.strip():
-                yield history
+                yield chat_history
                 return
-            history.append((message, ""))
-            yield history
-
-            for chunk in chatbot.get_response(message, history[:-1], thread_id):
-                history[-1] = (message, chunk)
-                yield history
-
-            sessions[thread_id] = history
+                
+            chat_history.append((message, ""))
+            yield chat_history
+            
+            full_response = ""
+            for chunk in chatbot.get_response(message, chat_history[:-1], thread_id):
+                full_response = chunk
+                chat_history[-1] = (message, full_response)
+                yield chat_history
+            
+            sessions[thread_id] = chat_history
             save_all_sessions(sessions)
+            
+            # Update dropdown if this was first message
+            if len(chat_history) == 1:
+                yield chat_history, gr.Dropdown.update(choices=get_dropdown_choices())
+            else:
+                yield chat_history
 
         def clear_chat(thread_id):
             sessions[thread_id] = []
             save_all_sessions(sessions)
             return []
 
-        # Events
-        new_chat_btn.click(start_new_chat, outputs=[current_thread_id, chatbot_ui, session_selector, session_selector])
-        session_selector.change(switch_chat, inputs=session_selector, outputs=[current_thread_id, chatbot_ui, session_selector])
-        send.click(respond, [msg, chatbot_ui, current_thread_id], [chatbot_ui]).then(lambda: "", None, msg)
-        msg.submit(respond, [msg, chatbot_ui, current_thread_id], [chatbot_ui]).then(lambda: "", None, msg)
-        clear.click(clear_chat, inputs=[current_thread_id], outputs=[chatbot_ui])
+        # Event handlers
+        new_chat_btn.click(
+            start_new_chat,
+            outputs=[chatbot_ui, session_selector]
+        )
+        
+        session_selector.change(
+            switch_chat,
+            inputs=session_selector,
+            outputs=[current_thread_id, chatbot_ui]
+        )
+        
+        send_btn.click(
+            respond,
+            inputs=[msg, chatbot_ui, current_thread_id],
+            outputs=[chatbot_ui, session_selector]
+        ).then(lambda: "", None, msg)
+        
+        msg.submit(
+            respond,
+            inputs=[msg, chatbot_ui, current_thread_id],
+            outputs=[chatbot_ui, session_selector]
+        ).then(lambda: "", None, msg)
+        
+        clear_btn.click(
+            clear_chat,
+            inputs=[current_thread_id],
+            outputs=[chatbot_ui]
+        )
 
     return demo
 
-# === Run App ===
+# Run the app
 if __name__ == "__main__":
     try:
         demo = launch_interface()
-        demo.launch()
+        demo.launch(server_name="0.0.0.0", server_port=7860)
     except Exception as e:
-        logger.critical(f"App failed: {e}")
+        logger.critical(f"Application failed to start: {e}")