Update app.py

app.py

@@ -67,6 +67,33 @@ def load_from_drive(file_id: str):
         st.error(f"Error loading file from Drive: {str(e)}")
         return None
 
+# @st.cache_resource(show_spinner=False)
+# def load_llama_model():
+#     """Load Llama model with caching"""
+#     try:
+#         model_path = "mistral-7b-v0.1.Q4_K_M.gguf"
+        
+#         if not os.path.exists(model_path):
+#             st.info("Downloading model... This may take a while.")
+#             direct_url = "https://huggingface.co/TheBloke/Mistral-7B-v0.1-GGUF/resolve/main/mistral-7b-v0.1.Q4_K_M.gguf"
+#             download_file_with_progress(direct_url, model_path)
+
+#         llm_config = {
+#             "model_path": model_path,
+#             "n_ctx": 2048,
+#             "n_threads": 4,
+#             "n_batch": 512,
+#             "n_gpu_layers": 0,
+#             "verbose": False
+#         }
+        
+#         model = Llama(**llm_config)
+#         st.success("Model loaded successfully!")
+#         return model
+#     except Exception as e:
+#         st.error(f"Error loading model: {str(e)}")
+#         raise
+
 @st.cache_resource(show_spinner=False)
 def load_llama_model():
     """Load Llama model with caching"""
@@ -78,20 +105,37 @@ def load_llama_model():
             direct_url = "https://huggingface.co/TheBloke/Mistral-7B-v0.1-GGUF/resolve/main/mistral-7b-v0.1.Q4_K_M.gguf"
             download_file_with_progress(direct_url, model_path)
 
+        if not os.path.exists(model_path):
+            raise FileNotFoundError("Model file not found after download attempt")
+
+        if os.path.getsize(model_path) < 1000000:  # Less than 1MB
+            raise ValueError("Model file is too small, likely corrupted")
+
         llm_config = {
             "model_path": model_path,
             "n_ctx": 2048,
             "n_threads": 4,
             "n_batch": 512,
             "n_gpu_layers": 0,
-            "verbose": False
+            "verbose": True  # Enable verbose mode for debugging
         }
         
+        logging.info("Initializing Llama model...")
         model = Llama(**llm_config)
+        
+        # Test the model
+        logging.info("Testing model...")
+        test_response = model("Test", max_tokens=10)
+        if not test_response:
+            raise RuntimeError("Model test failed")
+            
+        logging.info("Model loaded and tested successfully")
         st.success("Model loaded successfully!")
         return model
+        
     except Exception as e:
-        st.error(f"Error loading model: {str(e)}")
+        logging.error(f"Error loading model: {str(e)}")
+        logging.error("Full error details: ", exc_info=True)
         raise
 
 def check_environment():
@@ -152,67 +196,152 @@ class RAGPipeline:
             logging.error(f"Error in query_model: {str(e)}")
             raise
 
-    def process_query(self, query: str, placeholder) -> str:
-        try:
-            # Preprocess query
-            query = self.preprocess_query(query)
+    # def process_query(self, query: str, placeholder) -> str:
+    #     try:
+    #         # Preprocess query
+    #         query = self.preprocess_query(query)
             
-            # Show retrieval status
-            status = placeholder.empty()
-            status.write("🔍 Finding relevant information...")
+    #         # Show retrieval status
+    #         status = placeholder.empty()
+    #         status.write("🔍 Finding relevant information...")
             
-            # Get embeddings and search
-            query_embedding = self.retriever.encode([query])
-            similarities = F.cosine_similarity(query_embedding, self.retriever.doc_embeddings)
-            scores, indices = torch.topk(similarities, k=min(self.k, len(self.documents)))
+    #         # Get embeddings and search
+    #         query_embedding = self.retriever.encode([query])
+    #         similarities = F.cosine_similarity(query_embedding, self.retriever.doc_embeddings)
+    #         scores, indices = torch.topk(similarities, k=min(self.k, len(self.documents)))
             
-            relevant_docs = [self.documents[idx] for idx in indices.tolist()]
+    #         relevant_docs = [self.documents[idx] for idx in indices.tolist()]
             
-            # Update status
-            status.write("💭 Generating response...")
+    #         # Update status
+    #         status.write("💭 Generating response...")
             
-            # Prepare context and prompt
-            context = "\n".join(relevant_docs[:3])
-            prompt = f"""Context information is below:
-            {context}
+    #         # Prepare context and prompt
+    #         context = "\n".join(relevant_docs[:3])
+    #         prompt = f"""Context information is below:
+    #         {context}
             
-            Given the context above, please answer the following question:
-            {query}
-
-            Guidelines:
-            - If you cannot answer based on the context, say so politely
-            - Keep the response concise and focused
-            - Only include sports-related information
-            - No dates or timestamps in the response
-            - Use clear, natural language
+    #         Given the context above, please answer the following question:
+    #         {query}
+
+    #         Guidelines:
+    #         - If you cannot answer based on the context, say so politely
+    #         - Keep the response concise and focused
+    #         - Only include sports-related information
+    #         - No dates or timestamps in the response
+    #         - Use clear, natural language
             
-            Answer:"""
+    #         Answer:"""
             
-            # Generate response
-            response_placeholder = placeholder.empty()
+    #         # Generate response
+    #         response_placeholder = placeholder.empty()
             
-            try:
-                response_text = self.query_model(prompt)
-                if response_text:
-                    final_response = self.postprocess_response(response_text)
-                    response_placeholder.markdown(final_response)
-                    return final_response
-                else:
-                    message = "No relevant answer found. Please try rephrasing your question."
-                    response_placeholder.warning(message)
-                    return message
+    #         try:
+    #             response_text = self.query_model(prompt)
+    #             if response_text:
+    #                 final_response = self.postprocess_response(response_text)
+    #                 response_placeholder.markdown(final_response)
+    #                 return final_response
+    #             else:
+    #                 message = "No relevant answer found. Please try rephrasing your question."
+    #                 response_placeholder.warning(message)
+    #                 return message
                     
-            except Exception as e:
-                logging.error(f"Generation error: {str(e)}")
-                message = "Had some trouble generating the response. Please try again."
-                response_placeholder.warning(message)
-                return message
+    #         except Exception as e:
+    #             logging.error(f"Generation error: {str(e)}")
+    #             message = "Had some trouble generating the response. Please try again."
+    #             response_placeholder.warning(message)
+    #             return message
                 
+    #     except Exception as e:
+    #         logging.error(f"Process error: {str(e)}")
+    #         message = "Something went wrong. Please try again with a different question."
+    #         placeholder.warning(message)
+    #         return message
+
+    def process_query(self, query: str, placeholder) -> str:
+    try:
+        # Preprocess query
+        query = self.preprocess_query(query)
+        logging.info(f"Processing query: {query}")
+        
+        # Show retrieval status
+        status = placeholder.empty()
+        status.write("🔍 Finding relevant information...")
+        
+        # Get embeddings and search
+        query_embedding = self.retriever.encode([query])
+        similarities = F.cosine_similarity(query_embedding, self.retriever.doc_embeddings)
+        scores, indices = torch.topk(similarities, k=min(self.k, len(self.documents)))
+        
+        # Log similarity scores
+        for idx, score in zip(indices.tolist(), scores.tolist()):
+            logging.info(f"Score: {score:.4f} | Document: {self.documents[idx][:100]}...")
+        
+        relevant_docs = [self.documents[idx] for idx in indices.tolist()]
+        
+        # Update status
+        status.write("💭 Generating response...")
+        
+        # Prepare context and prompt
+        context = "\n".join(relevant_docs[:3])
+        prompt = f"""Context information is below:
+        {context}
+        
+        Given the context above, please answer the following question:
+        {query}
+
+        Guidelines:
+        - If you cannot answer based on the context, say so politely
+        - Keep the response concise and focused
+        - Only include sports-related information
+        - No dates or timestamps in the response
+        - Use clear, natural language
+        
+        Answer:"""
+        
+        # Generate response
+        response_placeholder = placeholder.empty()
+        
+        try:
+            # Add logging for model state
+            logging.info("Model state check - Is None?: " + str(self.llm is None))
+            
+            # Directly use Llama model
+            response = self.llm(
+                prompt,
+                max_tokens=512,
+                temperature=0.4,
+                top_p=0.95,
+                echo=False,
+                stop=["Question:", "\n\n"]
+            )
+            
+            logging.info(f"Raw model response: {response}")
+            
+            if response and isinstance(response, dict) and 'choices' in response:
+                generated_text = response['choices'][0].get('text', '').strip()
+                if generated_text:
+                    final_response = self.postprocess_response(generated_text)
+                    response_placeholder.markdown(final_response)
+                    return final_response
+            
+            message = "No relevant answer found. Please try rephrasing your question."
+            response_placeholder.warning(message)
+            return message
+            
         except Exception as e:
-            logging.error(f"Process error: {str(e)}")
-            message = "Something went wrong. Please try again with a different question."
-            placeholder.warning(message)
+            logging.error(f"Generation error: {str(e)}")
+            logging.error(f"Full error details: ", exc_info=True)
+            message = f"Had some trouble generating the response: {str(e)}"
+            response_placeholder.warning(message)
             return message
+            
+    except Exception as e:
+        logging.error(f"Process error: {str(e)}")
+        logging.error(f"Full error details: ", exc_info=True)
+        message = f"Something went wrong: {str(e)}"
+        placeholder.warning(message)
+        return message
 
 @st.cache_resource(show_spinner=False)
 def initialize_rag_pipeline():
@@ -244,6 +373,132 @@ def initialize_rag_pipeline():
         st.error(f"Failed to initialize the system: {str(e)}")
         raise
 
+# def main():
+#     try:
+#         # Environment check
+#         if not check_environment():
+#             return
+
+#         # Improved CSS styling
+#         st.markdown("""
+#             <style>
+#             /* Container styling */
+#             .block-container {
+#                 padding-top: 2rem;
+#                 padding-bottom: 2rem;
+#             }
+            
+#             /* Text input styling */
+#             .stTextInput > div > div > input {
+#                 width: 100%;
+#             }
+            
+#             /* Button styling */
+#             .stButton > button {
+#                 width: 200px;
+#                 margin: 0 auto;
+#                 display: block;
+#                 background-color: #FF4B4B;
+#                 color: white;
+#                 border-radius: 5px;
+#                 padding: 0.5rem 1rem;
+#             }
+            
+#             /* Title styling */
+#             .main-title {
+#                 text-align: center;
+#                 padding: 1rem 0;
+#                 font-size: 3rem;
+#                 color: #1F1F1F;
+#             }
+            
+#             .sub-title {
+#                 text-align: center;
+#                 padding: 0.5rem 0;
+#                 font-size: 1.5rem;
+#                 color: #4F4F4F;
+#             }
+            
+#             /* Description styling */
+#             .description {
+#                 text-align: center;
+#                 color: #666666;
+#                 padding: 0.5rem 0;
+#                 font-size: 1.1rem;
+#                 line-height: 1.6;
+#                 margin-bottom: 1rem;
+#             }
+
+#             /* Answer container styling */
+#             .stMarkdown {
+#                 max-width: 100%;
+#             }
+
+#             /* Streamlit default overrides */
+#             .st-emotion-cache-16idsys p {
+#                 font-size: 1.1rem;
+#                 line-height: 1.6;
+#             }
+            
+#             /* Container for main content */
+#             .main-content {
+#                 max-width: 1200px;
+#                 margin: 0 auto;
+#                 padding: 0 1rem;
+#             }
+#             </style>
+#         """, unsafe_allow_html=True)
+
+#         # Header section
+#         st.markdown("<h1 class='main-title'>🏆 The Sport Chatbot</h1>", unsafe_allow_html=True)
+#         st.markdown("<h3 class='sub-title'>Using ESPN API</h3>", unsafe_allow_html=True)
+#         st.markdown("""
+#             <p class='description'>
+#                 Hey there! 👋 I can help you with information on Ice Hockey, Baseball, American Football, Soccer, and Basketball. 
+#                 With access to the ESPN API, I'm up to date with the latest details for these sports up until October 2024.
+#             </p>
+#             <p class='description'>
+#                 Got any general questions? Feel free to ask—I'll do my best to provide answers based on the information I've been trained on!
+#             </p>
+#         """, unsafe_allow_html=True)
+
+#         # Initialize the pipeline
+#         if 'rag' not in st.session_state:
+#             with st.spinner("Loading resources..."):
+#                 st.session_state.rag = initialize_rag_pipeline()
+
+#         # Create columns for layout
+#         col1, col2, col3 = st.columns([1, 6, 1])
+        
+#         with col2:
+#             # Query input
+#             query = st.text_input("What would you like to know about sports?")
+            
+#             if st.button("Get Answer"):
+#                 if query:
+#                     response_placeholder = st.empty()
+#                     try:
+#                         response = st.session_state.rag.process_query(query, response_placeholder)
+#                         logging.info(f"Generated response: {response}")
+#                     except Exception as e:
+#                         logging.error(f"Query processing error: {str(e)}")
+#                         response_placeholder.warning("Unable to process your question. Please try again.")
+#                 else:
+#                     st.warning("Please enter a question!")
+
+#         # Footer
+#         st.markdown("<br><br>", unsafe_allow_html=True)
+#         st.markdown("---")
+#         st.markdown("""
+#             <p style='text-align: center; color: #666666; padding: 1rem 0;'>
+#                 Powered by ESPN Data & Mistral AI 🚀
+#             </p>
+#         """, unsafe_allow_html=True)
+
+#     except Exception as e:
+#         logging.error(f"Application error: {str(e)}")
+#         st.error("An unexpected error occurred. Please check the logs and try again.")
+
 def main():
     try:
         # Environment check
@@ -333,10 +588,17 @@ def main():
             </p>
         """, unsafe_allow_html=True)
 
-        # Initialize the pipeline
+        # Initialize the pipeline with better error handling
         if 'rag' not in st.session_state:
-            with st.spinner("Loading resources..."):
-                st.session_state.rag = initialize_rag_pipeline()
+            try:
+                with st.spinner("Loading resources..."):
+                    st.session_state.rag = initialize_rag_pipeline()
+                    logging.info("Pipeline initialized successfully")
+            except Exception as e:
+                logging.error(f"Pipeline initialization error: {str(e)}")
+                st.error("Failed to initialize the system. Please check the logs.")
+                st.stop()
+                return
 
         # Create columns for layout
         col1, col2, col3 = st.columns([1, 6, 1])
@@ -349,10 +611,18 @@ def main():
                 if query:
                     response_placeholder = st.empty()
                     try:
+                        # Log query processing start
+                        logging.info(f"Processing query: {query}")
+                        
+                        # Process query and get response
                         response = st.session_state.rag.process_query(query, response_placeholder)
+                        
+                        # Log successful response
                         logging.info(f"Generated response: {response}")
                     except Exception as e:
+                        # Log error details
                         logging.error(f"Query processing error: {str(e)}")
+                        logging.error("Full error details: ", exc_info=True)
                         response_placeholder.warning("Unable to process your question. Please try again.")
                 else:
                     st.warning("Please enter a question!")
@@ -368,7 +638,22 @@ def main():
 
     except Exception as e:
         logging.error(f"Application error: {str(e)}")
+        logging.error("Full error details: ", exc_info=True)
         st.error("An unexpected error occurred. Please check the logs and try again.")
 
+if __name__ == "__main__":
+    # Configure logging
+    logging.basicConfig(
+        level=logging.INFO,
+        format='%(asctime)s - %(levelname)s - %(message)s'
+    )
+    
+    try:
+        main()
+    except Exception as e:
+        logging.error(f"Fatal error: {str(e)}")
+        logging.error("Full error details: ", exc_info=True)
+        st.error("A fatal error occurred. Please check the logs and try again.")
+
 if __name__ == "__main__":
     main()