Upload streamlit_app.py

streamlit_app.py

@@ -12,8 +12,6 @@ import plotly.graph_objects as go
 from collections import Counter
 import nltk
 import string
-
-from canonical_mapping import canonicalize_found_terms
 from datetime import datetime
 import warnings
 import logging
@@ -914,9 +912,9 @@ class ChromaVectorStore:
                         'is_video_professional': job_categories.get('is_video_professional', False),
                         'is_photo_professional': job_categories.get('is_photo_professional', False),
                         'is_creative_professional': job_categories.get('is_creative_professional', False),
-                        'adobe_apps': creative_analysis.get('adobe_apps', []),
-                        'non_adobe_apps': creative_analysis.get('non_adobe_apps', []),
-                        'ai_tools': creative_analysis.get('ai_tools', []),
+                        'adobe_apps': ','.join(creative_analysis.get('adobe_apps', [])),
+                        'non_adobe_apps': ','.join(creative_analysis.get('non_adobe_apps', [])),
+                        'ai_tools': ','.join(creative_analysis.get('ai_tools', [])),
                         'has_adobe': len(creative_analysis.get('adobe_apps', [])) > 0,
                         'has_non_adobe': len(creative_analysis.get('non_adobe_apps', [])) > 0,
                         'has_ai_tools': len(creative_analysis.get('ai_tools', [])) > 0,
@@ -1032,40 +1030,14 @@ class ChromaVectorStore:
                     
                     embeddings_list = embeddings.tolist()
                     
-
                     # Create document IDs
                     doc_ids = [f"doc_{i+j}" for j in range(len(batch_texts))]
-
-                    # Sanitize metadata: Chroma expects primitive metadata values (str,int,float,bool,None)
-                    sanitized_metadatas = []
-                    for md in batch_metadatas:
-                        clean_md = {}
-                        if not md:
-                            sanitized_metadatas.append(clean_md)
-                            continue
-                        for k, v in md.items():
-                            # Convert lists to comma-separated strings
-                            if isinstance(v, list):
-                                clean_md[k] = ', '.join(str(x) for x in v)
-                            # Convert dicts to JSON string
-                            elif isinstance(v, dict):
-                                try:
-                                    clean_md[k] = json.dumps(v)
-                                except Exception:
-                                    clean_md[k] = str(v)
-                            # Accept primitive types
-                            elif isinstance(v, (str, int, float, bool)) or v is None:
-                                clean_md[k] = v
-                            else:
-                                # Fallback to string representation
-                                clean_md[k] = str(v)
-                        sanitized_metadatas.append(clean_md)
-
+                    
                     # Add to Chroma collection
                     self.collection.add(
                         embeddings=embeddings_list,
                         documents=batch_texts,
-                        metadatas=sanitized_metadatas,
+                        metadatas=batch_metadatas,
                         ids=doc_ids
                     )
                     
@@ -1116,7 +1088,7 @@ class ChromaVectorStore:
                 distances = results.get('distances', [[]])[0]
                 
                 for i, (doc, metadata, distance) in enumerate(zip(documents, metadatas, distances)):
-                    similarity_score = max(0.0, min(1.0, 1.0 - float(distance)))
+                    similarity_score = max(0.0, 1.0 - distance)
                     
                     # Convert string lists back to actual lists for certain fields
                     if isinstance(metadata.get('adobe_apps'), str):
@@ -1806,87 +1778,7 @@ def generate_qa_answers(analysis_results: Dict, processed_df: pd.DataFrame) -> D
     except Exception as e:
         logger.error(f"Error generating Q&A answers: {str(e)}")
         return answers
-
 class EnhancedOpenAIProcessor:
-    def query_with_enhanced_rag(self, question: str, vector_store, dataset_analysis: Dict = None) -> str:
-        """Process queries with enhanced RAG optimized for q.txt questions"""
-        
-        if not self.is_available():
-            return f"OpenAI client not available: {self._initialization_error}"
-
-        # Ensure dataset_analysis is a dict to avoid NoneType errors
-        dataset_analysis = dataset_analysis or {}
-        
-        try:
-            # Retrieve relevant documents
-            retrieved_docs = []
-            try:
-                retrieved_docs = vector_store.search(question, k=10)
-                logger.info(f"Retrieved {len(retrieved_docs)} documents for query")
-            except Exception as search_error:
-                logger.warning(f"Vector search failed: {search_error}")
-            
-            # Create enhanced system prompt
-            system_prompt = self.create_enhanced_system_prompt(dataset_analysis)
-            
-            # Prepare RAG context
-            rag_context = self.prepare_rag_context(retrieved_docs, question, dataset_analysis)
-            
-            # Create user message
-            user_message = f"Question: {question}"
-            if rag_context:
-                user_message += f"\n\nRelevant Data:\n{rag_context}"
-            
-            # Token management
-            system_tokens = self.count_tokens(system_prompt)
-            user_tokens = self.count_tokens(user_message)
-            total_input_tokens = system_tokens + user_tokens
-            
-            if total_input_tokens > self.max_input_tokens:
-                # Reduce RAG context if needed
-                excess_tokens = total_input_tokens - self.max_input_tokens
-                if rag_context:
-                    current_context_tokens = self.count_tokens(rag_context)
-                    reduced_tokens = max(200, current_context_tokens - excess_tokens)
-                    rag_context = self._truncate_text(rag_context, reduced_tokens)
-                    user_message = f"Question: {question}\n\nRelevant Data:\n{rag_context}"
-            
-            # Calculate available completion tokens
-            final_input_tokens = self.count_tokens(system_prompt) + self.count_tokens(user_message)
-            available_tokens = self.max_context_length - final_input_tokens - 100
-            completion_tokens = min(self.max_completion_tokens, max(500, available_tokens))
-            
-            # Make API call
-            try:
-                response = self.client.chat.completions.create(
-                    model="gpt-3.5-turbo",
-                    messages=[
-                        {"role": "system", "content": system_prompt},
-                        {"role": "user", "content": user_message}
-                    ],
-                    max_tokens=completion_tokens,
-                    temperature=0.2,  # Lower temperature for more consistent analysis
-                    timeout=30
-                )
-                
-                answer = response.choices[0].message.content
-                logger.info(f"Successfully processed query: {question[:50]}...")
-                return answer
-                
-            except openai.APIError as api_error:
-                error_msg = f"OpenAI API Error: {str(api_error)}"
-                logger.error(error_msg)
-                return f"API Error: {error_msg}"
-                
-            except Exception as api_error:
-                error_msg = f"API call failed: {str(api_error)}"
-                logger.error(error_msg)
-                return f"Error: {error_msg}"
-            
-        except Exception as e:
-            logger.error(f"Error in enhanced RAG query: {e}")
-            return f"Processing error: {str(e)}"
-    
     def __init__(self, api_key: str):
         self._api_key = api_key
         self.client = None
@@ -2091,6 +1983,85 @@ When answering questions, structure responses with:
             truncated = test_text
         
         return truncated + "\n[Content truncated for length...]" if truncated else text[:max_tokens*4]
+    
+    def query_with_enhanced_rag(self, question: str, vector_store, dataset_analysis: Dict = None) -> str:
+        """Process queries with enhanced RAG optimized for q.txt questions"""
+        
+        if not self.is_available():
+            return f"OpenAI client not available: {self._initialization_error}"
+
+        # Ensure dataset_analysis is a dict to avoid NoneType errors
+        dataset_analysis = dataset_analysis or {}
+        
+        try:
+            # Retrieve relevant documents
+            retrieved_docs = []
+            try:
+                retrieved_docs = vector_store.search(question, k=10)
+                logger.info(f"Retrieved {len(retrieved_docs)} documents for query")
+            except Exception as search_error:
+                logger.warning(f"Vector search failed: {search_error}")
+            
+            # Create enhanced system prompt
+            system_prompt = self.create_enhanced_system_prompt(dataset_analysis)
+            
+            # Prepare RAG context
+            rag_context = self.prepare_rag_context(retrieved_docs, question, dataset_analysis)
+            
+            # Create user message
+            user_message = f"Question: {question}"
+            if rag_context:
+                user_message += f"\n\nRelevant Data:\n{rag_context}"
+            
+            # Token management
+            system_tokens = self.count_tokens(system_prompt)
+            user_tokens = self.count_tokens(user_message)
+            total_input_tokens = system_tokens + user_tokens
+            
+            if total_input_tokens > self.max_input_tokens:
+                # Reduce RAG context if needed
+                excess_tokens = total_input_tokens - self.max_input_tokens
+                if rag_context:
+                    current_context_tokens = self.count_tokens(rag_context)
+                    reduced_tokens = max(200, current_context_tokens - excess_tokens)
+                    rag_context = self._truncate_text(rag_context, reduced_tokens)
+                    user_message = f"Question: {question}\n\nRelevant Data:\n{rag_context}"
+            
+            # Calculate available completion tokens
+            final_input_tokens = self.count_tokens(system_prompt) + self.count_tokens(user_message)
+            available_tokens = self.max_context_length - final_input_tokens - 100
+            completion_tokens = min(self.max_completion_tokens, max(500, available_tokens))
+            
+            # Make API call
+            try:
+                response = self.client.chat.completions.create(
+                    model="gpt-3.5-turbo",
+                    messages=[
+                        {"role": "system", "content": system_prompt},
+                        {"role": "user", "content": user_message}
+                    ],
+                    max_tokens=completion_tokens,
+                    temperature=0.2,  # Lower temperature for more consistent analysis
+                    timeout=30
+                )
+                
+                answer = response.choices[0].message.content
+                logger.info(f"Successfully processed query: {question[:50]}...")
+                return answer
+                
+            except openai.APIError as api_error:
+                error_msg = f"OpenAI API Error: {str(api_error)}"
+                logger.error(error_msg)
+                return f"API Error: {error_msg}"
+                
+            except Exception as api_error:
+                error_msg = f"API call failed: {str(api_error)}"
+                logger.error(error_msg)
+                return f"Error: {error_msg}"
+            
+        except Exception as e:
+            logger.error(f"Error in enhanced RAG query: {e}")
+            return f"Processing error: {str(e)}"
 
 class EnhancedCreativeJobProcessor:
     """Main processor class optimized for creative job analysis with Chroma persistence and auto-detection"""
@@ -2468,105 +2439,119 @@ class EnhancedCreativeJobProcessor:
         
         return False
 
-def main():
-    """Main Streamlit application with enhanced Chroma persistence support and auto-detection"""
+def initialize_session_state():
+    """Initialize session state variables for multi-view application"""
+    if 'current_view' not in st.session_state:
+        st.session_state.current_view = 'master'  # master, admin, client
     
-    st.title("🎨 Creative Professionals Job Analysis System")
-    st.markdown("**Enhanced RAG-powered analysis** with persistent vector storage using ChromaDB")
+    if 'processor' not in st.session_state:
+        st.session_state.processor = EnhancedCreativeJobProcessor()
     
-    # Initialize NLTK data
-    setup_nltk_data()
+    if 'openai_processor' not in st.session_state:
+        st.session_state.openai_processor = None
     
-    # NEW: Get API key from secrets
-    api_key = get_openai_api_key()
-    if not api_key:
-        st.error("❌ **OpenAI API Key Missing**: Please configure OPENAI_API_KEY in your secrets or environment variables")
-        st.info("For Streamlit Cloud, add it to your app secrets. For local development, set it as an environment variable.")
-        st.stop()
+    if 'rag_ready' not in st.session_state:
+        st.session_state.rag_ready = False
     
-    # Display persistence status at top
-    persistence_status = {
-        'chroma_available': CHROMA_AVAILABLE,
-        'persistence_enabled': ENABLE_PERSISTENCE,
-        'persist_path': CHROMA_PERSIST_PATH if ENABLE_PERSISTENCE else None
-    }
+    if 'auto_detected_mode' not in st.session_state:
+        st.session_state.auto_detected_mode = False
+    
+    if 'query_history' not in st.session_state:
+        st.session_state.query_history = []
+    
+    if 'last_query' not in st.session_state:
+        st.session_state.last_query = ""
+    
+    if 'last_response' not in st.session_state:
+        st.session_state.last_response = ""
+
+def show_master_view():
+    """Master view for selecting between Admin and Client modes"""
+    st.title("🎨 Creative Job RAG Analyzer")
+    st.markdown("### Choose Your Mode")
+    
+    # Check for existing RAG index
+    processor = st.session_state.processor
+    stats = processor.vector_store.get_stats()
     
-    # Persistence status indicator
-    if ENABLE_PERSISTENCE and CHROMA_AVAILABLE:
-        st.success(f"💾 Persistent mode enabled - Data stored at: {CHROMA_PERSIST_PATH}")
-    elif CHROMA_AVAILABLE:
-        st.info("💾 In-memory mode - ChromaDB available but persistence disabled")
+    if stats.get('documents_count', 0) > 0:
+        st.success(f"✅ Existing RAG Index Found: {stats['documents_count']:,} documents")
+        st.info(f"Backend: {stats['backend']} | Persistent: {'Yes' if stats.get('persistent') else 'No'}")
     else:
-        st.warning("⚠️ ChromaDB not available - Using fallback memory storage")
+        st.warning("⚠️ No RAG index found. Please create one in Admin Mode first.")
     
-    # Sidebar configuration
-    with st.sidebar:
-        st.header("🔧 System Configuration")
-        
-        # API Key status
-        st.subheader("🔑 API Configuration")
-        st.success("✅ OpenAI API Key Loaded")
-        st.caption("Configured via secrets/environment")
+    st.markdown("---")
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        st.markdown("### 🔧 Admin Mode")
+        st.markdown("""
+        **For Administrators:**
+        - Upload creative job datasets (CSV)
+        - Build and manage RAG indexes
+        - View dataset statistics
+        - Configure vector storage
+        """)
         
-        st.markdown("---")
+        if st.button("Enter Admin Mode", type="primary", use_container_width=True):
+            st.session_state.current_view = 'admin'
+            st.rerun()
+    
+    with col2:
+        st.markdown("### 💬 Client Mode")
+        st.markdown("""
+        **For Users:**
+        - Query the creative jobs database
+        - Get AI-powered insights
+        - Analyze industry trends
+        - Follow-up questions supported
+        """)
         
-        # Persistence controls
-        st.subheader("💾 Persistence Settings")
-        if ENABLE_PERSISTENCE:
-            st.success("✅ Persistence Enabled")
-            st.caption(f"Path: {CHROMA_PERSIST_PATH}")
+        if stats.get('documents_count', 0) > 0:
+            if st.button("Enter Client Mode", type="primary", use_container_width=True):
+                st.session_state.current_view = 'client'
+                st.rerun()
         else:
-            st.info("💾 Memory Mode")
-        
+            st.button("Enter Client Mode", type="primary", use_container_width=True, disabled=True)
+            st.caption("⚠️ Create RAG index in Admin Mode first")
+    
+    # System information
+    st.markdown("---")
+    st.markdown("### 📊 System Information")
+    
+    info_col1, info_col2, info_col3, info_col4 = st.columns(4)
+    
+    with info_col1:
         if CHROMA_AVAILABLE:
-            st.success("✅ ChromaDB Available")
+            st.success("✅ ChromaDB")
         else:
-            st.error("❌ ChromaDB Missing")
-            st.caption("Install chromadb for persistence")
-        
-        st.markdown("---")
-        
-        # Dependency status
-        dep_status = []
-        if USEARCH_AVAILABLE:
-            dep_status.append("✅ USearch (Fallback)")
+            st.error("❌ ChromaDB")
+    
+    with info_col2:
+        if ENABLE_PERSISTENCE:
+            st.success("✅ Persistence")
         else:
-            dep_status.append("❌ USearch - Install recommended")
-            
-        if SENTENCE_TRANSFORMERS_AVAILABLE:
-            dep_status.append("✅ SentenceTransformers")
+            st.info("💾 Memory Only")
+    
+    with info_col3:
+        api_key = get_openai_api_key()
+        if api_key:
+            st.success("✅ OpenAI API")
         else:
-            dep_status.append("❌ SentenceTransformers - Install required")
-            
-        if NLTK_AVAILABLE:
-            dep_status.append("✅ NLTK")
+            st.error("❌ No API Key")
+    
+    with info_col4:
+        if SENTENCE_TRANSFORMERS_AVAILABLE:
+            st.success("✅ Embeddings")
         else:
-            dep_status.append("⚠️ NLTK - Limited functionality")
-        
-        for status in dep_status:
-            if "✅" in status:
-                st.success(status)
-            elif "⚠️" in status:
-                st.warning(status)
-            else:
-                st.error(status)
-        
-        st.markdown("---")
-        st.header("📊 Analysis Settings")
-        
-        k_results = st.slider("Retrieved Documents", 5, 15, 10)
-        show_debug = st.checkbox("Show Debug Information", False)
-        
-        # Database management controls
-        st.markdown("---")
-        st.header("🗄️ Database Management")
-        
-        # Only show if Chroma is available
-        if CHROMA_AVAILABLE:
-            force_rebuild = st.checkbox("Force Index Rebuild", 
-                                      help="Force rebuilding the RAG index even if existing data is found")
+            st.error("❌ Embeddings")
+
+def initialize_session_state():
+    """Initialize session state variables for multi-view application"""
+    if 'current_view' not in st.session_state:
+        st.session_state.current_view = 'master'  # master, admin, client
     
-    # Initialize session state
     if 'processor' not in st.session_state:
         st.session_state.processor = EnhancedCreativeJobProcessor()
     
@@ -2579,276 +2564,235 @@ def main():
     if 'auto_detected_mode' not in st.session_state:
         st.session_state.auto_detected_mode = False
     
-    # Configure OpenAI with secret key
-    if api_key:
-        try:
-            st.session_state.openai_processor = EnhancedOpenAIProcessor(api_key)
-            if st.session_state.openai_processor.is_available():
-                st.sidebar.success("✅ OpenAI API Ready")
-            else:
-                st.sidebar.error(f"❌ OpenAI Error: {st.session_state.openai_processor._initialization_error}")
-        except Exception as e:
-            st.sidebar.error(f"❌ OpenAI Error: {str(e)}")
+    if 'query_history' not in st.session_state:
+        st.session_state.query_history = []
     
-    # NEW: Auto-detection check on startup
-    if CHROMA_AVAILABLE and not st.session_state.auto_detected_mode:
-        if st.session_state.processor.check_auto_detected_index():
-            st.session_state.auto_detected_mode = True
-            st.session_state.rag_ready = True
-            
-            # Show option to proceed with queries immediately
-            col1, col2 = st.columns(2)
-            with col1:
-                if st.button("🚀 Start Querying Immediately", type="primary", help="Use existing index for queries"):
-                    if st.session_state.processor.use_auto_detected_index():
-                        st.balloons()
-                        st.success("🎉 Ready for intelligent queries!")
-                        # Jump to query section by setting flag
-                        st.session_state.rag_ready = True
-                        st.experimental_rerun()
-            
-            with col2:
-                if st.button("📁 Upload New Dataset", help="Replace existing index with new data"):
-                    # Attempt to prepare the environment for uploading a new dataset by clearing existing index.
-                    try:
-                        proc = st.session_state.get('processor', None)
-                        if proc and hasattr(proc, 'vector_store'):
-                            vs = proc.vector_store
-                            # Prefer calling a clear_collection method on the vector store if available.
-                            cleared = False
-                            if hasattr(vs, 'clear_collection'):
-                                try:
-                                    cleared = vs.clear_collection()
-                                except Exception:
-                                    cleared = False
-                            elif hasattr(vs, 'chroma_store') and vs.chroma_store:
-                                try:
-                                    cleared = vs.chroma_store.clear_collection()
-                                except Exception:
-                                    cleared = False
-                            if cleared:
-                                st.success("✅ Existing index cleared. You can now upload a new dataset.")
-                            else:
-                                st.info("⚠️ Proceeding to upload. The existing index (if any) will be overwritten when you build the new index.")
-                        # Switch out of auto-detected mode and show the normal upload workflow
-                        st.session_state.auto_detected_mode = False
-                        st.session_state.rag_ready = False
-                        st.experimental_rerun()
-                    except Exception as e:
-                        st.error(f"Error preparing upload: {e}")
-    
-    # Show different interfaces based on mode
-    if st.session_state.auto_detected_mode and st.session_state.rag_ready:
-        # Auto-detected mode - show query interface directly
-        show_query_interface(st.session_state.processor, st.session_state.openai_processor, k_results, show_debug)
-    else:
-        # Normal mode - show file upload and processing
-        show_normal_workflow(st.session_state.processor, st.session_state.openai_processor, k_results, show_debug, locals().get('force_rebuild', False))
-
-def show_query_interface(processor, openai_processor, k_results, show_debug):
-    """Show the query interface for RAG-enhanced analysis"""
+    if 'last_query' not in st.session_state:
+        st.session_state.last_query = ""
     
-    st.header("🤖 Intelligent Creative Job Analysis")
-    st.markdown("Ask sophisticated questions about creative professionals, software requirements, and industry trends!")
+    if 'last_response' not in st.session_state:
+        st.session_state.last_response = ""
+
+def show_master_view():
+    """Master view for selecting between Admin and Client modes"""
+    st.title("🎨 Creative Job RAG Analyzer")
+    st.markdown("### Choose Your Mode")
     
-    # Quick stats with persistence info
+    # Check for existing RAG index
+    processor = st.session_state.processor
     stats = processor.vector_store.get_stats()
-    col1, col2, col3, col4 = st.columns(4)
-    with col1:
-        doc_count = stats.get('documents_count', 0)
-        st.info(f"📚 Documents: {doc_count}")
-    with col2:
-        st.info(f"🎯 Retrieval: Top {k_results}")
-    with col3:
-        backend = stats.get('backend', 'unknown')
-        st.info(f"⚡ Backend: {backend}")
-    with col4:
-        if stats.get('persistent', False):
-            st.success("💾 Persistent")
-        else:
-            st.warning("💾 Memory")
     
-    # Show auto-detection info if applicable
-    if stats.get('auto_detected', False):
-        st.success("🔍 **Using Auto-Detected Index** - No data processing required!")
+    if stats.get('documents_count', 0) > 0:
+        st.success(f"✅ Existing RAG Index Found: {stats['documents_count']:,} documents")
+        st.info(f"Backend: {stats['backend']} | Persistent: {'Yes' if stats.get('persistent') else 'No'}")
+    else:
+        st.warning("⚠️ No RAG index found. Please create one in Admin Mode first.")
+    
+    st.markdown("---")
     
-    # Example questions based on q.txt
-    with st.expander("💡 Example Questions from Your Analysis Requirements"):
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        st.markdown("### 🔧 Admin Mode")
         st.markdown("""
-        **Adobe vs Non-Adobe Analysis:**
-        - How many postings ask for non-Adobe apps but not Adobe apps? What are those apps?
-        - How many postings ask for both Adobe and non-Adobe apps? What are those combinations?
-        - How many job listings request experience with Photoshop? And how many request Photoshop's competitors?
-        
-        **Creative Role Analysis:**
-        - How many records describe a designer role?
-        - Find all designer roles and summarize their creative job requirements
-        - What are the top job titles among designer roles?
-        
-        **Cross-Disciplinary Requirements:**
-        - Which jobs are not video jobs but still require video editing tools? What video tools are they?
-        - Which jobs are not photo jobs but still require photo editing tools? What photo tools are they?
-        - Which jobs are not design jobs but still require design editing tools? What design tools are they?
+        **For Administrators:**
+        - Upload creative job datasets (CSV)
+        - Build and manage RAG indexes
+        - View dataset statistics
+        - Configure vector storage
+        """)
         
-        **AI Tools and Modern Workflows:**
-        - How many posts ask for AI skills? What are those AI tools? What are those occupations?
-        - What industries are hiring more creative professionals? What kind of creative professionals?
-        - What soft skills are mentioned in the postings for creative professionals?
+        if st.button("Enter Admin Mode", type="primary", use_container_width=True):
+            st.session_state.current_view = 'admin'
+            st.rerun()
+    
+    with col2:
+        st.markdown("### 💬 Client Mode")
+        st.markdown("""
+        **For Users:**
+        - Query the creative jobs database
+        - Get AI-powered insights
+        - Analyze industry trends
+        - Follow-up questions supported
         """)
+        
+        if stats.get('documents_count', 0) > 0:
+            if st.button("Enter Client Mode", type="primary", use_container_width=True):
+                st.session_state.current_view = 'client'
+                st.rerun()
+        else:
+            st.button("Enter Client Mode", type="primary", use_container_width=True, disabled=True)
+            st.caption("⚠️ Create RAG index in Admin Mode first")
     
-    # Query input
-    question = st.text_area(
-        "Ask about creative jobs, software requirements, or industry trends:",
-        placeholder="e.g., How many designer roles require Adobe software vs non-Adobe alternatives?",
-        height=100
-    )
+    # System information
+    st.markdown("---")
+    st.markdown("### 📊 System Information")
     
-    # Query options
-    show_retrieved = st.checkbox("Show Retrieved Context", value=True)
+    info_col1, info_col2, info_col3, info_col4 = st.columns(4)
     
-    if st.button("🚀 Analyze with Enhanced RAG", type="primary", use_container_width=True) and question:
-        if not openai_processor or not openai_processor.is_available():
-            st.error("OpenAI processor not available. Please check your API key configuration.")
-            return
-        
-        with st.spinner("Performing intelligent analysis..."):
-            try:
-                response = openai_processor.query_with_enhanced_rag(
-                    question,
-                    processor.vector_store,
-                    processor.dataset_analysis
-                )
-                
-                st.subheader("📊 Analysis Results")
-                st.write(response)
-                
-                # Show retrieved context if requested
-                if show_retrieved:
-                    with st.expander("📄 Retrieved Context"):
-                        retrieved_docs = processor.vector_store.search(question, k=k_results)
-                        if retrieved_docs:
-                            for i, doc in enumerate(retrieved_docs, 1):
-                                st.write(f"**Document {i}** (Score: {doc['score']:.3f})")
-                                st.write(doc['text'])
-                                
-                                metadata = doc.get('metadata', {})
-                                if metadata:
-                                    info_parts = []
-                                    if metadata.get('company'):
-                                        info_parts.append(f"Company: {metadata['company']}")
-                                    
-                                    # Handle both string and list formats for software
-                                    adobe_apps = metadata.get('adobe_apps', [])
-                                    if isinstance(adobe_apps, str):
-                                        adobe_apps = [app.strip() for app in adobe_apps.split(',') if app.strip()]
-                                    if adobe_apps:
-                                        info_parts.append(f"Adobe: {', '.join(adobe_apps)}")
-                                    
-                                    non_adobe_apps = metadata.get('non_adobe_apps', [])
-                                    if isinstance(non_adobe_apps, str):
-                                        non_adobe_apps = [app.strip() for app in non_adobe_apps.split(',') if app.strip()]
-                                    if non_adobe_apps:
-                                        info_parts.append(f"Non-Adobe: {', '.join(non_adobe_apps)}")
-                                    
-                                    if info_parts:
-                                        st.caption(" | ".join(info_parts))
-                                st.markdown("---")
-                        else:
-                            st.write("No relevant documents retrieved")
-                
-            except Exception as e:
-                st.error(f"Query processing error: {str(e)}")
-                if show_debug:
-                    st.exception(e)
+    with info_col1:
+        if CHROMA_AVAILABLE:
+            st.success("✅ ChromaDB")
+        else:
+            st.error("❌ ChromaDB")
     
-    # Quick analysis buttons
-    st.subheader("⚡ Quick Analysis")
-    quick_col1, quick_col2, quick_col3 = st.columns(3)
+    with info_col2:
+        if ENABLE_PERSISTENCE:
+            st.success("✅ Persistence")
+        else:
+            st.info("💾 Memory Only")
     
-    with quick_col1:
-        if st.button("Count Designer Roles", use_container_width=True):
-            if processor.dataset_analysis:
-                count = processor.dataset_analysis['role_analysis'].get('designer_count', 0)
-                st.success(f"**{count}** designer roles found")
-            else:
-                # Try to get quick stats from vector store
-                st.info("Analyzing designer roles from index...")
+    with info_col3:
+        api_key = get_openai_api_key()
+        if api_key:
+            st.success("✅ OpenAI API")
+        else:
+            st.error("❌ No API Key")
     
-    with quick_col2:
-        if st.button("Adobe vs Non-Adobe", use_container_width=True):
-            if processor.dataset_analysis:
-                adobe_analysis = processor.dataset_analysis['adobe_analysis']
-                st.success(f"Adobe only: **{adobe_analysis.get('adobe_only_count', 0)}** | Non-Adobe only: **{adobe_analysis.get('non_adobe_only_count', 0)}** | Both: **{adobe_analysis.get('both_apps_count', 0)}**")
-            else:
-                st.info("Analyzing software requirements from index...")
+    with info_col4:
+        if SENTENCE_TRANSFORMERS_AVAILABLE:
+            st.success("✅ Embeddings")
+        else:
+            st.error("❌ Embeddings")
+
+def show_admin_view():
+    """Admin view for RAG index creation and management"""
     
-    with quick_col3:
-        if st.button("AI Tools Count", use_container_width=True):
-            if processor.dataset_analysis:
-                count = processor.dataset_analysis['ai_tools_analysis'].get('ai_tools_count', 0)
-                st.success(f"**{count}** jobs mention AI tools")
-            else:
-                st.info("Analyzing AI tool mentions from index...")
+    # Header with back button
+    col1, col2 = st.columns([6, 1])
+    with col1:
+        st.title("🔧 Admin Mode - RAG Index Management")
+    with col2:
+        if st.button("← Back", type="secondary"):
+            st.session_state.current_view = 'master'
+            st.rerun()
     
-    # Option to switch back to normal mode
-    st.markdown("---")
-    if st.button("📁 Upload New Dataset", help="Replace current index with new data"):
-        # Attempt to clear existing index so user can upload a new dataset that will overwrite it.
-        try:
-            proc = st.session_state.get('processor', None)
-            if proc and hasattr(proc, 'vector_store'):
-                vs = proc.vector_store
-                cleared = False
-                if hasattr(vs, 'clear_collection'):
-                    try:
-                        cleared = vs.clear_collection()
-                    except Exception:
-                        cleared = False
-                elif hasattr(vs, 'chroma_store') and vs.chroma_store:
-                    try:
-                        cleared = vs.chroma_store.clear_collection()
-                    except Exception:
-                        cleared = False
-                if cleared:
-                    st.success("✅ Existing index cleared. You can now upload a new dataset.")
-                else:
-                    st.info("⚠️ Proceeding to upload. The existing index (if any) will be overwritten when you build the new index.")
-            st.session_state.auto_detected_mode = False
-            st.session_state.rag_ready = False
-            st.experimental_rerun()
-        except Exception as e:
-            st.error(f"Error preparing upload: {e}")
-
-def show_normal_workflow(processor, openai_processor, k_results, show_debug, force_rebuild):
-    """Show the normal workflow for uploading and processing new data"""
+    processor = st.session_state.processor
     
-    # Display existing index status if found
-    if CHROMA_AVAILABLE:
-        persistence_status = processor.get_persistence_status()
+    # Display RAG Index Status
+    st.markdown("### 📊 Current RAG Index Status")
+    
+    stats = processor.vector_store.get_stats()
+    
+    if stats.get('documents_count', 0) > 0:
+        # Display existing index information
+        col1, col2, col3, col4 = st.columns(4)
+        with col1:
+            st.metric("Documents", f"{stats['documents_count']:,}")
+        with col2:
+            st.metric("Backend", stats['backend'].title())
+        with col3:
+            if stats.get('persistent'):
+                st.metric("Storage", "Persistent", delta="✓")
+            else:
+                st.metric("Storage", "Memory", delta="⚠")
+        with col4:
+            st.metric("Status", "Active", delta="✓")
         
-        if persistence_status['collection_exists']:
-            st.info(f"📚 Found existing persistent index with {persistence_status['documents_count']} documents using {persistence_status['backend']} backend")
-            
-            # Option to use existing index
-            col1, col2 = st.columns(2)
-            with col1:
-                if st.button("💾 Use Existing Index", help="Skip to query interface using existing data"):
-                    st.session_state.rag_ready = True
-                    st.success("✅ Ready to query existing index!")
-                    st.experimental_rerun()
-            
-            with col2:
-                if st.button("🗑️ Clear Existing Index", help="Remove existing index data"):
+        # Auto-detected information
+        if stats.get('auto_detected'):
+            processor.vector_store.display_existing_index_info()
+        
+        # Management options
+        st.markdown("---")
+        st.markdown("### ⚙️ Index Management")
+        
+        mgmt_col1, mgmt_col2, mgmt_col3 = st.columns(3)
+        
+        with mgmt_col1:
+            if st.button("🔄 Rebuild Index", type="secondary", use_container_width=True):
+                if processor.processed_df is not None and processor.dataset_analysis is not None:
+                    with st.spinner("Rebuilding RAG index..."):
+                        if processor.build_rag_index(force_rebuild=True):
+                            st.success("✅ Index rebuilt successfully!")
+                            st.rerun()
+                else:
+                    st.error("No processed dataset available. Please upload and process data first.")
+        
+        with mgmt_col2:
+            if st.button("🗑️ Clear Index", type="secondary", use_container_width=True):
+                if st.button("⚠️ Confirm Clear", type="secondary"):
                     if processor.vector_store.use_chroma and processor.vector_store.chroma_store:
                         if processor.vector_store.chroma_store.clear_collection():
-                            st.success("✅ Existing index cleared")
+                            st.success("✅ Index cleared")
                             st.session_state.rag_ready = False
-                            st.experimental_rerun()
-                        else:
-                            st.error("❌ Failed to clear index")
+                            st.rerun()
+        
+        with mgmt_col3:
+            if st.button("📊 View Details", type="secondary", use_container_width=True):
+                with st.expander("Detailed Index Information", expanded=True):
+                    st.json(stats)
+    
+    else:
+        st.error("❌ No RAG index found")
+        st.info("👇 Upload a CSV file below to create a new RAG index")
+    
+    st.markdown("---")
+    
+    # Sidebar for configuration
+    with st.sidebar:
+        st.header("🔧 Configuration")
+        
+        # API Key status
+        st.subheader("🔑 API Configuration")
+        if st.session_state.openai_processor and st.session_state.openai_processor.is_available():
+            st.success("✅ OpenAI API Ready")
+        else:
+            st.error("❌ OpenAI API Not Available")
+            st.caption("Check your API key configuration")
+        
+        st.markdown("---")
+        
+        # Persistence settings
+        st.subheader("💾 Storage Settings")
+        if ENABLE_PERSISTENCE:
+            st.success("✅ Persistence Enabled")
+            st.caption(f"Path: {CHROMA_PERSIST_PATH}")
+        else:
+            st.info("💾 Memory Mode Active")
+        
+        if CHROMA_AVAILABLE:
+            st.success("✅ ChromaDB Available")
+        else:
+            st.error("❌ ChromaDB Missing")
+        
+        st.markdown("---")
+        
+        # Processing options
+        st.subheader("⚙️ Processing Options")
+        force_rebuild = st.checkbox("Force Index Rebuild", help="Rebuild index even if data hasn't changed")
+        
+        st.markdown("---")
+        
+        # Dependency status
+        st.subheader("📦 Dependencies")
+        dep_status = []
+        if SENTENCE_TRANSFORMERS_AVAILABLE:
+            dep_status.append("✅ SentenceTransformers")
+        else:
+            dep_status.append("❌ SentenceTransformers")
+        
+        if NLTK_AVAILABLE:
+            dep_status.append("✅ NLTK")
+        else:
+            dep_status.append("⚠️ NLTK Limited")
+        
+        if TIKTOKEN_AVAILABLE:
+            dep_status.append("✅ Tiktoken")
+        else:
+            dep_status.append("⚠️ Tiktoken Fallback")
+        
+        for status in dep_status:
+            if "✅" in status:
+                st.success(status)
+            elif "⚠️" in status:
+                st.warning(status)
+            else:
+                st.error(status)
     
     # File upload section
-    st.header("📄 Upload Creative Job Dataset")
+    st.markdown("### 📁 Upload Creative Job Dataset")
+    
     uploaded_file = st.file_uploader(
         "Choose a CSV file containing creative job data",
         type="csv",
@@ -2856,11 +2800,10 @@ def show_normal_workflow(processor, openai_processor, k_results, show_debug, for
     )
     
     if uploaded_file is not None:
-        # Check if new file will overwrite existing data
+        # Warning if overwriting
         if processor.vector_store.collection_exists():
-            st.warning("⚠️ **Data Overwrite Warning**: Uploading a new CSV will replace the existing RAG index with new data. The current persistent index will be overwritten.")
-            
-            if not st.checkbox("I understand that existing data will be overwritten"):
+            st.warning("⚠️ **Data Overwrite Warning**: Uploading a new CSV will replace the existing RAG index.")
+            if not st.checkbox("I understand existing data will be overwritten", key="overwrite_confirm"):
                 st.stop()
         
         # Load data
@@ -2882,7 +2825,8 @@ def show_normal_workflow(processor, openai_processor, k_results, show_debug, for
                 st.dataframe(processor.df.head(), use_container_width=True)
             
             # Processing workflow
-            st.header("⚙️ Processing Workflow")
+            st.markdown("---")
+            st.markdown("### ⚙️ Processing Workflow")
             
             col1, col2, col3 = st.columns(3)
             
@@ -2891,6 +2835,7 @@ def show_normal_workflow(processor, openai_processor, k_results, show_debug, for
                     with st.spinner("Cleaning and processing data..."):
                         if processor.clean_and_process():
                             st.success("✅ Data processed!")
+                            st.rerun()
                         else:
                             st.error("❌ Processing failed")
             
@@ -2900,6 +2845,7 @@ def show_normal_workflow(processor, openai_processor, k_results, show_debug, for
                         with st.spinner("Analyzing creative job patterns..."):
                             if processor.analyze_dataset():
                                 st.success("✅ Analysis complete!")
+                                st.rerun()
                             else:
                                 st.error("❌ Analysis failed")
                     else:
@@ -2914,12 +2860,7 @@ def show_normal_workflow(processor, openai_processor, k_results, show_debug, for
                             if processor.build_rag_index(force_rebuild):
                                 st.session_state.rag_ready = True
                                 st.success("✅ RAG system ready!")
-                                
-                                # Show persistence confirmation
-                                stats = processor.vector_store.get_stats()
-                                if stats.get('persistent', False):
-                                    st.success("💾 Index saved to persistent storage!")
-                                
+                                st.rerun()
                             else:
                                 st.error("❌ RAG build failed")
                     else:
@@ -2933,78 +2874,70 @@ def show_normal_workflow(processor, openai_processor, k_results, show_debug, for
                         st.session_state.rag_ready = True
                         st.balloons()
                         st.success("🎉 Complete workflow successful!")
-                        
-                        # Show persistence status
-                        stats = processor.vector_store.get_stats()
-                        if stats.get('persistent', False):
-                            st.info(f"💾 Data persisted using {stats.get('backend')} backend")
+                        st.rerun()
                     else:
                         st.error("❌ Workflow failed")
             
-            # Processing status indicators
-            show_processing_status(processor, openai_processor)
+            # Processing status
+            st.markdown("---")
+            show_processing_status_admin(processor)
             
-            # Show analysis results if available
+            # Analysis results
             if processor.dataset_analysis is not None:
-                show_analysis_results(processor)
-            
-            # Show RAG interface if ready
-            if st.session_state.rag_ready and processor.is_ready_for_queries():
-                if openai_processor and openai_processor.is_available():
-                    st.markdown("---")
-                    show_query_interface(processor, openai_processor, k_results, show_debug)
-                else:
-                    st.header("⚠️ RAG System Setup Required")
-                    st.error("OpenAI processor not available. Please check your API key configuration.")
+                st.markdown("---")
+                show_analysis_results_admin(processor)
             
             # Export functionality
             if processor.processed_df is not None:
-                show_export_options(processor)
+                st.markdown("---")
+                show_export_options_admin(processor)
 
-def show_processing_status(processor, openai_processor):
-    """Show processing status indicators"""
+def show_processing_status_admin(processor):
+    """Show processing status indicators in admin view"""
+    st.markdown("### 📈 Processing Status")
+    
     status_cols = st.columns(5)
+    
     with status_cols[0]:
         if processor.processed_df is not None:
-            st.info("✅ Data Processed")
+            st.success("✅ Data Processed")
         else:
-            st.warning("⏳ Data Not Processed")
+            st.warning("⏳ Not Processed")
     
     with status_cols[1]:
         if processor.dataset_analysis is not None:
-            st.info("✅ Analysis Complete")
+            st.success("✅ Analysis Complete")
         else:
-            st.warning("⏳ Analysis Pending")
+            st.warning("⏳ Pending")
     
     with status_cols[2]:
         if st.session_state.rag_ready:
-            st.info("✅ RAG Ready")
+            st.success("✅ RAG Ready")
         else:
-            st.warning("⏳ RAG Not Built")
+            st.warning("⏳ Not Built")
     
     with status_cols[3]:
-        if openai_processor and openai_processor.is_available():
-            st.info("✅ OpenAI Ready")
+        if st.session_state.openai_processor and st.session_state.openai_processor.is_available():
+            st.success("✅ OpenAI Ready")
         else:
             st.warning("⏳ API Key Needed")
     
     with status_cols[4]:
-        # Persistence status
         stats = processor.vector_store.get_stats()
         if stats.get('persistent', False):
-            st.info("✅ Persistent")
+            st.success("✅ Persistent")
         else:
-            st.warning("💾 Memory Only")
+            st.info("💾 Memory")
 
-def show_analysis_results(processor):
-    """Show comprehensive analysis results"""
-    st.header("📈 Creative Job Analysis Results")
+def show_analysis_results_admin(processor):
+    """Show analysis results in admin view"""
+    st.markdown("### 📊 Creative Job Analysis Results")
     
     analysis_summary = processor.get_analysis_summary()
     
     if analysis_summary:
         # Key metrics
-        st.subheader("📊 Key Metrics")
+        st.subheader("Key Metrics")
         metric_cols = st.columns(4)
         
         with metric_cols[0]:
@@ -3017,7 +2950,7 @@ def show_analysis_results(processor):
             st.metric("Photo Professionals", f"{analysis_summary['role_counts']['photo_professionals']:,}")
         
         # Software analysis
-        st.subheader("💻 Software Requirements Analysis")
+        st.subheader("Software Requirements Analysis")
         software_cols = st.columns(4)
         
         with software_cols[0]:
@@ -3033,7 +2966,7 @@ def show_analysis_results(processor):
         col1, col2 = st.columns(2)
         
         with col1:
-            st.subheader("🎨 Top Adobe Applications")
+            st.subheader("Top Adobe Applications")
             if analysis_summary['top_adobe_apps']:
                 adobe_df = pd.DataFrame(analysis_summary['top_adobe_apps'], columns=['Software', 'Mentions'])
                 st.dataframe(adobe_df, use_container_width=True)
@@ -3041,7 +2974,7 @@ def show_analysis_results(processor):
                 st.info("No Adobe applications found in dataset")
         
         with col2:
-            st.subheader("🛠️ Top Non-Adobe Applications")
+            st.subheader("Top Non-Adobe Applications")
             if analysis_summary['top_non_adobe_apps']:
                 non_adobe_df = pd.DataFrame(analysis_summary['top_non_adobe_apps'], columns=['Software', 'Mentions'])
                 st.dataframe(non_adobe_df, use_container_width=True)
@@ -3049,7 +2982,7 @@ def show_analysis_results(processor):
                 st.info("No non-Adobe applications found in dataset")
         
         # Cross-disciplinary analysis
-        st.subheader("🔄 Cross-Disciplinary Requirements")
+        st.subheader("Cross-Disciplinary Requirements")
         cross_cols = st.columns(3)
         
         with cross_cols[0]:
@@ -3058,37 +2991,15 @@ def show_analysis_results(processor):
             st.metric("Non-Photo Jobs with Photo Tools", analysis_summary['cross_disciplinary']['non_photo_with_photo_tools'])
         with cross_cols[2]:
             st.metric("Non-Design Jobs with Design Tools", analysis_summary['cross_disciplinary']['non_design_with_design_tools'])
-        
-        # Show persistence information
-        if analysis_summary.get('persistence_info'):
-            with st.expander("🔧 Technical Details"):
-                persistence_info = analysis_summary['persistence_info']
-                
-                info_cols = st.columns(4)
-                with info_cols[0]:
-                    st.metric("Backend", persistence_info.get('backend', 'unknown'))
-                with info_cols[1]:
-                    if persistence_info.get('persistent', False):
-                        st.success("Persistent Storage")
-                    else:
-                        st.info("Memory Storage")
-                with info_cols[2]:
-                    if persistence_info.get('auto_detected'):
-                        st.success("Auto-Detected")
-                    else:
-                        st.info("Manually Built")
-                with info_cols[3]:
-                    if persistence_info.get('dataset_fingerprint'):
-                        st.caption(f"Dataset ID: {persistence_info['dataset_fingerprint'][:8]}...")
 
-def show_export_options(processor):
-    """Show export functionality"""
-    st.header("📤 Export Results")
+def show_export_options_admin(processor):
+    """Show export functionality in admin view"""
+    st.markdown("### 📤 Export Results")
     
     export_col1, export_col2, export_col3, export_col4 = st.columns(4)
     
     with export_col1:
-        if st.button("📊 Download Processed Data"):
+        if st.button("📊 Download Processed Data", use_container_width=True):
             csv = processor.processed_df.to_csv(index=False)
             st.download_button(
                 label="Download CSV",
@@ -3098,7 +3009,7 @@ def show_export_options(processor):
             )
     
     with export_col2:
-        if st.button("📈 Download Analysis Results"):
+        if st.button("📈 Download Analysis Results", use_container_width=True):
             if processor.dataset_analysis:
                 json_data = json.dumps(processor.dataset_analysis, indent=2, default=str)
                 st.download_button(
@@ -3109,7 +3020,7 @@ def show_export_options(processor):
                 )
     
     with export_col3:
-        if st.button("🤖 Download Q&A Answers"):
+        if st.button("🤖 Download Q&A Answers", use_container_width=True):
             if processor.qa_answers:
                 json_data = json.dumps(processor.qa_answers, indent=2, default=str)
                 st.download_button(
@@ -3120,7 +3031,7 @@ def show_export_options(processor):
                 )
     
     with export_col4:
-        if st.button("🔧 Download System Info"):
+        if st.button("🔧 Download System Info", use_container_width=True):
             system_info = {
                 'persistence_status': processor.get_persistence_status(),
                 'analysis_summary': processor.get_analysis_summary(),
@@ -3134,29 +3045,295 @@ def show_export_options(processor):
                 mime="application/json"
             )
 
-    # Footer with technical information
-    st.markdown("---")
-    st.markdown("### 🔧 Technical Details")
+def show_client_view():
+    """Client view for querying the RAG system"""
+    
+    # Header with back button
+    col1, col2 = st.columns([6, 1])
+    with col1:
+        st.title("💬 Client Mode - Query Interface")
+    with col2:
+        if st.button("← Back", type="secondary"):
+            st.session_state.current_view = 'master'
+            st.rerun()
     
-    tech_col1, tech_col2, tech_col3 = st.columns(3)
+    processor = st.session_state.processor
+    openai_processor = st.session_state.openai_processor
     
-    with tech_col1:
-        st.caption("**Vector Storage**")
-        if CHROMA_AVAILABLE:
-            st.caption("✅ ChromaDB Available")
+    # Check RAG Index Status
+    st.markdown("### 📊 RAG Index Status")
+    
+    stats = processor.vector_store.get_stats()
+    
+    if stats.get('documents_count', 0) > 0:
+        # Display index information
+        col1, col2, col3, col4 = st.columns(4)
+        with col1:
+            st.metric("Documents", f"{stats['documents_count']:,}")
+        with col2:
+            st.metric("Backend", stats['backend'].title())
+        with col3:
+            if stats.get('persistent'):
+                st.success("💾 Persistent Storage")
+            else:
+                st.info("💾 Memory Storage")
+        with col4:
+            st.success("✅ Index Active")
+        
+        if stats.get('auto_detected'):
+            st.info("🔍 Using auto-detected existing index")
+    else:
+        st.error("❌ No RAG index found")
+        st.warning("⚠️ Please create a RAG index in Admin Mode before querying")
+        st.info("👈 Return to Master View and enter Admin Mode to create an index")
+        st.stop()
+    
+    st.markdown("---")
+    
+    # Sidebar configuration
+    with st.sidebar:
+        st.header("⚙️ Query Settings")
+        
+        k_results = st.slider("Retrieved Documents", 5, 15, 10, help="Number of relevant documents to retrieve")
+        show_retrieved = st.checkbox("Show Retrieved Context", value=True, help="Display the documents used to answer your question")
+        show_debug = st.checkbox("Show Debug Information", value=False, help="Display technical debugging information")
+        
+        st.markdown("---")
+        
+        st.header("🔑 API Status")
+        if openai_processor and openai_processor.is_available():
+            st.success("✅ OpenAI API Ready")
         else:
-            st.caption("❌ ChromaDB Missing")
+            st.error("❌ OpenAI API Not Available")
+            st.caption("Check API key configuration")
+        
+        st.markdown("---")
+        
+        st.header("📚 Query History")
+        if st.session_state.query_history:
+            st.caption(f"Recent queries: {len(st.session_state.query_history)}")
+            if st.button("Clear History", type="secondary", use_container_width=True):
+                st.session_state.query_history = []
+                st.session_state.last_query = ""
+                st.session_state.last_response = ""
+                st.rerun()
+            
+            with st.expander("View History"):
+                for i, query in enumerate(reversed(st.session_state.query_history[-5:]), 1):
+                    st.caption(f"{i}. {query[:50]}...")
+        else:
+            st.caption("No queries yet")
     
-    with tech_col2:
-        st.caption("**Persistence**")
-        if ENABLE_PERSISTENCE:
-            st.caption(f"✅ Enabled: {CHROMA_PERSIST_PATH}")
+    # Main query interface
+    st.markdown("### 🤖 Intelligent Creative Job Analysis")
+    st.markdown("Ask sophisticated questions about creative professionals, software requirements, and industry trends!")
+    
+    # Example questions
+    with st.expander("💡 Example Questions from Your Analysis Requirements"):
+        st.markdown("""
+        **Adobe vs Non-Adobe Analysis:**
+        - How many postings ask for non-Adobe apps but not Adobe apps? What are those apps?
+        - How many postings ask for both Adobe and non-Adobe apps? What are those combinations?
+        - How many job listings request experience with Photoshop? And how many request Photoshop's competitors?
+        
+        **Creative Role Analysis:**
+        - How many records describe a designer role?
+        - Find all designer roles and summarize their creative job requirements
+        - What are the top job titles among designer roles?
+        
+        **Cross-Disciplinary Requirements:**
+        - Which jobs are not video jobs but still require video editing tools? What video tools are they?
+        - Which jobs are not photo jobs but still require photo editing tools? What photo tools are they?
+        - Which jobs are not design jobs but still require design editing tools? What design tools are they?
+        
+        **AI Tools and Modern Workflows:**
+        - How many posts ask for AI skills? What are those AI tools? What are those occupations?
+        - What industries are hiring more creative professionals? What kind of creative professionals?
+        - What soft skills are mentioned in the postings for creative professionals?
+        """)
+    
+    # Query input with follow-up support
+    if st.session_state.last_response:
+        st.info("💬 **Previous Response Available** - You can ask a follow-up question or start a new query")
+        
+        col1, col2 = st.columns([1, 1])
+        with col1:
+            if st.button("🔄 Ask Follow-up Question", type="secondary", use_container_width=True):
+                st.session_state.query_mode = 'followup'
+        with col2:
+            if st.button("✨ Start New Query", type="secondary", use_container_width=True):
+                st.session_state.query_mode = 'new'
+                st.session_state.last_query = ""
+                st.session_state.last_response = ""
+    
+    # Determine query mode
+    query_mode = st.session_state.get('query_mode', 'new')
+    
+    if query_mode == 'followup' and st.session_state.last_response:
+        st.markdown("#### Follow-up Question")
+        st.caption(f"Previous query: {st.session_state.last_query[:100]}...")
+        question = st.text_area(
+            "Ask a follow-up question about the previous response:",
+            placeholder="e.g., Can you provide more details about those designer roles?",
+            height=100,
+            key="followup_query"
+        )
+    else:
+        st.markdown("#### New Query")
+        question = st.text_area(
+            "Ask about creative jobs, software requirements, or industry trends:",
+            placeholder="e.g., How many designer roles require Adobe software vs non-Adobe alternatives?",
+            height=100,
+            key="new_query"
+        )
+    
+    # Query button
+    if st.button("🚀 Analyze with Enhanced RAG", type="primary", use_container_width=True) and question:
+        if not openai_processor or not openai_processor.is_available():
+            st.error("OpenAI processor not available. Please check your API key configuration.")
+            st.stop()
+        
+        # Add to history
+        st.session_state.query_history.append(question)
+        
+        # Build context-aware query for follow-ups
+        if query_mode == 'followup' and st.session_state.last_query:
+            contextual_question = f"Previous question: {st.session_state.last_query}\n\nFollow-up: {question}"
         else:
-            st.caption("💾 Memory Mode")
+            contextual_question = question
+        
+        with st.spinner("Performing intelligent analysis..."):
+            try:
+                response = openai_processor.query_with_enhanced_rag(
+                    contextual_question,
+                    processor.vector_store,
+                    processor.dataset_analysis
+                )
+                
+                # Store for follow-up
+                st.session_state.last_query = question
+                st.session_state.last_response = response
+                
+                st.markdown("---")
+                st.subheader("📊 Analysis Results")
+                st.write(response)
+                
+                # Show retrieved context if requested
+                if show_retrieved:
+                    with st.expander("📄 Retrieved Context"):
+                        retrieved_docs = processor.vector_store.search(contextual_question, k=k_results)
+                        if retrieved_docs:
+                            for i, doc in enumerate(retrieved_docs, 1):
+                                st.write(f"**Document {i}** (Score: {doc['score']:.3f})")
+                                st.write(doc['text'])
+                                
+                                metadata = doc.get('metadata', {})
+                                if metadata:
+                                    info_parts = []
+                                    if metadata.get('company'):
+                                        info_parts.append(f"Company: {metadata['company']}")
+                                    
+                                    # Handle both string and list formats for software
+                                    adobe_apps = metadata.get('adobe_apps', [])
+                                    if isinstance(adobe_apps, str):
+                                        adobe_apps = [app.strip() for app in adobe_apps.split(',') if app.strip()]
+                                    if adobe_apps:
+                                        info_parts.append(f"Adobe: {', '.join(adobe_apps)}")
+                                    
+                                    non_adobe_apps = metadata.get('non_adobe_apps', [])
+                                    if isinstance(non_adobe_apps, str):
+                                        non_adobe_apps = [app.strip() for app in non_adobe_apps.split(',') if app.strip()]
+                                    if non_adobe_apps:
+                                        info_parts.append(f"Non-Adobe: {', '.join(non_adobe_apps)}")
+                                    
+                                    if info_parts:
+                                        st.caption(" | ".join(info_parts))
+                                st.markdown("---")
+                        else:
+                            st.write("No relevant documents retrieved")
+                
+                # Debug information
+                if show_debug:
+                    with st.expander("🔍 Debug Information"):
+                        st.write("**Query Mode:**", query_mode)
+                        st.write("**Original Question:**", question)
+                        st.write("**Contextual Question:**", contextual_question)
+                        st.write("**Retrieved Documents:**", len(retrieved_docs) if retrieved_docs else 0)
+                        st.write("**Vector Store Stats:**", stats)
+                
+                # Reset query mode
+                st.session_state.query_mode = 'new'
+                
+            except Exception as e:
+                st.error(f"Query processing error: {str(e)}")
+                if show_debug:
+                    st.exception(e)
+    
+    # Quick analysis buttons
+    st.markdown("---")
+    st.subheader("⚡ Quick Analysis")
+    
+    quick_col1, quick_col2, quick_col3 = st.columns(3)
+    
+    with quick_col1:
+        if st.button("Count Designer Roles", use_container_width=True):
+            if processor.dataset_analysis:
+                count = processor.dataset_analysis['role_analysis'].get('designer_count', 0)
+                st.success(f"**{count}** designer roles found")
+            else:
+                st.info("Analyzing designer roles from index...")
     
-    with tech_col3:
-        st.caption("**API Configuration**")
-        st.caption("✅ Secrets-based Config")
+    with quick_col2:
+        if st.button("Adobe vs Non-Adobe", use_container_width=True):
+            if processor.dataset_analysis:
+                adobe_analysis = processor.dataset_analysis['adobe_analysis']
+                st.success(f"Adobe only: **{adobe_analysis.get('adobe_only_count', 0)}** | Non-Adobe only: **{adobe_analysis.get('non_adobe_only_count', 0)}** | Both: **{adobe_analysis.get('both_apps_count', 0)}**")
+            else:
+                st.info("Analyzing software requirements from index...")
+    
+    with quick_col3:
+        if st.button("AI Tools Count", use_container_width=True):
+            if processor.dataset_analysis:
+                count = processor.dataset_analysis['ai_tools_analysis'].get('ai_tools_count', 0)
+                st.success(f"**{count}** jobs mention AI tools")
+            else:
+                st.info("Analyzing AI tool mentions from index...")
+    
+    # Display last response if available
+    if st.session_state.last_response and not question:
+        st.markdown("---")
+        st.markdown("### 📝 Last Response")
+        with st.expander("View Last Response", expanded=False):
+            st.write(f"**Query:** {st.session_state.last_query}")
+            st.markdown("---")
+            st.write(st.session_state.last_response)
+
+def main():
+    """Main Streamlit application with multi-view support"""
+    
+    # Initialize NLTK data
+    setup_nltk_data()
+    
+    # Initialize session state
+    initialize_session_state()
+    
+    # Get API key from secrets
+    api_key = get_openai_api_key()
+    
+    # Configure OpenAI processor if key is available
+    if api_key and st.session_state.openai_processor is None:
+        try:
+            st.session_state.openai_processor = EnhancedOpenAIProcessor(api_key)
+        except Exception as e:
+            logger.error(f"Failed to initialize OpenAI processor: {e}")
+    
+    # Route to appropriate view
+    if st.session_state.current_view == 'master':
+        show_master_view()
+    elif st.session_state.current_view == 'admin':
+        show_admin_view()
+    elif st.session_state.current_view == 'client':
+        show_client_view()
 
 if __name__ == "__main__":
     main()