Update app.py

app.py

@@ -1,62 +1,296 @@
-import gradio as gr
 import os
+import gradio as gr
 from huggingface_hub import InferenceClient
+import firebase_admin
+from firebase_admin import credentials, auth, firestore
+import json
 
-hf_token = os.getenv("hf_token")
-
-client = InferenceClient(api_key=hf_token)
-
-def get_response(user_input):
-    messages = [
-        { "role": "system", "content": "you are xylaria 1.4 senoa, developed by sk md saad amin" },
-        { "role": "user", "content": user_input }
-    ]
-    
-    stream = client.chat.completions.create(
-        model="Qwen/QwQ-32B-Preview", 
-        messages=messages, 
-        temperature=0.5,
-        max_tokens=10240,
-        top_p=0.7,
-        stream=True
-    )
-    
-    response = ""
-    for chunk in stream:
-        response += chunk.choices[0].delta.content
-    return response
-
-def chat_interface():
-    with gr.Blocks() as demo:
-        with gr.Row():
-            with gr.Column(scale=0.8):
-                input_textbox = gr.Textbox(
-                    label="Type your message", 
-                    placeholder="Ask me anything...",
-                    lines=1,
-                    max_lines=3,
-                    interactive=True,
-                    elem_id="user-input",
-                    show_label=False
-                )
-            with gr.Column(scale=0.2):
-                send_button = gr.Button("Send", elem_id="send-btn")
-
-        chat_output = gr.Chatbot(
-            elem_id="chat-box",
-            label="Xylaria 1.4 Senoa Chatbot",
-            show_label=False
+class XylariaChat:
+    def __init__(self):
+        # Securely load HuggingFace token
+        self.hf_token = os.getenv("HF_TOKEN")
+        if not self.hf_token:
+            raise ValueError("HuggingFace token not found in environment variables")
+        
+        # Initialize Firebase
+        self._initialize_firebase()
+        
+        # Initialize the inference client
+        self.client = InferenceClient(
+            model="Qwen/QwQ-32B-Preview", 
+            api_key=self.hf_token
         )
         
-        def submit_input(user_input, chat_history):
-            response = get_response(user_input)
-            chat_history.append((user_input, response))
-            return "", chat_history
+        # Initialize conversation history and persistent memory
+        self.conversation_history = []
+        self.persistent_memory = {}
+        
+        # System prompt with more detailed instructions
+        self.system_prompt = """You are Xylaria 1.4 Senoa, an AI assistant created by Sk Md Saad Amin, designed to provide helpful, accurate, and engaging support across a wide range of topics. Key guidelines for our interaction include:
+Core Principles:
+- Provide accurate and comprehensive assistance
+- Maintain a friendly and approachable communication style
+- Prioritize the user's needs and context
+Communication Style:
+- Be conversational and warm
+- Use clear, concise language
+- Occasionally use light, appropriate emoji to enhance communication
+- Adapt communication style to the user's preferences
+- Respond in english
+Important Notes:
+- I am an AI assistant created by an independent developer
+- I do not represent OpenAI or any other AI institution
+Capabilities:
+- Assist with research, writing, analysis, problem-solving, and creative tasks
+- Answer questions across various domains
+- Provide explanations and insights
+- Offer supportive and constructive guidance"""
+
+    def _initialize_firebase(self):
+        """Initialize Firebase with credentials from environment variable"""
+        try:
+            # Retrieve Firebase configuration from environment variable
+            firebase_config_str = os.getenv('FIREBASE_CONFIG')
+            if not firebase_config_str:
+                raise ValueError("Firebase configuration not found in environment variables")
+            
+            # Parse the Firebase configuration
+            firebase_config = json.loads(firebase_config_str)
+            
+            # Check if Firebase is already initialized
+            if not firebase_admin._apps:
+                # Initialize Firebase Admin SDK
+                cred = credentials.Certificate({
+                    "type": "service_account",
+                    "project_id": firebase_config.get('projectId'),
+                    "private_key_id": os.getenv('FIREBASE_PRIVATE_KEY_ID'),
+                    "private_key": os.getenv('FIREBASE_PRIVATE_KEY').replace('\\n', '\n'),
+                    "client_email": os.getenv('FIREBASE_CLIENT_EMAIL'),
+                    "client_id": firebase_config.get('clientId'),
+                    "auth_uri": "https://accounts.google.com/o/oauth2/auth",
+                    "token_uri": "https://oauth2.googleapis.com/token",
+                    "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
+                    "client_x509_cert_url": os.getenv('FIREBASE_CERT_URL')
+                })
+                firebase_admin.initialize_app(cred)
+            
+            # Initialize Firestore
+            self.firestore_client = firestore.client()
+        except Exception as e:
+            print(f"Firebase initialization error: {e}")
+            raise
+
+    def store_information(self, user_id, key, value):
+        """Store important information in Firestore"""
+        try:
+            user_doc_ref = self.firestore_client.collection('user_memories').document(user_id)
+            user_doc_ref.set({
+                key: value
+            }, merge=True)
+        except Exception as e:
+            print(f"Error storing information: {e}")
+
+    def retrieve_information(self, user_id, key):
+        """Retrieve information from Firestore"""
+        try:
+            user_doc = self.firestore_client.collection('user_memories').document(user_id).get()
+            return user_doc.to_dict().get(key) if user_doc.exists else None
+        except Exception as e:
+            print(f"Error retrieving information: {e}")
+            return None
+
+    def reset_conversation(self):
+        """
+        Completely reset the conversation history
+        This helps prevent exposing previous users' conversations
+        """
+        self.conversation_history = []
+        self.persistent_memory = {}
+
+    def get_response(self, user_input):
+        # Prepare messages with conversation context and persistent memory
+        messages = [
+            {"role": "system", "content": self.system_prompt},
+            *self.conversation_history,
+            {"role": "user", "content": user_input}
+        ]
+        
+        # Generate response with streaming
+        try:
+            stream = self.client.chat.completions.create(
+                messages=messages,
+                temperature=0.5,
+                max_tokens=10240,
+                top_p=0.7,
+                stream=True
+            )
+            
+            return stream
+        
+        except Exception as e:
+            return f"Error generating response: {str(e)}"
+
+    def create_interface(self):
+        # Enhanced custom CSS with modern, clean design
+        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;
+            background-color: #f4f4f4;
+        }
+        
+        .chatbot-container {
+            max-width: 800px;
+            margin: 0 auto;
+            background-color: white;
+            box-shadow: 0 4px 6px rgba(0,0,0,0.1);
+            border-radius: 12px;
+            overflow: hidden;
+        }
+        
+        .gradio-container .message {
+            font-family: 'Inter', sans-serif !important;
+            padding: 10px 15px;
+            margin: 8px 0;
+            border-radius: 8px;
+            max-width: 80%;
+        }
+        
+        .gradio-container .message.user {
+            background-color: #e6f2ff;
+            align-self: flex-end;
+            margin-left: auto;
+        }
+        
+        .gradio-container .message.assistant {
+            background-color: #f0f0f0;
+            align-self: flex-start;
+        }
+        
+        .gradio-container input, 
+        .gradio-container textarea, 
+        .gradio-container button {
+            font-family: 'Inter', sans-serif !important;
+            border-radius: 8px;
+            transition: all 0.3s ease;
+        }
+        
+        .gradio-container button {
+            background-color: #4A90E2;
+            color: white;
+            border: none;
+            padding: 10px 15px;
+        }
+        
+        .gradio-container button:hover {
+            background-color: #357ABD;
+            transform: translateY(-2px);
+            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+        }
+        """
 
-        input_textbox.submit(submit_input, [input_textbox, chat_output], [input_textbox, chat_output])
-        send_button.click(submit_input, [input_textbox, chat_output], [input_textbox, chat_output])
+        with gr.Blocks(theme='soft', css=custom_css) as demo:
+            # Main container with improved layout
+            with gr.Container(elem_classes="chatbot-container"):
+                # Chat interface with improved styling
+                with gr.Column():
+                    chatbot = gr.Chatbot(
+                        label="Xylaria 1.4 Senoa",
+                        height=500,
+                        show_copy_button=True,
+                        bubble_full_width=False,
+                        layout='bubble'
+                    )
+                    
+                    # Input row with improved layout
+                    with gr.Row():
+                        txt = gr.Textbox(
+                            show_label=False, 
+                            placeholder="Type your message here...", 
+                            container=False,
+                            scale=4
+                        )
+                        btn = gr.Button("Send", scale=1)
+                    
+                    # Control buttons with improved styling
+                    with gr.Row():
+                        clear = gr.Button("Clear Conversation", variant="secondary")
+                        clear_memory = gr.Button("Clear Memory", variant="stop")
+            
+            # Event handlers
+            def streaming_response(message, chat_history):
+                # Clear input textbox
+                response_stream = self.get_response(message)
+                
+                # If it's an error, return immediately
+                if isinstance(response_stream, str):
+                    return "", chat_history + [[message, response_stream]]
+                
+                # Prepare for streaming response
+                full_response = ""
+                updated_history = chat_history + [[message, ""]]
+                
+                # Streaming output
+                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
+                
+                # Update conversation history
+                self.conversation_history.append(
+                    {"role": "user", "content": message}
+                )
+                self.conversation_history.append(
+                    {"role": "assistant", "content": full_response}
+                )
+                
+                # Limit conversation history to prevent token overflow
+                if len(self.conversation_history) > 10:
+                    self.conversation_history = self.conversation_history[-10:]
+            
+            # Submit functionality with streaming
+            btn.click(
+                fn=streaming_response, 
+                inputs=[txt, chatbot], 
+                outputs=[txt, chatbot]
+            )
+            txt.submit(
+                fn=streaming_response, 
+                inputs=[txt, chatbot], 
+                outputs=[txt, chatbot]
+            )
+            
+            # Clear conversation history
+            clear.click(
+                fn=lambda: None, 
+                inputs=None, 
+                outputs=[chatbot],
+                queue=False
+            )
+            
+            # Clear persistent memory and reset conversation
+            clear_memory.click(
+                fn=self.reset_conversation,
+                inputs=None,
+                outputs=[chatbot],
+                queue=False
+            )
         
-    return demo
+        return demo
+
+# 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
+    )
 
-demo = chat_interface()
-demo.launch()
+if __name__ == "__main__":
+    main()