Update app.py

app.py

@@ -1,11 +1,6 @@
 import os
 import gradio as gr
 from huggingface_hub import InferenceClient
-import json
-
-# Global variables to track state (use with caution!)
-chat_visible_global = False
-sidebar_collapsed = False
 
 class XylariaChat:
     def __init__(self):
@@ -16,18 +11,35 @@ class XylariaChat:
 
         # Initialize the inference client
         self.client = InferenceClient(
-            model="Qwen/Qwen-32B-Preview",
-            api_key=self.hf_token
+            model="Qwen/QwQ-32B-Preview",  # Changed model name
+            token=self.hf_token
         )
 
         # Initialize conversation history and persistent memory
         self.conversation_history = []
         self.persistent_memory = {}
-        self.chat_file_path = "chat_history.txt"  # File to save chats
 
-        # System prompt
-        self.system_prompt = """You are a helpful and harmless AI assistant you are Xylaria 1.4 Senoa, Made by Sk Md Saad Amin you think step by step
-"""
+        # System prompt with more detailed instructions
+        self.system_prompt = """You are Xylaria 1.4 Senoa, Made 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
+- For image-related queries, I can describe images or provide analysis, or generate or link to images directly
+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 store_information(self, key, value):
         """Store important information in persistent memory"""
@@ -37,53 +49,14 @@ class XylariaChat:
         """Retrieve information from persistent memory"""
         return self.persistent_memory.get(key)
 
-    def save_chat(self):
-        """Saves the current chat history to a text file."""
-        try:
-            with open(self.chat_file_path, "w") as f:
-                chat_data = {
-                    "conversation_history": self.conversation_history,
-                    "persistent_memory": self.persistent_memory
-                }
-                json.dump(chat_data, f)
-        except Exception as e:
-            print(f"Error saving chat history: {e}")
-
-    def load_chat(self):
-        """Loads chat history from a text file."""
-        try:
-            with open(self.chat_file_path, "r") as f:
-                chat_data = json.load(f)
-                self.conversation_history = chat_data.get("conversation_history", [])
-                self.persistent_memory = chat_data.get("persistent_memory", {})
-                return self.conversation_history, self.persistent_memory
-        except FileNotFoundError:
-            print("Chat history file not found.")
-            return [], {}
-        except Exception as e:
-            print(f"Error loading chat history: {e}")
-            return [], {}
-
     def reset_conversation(self):
         """
-        Completely reset the conversation history, persistent memory,
-        and clear API-side memory
+        Completely reset the conversation history and persistent memory
+        This helps prevent exposing previous users' conversations
         """
-        # Clear local memory
         self.conversation_history = []
-        self.persistent_memory.clear()
-
-        # Clear API-side memory by resetting the conversation
-        try:
-            # Attempt to clear any API-side session or context
-            self.client = InferenceClient(
-                model="Qwen/Qwen-32B-Preview",
-                api_key=self.hf_token
-            )
-        except Exception as e:
-            print(f"Error resetting API client: {e}")
-
-        self.save_chat()  # Save the empty chat history
+        self.persistent_memory = {}
+        return []
 
     def get_response(self, user_input):
         # Prepare messages with conversation context and persistent memory
@@ -102,37 +75,76 @@ class XylariaChat:
 
         # Generate response with streaming
         try:
-            stream = self.client.chat.completions.create(
-                messages=messages,
+            response_stream = self.client.text_generation(
+                prompt=self.messages_to_prompt(messages),  # Convert messages to prompt format
+                max_new_tokens=1024,
                 temperature=0.5,
-                max_tokens=10240,
                 top_p=0.7,
                 stream=True
             )
 
-            return stream
+            return response_stream
 
         except Exception as e:
             return f"Error generating response: {str(e)}"
 
+    def messages_to_prompt(self, messages):
+        """
+        Converts a list of messages in OpenAI format to a prompt string.
+        """
+        prompt = ""
+        for message in messages:
+            if message["role"] == "system":
+                prompt += f"<|im_start|>system\n{message['content']}<|im_end|>\n"
+            elif message["role"] == "user":
+                prompt += f"<|im_start|>user\n{message['content']}<|im_end|>\n"
+            elif message["role"] == "assistant":
+                prompt += f"<|im_start|>assistant\n{message['content']}<|im_end|>\n"
+        prompt += "<|im_start|>assistant\n"
+        return prompt
+
     def create_interface(self):
+        # Local storage JavaScript functions (these are strings, not functions)
+        load_from_local_storage_js = """
+        async () => {
+            const savedHistory = localStorage.getItem('xylaria_chat_history');
+            return savedHistory ? JSON.parse(savedHistory) : [];
+        }
+        """
+
+        save_to_local_storage_js = """
+        async (chatHistory) => {
+            localStorage.setItem('xylaria_chat_history', JSON.stringify(chatHistory));
+        }
+        """
+
+        clear_local_storage_js = """
+        async () => {
+            localStorage.removeItem('xylaria_chat_history');
+        }
+        """
+
         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):
-                # Error handling: directly append error message to chat history
                 return "", chat_history + [[message, response_stream]]
 
+            # Prepare for streaming response
             full_response = ""
             updated_history = chat_history + [[message, ""]]
 
-            for chunk in response_stream:
-                if chunk.choices[0].delta.content:
-                    chunk_content = chunk.choices[0].delta.content
-                    full_response += chunk_content
-                    updated_history[-1][1] = full_response
-                    yield "", updated_history
+            # Streaming output
+            for response_text in response_stream:
+                full_response += response_text
 
+                # 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}
             )
@@ -140,282 +152,116 @@ class XylariaChat:
                 {"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:]
 
-            self.save_chat()  # Save after each interaction
-
-        # Function to format and display chat history
-        def format_chat_history():
-            self.load_chat()  # Load the chat history first
-            if not self.conversation_history:
-                return "No chat history found."
+            return "", updated_history
 
-            formatted_history = ""
-            for chat in self.conversation_history:
-                if chat["role"] == "user":
-                    formatted_history += f"**You:** {chat['content']}\n\n"
-                elif chat["role"] == "assistant":
-                    formatted_history += f"**Xylaria:** {chat['content']}\n\n"
-
-            return formatted_history
-
-        # Custom CSS for improved colors and styling
+        # 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;
-            background-color: #f8f8f8; /* Light background */
         }
-
-        /* Chatbot styling */
         .chatbot-container .message {
             font-family: 'Inter', sans-serif !important;
-            padding: 10px 15px;
-            border-radius: 10px;
-            margin-bottom: 8px; /* Add margin between messages */
-        }
-
-        .chatbot-container .user {
-            background-color: #e0f2f7; /* Light blue for user messages */
-            border: 1px solid #a7d9ed; /* Light blue border */
-        }
-
-        .chatbot-container .assistant {
-            background-color: #f0f0f0; /* Light gray for assistant messages */
-            border: 1px solid #d3d3d3; /* Light gray border */
         }
-
-        .chatbot-container .message-tools {
-            margin-right: 10px; /* Add some space between text and buttons */
-        }
-
-        /* Sidebar styling */
-        #sidebar {
-            background-color: #f2f2f2;
-            border-right: 1px solid #ccc;
-            padding: 10px;
-            height: 100vh;
-            overflow-y: auto;
-            transition: width 0.3s ease; /* Smooth transition for collapse */
-            width: 250px; /* Initial width */
-        }
-
-        #sidebar.collapsed {
-            width: 50px; /* Collapsed width */
-        }
-
-        #sidebar.collapsed #sidebar-content {
-            display: none; /* Hide content when collapsed */
-        }
-
-        #sidebar-content {
-            display: block;
-        }
-
-        #collapse-button {
-            width: 100%;
-            margin-bottom: 10px;
-            background-color: transparent;
-            border: none;
-            cursor: pointer;
-            text-align: left;
-            padding: 5px;
-        }
-
-        /* Main chat area */
-        #main-chat {
-            padding: 20px;
-        }
-
-        /* Textbox and buttons */
         .gradio-container input, 
         .gradio-container textarea, 
         .gradio-container button {
             font-family: 'Inter', sans-serif !important;
-            border-radius: 5px; /* Rounded corners */
-        }
-
-        .gradio-container button {
-            background-color: #4CAF50; /* Green button */
-            color: white;
-            transition: background-color 0.2s; /* Smooth transition for hover effect */
-        }
-
-        .gradio-container button:hover {
-            background-color: #3e8e41; /* Darker green on hover */
         }
         """
 
-        # Example prompts
-        example_prompts = [
-            "How do I get started with coding?",
-            "Tell me a fun fact about science.",
-            "What are some good books to read?"
-        ]
-
-        # Function to forward prompt to the textbox
-        def forward_prompt(prompt):
-            return prompt
-
-        # Create the interface
-        with gr.Blocks(css=custom_css) as demo:
-            # Access global variables (use with caution!)
-            global chat_visible_global
-            global sidebar_collapsed_global
-
-            with gr.Row():
-                # Sidebar for displaying chat history
-                with gr.Column(scale=1) as sidebar:
-                    # Collapse button
-                    collapse_button = gr.Button("<<", elem_id="collapse-button")
-
-                    # Sidebar content (in a nested column for easier hiding)
-                    with gr.Column(elem_id="sidebar-content") as sidebar_content:
-                        gr.Markdown("### Chat History")
-                        load_button = gr.Button("Load Chat History")
-                        chat_list = gr.Markdown("No chat history found.")
-
-                        load_button.click(
-                            fn=lambda *args: format_chat_history(),
-                            inputs=None,
-                            outputs=[chat_list]
-                        )
-
-                # Main chat interface
-                with gr.Column(scale=3) as main_chat:
-                    # Input row (stays visible)
-                    with gr.Row():
-                        txt = gr.Textbox(
-                            show_label=False,
-                            placeholder="Type your message...",
-                            container=False,
-                            scale=4
-                        )
-                        btn = gr.Button("Send", scale=1)
-
-                    # Xylaria welcome and example prompts (initially visible)
-                    with gr.Column(visible=True) as start_page:
-                        gr.Markdown("# Xylaria")
-                        with gr.Row():
-                            for prompt in example_prompts:
-                                gr.Button(prompt).click(
-                                    fn=lambda p=prompt: p,
-                                    inputs=gr.State(prompt),
-                                    outputs=txt
-                                )
-
-                    # Chat interface (initially hidden)
-                    with gr.Column(visible=False) as chat_page:
-                        chatbot = gr.Chatbot(
-                            label="Xylaria 1.4 Senoa",
-                            height=500,
-                            show_copy_button=True,
-                            avatar_images=("user.png", "xylaria.png"),
-                            bubble_full_width=False
-                        )
-
-                        # Clear history and memory buttons
-                        clear = gr.Button("Clear Conversation")
-                        clear_memory = gr.Button("Clear Memory")
-
-            # Toggle between start and chat pages (using visibility and global variable)
-            def toggle_page(*args):
-                global chat_visible_global
-                chat_visible_global = not chat_visible_global
-                return not chat_visible_global, chat_visible_global
-
-            # Toggle sidebar visibility (using global variable)
-            def toggle_sidebar(*args):
-                global sidebar_collapsed_global
-                sidebar_collapsed_global = not sidebar_collapsed_global
-                if sidebar_collapsed_global:
-                    # If currently collapsed, expand
-                    return False, "250px", "block"  # Expand, normal width, display content
-                else:
-                    # If currently expanded, collapse
-                    return True, "50px", "none"  # Collapse, narrow width, hide content
-
-            # Collapse button click (handle sidebar toggling)
-            collapse_button.click(
-                fn=toggle_sidebar,
-                inputs=[],
-                outputs=[sidebar_collapsed, sidebar, sidebar_content]
+        with gr.Blocks(theme='soft', css=custom_css) as demo:
+            # Chat interface with improved styling
+            with gr.Column():
+                chatbot = gr.Chatbot(
+                    label="Xylaria 1.4 Senoa",
+                    height=500,
+                    show_copy_button=True,
+                    # type="messages"  # Use the 'messages' format
+                )
+
+                # 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 history and memory buttons
+                clear = gr.Button("Clear Conversation")
+                clear_memory = gr.Button("Clear Memory")
+
+            # Use `gr.State` to manage initial chatbot value and `demo.load` for initialization
+            initial_chat_history = gr.State([])
+
+            demo.load(
+              fn=lambda: initial_chat_history.value,
+              inputs=None,
+              outputs=[chatbot],
+              js=load_from_local_storage_js
             )
 
-            # Submit prompt
-            submit_event = btn.click(
+            # Submit functionality with local storage save
+            btn.click(
                 fn=streaming_response,
                 inputs=[txt, chatbot],
                 outputs=[txt, chatbot]
+            ).then(
+                fn=None,
+                inputs=[chatbot],  # Pass chatbot history to JavaScript
+                outputs=None,
+                js=save_to_local_storage_js
             )
-            txt_submit_event = txt.submit(
+            txt.submit(
                 fn=streaming_response,
                 inputs=[txt, chatbot],
                 outputs=[txt, chatbot]
+            ).then(
+                fn=None,
+                inputs=[chatbot],  # Pass chatbot history to JavaScript
+                outputs=None,
+                js=save_to_local_storage_js
             )
 
-            # Toggle to chat page after sending the first message
-            submit_event.then(
-                fn=toggle_page,
-                inputs=[],
-                outputs=[start_page, chat_page]
-            )
-            txt_submit_event.then(
-                fn=toggle_page,
-                inputs=[],
-                outputs=[start_page, chat_page]
-            )
-
-            # Clear conversation
+            # Clear conversation history with local storage clear
             clear.click(
-                fn=lambda *args: [],
+                fn=lambda: [],
                 inputs=None,
-                outputs=[chatbot],
-                queue=False
+                outputs=[chatbot]
             ).then(
-                fn=lambda *args: (True, False),
+                fn=None,
                 inputs=None,
-                outputs=[start_page, chat_page]
+                outputs=None,
+                js=clear_local_storage_js
             )
 
-            # Clear memory
+            # Clear persistent memory and reset conversation with local storage clear
             clear_memory.click(
                 fn=self.reset_conversation,
                 inputs=None,
-                outputs=None,
-                queue=False
+                outputs=[chatbot]
             ).then(
-                fn=lambda *args: (True, False),
+                fn=None,
                 inputs=None,
-                outputs=[start_page, chat_page]
+                outputs=None,
+                js=clear_local_storage_js
             )
 
-            # Load on startup
-            demo.load(fn=self.reset_conversation, inputs=None, outputs=None)
-
-            return demo
-
-    def format_chat_history(self):
-        """Formats the chat history for display in the sidebar."""
-        self.load_chat()  # Load the chat history first
-        if not self.conversation_history:
-            return "No chat history found."
-
-        formatted_history = ""
-        for chat in self.conversation_history:
-            if chat["role"] == "user":
-                formatted_history += f"**You:** {chat['content']}\n\n"
-            elif chat["role"] == "assistant":
-                formatted_history += f"**Xylaria:** {chat['content']}\n\n"
+        return demo
 
-        return formatted_history
+# Launch the interface
 def main():
     chat = XylariaChat()
     interface = chat.create_interface()
     interface.launch(
-        share=False,  # Set to True to create a public link
+        share=True,  # Optional: create a public link
         debug=True   # Show detailed errors
     )