Update app.py

app.py

@@ -1,129 +1,52 @@
 import os
 import gradio as gr
 from huggingface_hub import InferenceClient
-import firebase_admin
-from firebase_admin import credentials, firestore, auth
-import uuid
-import tempfile
-import json
 
 class XylariaChat:
     def __init__(self):
-        # Securely load HuggingFace and Firebase tokens from environment variables
-        self.hf_token = os.environ.get("HF_TOKEN")
-        firebase_cred_json = os.environ.get("FIREBASE_SERVICE_ACCOUNT")
-        
-        # Optional: Add more robust error handling for missing environment variables
+        # Securely load HuggingFace token
+        self.hf_token = os.getenv("HF_TOKEN")
         if not self.hf_token:
-            print("Warning: HuggingFace token not found. Some functionality may be limited.")
-        
-        # Firebase initialization
-        self.db = None
-        if firebase_cred_json:
-            try:
-                # Convert the JSON string to a temporary credentials file
-                with tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.json') as temp_cred_file:
-                    # Add error handling for JSON parsing
-                    try:
-                        firebase_creds = json.loads(firebase_cred_json)
-                        json.dump(firebase_creds, temp_cred_file)
-                        temp_cred_file.close()
-                        
-                        firebase_cred = credentials.Certificate(temp_cred_file.name)
-                        firebase_admin.initialize_app(firebase_cred)
-                        self.db = firestore.client()
-                    except json.JSONDecodeError:
-                        print("Error: Invalid Firebase credentials JSON")
-                    
-                # Remove the temporary credentials file
-                os.unlink(temp_cred_file.name)
-            except Exception as e:
-                print(f"Firebase initialization error: {e}")
+            raise ValueError("HuggingFace token not found in environment variables")
         
-        # Initialize the inference client (only if token is available)
-        self.client = None
-        if self.hf_token:
-            try:
-                self.client = InferenceClient(
-                    model="Qwen/QwQ-32B-Preview", 
-                    api_key=self.hf_token
-                )
-            except Exception as e:
-                print(f"Inference client initialization error: {e}")
+        # Initialize the inference client
+        self.client = InferenceClient(
+            model="Qwen/QwQ-32B-Preview", 
+            api_key=self.hf_token
+        )
         
-        # Initialize conversation history
+        # Initialize conversation history and persistent memory
         self.conversation_history = []
-
-    def signup(self, username, email, password):
-        """User signup method"""
-        if not self.db:
-            return "Firebase is not initialized. Signup unavailable."
+        self.persistent_memory = {}
         
-        try:
-            # Create user in Firebase Authentication
-            user = auth.create_user(
-                email=email,
-                password=password,
-                display_name=username
-            )
-            
-            # Store additional user info in Firestore
-            user_ref = self.db.collection('users').document(user.uid)
-            user_ref.set({
-                'username': username,
-                'email': email,
-                'created_at': firestore.SERVER_TIMESTAMP
-            })
-            
-            return f"Successfully created account for {username}"
-        except Exception as e:
-            return f"Signup error: {str(e)}"
+        # System prompt with more detailed instructions
+        self.system_prompt = """You are Xylaria 1.4 Senoa, an AI assistant developed by SK MD Saad Amin. 
+        -Youre NOT MADE BY OPENAI OR ANY OTHER INSTITUITON
+        - respond to image quires with the link of the image
+        - be as friendly and chatty as possible, use emoji sometimes. """
 
-    def login(self, email, password):
-        """User login method"""
-        if not self.db:
-            return "Firebase is not initialized. Login unavailable."
-        
-        try:
-            # Authenticate user with Firebase
-            user = auth.get_user_by_email(email)
-            
-            # In a real-world scenario, you'd use Firebase Auth's sign-in method
-            # This is a simplified version for demonstration
-            return f"Login successful for {user.display_name}"
-        except Exception as e:
-            return f"Login error: {str(e)}"
+    def store_information(self, key, value):
+        """Store important information in persistent memory"""
+        self.persistent_memory[key] = value
 
-    def save_message(self, user_id, message, sender):
-        """Save message to Firestore"""
-        if not self.db:
-            return
-        
-        try:
-            messages_ref = self.db.collection('conversations').document(user_id)
-            messages_ref.collection('messages').add({
-                'text': message,
-                'sender': sender,
-                'timestamp': firestore.SERVER_TIMESTAMP
-            })
-        except Exception as e:
-            print(f"Error saving message: {e}")
+    def retrieve_information(self, key):
+        """Retrieve information from persistent memory"""
+        return self.persistent_memory.get(key)
 
-    def get_response(self, user_input, chat_history):
-        # Check if client is initialized
-        if not self.client:
-            return "AI response is currently unavailable."
-        
-        # Prepare messages with conversation context
+    def get_response(self, user_input):
+        # Prepare messages with conversation context and persistent memory
         messages = [
-            {"role": "system", "content": """You are Xylaria 1.4 Senoa, an AI assistant developed by SK MD Saad Amin. 
-            - You're NOT MADE BY OPENAI OR ANY OTHER INSTITUTION
-            - Be friendly and chatty, use emoji sometimes."""},
-            *[{"role": "user" if msg[0] else "assistant", "content": msg[1]} for msg in chat_history]
+            {"role": "system", "content": self.system_prompt},
+            *self.conversation_history,
+            {"role": "user", "content": user_input}
         ]
         
-        # Add current user input
-        messages.append({"role": "user", "content": user_input})
+        # Add persistent memory context if available
+        if self.persistent_memory:
+            memory_context = "Remembered Information:\n" + "\n".join(
+                [f"{k}: {v}" for k, v in self.persistent_memory.items()]
+            )
+            messages.insert(1, {"role": "system", "content": memory_context})
         
         # Generate response with streaming
         try:
@@ -141,36 +64,11 @@ class XylariaChat:
             return f"Error generating response: {str(e)}"
 
     def create_interface(self):
-        # Dynamic CSS for OS theme detection
-        custom_css = """
-        /* OS Theme Detection */
-        @media (prefers-color-scheme: dark) {
-            .gradio-container {
-                background-color: #121212;
-                color: #ffffff;
-            }
-        }
-        
-        @media (prefers-color-scheme: light) {
-            .gradio-container {
-                font-family: 'Inter', sans-serif;
-                background-color: #f3f4f6;
-                color: #1f2937;
-            }
-        }
-        """
-
         def streaming_response(message, chat_history):
-            # Unique user ID (in a real app, you'd use actual user authentication)
-            user_id = str(uuid.uuid4())
-            
-            # Save user message to Firestore
-            self.save_message(user_id, message, 'user')
+            # Clear input textbox
+            response_stream = self.get_response(message)
             
-            # Get AI response stream
-            response_stream = self.get_response(message, chat_history)
-            
-            # If it's an error or string, return immediately
+            # If it's an error, return immediately
             if isinstance(response_stream, str):
                 return "", chat_history + [[message, response_stream]]
             
@@ -179,74 +77,68 @@ class XylariaChat:
             updated_history = chat_history + [[message, ""]]
             
             # Streaming output
-            try:
-                for chunk in response_stream:
-                    if chunk.choices[0].delta.content:
-                        chunk_content = chunk.choices[0].delta.content
-                        full_response += chunk_content
-                        
-                        # Update the last message in chat history with partial response
-                        updated_history[-1][1] = full_response
-                        yield "", updated_history
-            except Exception as e:
-                return "", updated_history + [["", f"Error in response: {str(e)}"]]
+            for chunk in response_stream:
+                if chunk.choices[0].delta.content:
+                    chunk_content = chunk.choices[0].delta.content
+                    full_response += chunk_content
+                    
+                    # Update the last message in chat history with partial response
+                    updated_history[-1][1] = full_response
+                    yield "", updated_history
             
-            # Save bot message to Firestore
-            self.save_message(user_id, full_response, 'bot')
+            # Update conversation history
+            self.conversation_history.append(
+                {"role": "user", "content": message}
+            )
+            self.conversation_history.append(
+                {"role": "assistant", "content": full_response}
+            )
             
-            return "", updated_history
+            # Limit conversation history to prevent token overflow
+            if len(self.conversation_history) > 10:
+                self.conversation_history = self.conversation_history[-10:]
+
+        # Custom CSS for Inter font
+        custom_css = """
+        @import url('https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&display=swap');
+        
+        body, .gradio-container {
+            font-family: 'Inter', sans-serif !important;
+        }
+        
+        .chatbot-container .message {
+            font-family: 'Inter', sans-serif !important;
+        }
+        
+        .gradio-container input, 
+        .gradio-container textarea, 
+        .gradio-container button {
+            font-family: 'Inter', sans-serif !important;
+        }
+        """
 
         with gr.Blocks(theme='soft', css=custom_css) as demo:
-            # Authentication Tab
-            with gr.Tabs():
-                with gr.TabItem("Login"):
-                    with gr.Column():
-                        login_email = gr.Textbox(label="Email")
-                        login_password = gr.Textbox(label="Password", type="password")
-                        login_btn = gr.Button("Login")
-                        login_output = gr.Textbox(label="Login Status")
-                
-                with gr.TabItem("Signup"):
-                    with gr.Column():
-                        signup_username = gr.Textbox(label="Username")
-                        signup_email = gr.Textbox(label="Email")
-                        signup_password = gr.Textbox(label="Password", type="password")
-                        signup_btn = gr.Button("Sign Up")
-                        signup_output = gr.Textbox(label="Signup Status")
-            
-            # Chat Interface
-            with gr.Column(scale=1):
+            # Chat interface with improved styling
+            with gr.Column():
                 chatbot = gr.Chatbot(
                     label="Xylaria 1.4 Senoa",
                     height=500,
-                    show_copy_button=True,
-                    type="messages"  # Added to resolve deprecation warning
+                    show_copy_button=True
                 )
                 
-                # Input row with minimalist design
+                # Input row with improved layout
                 with gr.Row():
                     txt = gr.Textbox(
                         show_label=False, 
                         placeholder="Type your message...", 
+                        container=False,
                         scale=4
                     )
                     btn = gr.Button("Send", scale=1)
                 
-                # Clear conversation button
+                # Clear history and memory buttons
                 clear = gr.Button("Clear Conversation")
-            
-            # Authentication Event Handlers
-            login_btn.click(
-                fn=self.login, 
-                inputs=[login_email, login_password], 
-                outputs=[login_output]
-            )
-            
-            signup_btn.click(
-                fn=self.signup, 
-                inputs=[signup_username, signup_email, signup_password], 
-                outputs=[signup_output]
-            )
+                clear_memory = gr.Button("Clear Memory")
             
             # Submit functionality with streaming
             btn.click(
@@ -259,10 +151,33 @@ class XylariaChat:
                 inputs=[txt, chatbot], 
                 outputs=[txt, chatbot]
             )
-            clear.click(lambda: None, None, chatbot)
-
+            
+            # Clear conversation history
+            clear.click(
+                fn=lambda: None, 
+                inputs=None, 
+                outputs=[chatbot],
+                queue=False
+            )
+            
+            # Clear persistent memory
+            clear_memory.click(
+                fn=lambda: None,
+                inputs=None,
+                outputs=[],
+                queue=False
+            )
+        
         return demo
 
-# Note: Actual launch should be done with proper environment variable setup
-xylaria_chat = XylariaChat()
-xylaria_chat.create_interface().launch(share=True)
+# Launch the interface
+def main():
+    chat = XylariaChat()
+    interface = chat.create_interface()
+    interface.launch(
+        share=True,  # Optional: create a public link
+        debug=True   # Show detailed errors
+    )
+
+if __name__ == "__main__":
+    main()