Update app.py

app.py

@@ -12,18 +12,39 @@ from typing import List, Tuple
 import re
 import json
 from datetime import datetime
+import logging
+import sys
+
+# Set up logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler('chatbot.log'),
+        logging.StreamHandler(sys.stdout)
+    ]
+)
 
 TOGETHER_API_KEY = os.getenv('TOGETHER_API_KEY')
+DATA_DIR = "data"
+LEARNED_DATA_FILE = os.path.join(DATA_DIR, "learned_data.json")
+VECTOR_STORE_DIR = os.path.join(DATA_DIR, "vector_store")
 
 class LearningChatBot:
     def __init__(self):
-        # Initialize embeddings
-        self.embeddings = TogetherEmbeddings(
-            model="togethercomputer/m2-bert-80M-32k-retrieval",
-            together_api_key=TOGETHER_API_KEY
-        )
+        self.setup_directories()
         
-        # Initialize text splitter for processing new information
+        try:
+            # Initialize embeddings
+            self.embeddings = TogetherEmbeddings(
+                model="togethercomputer/m2-bert-80M-32k-retrieval",
+                together_api_key=TOGETHER_API_KEY
+            )
+        except Exception as e:
+            logging.error(f"Failed to initialize embeddings: {str(e)}")
+            raise
+
+        # Initialize text splitter
         self.text_splitter = RecursiveCharacterTextSplitter(
             chunk_size=1000,
             chunk_overlap=200,
@@ -33,14 +54,18 @@ class LearningChatBot:
         # Load or create the FAISS index
         self.load_or_create_vectorstore()
         
-        # Initialize the model
-        self.model = Together(
-            model="meta-llama/Llama-3.3-70B-Instruct-Turbo",
-            temperature=0.7,
-            max_tokens=150,
-            top_k=30,
-            together_api_key=TOGETHER_API_KEY
-        )
+        try:
+            # Initialize the model
+            self.model = Together(
+                model="meta-llama/Llama-3.3-70B-Instruct-Turbo",
+                temperature=0.7,
+                max_tokens=150,
+                top_k=30,
+                together_api_key=TOGETHER_API_KEY
+            )
+        except Exception as e:
+            logging.error(f"Failed to initialize Together model: {str(e)}")
+            raise
         
         # Initialize memory
         self.memory = ConversationBufferMemory(
@@ -64,47 +89,98 @@ Javobni faqat matn shaklida bering, kod yoki ortiqcha belgilar kiritmang."""
         # Load learned data
         self.learned_data = self.load_learned_data()
 
+    def setup_directories(self):
+        """Create necessary directories if they don't exist"""
+        try:
+            # Create data directory if it doesn't exist
+            os.makedirs(DATA_DIR, exist_ok=True)
+            os.makedirs(VECTOR_STORE_DIR, exist_ok=True)
+            
+            # Create learned_data.json if it doesn't exist
+            if not os.path.exists(LEARNED_DATA_FILE):
+                with open(LEARNED_DATA_FILE, 'w', encoding='utf-8') as f:
+                    json.dump({}, f, ensure_ascii=False, indent=2)
+                logging.info(f"Created new learned_data.json file at {LEARNED_DATA_FILE}")
+        except Exception as e:
+            logging.error(f"Failed to setup directories: {str(e)}")
+            raise
+
     def load_or_create_vectorstore(self):
         """Load existing vectorstore or create a new one"""
         try:
-            self.vectorstore = FAISS.load_local(
-                ".",
-                embeddings=self.embeddings,
-                allow_dangerous_deserialization=True
-            )
-        except:
-            # If no existing vectorstore, create an empty one
-            self.vectorstore = FAISS.from_texts(
-                ["Initial empty index"],
-                self.embeddings
-            )
-        self.retriever = self.vectorstore.as_retriever()
+            if os.path.exists(os.path.join(VECTOR_STORE_DIR, "index.faiss")):
+                self.vectorstore = FAISS.load_local(
+                    VECTOR_STORE_DIR,
+                    embeddings=self.embeddings,
+                    allow_dangerous_deserialization=True
+                )
+                logging.info("Loaded existing vectorstore")
+            else:
+                # If no existing vectorstore, create an empty one
+                self.vectorstore = FAISS.from_texts(
+                    ["Initial empty index"],
+                    self.embeddings
+                )
+                # Save the initial vectorstore
+                self.vectorstore.save_local(VECTOR_STORE_DIR)
+                logging.info("Created new vectorstore")
+            
+            self.retriever = self.vectorstore.as_retriever()
+        except Exception as e:
+            logging.error(f"Failed to load or create vectorstore: {str(e)}")
+            raise
 
     def setup_chain(self):
         """Set up the processing chain"""
-        self.chain = (
-            {
-                "context": self.retriever,
-                "chat_history": lambda x: self.get_chat_history(),
-                "question": RunnablePassthrough()
-            }
-            | self.prompt
-            | self.model
-            | StrOutputParser()
-        )
+        try:
+            self.chain = (
+                {
+                    "context": self.retriever,
+                    "chat_history": lambda x: self.get_chat_history(),
+                    "question": RunnablePassthrough()
+                }
+                | self.prompt
+                | self.model
+                | StrOutputParser()
+            )
+        except Exception as e:
+            logging.error(f"Failed to setup chain: {str(e)}")
+            raise
 
     def load_learned_data(self) -> dict:
         """Load previously learned data from file"""
         try:
-            with open('learned_data.json', 'r', encoding='utf-8') as f:
+            with open(LEARNED_DATA_FILE, 'r', encoding='utf-8') as f:
                 return json.load(f)
         except FileNotFoundError:
+            logging.warning(f"learned_data.json not found at {LEARNED_DATA_FILE}")
+            return {}
+        except json.JSONDecodeError:
+            logging.error("Error decoding learned_data.json. Creating backup and starting fresh.")
+            # Create backup of corrupted file
+            backup_file = f"{LEARNED_DATA_FILE}.backup-{datetime.now().strftime('%Y%m%d-%H%M%S')}"
+            os.rename(LEARNED_DATA_FILE, backup_file)
+            return {}
+        except Exception as e:
+            logging.error(f"Unexpected error loading learned data: {str(e)}")
             return {}
 
     def save_learned_data(self):
         """Save learned data to file"""
-        with open('learned_data.json', 'w', encoding='utf-8') as f:
-            json.dump(self.learned_data, f, ensure_ascii=False, indent=2)
+        try:
+            # Create temporary file
+            temp_file = f"{LEARNED_DATA_FILE}.temp"
+            with open(temp_file, 'w', encoding='utf-8') as f:
+                json.dump(self.learned_data, f, ensure_ascii=False, indent=2)
+            
+            # Rename temporary file to actual file
+            os.replace(temp_file, LEARNED_DATA_FILE)
+            logging.info("Successfully saved learned data")
+        except Exception as e:
+            logging.error(f"Failed to save learned data: {str(e)}")
+            if os.path.exists(temp_file):
+                os.remove(temp_file)
+            raise
 
     def learn_new_information(self, information: str, source: str = "user_input") -> bool:
         """Process and store new information"""
@@ -129,28 +205,37 @@ Javobni faqat matn shaklida bering, kod yoki ortiqcha belgilar kiritmang."""
             self.save_learned_data()
             
             # Save the updated vectorstore
-            self.vectorstore.save_local(".")
+            self.vectorstore.save_local(VECTOR_STORE_DIR)
             
+            logging.info(f"Successfully learned new information from {source}")
             return True
         except Exception as e:
-            print(f"Error learning new information: {str(e)}")
+            logging.error(f"Error learning new information: {str(e)}")
             return False
 
     def get_chat_history(self) -> str:
         """Format chat history for the prompt"""
-        messages = self.memory.load_memory_variables({})["chat_history"]
-        return "\n".join([f"{m.type}: {m.content}" for m in messages])
+        try:
+            messages = self.memory.load_memory_variables({})["chat_history"]
+            return "\n".join([f"{m.type}: {m.content}" for m in messages])
+        except Exception as e:
+            logging.error(f"Error getting chat history: {str(e)}")
+            return ""
 
     def process_response(self, response: str) -> str:
         """Clean up the response"""
-        unwanted_tags = ["[INST]", "[/INST]", "<s>", "</s>"]
-        for tag in unwanted_tags:
-            response = response.replace(tag, "")
+        try:
+            unwanted_tags = ["[INST]", "[/INST]", "<s>", "</s>"]
+            for tag in unwanted_tags:
+                response = response.replace(tag, "")
+            
+            response = re.sub(r"```.*?```", "", response, flags=re.DOTALL)
+            response = re.sub(r"print\(.*?\)", "", response)
         
-        response = re.sub(r"```.*?```", "", response, flags=re.DOTALL)
-        response = re.sub(r"print\(.*?\)", "", response)
-    
-        return response.strip()
+            return response.strip()
+        except Exception as e:
+            logging.error(f"Error processing response: {str(e)}")
+            return response
 
     def chat(self, message: str, history: List[Tuple[str, str]]) -> str:
         """Process a single chat message"""
@@ -159,6 +244,9 @@ Javobni faqat matn shaklida bering, kod yoki ortiqcha belgilar kiritmang."""
             if message.lower().startswith("o'rgan:") or message.lower().startswith("learn:"):
                 # Extract the learning content
                 learning_content = message[message.find(':')+1:].strip()
+                if not learning_content:
+                    return "O'rganish uchun ma'lumot kiritilmadi."
+                
                 if self.learn_new_information(learning_content):
                     return "Yangi ma'lumot muvaffaqiyatli o'rganildi va saqlandi."
                 else:
@@ -174,53 +262,66 @@ Javobni faqat matn shaklida bering, kod yoki ortiqcha belgilar kiritmang."""
             self.memory.chat_memory.add_ai_message(clean_response)
             return clean_response
         except Exception as e:
-            return f"Xatolik yuz berdi: {str(e)}"
+            logging.error(f"Error in chat: {str(e)}")
+            return f"Xatolik yuz berdi. Iltimos qaytadan urinib ko'ring."
 
     def reset_chat(self) -> List[Tuple[str, str]]:
         """Reset the chat history"""
-        self.memory.clear()
-        return []
+        try:
+            self.memory.clear()
+            return []
+        except Exception as e:
+            logging.error(f"Error resetting chat: {str(e)}")
+            return []
 
 def create_demo() -> gr.Interface:
-    chatbot = LearningChatBot()
-    
-    with gr.Blocks() as demo:
-        gr.Markdown("""# O'rganuvchi RAG Chatbot
-        Beeline Uzbekistan ma'lumotlari va yangi o'rganilgan ma'lumotlar asosida javob beruvchi bot
-        
-        Yangi ma'lumot o'rgatish uchun xabarni "o'rgan:" yoki "learn:" bilan boshlang.""")
-        
-        chatbot_interface = gr.Chatbot(
-            height=600,
-            show_copy_button=True,
-        )
+    try:
+        chatbot = LearningChatBot()
         
-        with gr.Row():
-            msg = gr.Textbox(
-                show_label=False,
-                placeholder="Xabaringizni shu yerda yozing",
-                container=False
+        with gr.Blocks() as demo:
+            gr.Markdown("""# O'rganuvchi RAG Chatbot
+            Beeline Uzbekistan ma'lumotlari va yangi o'rganilgan ma'lumotlar asosida javob beruvchi bot
+            
+            Yangi ma'lumot o'rgatish uchun xabarni "o'rgan:" yoki "learn:" bilan boshlang.""")
+            
+            chatbot_interface = gr.Chatbot(
+                height=600,
+                show_copy_button=True,
             )
-            submit = gr.Button("Xabarni yuborish", variant="primary")
-        
-        clear = gr.Button("Yangi suhbat")
-        
-        def respond(message, chat_history):
-            message = message.strip()
-            if not message:
+            
+            with gr.Row():
+                msg = gr.Textbox(
+                    show_label=False,
+                    placeholder="Xabaringizni shu yerda yozing",
+                    container=False
+                )
+                submit = gr.Button("Xabarni yuborish", variant="primary")
+            
+            clear = gr.Button("Yangi suhbat")
+            
+            def respond(message, chat_history):
+                message = message.strip()
+                if not message:
+                    return "", chat_history
+                
+                bot_message = chatbot.chat(message, chat_history)
+                chat_history.append((message, bot_message))
                 return "", chat_history
             
-            bot_message = chatbot.chat(message, chat_history)
-            chat_history.append((message, bot_message))
-            return "", chat_history
+            submit.click(respond, [msg, chatbot_interface], [msg, chatbot_interface])
+            msg.submit(respond, [msg, chatbot_interface], [msg, chatbot_interface])
+            clear.click(lambda: chatbot.reset_chat(), None, chatbot_interface)
         
-        submit.click(respond, [msg, chatbot_interface], [msg, chatbot_interface])
-        msg.submit(respond, [msg, chatbot_interface], [msg, chatbot_interface])
-        clear.click(lambda: chatbot.reset_chat(), None, chatbot_interface)
-    
-    return demo
+        return demo
+    except Exception as e:
+        logging.error(f"Error creating demo: {str(e)}")
+        raise
 
 demo = create_demo()
 
 if __name__ == "__main__":
-    demo.launch()
+    try:
+        demo.launch()
+    except Exception as e:
+        logging.error(f"Failed to launch demo: {str(e)}")
+        raise