Update app.py

app.py

@@ -1,6 +1,7 @@
 import os
 import gradio as gr
 from huggingface_hub import InferenceClient
+import json
 
 class XylariaChat:
     def __init__(self):
@@ -11,35 +12,18 @@ class XylariaChat:
 
         # Initialize the inference client
         self.client = InferenceClient(
-            model="Qwen/QwQ-32B-Preview",  # Changed model name
-            token=self.hf_token
+            model="Qwen/Qwen-32B-Preview",  # Changed model to Qwen/Qwen-32B-Preview to test streaming
+            api_key=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 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 """
+        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
+"""
 
     def store_information(self, key, value):
         """Store important information in persistent memory"""
@@ -49,14 +33,54 @@ Capabilities:
         """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 and persistent memory
-        This helps prevent exposing previous users' conversations
+        Completely reset the conversation history, persistent memory,
+        and clear API-side memory
         """
+        # Clear local memory
         self.conversation_history = []
-        self.persistent_memory = {}
-        return []
+        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
+        return None  # To clear the chatbot interface
 
     def get_response(self, user_input):
         # Prepare messages with conversation context and persistent memory
@@ -75,55 +99,20 @@ Capabilities:
 
         # Generate response with streaming
         try:
-            response_stream = self.client.text_generation(
-                prompt=self.messages_to_prompt(messages),  # Convert messages to prompt format
-                max_new_tokens=1024,
+            stream = self.client.chat.completions.create(
+                messages=messages,
                 temperature=0.5,
+                max_tokens=10240,
                 top_p=0.7,
                 stream=True
             )
 
-            return response_stream
+            return 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)
@@ -137,12 +126,14 @@ Capabilities:
             updated_history = chat_history + [[message, ""]]
 
             # Streaming output
-            for response_text in response_stream:
-                full_response += response_text
+            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 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(
@@ -156,112 +147,186 @@ Capabilities:
             if len(self.conversation_history) > 10:
                 self.conversation_history = self.conversation_history[-10:]
 
-            return "", updated_history
+            self.save_chat()
 
-        # Custom CSS for Inter font
+        def load_chat_interface():
+            """Loads the chat history into the chatbot interface."""
+            self.load_chat()
+            return self.conversation_history
+
+        # Custom CSS for Inter font and sidebar
         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;
         }
+
+        /* Sidebar styling */
+        #sidebar {
+            background-color: #f2f2f2;
+            border-right: 1px solid #ccc;
+            padding: 10px;
+            height: 100vh;
+            overflow-y: auto;
+        }
+
+        #sidebar ul {
+            list-style-type: none;
+            padding: 0;
+        }
+
+        #sidebar li {
+            margin-bottom: 5px;
+        }
+        /* Main chat area */
+        #main-chat {
+            padding: 20px;
+        }
         """
 
+        # 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
+
         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
+            with gr.Row():
+                # Sidebar for displaying chat history
+                with gr.Column(elem_id="sidebar", scale=1):
+                    gr.Markdown("### Chat History")
+                    load_button = gr.Button("Load Chat History")
+                    chat_list = gr.Markdown("No chat history found.")
+
+                    load_button.click(
+                        fn=lambda: gr.Markdown.update(value=self.format_chat_history()),
+                        inputs=None,
+                        outputs=[chat_list]
                     )
-                    btn = gr.Button("Send", scale=1)
 
-                # Clear history and memory buttons
-                clear = gr.Button("Clear Conversation")
-                clear_memory = gr.Button("Clear Memory")
+                # Main chat interface
+                with gr.Column(elem_id="main-chat", scale=3):
+                    # Input row with improved layout (moved txt outside of conditional columns)
+                    with gr.Row():
+                        txt = gr.Textbox(
+                            show_label=False,
+                            placeholder="Type your message...",
+                            container=False,
+                            scale=4
+                        )
+                        btn = gr.Button("Send", scale=1)
+                    # Show Xylaria and example prompts only on the first page/new chat
+                    with gr.Column(visible=True) as start_page:
+                        gr.Markdown("# Xylaria")
+                        with gr.Row():
+                            for prompt in example_prompts:
+                                gr.Button(prompt).click(
+                                    fn=forward_prompt,
+                                    inputs=gr.State(prompt),
+                                    outputs=txt
+                                )
+
+                    with gr.Column(visible=False) as chat_page:
+                        chatbot = gr.Chatbot(
+                            label="Xylaria 1.4 Senoa",
+                            height=500,
+                            show_copy_button=True
+                        )
+
+                        # Clear history and memory buttons
+                        clear = gr.Button("Clear Conversation")
+                        clear_memory = gr.Button("Clear Memory")
+
+                    # Toggle between start page and chat page
+                    def toggle_page(choice):
+                        return gr.Column.update(visible=choice == "chat"), gr.Column.update(visible=choice == "start")
+
+                    # Submit functionality with streaming
+                    btn.click(
+                        fn=streaming_response,
+                        inputs=[txt, chatbot],
+                        outputs=[txt, chatbot]
+                    ).then(
+                        fn=lambda: toggle_page("chat"),
+                        inputs=gr.State("chat"),
+                        outputs=[chat_page, start_page]
+                    )
+                    txt.submit(
+                        fn=streaming_response,
+                        inputs=[txt, chatbot],
+                        outputs=[txt, chatbot]
+                    ).then(
+                        fn=lambda: toggle_page("chat"),
+                        inputs=gr.State("chat"),
+                        outputs=[chat_page, start_page]
+                    )
 
-            # Use `gr.State` to manage initial chatbot value and `demo.load` for initialization
-            initial_chat_history = gr.State([])
+                    # Clear conversation history
+                    clear.click(
+                        fn=lambda: None,
+                        inputs=None,
+                        outputs=[chatbot],
+                        queue=False
+                    ).then(
+                        fn=lambda: toggle_page("start"),
+                        inputs=gr.State("start"),
+                        outputs=[chat_page, start_page]
+                    )
 
-            demo.load(
-              fn=lambda: initial_chat_history.value,
-              inputs=None,
-              outputs=[chatbot],
-              js=load_from_local_storage_js
-            )
+                    # Clear persistent memory and reset conversation
+                    clear_memory.click(
+                        fn=self.reset_conversation,
+                        inputs=None,
+                        outputs=[chatbot],
+                        queue=False
+                    ).then(
+                        fn=lambda: toggle_page("start"),
+                        inputs=gr.State("start"),
+                        outputs=[chat_page, start_page]
+                    )
 
-            # 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(
-                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
-            )
+                    # Ensure memory is cleared when the interface is closed
+                    demo.load(self.reset_conversation, None, None)
 
-            # Clear conversation history with local storage clear
-            clear.click(
-                fn=lambda: [],
-                inputs=None,
-                outputs=[chatbot]
-            ).then(
-                fn=None,
-                inputs=None,
-                outputs=None,
-                js=clear_local_storage_js
-            )
+        return demo
 
-            # Clear persistent memory and reset conversation with local storage clear
-            clear_memory.click(
-                fn=self.reset_conversation,
-                inputs=None,
-                outputs=[chatbot]
-            ).then(
-                fn=None,
-                inputs=None,
-                outputs=None,
-                js=clear_local_storage_js
-            )
+    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."
 
-        return demo
+        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
 
 # Launch the interface
 def main():
     chat = XylariaChat()
     interface = chat.create_interface()
     interface.launch(
-        share=True,  # Optional: create a public link
+        share=False,  # Optional: create a public link
         debug=True   # Show detailed errors
     )