Update app.py

app.py

@@ -88,19 +88,24 @@ class RAGPipeline:
             self.retriever = SentenceTransformerRetriever()
             self.documents = []
             self.device = torch.device("cpu")
-            self.model_path = "mistral-7b-v0.1.Q4_K_M.gguf"
-            self.llm = None
-            self.initialize_model()  # Using the class method
+            
+            # Model path with absolute path
+            current_dir = os.path.dirname(os.path.abspath(__file__))
+            self.model_path = os.path.join(current_dir, "models", "mistral-7b-v0.1.Q4_K_M.gguf")
+            
+            # Initialize model
+            self.llm = self.get_model()
             
         except Exception as e:
             logging.error(f"Error in RAGPipeline initialization: {str(e)}")
             raise
 
-    @st.cache_resource
-    def initialize_model(_self):  # Changed 'self' to '_self' for Streamlit caching
-        """Initialize the model with proper error handling and verification"""
+    @st.cache_resource(show_spinner=False)
+    def get_model(_self):
+        """Get or initialize the model with caching"""
         try:
             if not os.path.exists(_self.model_path):
+                os.makedirs(os.path.dirname(_self.model_path), exist_ok=True)
                 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"
                 _self.download_file_with_progress(direct_url, _self.model_path)
@@ -112,17 +117,19 @@ class RAGPipeline:
             if os.path.getsize(_self.model_path) < 1000000:  # Less than 1MB
                 os.remove(_self.model_path)
                 raise ValueError("Downloaded model file is too small, likely corrupted")
-            
+
             llm_config = {
+                "model_path": _self.model_path,
                 "n_ctx": 2048,
                 "n_threads": 4,
                 "n_batch": 512,
                 "n_gpu_layers": 0,
                 "verbose": False
             }
-        
-            _self.llm = Llama(model_path=_self.model_path, **llm_config)
+            
+            model = Llama(**llm_config)
             st.success("Model loaded successfully!")
+            return model
             
         except Exception as e:
             st.error(f"Error initializing model: {str(e)}")
@@ -393,7 +400,7 @@ def initialize_rag_pipeline():
         for directory in ['models', 'ESPN_data', 'embeddings_cache']:
             os.makedirs(directory, exist_ok=True)
             
-        # Load embeddings from Drive
+        # Load embeddings from Drive first
         drive_file_id = "1MuV63AE9o6zR9aBvdSDQOUextp71r2NN"
         with st.spinner("Loading embeddings from Google Drive..."):
             cache_data = load_from_drive(drive_file_id)
@@ -401,26 +408,20 @@ def initialize_rag_pipeline():
                 st.error("Failed to load embeddings from Google Drive")
                 st.stop()
         
-        # Initialize pipeline
+        # Now initialize pipeline
         data_folder = "ESPN_data"
-        rag = RAGPipeline(data_folder)  # This will automatically initialize the model through __init__
+        rag = RAGPipeline(data_folder)
         
         # Store embeddings
         rag.documents = cache_data['documents']
         rag.retriever.store_embeddings(cache_data['embeddings'])
         
-        st.success("System initialized successfully!")
         return rag
         
     except Exception as e:
         logging.error(f"Pipeline initialization error: {str(e)}")
         st.error(f"Failed to initialize the system: {str(e)}")
         raise
-        
-    except Exception as e:
-        logging.error(f"Pipeline initialization error: {str(e)}")
-        st.error(f"Failed to initialize the system: {str(e)}")
-        raise
 
 def main():
     try: