simplify

src/legisqa_local/app.py

@@ -36,10 +36,8 @@ def main():
     setup_chromadb()
     logger.info("✅ ChromaDB setup complete")
     
-    # Initialize vectorstore (load once and cache)
-    logger.info("🔄 Initializing vectorstore...")
+    # Initialize vectorstore (load once and cache in session state)
     initialize_vectorstore()
-    logger.info("✅ Vectorstore initialization complete")
     
     # Main content
     st.title(":classical_building: LegisQA :classical_building:")

src/legisqa_local/components/sidebar.py

@@ -3,28 +3,29 @@
 import streamlit as st
 import os
 from legisqa_local.config.settings import get_chroma_config
+from legisqa_local.core.vectorstore import get_vectorstore
 
 
 def render_chromadb_status():
     """Render ChromaDB status in sidebar"""
     st.subheader("🗄️ Vector Database")
     
-    try:
-        config = get_chroma_config()
-        chromadb_path = config["persist_directory"]
-        
-        if os.path.exists(chromadb_path):
+    vectorstore = get_vectorstore()
+    if vectorstore is not None:
+        try:
+            # Test the vectorstore to get document count
+            count = vectorstore._collection.count()
             st.success("✅ ChromaDB Ready")
-            st.caption("📊 Using pre-existing database")
+            st.caption(f"📊 {count:,} documents loaded")
+            
+            config = get_chroma_config()
             st.caption(f"📁 Collection: {config['collection_name']}")
-            st.caption(f"📁 Path: .../{os.path.basename(os.path.dirname(chromadb_path))}")
-        else:
-            st.error("❌ ChromaDB Not Found")
-            st.caption(f"Expected path: {chromadb_path}")
-            st.caption("Please check the database path")
-    except Exception as e:
-        st.error("❌ ChromaDB Configuration Error")
-        st.caption(f"Error: {str(e)[:50]}...")
+        except Exception as e:
+            st.warning("⚠️ ChromaDB Loaded (verification failed)")
+            st.caption(f"Error: {str(e)[:50]}...")
+    else:
+        st.info("⏳ ChromaDB Loading...")
+        st.caption("Vectorstore is being initialized")
 
 
 def render_outreach_links():

src/legisqa_local/core/rag.py

@@ -4,7 +4,7 @@ from langchain_core.prompts import ChatPromptTemplate
 from langchain_core.runnables import RunnableParallel, RunnablePassthrough
 
 from legisqa_local.core.llm import get_llm
-from legisqa_local.core.vectorstore import load_vectorstore, get_vectorstore_filter
+from legisqa_local.core.vectorstore import get_vectorstore, get_vectorstore_filter
 from legisqa_local.utils.formatting import format_docs
 
 
@@ -41,7 +41,15 @@ Query: {query}"""
 
 def process_query(gen_config: dict, ret_config: dict, query: str):
     """Process a query using RAG"""
-    vectorstore = load_vectorstore()
+    # Check if vectorstore is loaded
+    vectorstore = get_vectorstore()
+    if vectorstore is None:
+        return {
+            "aimessage": "⏳ Vectorstore is still loading. Please wait a moment and try again.",
+            "docs": [],
+            "query": query
+        }
+    
     llm = get_llm(gen_config)
     vs_filter = get_vectorstore_filter(ret_config)
     

src/legisqa_local/core/vectorstore.py

@@ -11,65 +11,42 @@ logger = logging.getLogger(__name__)
 
 
 def load_vectorstore():
-    """Load and return the ChromaDB vectorstore (cached in session state)"""
-    # Check if vectorstore is already loaded in session state
-    if hasattr(st, 'session_state') and hasattr(st.session_state, 'vectorstore'):
-        logger.debug("Using cached vectorstore from session state")
-        return st.session_state.vectorstore
-    
+    """Load and return the ChromaDB vectorstore"""
     logger.info("🔄 Loading ChromaDB vectorstore...")
     config = get_chroma_config()
     emb_fn = load_embeddings()
     
-    # Debug logging to identify path issues
-    logger.info(f"🔍 Vectorstore config:")
-    logger.info(f"   persist_directory: {config['persist_directory']}")
-    logger.info(f"   collection_name: {config['collection_name']}")
-    logger.info(f"🌍 Environment variables:")
-    for key, value in os.environ.items():
-        if "CHROMA" in key:
-            logger.info(f"   {key}={value}")
-    
-    # Check if the directory actually exists
-    if not os.path.exists(config["persist_directory"]):
-        logger.error(f"❌ ChromaDB directory does not exist: {config['persist_directory']}")
-        # Try to find the correct path
-        if os.path.exists("/data/chromadb"):
-            logger.info(f"🔧 Found ChromaDB at /data/chromadb, updating config")
-            config["persist_directory"] = "/data/chromadb"
-            os.environ["CHROMA_PERSIST_DIRECTORY"] = "/data/chromadb"
-    
     vectorstore = Chroma(
         persist_directory=config["persist_directory"],
         collection_name=config["collection_name"],
         embedding_function=emb_fn,
     )
     
-    # Cache in session state for future use
-    if hasattr(st, 'session_state'):
-        st.session_state.vectorstore = vectorstore
-        logger.info("✅ Vectorstore loaded and cached in session state")
-    else:
-        logger.info("✅ Vectorstore loaded (session state not available)")
-    
+    logger.info("✅ Vectorstore loaded successfully")
     return vectorstore
 
 
 def initialize_vectorstore():
-    """Initialize the vectorstore at application startup"""
+    """Initialize the vectorstore at application startup and cache in session state"""
     logger.info("🚀 Initializing vectorstore at startup...")
-    vectorstore = load_vectorstore()
     
-    # Test the vectorstore with a simple query to ensure it's working
     try:
-        # Get collection info for verification
+        vectorstore = load_vectorstore()
+        st.session_state.vectorstore = vectorstore
+        
+        # Test the vectorstore to verify it's working
         collection = vectorstore._collection
         count = collection.count()
-        logger.info(f"✅ Vectorstore initialized successfully - {count} documents available")
-        return vectorstore
+        logger.info(f"✅ Vectorstore initialized and cached - {count} documents available")
+        
     except Exception as e:
-        logger.error(f"❌ Error testing vectorstore: {e}")
-        raise
+        logger.error(f"❌ Error initializing vectorstore: {e}")
+        # Don't raise - let the app continue and show loading message to users
+
+
+def get_vectorstore():
+    """Get vectorstore from session state, or return None if not loaded"""
+    return getattr(st.session_state, 'vectorstore', None)
 
 
 def get_vectorstore_filter(ret_config: dict) -> dict: