demo version

.gitignore

@@ -0,0 +1,112 @@
+# ==========================================
+# PYTHON
+# ==========================================
+__pycache__/
+*.py[cod]
+*.pyo
+*.pyd
+*$py.class
+
+# Virtual environments
+.venv/
+venv/
+env/
+ENV/
+.conda/
+.venv*/
+
+# Byte-compiled / optimized / DLL files
+*.so
+*.dll
+*.dylib
+
+# Logs and debug
+*.log
+*.out
+*.err
+logs/
+debug/
+*.sqlite3
+
+# ==========================================
+# BUILD / PACKAGING
+# ==========================================
+build/
+dist/
+*.egg-info/
+.eggs/
+pip-wheel-metadata/
+.wheels/
+
+# ==========================================
+# JUPYTER / NOTEBOOKS
+# ==========================================
+.ipynb_checkpoints/
+*.ipynb_convert/
+
+# ==========================================
+# DATA / MODELS / CACHE
+# ==========================================
+data/
+datasets/
+.cache/
+*.ckpt
+*.h5
+*.hdf5
+*.tflite
+*.onnx
+*.pth
+*.pt
+*.joblib
+*.pkl
+*.pickle
+*.npz
+*.npy
+outputs/
+artifacts/
+checkpoints/
+runs/
+wandb/
+mlruns/
+lightning_logs/
+
+# Hugging Face
+huggingface/
+~/.cache/huggingface/
+~/.cache/torch/
+~/.cache/datasets/
+~/.cache/transformers/
+
+# ==========================================
+# EDITORS / TOOLS
+# ==========================================
+.vscode/
+.idea/
+*.swp
+*.swo
+*.bak
+.DS_Store
+Thumbs.db
+
+# ==========================================
+# ENV FILES / CREDENTIALS
+# ==========================================
+.env
+.env.*
+*.env.local
+secrets.*
+config.json
+token.json
+
+# ==========================================
+# TESTS / TEMP FILES
+# ==========================================
+__tests__/
+.tox/
+.coverage
+.cache/
+pytest_cache/
+tmp/
+temp/
+*.tmp
+*.temp

add_district_metadata.py

@@ -0,0 +1,379 @@
+#!/usr/bin/env python3
+"""
+Script to add District metadata to Qdrant chunks based on filename analysis.
+Handles Uganda districts, ministry mappings, and LLM inference for ambiguous cases.
+"""
+import re
+import yaml
+import logging
+from dataclasses import dataclass
+from typing import Dict, List, Optional
+
+
+from qdrant_client import QdrantClient
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class DistrictMapping:
+    """Mapping for district-related entities"""
+    name: str
+    aliases: List[str]
+    is_district: bool = True
+
+
+class DistrictMetadataProcessor:
+    def __init__(self, config_path: str = "src/config/settings.yaml"):
+        # Load config manually
+        with open(config_path, 'r') as f:
+            self.config = yaml.safe_load(f)
+        
+        # Initialize Qdrant client (will be imported when needed)
+        self.llm_client = None
+        self.qdrant_client = None
+        self.collection_name = self.config["qdrant"]["collection_name"]
+        
+        # Initialize district mappings
+        self.district_mappings = self._initialize_district_mappings()
+        self.ministry_mappings = self._initialize_ministry_mappings()
+        
+    def _initialize_district_mappings(self) -> Dict[str, DistrictMapping]:
+        """Initialize Uganda districts and their aliases"""
+        districts = [
+            # Central Region
+            DistrictMapping("Kampala", ["KCCA", "Kampala Capital City Authority"]),
+            DistrictMapping("Wakiso", ["Wakiso"]),
+            DistrictMapping("Mukono", ["Mukono"]),
+            DistrictMapping("Luweero", ["Luweero"]),
+            DistrictMapping("Nakaseke", ["Nakaseke"]),
+            DistrictMapping("Nakasongola", ["Nakasongola"]),
+            DistrictMapping("Kayunga", ["Kayunga"]),
+            DistrictMapping("Buikwe", ["Buikwe"]),
+            DistrictMapping("Buvuma", ["Buvuma"]),
+            
+            # Northern Region
+            DistrictMapping("Gulu", ["Gulu", "Gulu DLG"]),
+            DistrictMapping("Kitgum", ["Kitgum"]),
+            DistrictMapping("Pader", ["Pader"]),
+            DistrictMapping("Agago", ["Agago"]),
+            DistrictMapping("Lamwo", ["Lamwo"]),
+            DistrictMapping("Nwoya", ["Nwoya"]),
+            DistrictMapping("Amuru", ["Amuru"]),
+            DistrictMapping("Omoro", ["Omoro"]),
+            DistrictMapping("Oyam", ["Oyam"]),
+            DistrictMapping("Kole", ["Kole"]),
+            DistrictMapping("Apac", ["Apac", "Apac District"]),
+            DistrictMapping("Lira", ["Lira"]),
+            DistrictMapping("Alebtong", ["Alebtong"]),
+            DistrictMapping("Amolatar", ["Amolatar"]),
+            DistrictMapping("Dokolo", ["Dokolo"]),
+            DistrictMapping("Otuke", ["Otuke"]),
+            DistrictMapping("Kwania", ["Kwania"]),
+            
+            # Eastern Region
+            DistrictMapping("Jinja", ["Jinja"]),
+            DistrictMapping("Kamuli", ["Kamuli"]),
+            DistrictMapping("Iganga", ["Iganga"]),
+            DistrictMapping("Bugiri", ["Bugiri"]),
+            DistrictMapping("Mayuge", ["Mayuge"]),
+            DistrictMapping("Namayingo", ["Namayingo"]),
+            DistrictMapping("Busia", ["Busia"]),
+            DistrictMapping("Tororo", ["Tororo"]),
+            DistrictMapping("Pallisa", ["Pallisa"]),
+            DistrictMapping("Kumi", ["Kumi"]),
+            DistrictMapping("Bukedea", ["Bukedea"]),
+            DistrictMapping("Soroti", ["Soroti"]),
+            DistrictMapping("Serere", ["Serere"]),
+            DistrictMapping("Ngora", ["Ngora"]),
+            DistrictMapping("Kaberamaido", ["Kaberamaido"]),
+            DistrictMapping("Kalaki", ["Kalaki"]),
+            DistrictMapping("Kapelebyong", ["Kapelebyong"]),
+            DistrictMapping("Amuria", ["Amuria"]),
+            DistrictMapping("Katakwi", ["Katakwi"]),
+            DistrictMapping("Kotido", ["Kotido"]),
+            DistrictMapping("Abim", ["Abim"]),
+            DistrictMapping("Kaabong", ["Kaabong", "Kaabong District"]),
+            DistrictMapping("Karenga", ["Karenga"]),
+            DistrictMapping("Moroto", ["Moroto"]),
+            DistrictMapping("Napak", ["Napak"]),
+            DistrictMapping("Nabilatuk", ["Nabilatuk"]),
+            DistrictMapping("Amudat", ["Amudat"]),
+            DistrictMapping("Nakapiripirit", ["Nakapiripirit"]),
+            DistrictMapping("Bukwo", ["Bukwo"]),
+            DistrictMapping("Kween", ["Kween"]),
+            DistrictMapping("Kapchorwa", ["Kapchorwa"]),
+            DistrictMapping("Sironko", ["Sironko"]),
+            DistrictMapping("Manafwa", ["Manafwa"]),
+            DistrictMapping("Bududa", ["Bududa"]),
+            DistrictMapping("Mbale", ["Mbale"]),
+            DistrictMapping("Butaleja", ["Butaleja"]),
+            DistrictMapping("Namisindwa", ["Namisindwa"]),
+            DistrictMapping("Bulambuli", ["Bulambuli"]),
+            
+            # Western Region
+            DistrictMapping("Masaka", ["Masaka"]),
+            DistrictMapping("Kalungu", ["Kalungu"]),
+            DistrictMapping("Bukomansimbi", ["Bukomansimbi"]),
+            DistrictMapping("Lwengo", ["Lwengo"]),
+            DistrictMapping("Sembabule", ["Sembabule"]),
+            DistrictMapping("Rakai", ["Rakai"]),
+            DistrictMapping("Kyotera", ["Kyotera"]),
+            DistrictMapping("Mpigi", ["Mpigi"]),
+            DistrictMapping("Butambala", ["Butambala"]),
+            DistrictMapping("Gomba", ["Gomba"]),
+            DistrictMapping("Mityana", ["Mityana"]),
+            DistrictMapping("Mubende", ["Mubende"]),
+            DistrictMapping("Kassanda", ["Kassanda"]),
+            DistrictMapping("Kiboga", ["Kiboga"]),
+            DistrictMapping("Kyankwanzi", ["Kyankwanzi"]),
+            DistrictMapping("Hoima", ["Hoima"]),
+            DistrictMapping("Kikuube", ["Kikuube"]),
+            DistrictMapping("Kakumiro", ["Kakumiro"]),
+            DistrictMapping("Kibaale", ["Kibaale"]),
+            DistrictMapping("Kagadi", ["Kagadi"]),
+            DistrictMapping("Buliisa", ["Buliisa"]),
+            DistrictMapping("Masindi", ["Masindi"]),
+            DistrictMapping("Kiryandongo", ["Kiryandongo"]),
+            DistrictMapping("Buliisa", ["Buliisa"]),
+            DistrictMapping("Pakwach", ["Pakwach"]),
+            DistrictMapping("Nebbi", ["Nebbi"]),
+            DistrictMapping("Zombo", ["Zombo"]),
+            DistrictMapping("Arua", ["Arua"]),
+            DistrictMapping("Terego", ["Terego"]),
+            DistrictMapping("Madi-Okollo", ["Madi-Okollo"]),
+            DistrictMapping("Obongi", ["Obongi"]),
+            DistrictMapping("Moyo", ["Moyo"]),
+            DistrictMapping("Yumbe", ["Yumbe"]),
+            DistrictMapping("Koboko", ["Koboko"]),
+            DistrictMapping("Maracha", ["Maracha"]),
+            DistrictMapping("Adjumani", ["Adjumani"]),
+            
+            # South Western Region
+            DistrictMapping("Mbarara", ["Mbarara"]),
+            DistrictMapping("Ibanda", ["Ibanda"]),
+            DistrictMapping("Isingiro", ["Isingiro"]),
+            DistrictMapping("Kiruhura", ["Kiruhura"]),
+            DistrictMapping("Kazo", ["Kazo"]),
+            DistrictMapping("Ntungamo", ["Ntungamo"]),
+            DistrictMapping("Rwampara", ["Rwampara"]),
+            DistrictMapping("Rubanda", ["Rubanda"]),
+            DistrictMapping("Rukiga", ["Rukiga"]),
+            DistrictMapping("Kanungu", ["Kanungu"]),
+            DistrictMapping("Rukungiri", ["Rukungiri"]),
+            DistrictMapping("Kisoro", ["Kisoro"]),
+            DistrictMapping("Bundibugyo", ["Bundibugyo"]),
+            DistrictMapping("Ntoroko", ["Ntoroko"]),
+            DistrictMapping("Kasese", ["Kasese"]),
+            DistrictMapping("Bunyangabu", ["Bunyangabu"]),
+            DistrictMapping("Fort Portal", ["Fort Portal"]),
+            DistrictMapping("Kabarole", ["Kabarole"]),
+            DistrictMapping("Kyenjojo", ["Kyenjojo"]),
+            DistrictMapping("Kamwenge", ["Kamwenge"]),
+            DistrictMapping("Kitagwenda", ["Kitagwenda"]),
+            DistrictMapping("Kyegegwa", ["Kyegegwa"]),
+            DistrictMapping("Mitooma", ["Mitooma"]),
+            DistrictMapping("Rubirizi", ["Rubirizi"]),
+            DistrictMapping("Sheema", ["Sheema"]),
+            DistrictMapping("Bushenyi", ["Bushenyi"]),
+            
+            # Special cases
+            DistrictMapping("Kalangala", ["Kalangala", "Kalangala DLG"]),
+        ]
+        
+        # Create mapping dictionary
+        mapping_dict = {}
+        for district in districts:
+            mapping_dict[district.name.lower()] = district
+            for alias in district.aliases:
+                mapping_dict[alias.lower()] = district
+        return mapping_dict
+    
+    def _initialize_ministry_mappings(self) -> Dict[str, str]:
+        """Initialize ministry and organization mappings"""
+        return {
+            "maaif": "Ministry of Agriculture, Animal Industry and Fisheries",
+            "mwts": "Ministry of Works and Transport",
+            "kcca": "Kampala Capital City Authority",
+            "oag": "Office of the Auditor General",
+            "arsdp": "Albertine Regional Sustainable Development Project",
+            "avcdp": "Agriculture Value Chain Development Project",
+            "ida": "International Development Association",
+            "dlg": "District Local Government",
+            "lg": "Local Government",
+        }
+    
+    def _extract_district_from_filename(self, filename: str) -> Optional[str]:
+        """Extract district from filename using pattern matching"""
+        filename_lower = filename.lower()
+        
+        # Check for explicit district mentions
+        for key, district_mapping in self.district_mappings.items():
+            if key in filename_lower:
+                return district_mapping.name
+        
+        # Check for ministry/organization patterns that are NOT districts
+        for ministry_key in self.ministry_mappings.keys():
+            if ministry_key in filename_lower:
+                return None  # This is a ministry, not a district
+        
+        # Check for patterns like "District Local Government"
+        district_pattern = r'(\w+)\s+district\s+local\s+government'
+        match = re.search(district_pattern, filename_lower)
+        if match:
+            district_name = match.group(1).title()
+            if district_name.lower() in self.district_mappings:
+                return self.district_mappings[district_name.lower()].name
+        
+        # Check for patterns like "DLG Report"
+        dlg_pattern = r'(\w+)\s+dlg\s+report'
+        match = re.search(dlg_pattern, filename_lower)
+        if match:
+            district_name = match.group(1).title()
+            if district_name.lower() in self.district_mappings:
+                return self.district_mappings[district_name.lower()].name
+        
+        return None
+    
+    def _infer_district_with_llm(self, filename: str) -> Optional[str]:
+        """Use LLM to infer district from filename when pattern matching fails"""
+        # For now, return None - LLM integration can be added later
+        logger.info(f"LLM inference needed for filename: {filename}")
+        return None
+    
+    def infer_district(self, filename: str) -> Optional[str]:
+        """Main method to infer district from filename"""
+        # First try pattern matching
+        district = self._extract_district_from_filename(filename)
+        if district:
+            return district
+        
+        # If pattern matching fails, use LLM
+        return self._infer_district_with_llm(filename)
+    
+    def fetch_chunks_batch(self, batch_size: int = 100, offset: int = 0) -> List[Dict]:
+        """Fetch a batch of chunks from Qdrant (metadata only)"""
+        try:
+            # Import Qdrant client when needed
+            if self.qdrant_client is None:
+                self.qdrant_client = QdrantClient(
+                    url=self.config["qdrant"]["url"],
+                    api_key=self.config["qdrant"]["api_key"]
+                )
+            
+            # Get points with metadata only (no vectors)
+            points = self.qdrant_client.scroll(
+                collection_name=self.collection_name,
+                limit=batch_size,
+                offset=offset,
+                with_payload=True,
+                with_vectors=False
+            )[0]
+            
+            return points
+        except Exception as e:
+            logger.error(f"Failed to fetch batch: {e}")
+            return []
+    
+    def update_chunks_with_district(self, points: List[Dict]) -> int:
+        """Update chunks with district metadata"""
+        updated_count = 0
+        
+        # Import Qdrant client when needed
+        if self.qdrant_client is None:
+            from qdrant_client import QdrantClient
+            self.qdrant_client = QdrantClient(
+                url=self.config["qdrant"]["url"],
+                api_key=self.config["qdrant"]["api_key"]
+            )
+        
+        for point in points:
+            try:
+                point_id = point.id
+                metadata = point.payload.get("metadata", {})
+                filename = metadata.get("filename", "")
+                
+                if not filename:
+                    logger.warning(f"Point {point_id} has no filename")
+                    continue
+                
+                # Infer district
+                district = self.infer_district(filename)
+                
+                # Update metadata
+                updated_metadata = metadata.copy()
+                updated_metadata["district"] = district
+                
+                # Update point in Qdrant
+                self.qdrant_client.set_payload(
+                    collection_name=self.collection_name,
+                    payload={"metadata": updated_metadata},
+                    points=[point_id]
+                )
+                
+                updated_count += 1
+                logger.info(f"Updated point {point_id}: {filename} -> {district}")
+                
+            except Exception as e:
+                logger.error(f"Failed to update point {point_id}: {e}")
+        
+        return updated_count
+    
+    def process_all_chunks(self, batch_size: int = 100):
+        """Process all chunks in batches"""
+        total_updated = 0
+        offset = 0
+        
+        logger.info(f"Starting to process chunks in batches of {batch_size}")
+        
+        while True:
+            # Fetch batch
+            points = self.fetch_chunks_batch(batch_size, offset)
+            if not points:
+                break
+            
+            logger.info(f"Processing batch: {len(points)} points (offset: {offset})")
+            
+            # Update batch
+            updated_count = self.update_chunks_with_district(points)
+            total_updated += updated_count
+            
+            logger.info(f"Updated {updated_count} points in this batch")
+            
+            # Move to next batch
+            offset += batch_size
+        
+        logger.info(f"Total updated: {total_updated} points")
+        return total_updated
+
+def main():
+    """Main function to run the district metadata processor"""
+    try:
+        processor = DistrictMetadataProcessor()
+        
+        # Test with a small batch first
+        logger.info("Testing with first 10 chunks...")
+        test_points = processor.fetch_chunks_batch(10, 0)
+        
+        if test_points:
+            logger.info("Test batch fetched successfully. Processing...")
+            for point in test_points:
+                filename = point.payload.get("metadata", {}).get("filename", "")
+                district = processor.infer_district(filename)
+                logger.info(f"Test: {filename} -> {district}")
+        
+        # Ask user if they want to proceed with full processing
+        response = input("\nProceed with full processing? (y/n): ")
+        if response.lower() == 'y':
+            processor.process_all_chunks(batch_size=100)
+        else:
+            logger.info("Processing cancelled by user")
+            
+    except Exception as e:
+        logger.error(f"Error in main: {e}")
+        raise
+
+if __name__ == "__main__":
+    main()

app.py

@@ -3,7 +3,32 @@ Intelligent Audit Report Chatbot UI
 """
 
 import os
-import sys
+
+import time
+import json
+import uuid
+import logging
+import traceback
+from pathlib import Path
+from typing import List, Dict, Any
+from collections import Counter
+
+import streamlit as st
+from langchain_core.messages import HumanMessage, AIMessage
+import pandas as pd
+import plotly.express as px
+
+from multi_agent_chatbot import get_multi_agent_chatbot
+from smart_chatbot import get_chatbot as get_smart_chatbot
+from src.reporting.feedback_schema import create_feedback_from_dict
+from src.reporting.snowflake_connector import save_to_snowflake
+from src.config.paths import (
+    IS_DEPLOYED,
+    PROJECT_DIR,
+    HF_CACHE_DIR,
+    FEEDBACK_DIR,
+    CONVERSATIONS_DIR,
+)
 
 # ===== CRITICAL: Fix OMP_NUM_THREADS FIRST, before ANY other imports =====
 # Some libraries load at import time and will fail if OMP_NUM_THREADS is invalid
@@ -29,42 +54,30 @@ except (ValueError, TypeError):
 
 # ===== Setup HuggingFace cache directories BEFORE any model imports =====
 # CRITICAL: Set these before any imports that might use HuggingFace (like sentence-transformers)
-# This ensures models downloaded during Docker build are found at runtime
-cache_dir = "/app/.cache/huggingface"
-os.environ["HF_HOME"] = cache_dir
-os.environ["TRANSFORMERS_CACHE"] = cache_dir
-os.environ["HF_DATASETS_CACHE"] = cache_dir
-os.environ["HF_HUB_CACHE"] = cache_dir
-os.environ["SENTENCE_TRANSFORMERS_HOME"] = cache_dir
-
-# Ensure cache directory exists (created in Dockerfile, but ensure it's there)
-try:
-    os.makedirs(cache_dir, mode=0o755, exist_ok=True)
-except (PermissionError, OSError) as e:
-    # If we can't create it, log but continue (might already exist from Dockerfile)
-    # HuggingFace will try to create subdirectories, but we need parent to exist
-    pass
-
-import time
-import json
-import uuid
-import logging
-from pathlib import Path
-
-import argparse
-import streamlit as st
-from langchain_core.messages import HumanMessage, AIMessage
-
-from multi_agent_chatbot import get_multi_agent_chatbot
-from smart_chatbot import get_chatbot as get_smart_chatbot
-from src.reporting.feedback_schema import create_feedback_from_dict
+# Only override cache directories in deployed environment (local uses defaults)
+if IS_DEPLOYED and HF_CACHE_DIR:
+    cache_dir = str(HF_CACHE_DIR)
+    os.environ["HF_HOME"] = cache_dir
+    os.environ["TRANSFORMERS_CACHE"] = cache_dir
+    os.environ["HF_DATASETS_CACHE"] = cache_dir
+    os.environ["HF_HUB_CACHE"] = cache_dir
+    os.environ["SENTENCE_TRANSFORMERS_HOME"] = cache_dir
+    
+    # Ensure cache directory exists (created in Dockerfile, but ensure it's there)
+    try:
+        os.makedirs(cache_dir, mode=0o755, exist_ok=True)
+    except (PermissionError, OSError):
+        # If we can't create it, log but continue (might already exist from Dockerfile)
+        pass
 
 # Configure logging
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
 
 # Log environment setup for debugging
-logger.info(f"📁 HuggingFace cache directory: {os.environ.get('HF_HOME', 'NOT SET')}")
+logger.info(f"🌍 Environment: {'DEPLOYED' if IS_DEPLOYED else 'LOCAL'}")
+logger.info(f"📁 PROJECT_DIR: {PROJECT_DIR}")
+logger.info(f"📁 HuggingFace cache: {os.environ.get('HF_HOME', 'DEFAULT (not overridden)')}")
 logger.info(f"🔧 OMP_NUM_THREADS: {os.environ.get('OMP_NUM_THREADS', 'NOT SET')}")
     
 
@@ -94,6 +107,54 @@ st.markdown("""
         margin-bottom: 2rem;
     }
     
+    .example-questions-header {
+        text-align: center;
+        margin-bottom: 1rem;
+    }
+    
+    .example-questions-description {
+        text-align: center;
+        color: #666;
+        margin-bottom: 2rem;
+    }
+    
+    /* Hide ALL default Streamlit text input help messages about Enter key */
+    /* This is the key one - hides "Press Enter to apply" message inside input field */
+    div[data-testid="InputInstructions"],
+    span[data-testid="InputInstructions"],
+    *[data-testid="InputInstructions"] {
+        display: none !important;
+        visibility: hidden !important;
+        opacity: 0 !important;
+        height: 0 !important;
+        width: 0 !important;
+        overflow: hidden !important;
+        position: absolute !important;
+        left: -9999px !important;
+    }
+    
+    /* Also hide other potential locations */
+    div[data-testid="stTextInput"] + div > small,
+    div[data-testid="stTextInput"] ~ div > small,
+    div[data-testid="stTextInputContainer"] + div > small,
+    div[data-testid="stTextInputContainer"] ~ div > small,
+    div[data-baseweb="input"] + div > small,
+    div[data-baseweb="input"] ~ div > small {
+        display: none !important;
+        visibility: hidden !important;
+        opacity: 0 !important;
+        height: 0 !important;
+        overflow: hidden !important;
+    }
+    
+    /* Custom help text for input */
+    .input-help-text {
+        font-size: 0.85rem;
+        color: #666;
+        margin-top: 0.25rem;
+        text-align: left;
+    }
+    
     .session-info {
         background-color: #f0f2f6;
         padding: 10px;
@@ -152,6 +213,34 @@ st.markdown("""
         margin: 10px 0;
         border-left: 4px solid #007bff;
     }
+    
+    .retrieval-distribution-container {
+        background-color: #ffffff;
+        padding: 25px;
+        border-radius: 10px;
+        margin: 20px 0;
+        border: 2px solid #e0e0e0;
+        box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1), 0 2px 4px rgba(0, 0, 0, 0.06);
+    }
+    
+    .metric-label {
+        font-size: 0.9rem;
+        color: #555;
+        margin-bottom: 5px;
+        text-align: center;
+    }
+    
+    .metric-value {
+        font-size: 1.8rem;
+        font-weight: bold;
+        color: #000000;
+        text-align: center;
+    }
+    
+    .metric-container {
+        text-align: center;
+        padding: 10px;
+    }
 </style>
 """, unsafe_allow_html=True)
 
@@ -215,13 +304,270 @@ def serialize_documents(sources):
     
     return serialized
 
+def extract_chunk_statistics(sources: List[Any]) -> Dict[str, Any]:
+    """Extract statistics from retrieved chunks."""
+    if not sources:
+        return {}
+    
+    sources_list = []
+    years = []
+    filenames = []
+    districts = []
+    
+    for doc in sources:
+        metadata = getattr(doc, 'metadata', {})
+        
+        # Extract source
+        source = metadata.get('source', 'Unknown')
+        sources_list.append(source)
+        
+        # Extract year
+        year = metadata.get('year', 'Unknown')
+        if year and year != 'Unknown':
+            try:
+                # Convert to int first, then back to string to ensure it's a proper year
+                year_int = int(float(year))  # Handle both int and float strings
+                if 1900 <= year_int <= 2030:  # Reasonable year range
+                    years.append(str(year_int))
+                else:
+                    years.append('Unknown')
+            except (ValueError, TypeError):
+                years.append('Unknown')
+        else:
+            years.append('Unknown')
+        
+        # Extract filename
+        filename = metadata.get('filename', 'Unknown')
+        filenames.append(filename)
+        
+        # Extract district
+        district = metadata.get('district', 'Unknown')
+        if district and district != 'Unknown':
+            districts.append(district)
+        else:
+            districts.append('Unknown')
+    
+    # Count occurrences
+    source_counts = Counter(sources_list)
+    year_counts = Counter(years)
+    filename_counts = Counter(filenames)
+    district_counts = Counter(districts)
+    
+    return {
+        'total_chunks': len(sources),
+        'unique_sources': len(source_counts),
+        'unique_years': len([y for y in year_counts.keys() if y != 'Unknown']),
+        'unique_filenames': len(filename_counts),
+        'unique_districts': len([d for d in district_counts.keys() if d != 'Unknown']),
+        'source_distribution': dict(source_counts),
+        'year_distribution': dict(year_counts),
+        'filename_distribution': dict(filename_counts),
+        'district_distribution': dict(district_counts),
+        'sources': sources_list,
+        'years': years,
+        'filenames': filenames,
+        'districts': districts
+    }
+
+def display_chunk_statistics_charts(stats: Dict[str, Any], title: str = "Retrieval Statistics"):
+    """Display statistics as interactive charts for 10+ results."""
+    if not stats or stats.get('total_chunks', 0) == 0:
+        return
+    
+    # Wrap everything in one styled container - open it
+    st.markdown(f"""
+    <div class="retrieval-distribution-container">
+        <h3 style="margin-top: 0;">📊 {title}</h3>
+        <div style="display: flex; justify-content: space-around; align-items: center; padding: 15px 0; border-bottom: 1px solid #e0e0e0; margin-bottom: 20px;">
+            <div class="metric-container">
+                <div class="metric-label">Total Chunks</div>
+                <div class="metric-value">{stats['total_chunks']}</div>
+            </div>
+            <div class="metric-container">
+                <div class="metric-label">Unique Sources</div>
+                <div class="metric-value">{stats['unique_sources']}</div>
+            </div>
+            <div class="metric-container">
+                <div class="metric-label">Unique Years</div>
+                <div class="metric-value">{stats['unique_years']}</div>
+            </div>
+            <div class="metric-container">
+                <div class="metric-label">Unique Files</div>
+                <div class="metric-value">{stats['unique_filenames']}</div>
+            </div>
+        </div>
+    """, unsafe_allow_html=True)
+    
+    # Charts - three columns to include Districts
+    col1, col2, col3 = st.columns(3)
+    
+    with col1:
+        # Source distribution chart
+        if stats['source_distribution']:
+            source_df = pd.DataFrame(
+                list(stats['source_distribution'].items()),
+                columns=['Source', 'Count']
+            )
+            fig_source = px.bar(
+                source_df,
+                x='Count',
+                y='Source',
+                orientation='h',
+                title='Distribution by Source',
+                color='Count',
+                color_continuous_scale='viridis'
+            )
+            fig_source.update_layout(height=400, showlegend=False)
+            st.plotly_chart(fig_source, use_container_width=True)
+    
+    with col2:
+        # Year distribution chart
+        if stats['year_distribution']:
+            # Filter out 'Unknown' years for the chart
+            year_dist_filtered = {k: v for k, v in stats['year_distribution'].items() if k != 'Unknown'}
+            if year_dist_filtered:
+                year_df = pd.DataFrame(
+                    list(year_dist_filtered.items()),
+                    columns=['Year', 'Count']
+                )
+                # Sort by year as integer but keep as string for categorical display
+                year_df['Year_Int'] = year_df['Year'].astype(int)
+                year_df = year_df.sort_values('Year_Int').drop('Year_Int', axis=1)
+                
+                fig_year = px.bar(
+                    year_df,
+                    x='Year',
+                    y='Count',
+                    title='Distribution by Year',
+                    color='Count',
+                    color_continuous_scale='plasma'
+                )
+                # Ensure years are treated as categorical (discrete) not continuous
+                fig_year.update_xaxes(type='category')
+                fig_year.update_layout(height=400, showlegend=False)
+                st.plotly_chart(fig_year, use_container_width=True)
+            else:
+                st.info("No valid years found in the results")
+    
+    with col3:
+        # District distribution chart
+        if stats.get('district_distribution'):
+            district_dist_filtered = {k: v for k, v in stats['district_distribution'].items() if k != 'Unknown'}
+            if district_dist_filtered:
+                district_df = pd.DataFrame(
+                    list(district_dist_filtered.items()),
+                    columns=['District', 'Count']
+                )
+                district_df = district_df.sort_values('Count', ascending=False)
+                
+                fig_district = px.bar(
+                    district_df,
+                    x='Count',
+                    y='District',
+                    orientation='h',
+                    title='Distribution by District',
+                    color='Count',
+                    color_continuous_scale='blues'
+                )
+                fig_district.update_layout(height=400, showlegend=False)
+                st.plotly_chart(fig_district, use_container_width=True)
+            else:
+                st.info("No valid districts found in the results")
+    
+    # Close the container
+    st.markdown('</div>', unsafe_allow_html=True)
+
+def display_chunk_statistics_table(stats: Dict[str, Any], title: str = "Retrieval Distribution"):
+    """Display statistics as tables for smaller results with fixed alignment."""
+    if not stats or stats.get('total_chunks', 0) == 0:
+        return
+    
+    # Wrap in styled container
+    # st.markdown('<div class="retrieval-distribution-container">', unsafe_allow_html=True)
+    
+    st.subheader(f"📊 {title}")
+    
+    # Create a container with fixed height for alignment
+    stats_container = st.container()
+    
+    with stats_container:
+        # Create 4 equal columns for consistent alignment
+        col1, col2, col3, col4 = st.columns(4)
+        
+        with col1:
+            st.markdown("**🏘️ Districts**")
+            if stats.get('district_distribution'):
+                district_dist_filtered = {k: v for k, v in stats['district_distribution'].items() if k != 'Unknown'}
+                if district_dist_filtered:
+                    district_data = {
+                        "District": list(district_dist_filtered.keys()),
+                        "Count": list(district_dist_filtered.values())
+                    }
+                    district_df = pd.DataFrame(district_data).sort_values('Count', ascending=False)
+                    st.dataframe(district_df, hide_index=True, use_container_width=True)
+                else:
+                    st.write("No district data")
+            else:
+                st.write("No district data")
+        
+        with col2:
+            st.markdown("**📂 Sources**")
+            if stats['source_distribution']:
+                source_data = {
+                    "Source": list(stats['source_distribution'].keys()),
+                    "Count": list(stats['source_distribution'].values())
+                }
+                source_df = pd.DataFrame(source_data).sort_values('Count', ascending=False)
+                st.dataframe(source_df, hide_index=True, use_container_width=True)
+            else:
+                st.write("No source data")
+        
+        with col3:
+            st.markdown("**📅 Years**")
+            if stats['year_distribution']:
+                year_dist_filtered = {k: v for k, v in stats['year_distribution'].items() if k != 'Unknown'}
+                if year_dist_filtered:
+                    year_data = {
+                        "Year": list(year_dist_filtered.keys()),
+                        "Count": list(year_dist_filtered.values())
+                    }
+                    year_df = pd.DataFrame(year_data)
+                    # Sort by year as integer but display as string
+                    year_df['Year_Int'] = year_df['Year'].astype(int)
+                    year_df = year_df.sort_values('Year_Int')[['Year', 'Count']]
+                    st.dataframe(year_df, hide_index=True, use_container_width=True)
+                else:
+                    st.write("No year data")
+            else:
+                st.write("No year data")
+        
+        with col4:
+            st.markdown("**📄 Files**")
+            if stats['filename_distribution']:
+                filename_items = list(stats['filename_distribution'].items())
+                filename_items.sort(key=lambda x: x[1], reverse=True)
+                
+                # Show top files with truncated names
+                file_data = {
+                    "File": [f[:30] + "..." if len(f) > 30 else f for f, c in filename_items[:5]],
+                    "Count": [c for f, c in filename_items[:5]]
+                }
+                file_df = pd.DataFrame(file_data)
+                st.dataframe(file_df, hide_index=True, use_container_width=True)
+            else:
+                st.write("No file data")
+    
+    # Close container
+    st.markdown('</div>', unsafe_allow_html=True)
+
 @st.cache_data
 def load_filter_options():
     try:
-        with open("src/config/filter_options.json", "r") as f:
+        filter_options_path = PROJECT_DIR / "src" / "config" / "filter_options.json"
+        with open(filter_options_path, "r") as f:
             return json.load(f)
     except FileNotFoundError:
-        st.info([x for x in os.listdir() if x.endswith('.json')])
+        st.info(f"Looking for filter_options.json in: {PROJECT_DIR / 'src' / 'config'}")
         st.error("filter_options.json not found. Please run the metadata analysis script.")
         return {"sources": [], "years": [], "districts": [], 'filenames': []}
 
@@ -254,16 +600,8 @@ def main():
         st.session_state.reset_conversation = False
         st.rerun()
 
-    # Header with system indicator
-    col1, col2 = st.columns([3, 1])
-    with col1:
-        st.markdown('<h1 class="main-header">🤖 Intelligent Audit Report Chatbot</h1>', unsafe_allow_html=True)
-    with col2:
-        system_type = get_system_type()
-        if "Multi-Agent" in system_type:
-            st.success(f"🔧 {system_type}")
-        else:
-            st.info(f"🔧 {system_type}")
+    # Header - centered
+    st.markdown('<h1 class="main-header">🤖 Intelligent Audit Report Chatbot</h1>', unsafe_allow_html=True)
     st.markdown('<p class="subtitle">Ask questions about audit reports. Use the sidebar filters to narrow down your search!</p>', unsafe_allow_html=True)
     
     # Session info
@@ -280,6 +618,40 @@ def main():
 
     # Sidebar for filters
     with st.sidebar:
+        # Instructions section (collapsible)
+        with st.expander("📖 How to Use", expanded=False):
+            st.markdown("""
+            #### 🎯 Using Filters
+            
+            1. **Select filters** from the sidebar to narrow your search:
+            
+            2. **Leave filters empty** to search across all data
+            
+            3. **Type your question** in the chat and click "Send"
+            
+            4. **Choose sample questions from the bottom of the page**
+            
+            #### 💡 Tips
+            
+            - Use specific questions for better results
+            - Combine multiple filters for precise searches
+            - Check the "Retrieved Documents" tab to get various insights
+            
+            #### 💬 Feedback Section
+            
+            - Rate your experience (1-5 stars)
+            - Provide optional text feedback
+            - Located at the bottom of the page
+            
+            #### ⚠️ Important
+            
+            **When finished, please close the browser window** to free up computational resources.
+            
+            ---
+            
+            For more detailed help, see the example questions at the bottom of the page.
+            """)
+        
         st.markdown("### 🔍 Search Filters")
         st.markdown("Select filters to narrow down your search. Leave empty to search all data.")
         
@@ -294,11 +666,13 @@ def main():
                 help="Choose specific reports to search. When enabled, all other filters are ignored."
             )
         st.markdown('</div>', unsafe_allow_html=True)
+
+        st.markdown('---')
         
         # Determine if filename filter is active
         filename_mode = len(selected_filenames) > 0
         # Sources filter
-        st.markdown('<div class="filter-section">', unsafe_allow_html=True)
+        # st.markdown('<div class="filter-section">', unsafe_allow_html=True)
         st.markdown('<div class="filter-title">📊 Sources</div>', unsafe_allow_html=True)
         selected_sources = st.multiselect(
             "Select sources:",
@@ -311,7 +685,7 @@ def main():
         st.markdown('</div>', unsafe_allow_html=True)
         
         # Years filter
-        st.markdown('<div class="filter-section">', unsafe_allow_html=True)
+        # st.markdown('<div class="filter-section">', unsafe_allow_html=True)
         st.markdown('<div class="filter-title">📅 Years</div>', unsafe_allow_html=True)
         selected_years = st.multiselect(
             "Select years:",
@@ -324,7 +698,7 @@ def main():
         st.markdown('</div>', unsafe_allow_html=True)
         
         # Districts filter
-        st.markdown('<div class="filter-section">', unsafe_allow_html=True)
+        # st.markdown('<div class="filter-section">', unsafe_allow_html=True)
         st.markdown('<div class="filter-title">🏘️ Districts</div>', unsafe_allow_html=True)
         selected_districts = st.multiselect(
             "Select districts:",
@@ -375,12 +749,85 @@ def main():
             if 'input_counter' not in st.session_state:
                 st.session_state.input_counter = 0
             
+            # Handle pending question from example questions section
+            if 'pending_question' in st.session_state and st.session_state.pending_question:
+                default_value = st.session_state.pending_question
+                # Increment counter to force new input widget
+                st.session_state.input_counter = (st.session_state.get('input_counter', 0) + 1) % 1000
+                del st.session_state.pending_question
+                key_suffix = st.session_state.input_counter
+            else:
+                default_value = ""
+                key_suffix = st.session_state.input_counter
+            
             user_input = st.text_input(
                 "Type your message here...",
                 placeholder="Ask about budget allocations, expenditures, or audit findings...",
-                key=f"user_input_{st.session_state.input_counter}",
-                label_visibility="collapsed"
+                key=f"user_input_{key_suffix}",
+                label_visibility="collapsed",
+                value=default_value if default_value else None
             )
+            
+            # Use JavaScript to specifically target and hide "Press Enter to apply" message
+            st.markdown("""
+            <script>
+                (function() {
+                    // Hide InputInstructions element (contains "Press Enter to apply")
+                    function hideInputInstructions() {
+                        // Target the specific Streamlit element
+                        const instructions = document.querySelector('[data-testid="InputInstructions"]');
+                        if (instructions) {
+                            instructions.style.display = 'none';
+                            instructions.style.visibility = 'hidden';
+                            instructions.style.opacity = '0';
+                            instructions.style.height = '0';
+                            instructions.style.width = '0';
+                            instructions.style.overflow = 'hidden';
+                            instructions.style.position = 'absolute';
+                            instructions.style.left = '-9999px';
+                        }
+                        
+                        // Also search for any text containing "Press Enter" or "apply" inside input containers
+                        const allElements = document.querySelectorAll('*');
+                        allElements.forEach(el => {
+                            const text = el.textContent || el.innerText || '';
+                            if ((text.toLowerCase().includes('press enter') || 
+                                 text.toLowerCase().includes('enter to') ||
+                                 text.toLowerCase().includes('to apply')) &&
+                                (el.tagName === 'SPAN' || el.tagName === 'DIV' || el.tagName === 'SMALL')) {
+                                const style = window.getComputedStyle(el);
+                                const fontSize = parseFloat(style.fontSize);
+                                // Hide if it's small text (likely help text)
+                                if (fontSize < 14 || el.hasAttribute('data-testid')) {
+                                    el.style.display = 'none';
+                                    el.style.visibility = 'hidden';
+                                    el.style.height = '0';
+                                    el.style.overflow = 'hidden';
+                                }
+                            }
+                        });
+                    }
+                    
+                    // Run immediately and after delays to catch dynamic elements
+                    hideInputInstructions();
+                    setTimeout(hideInputInstructions, 50);
+                    setTimeout(hideInputInstructions, 100);
+                    setTimeout(hideInputInstructions, 500);
+                    
+                    // Observe for new elements added by Streamlit
+                    const observer = new MutationObserver(function(mutations) {
+                        hideInputInstructions();
+                    });
+                    observer.observe(document.body, { childList: true, subtree: true, attributes: true });
+                })();
+            </script>
+            """, unsafe_allow_html=True)
+            
+            # # Show custom help text below input - this replaces the default "Press Enter" message
+            # st.markdown(
+            #     "<div class='input-help-text'>💡 Press the <strong>Send</strong> button to submit your question</div>",
+            #     unsafe_allow_html=True
+            # )
         
         with col2:
             send_button = st.button("Send", key="send_button", use_container_width=True)
@@ -389,12 +836,11 @@ def main():
         if st.button("🗑️ Clear Chat", key="clear_chat_button"):
             st.session_state.reset_conversation = True
             # Clear all conversation files
-            import os
-            conversations_dir = "conversations"
-            if os.path.exists(conversations_dir):
-                for file in os.listdir(conversations_dir):
-                    if file.endswith('.json'):
-                        os.remove(os.path.join(conversations_dir, file))
+            conversations_path = CONVERSATIONS_DIR
+            if conversations_path.exists():
+                for file in conversations_path.iterdir():
+                    if file.suffix == '.json':
+                        file.unlink()
             st.rerun()
         
         # Handle user input
@@ -484,14 +930,30 @@ def main():
                 # Count unique filenames
                 unique_filenames = set()
                 for doc in sources:
-                    filename = getattr(doc, 'metadata', {}).get('filename', 'Unknown')
+                    metadata = getattr(doc, 'metadata', {})
+                    filename = metadata.get('filename', 'Unknown')
                     unique_filenames.add(filename)
                 
-                st.markdown(f"**Found {len(sources)} document chunks from {len(unique_filenames)} unique documents (showing top 10):**")
+                st.markdown(f"**Found {len(sources)} document chunks from {len(unique_filenames)} unique documents (showing top 20):**")
                 if len(unique_filenames) < len(sources):
                     st.info(f"💡 **Note**: Each document is split into multiple chunks. You're seeing {len(sources)} chunks from {len(unique_filenames)} documents.")
                 
-                for i, doc in enumerate(sources[:10]):  # Show top 10
+                # Extract and display statistics
+                stats = extract_chunk_statistics(sources)
+                
+                # Show charts for 10+ results, tables for fewer
+                if len(sources) >= 10:
+                    display_chunk_statistics_charts(stats, "Retrieval Statistics")
+                    # Also show tables below charts for detailed view
+                    st.markdown("---")
+                    display_chunk_statistics_table(stats, "Retrieval Distribution")
+                else:
+                    display_chunk_statistics_table(stats, "Retrieval Distribution")
+                
+                st.markdown("---")
+                st.markdown("### 📄 Document Details")
+                
+                for i, doc in enumerate(sources):  # Show all documents
                     # Get relevance score and ID if available
                     metadata = getattr(doc, 'metadata', {})
                     score = metadata.get('reranked_score', metadata.get('original_score', None))
@@ -524,6 +986,44 @@ def main():
                 st.info("No documents were retrieved for the last query.")
         else:
             st.info("No documents have been retrieved yet. Start a conversation to see retrieved documents here.")
+        
+        # Display retrieval history stats
+        st.markdown("---")
+        if st.session_state.rag_retrieval_history:
+            st.markdown("#### 📊 Retrieval History")
+            st.markdown(f"This conversation has **{len(st.session_state.rag_retrieval_history)}** retrieval entries.")
+            
+            with st.expander(f"View {len(st.session_state.rag_retrieval_history)} retrieval entries", expanded=False):
+                for idx, entry in enumerate(st.session_state.rag_retrieval_history, 1):
+                    with st.expander(f"Entry {idx}: {entry.get('rag_query_expansion', 'N/A')[:50]}...", expanded=False):
+                        st.markdown(f"**Query:** {entry.get('rag_query_expansion', 'N/A')}")
+                        st.markdown(f"**Documents Retrieved:** {len(entry.get('docs_retrieved', []))}")
+                        
+                        # Show conversation up to this point
+                        conversation = entry.get('conversation_up_to', [])
+                        if conversation:
+                            st.markdown("**Conversation Context:**")
+                            for msg in conversation[-3:]:  # Show last 3 messages
+                                role = msg.get('type', 'unknown')
+                                content = msg.get('content', '')[:200] + "..." if len(msg.get('content', '')) > 200 else msg.get('content', '')
+                                if role == 'human':
+                                    st.markdown(f"- **You:** {content}")
+                                elif role == 'ai':
+                                    st.markdown(f"- **Bot:** {content}")
+                        
+                        # Show retrieved documents summary
+                        docs = entry.get('docs_retrieved', [])
+                        if docs:
+                            st.markdown("**Retrieved Documents:**")
+                            for doc_idx, doc in enumerate(docs[:5], 1):  # Show first 5
+                                doc_meta = doc.get('metadata', {})
+                                filename = doc_meta.get('filename', 'Unknown')[:50]
+                                st.markdown(f"{doc_idx}. {filename}")
+                            if len(docs) > 5:
+                                st.markdown(f"... and {len(docs) - 5} more documents")
+        else:
+            st.markdown("---")
+            st.info("📊 Retrieval history will appear here after you start asking questions.")
     
     # Feedback Dashboard Section
     st.markdown("---")
@@ -543,200 +1043,271 @@ def main():
         if 'feedback_submitted' not in st.session_state:
             st.session_state.feedback_submitted = False
         
-        # Feedback form
-        with st.form("feedback_form", clear_on_submit=False):
-            col1, col2 = st.columns([1, 1])
-            
-            with col1:
-                feedback_score = st.slider(
-                    "Rate this conversation (1-5)",
-                    min_value=1,
-                    max_value=5,
-                    help="How satisfied are you with the conversation?"
-                )
-            
-            with col2:
-                is_feedback_about_last_retrieval = st.checkbox(
-                    "Feedback about last retrieval only",
-                    value=True,
-                    help="If checked, feedback applies to the most recent document retrieval"
-                )
-            
-            open_ended_feedback = st.text_area(
-                "Your feedback (optional)",
-                placeholder="Tell us what went well or what could be improved...",
-                height=100
-            )
-            
-            # Disable submit if no score selected
-            submit_disabled = feedback_score is None
-            
-            submitted = st.form_submit_button(
-                "📤 Submit Feedback", 
-                use_container_width=True,
-                disabled=submit_disabled
-            )
-            
-            if submitted and not st.session_state.feedback_submitted:
-                # Log the feedback data being submitted
-                print("=" * 80)
-                print("🔄 FEEDBACK SUBMISSION: Starting...")
-                print("=" * 80)
-                st.write("🔍 **Debug: Feedback Data Being Submitted:**")
+        # Feedback form - only show if feedback not already submitted
+        if not st.session_state.feedback_submitted:
+            with st.form("feedback_form", clear_on_submit=False):
+                col1, col2 = st.columns([1, 1])
                 
-                # Create feedback data dictionary
-                feedback_dict = {
-                    "open_ended_feedback": open_ended_feedback,
-                    "score": feedback_score,
-                    "is_feedback_about_last_retrieval": is_feedback_about_last_retrieval,
-                    "retrieved_data": st.session_state.rag_retrieval_history.copy() if st.session_state.rag_retrieval_history else [],
-                    "conversation_id": st.session_state.conversation_id,
-                    "timestamp": time.time(),
-                    "message_count": len(st.session_state.messages),
-                    "has_retrievals": has_retrievals,
-                    "retrieval_count": len(st.session_state.rag_retrieval_history)
-                }
+                with col1:
+                    feedback_score = st.slider(
+                        "Rate this conversation (1-5)",
+                        min_value=1,
+                        max_value=5,
+                        help="How satisfied are you with the conversation?"
+                    )
                 
-                print(f"📝 FEEDBACK SUBMISSION: Score={feedback_score}, Retrievals={len(st.session_state.rag_retrieval_history) if st.session_state.rag_retrieval_history else 0}")
+                with col2:
+                    is_feedback_about_last_retrieval = st.checkbox(
+                        "Feedback about last retrieval only",
+                        value=True,
+                        help="If checked, feedback applies to the most recent document retrieval"
+                    )
                 
-                # Create UserFeedback dataclass instance
-                feedback_obj = None  # Initialize outside try block
-                try:
-                    feedback_obj = create_feedback_from_dict(feedback_dict)
-                    print(f"✅ FEEDBACK SUBMISSION: Feedback object created - ID={feedback_obj.feedback_id}")
-                    st.write(f"✅ **Feedback Object Created**")
-                    st.write(f"- Feedback ID: {feedback_obj.feedback_id}")
-                    st.write(f"- Score: {feedback_obj.score}/5")
-                    st.write(f"- Has Retrievals: {feedback_obj.has_retrievals}")
-                    
-                    # Convert back to dict for JSON serialization
-                    feedback_data = feedback_obj.to_dict()
-                except Exception as e:
-                    print(f"❌ FEEDBACK SUBMISSION: Failed to create feedback object: {e}")
-                    st.error(f"Failed to create feedback object: {e}")
-                    feedback_data = feedback_dict
-                
-                # Display the data being submitted
-                st.json(feedback_data)
+                open_ended_feedback = st.text_area(
+                    "Your feedback (optional)",
+                    placeholder="Tell us what went well or what could be improved...",
+                    height=100
+                )
                 
-                # Save feedback to file - use absolute path in /app to ensure writability
-                feedback_dir = Path("/app/feedback")
-                try:
-                    # Ensure directory exists with write permissions (777 for compatibility)
-                    feedback_dir.mkdir(parents=True, mode=0o777, exist_ok=True)
-                except (PermissionError, OSError) as e:
-                    logger.warning(f"Could not create feedback directory at {feedback_dir}: {e}")
-                    # Fallback to relative path
-                    feedback_dir = Path("feedback")
-                    feedback_dir.mkdir(parents=True, mode=0o777, exist_ok=True)
+                # Disable submit if no score selected
+                submit_disabled = feedback_score is None
                 
-                feedback_file = feedback_dir / f"feedback_{st.session_state.conversation_id}_{int(time.time())}.json"
+                submitted = st.form_submit_button(
+                    "📤 Submit Feedback", 
+                    use_container_width=True,
+                    disabled=submit_disabled
+                )
                 
-                try:
-                    # Ensure parent directory exists before writing
-                    feedback_file.parent.mkdir(parents=True, mode=0o777, exist_ok=True)
-                    
-                    # Save to local file
-                    print(f"💾 FEEDBACK SAVE: Saving to local file: {feedback_file}")
-                    with open(feedback_file, 'w') as f:
-                        json.dump(feedback_data, f, indent=2, default=str)
+                if submitted:
+                    # Log the feedback data being submitted
+                    print("=" * 80)
+                    print("🔄 FEEDBACK SUBMISSION: Starting...")
+                    print("=" * 80)
+                    st.write("🔍 **Debug: Feedback Data Being Submitted:**")
                     
-                    print(f"✅ FEEDBACK SAVE: Local file saved successfully")
-                    st.success("✅ Thank you for your feedback! It has been saved locally.")
-                    st.balloons()
+                    # Create feedback data dictionary
+                    feedback_dict = {
+                        "open_ended_feedback": open_ended_feedback,
+                        "score": feedback_score,
+                        "is_feedback_about_last_retrieval": is_feedback_about_last_retrieval,
+                        "retrieved_data": st.session_state.rag_retrieval_history.copy() if st.session_state.rag_retrieval_history else [],
+                        "conversation_id": st.session_state.conversation_id,
+                        "timestamp": time.time(),
+                        "message_count": len(st.session_state.messages),
+                        "has_retrievals": has_retrievals,
+                        "retrieval_count": len(st.session_state.rag_retrieval_history)
+                    }
                     
-                    # Save to Snowflake if enabled and credentials available
-                    logger.info("🔄 FEEDBACK SAVE: Starting Snowflake save process...")
-                    logger.info(f"📊 FEEDBACK SAVE: feedback_obj={'exists' if feedback_obj else 'None'}")
+                    print(f"📝 FEEDBACK SUBMISSION: Score={feedback_score}, Retrievals={len(st.session_state.rag_retrieval_history) if st.session_state.rag_retrieval_history else 0}")
                     
+                    # Create UserFeedback dataclass instance
+                    feedback_obj = None  # Initialize outside try block
                     try:
-                        import os
-                        snowflake_enabled = os.getenv("SNOWFLAKE_ENABLED", "false").lower() == "true"
-                        logger.info(f"🔍 SNOWFLAKE CHECK: enabled={snowflake_enabled}")
+                        feedback_obj = create_feedback_from_dict(feedback_dict)
+                        print(f"✅ FEEDBACK SUBMISSION: Feedback object created - ID={feedback_obj.feedback_id}")
+                        st.write(f"✅ **Feedback Object Created**")
+                        st.write(f"- Feedback ID: {feedback_obj.feedback_id}")
+                        st.write(f"- Score: {feedback_obj.score}/5")
+                        st.write(f"- Has Retrievals: {feedback_obj.has_retrievals}")
                         
-                        if snowflake_enabled:
-                            if feedback_obj:
-                                try:
-                                    from src.reporting.snowflake_connector import save_to_snowflake
-                                    logger.info("📤 SNOWFLAKE UI: Attempting to save feedback to Snowflake...")
-                                    print("📤 SNOWFLAKE UI: Attempting to save feedback to Snowflake...")  # Also print to terminal
-                                    
-                                    if save_to_snowflake(feedback_obj):
-                                        logger.info("✅ SNOWFLAKE UI: Successfully saved to Snowflake")
-                                        print("✅ SNOWFLAKE UI: Successfully saved to Snowflake")  # Also print to terminal
-                                        st.success("✅ Feedback also saved to Snowflake!")
-                                    else:
-                                        logger.warning("⚠️ SNOWFLAKE UI: Save failed")
-                                        print("⚠️ SNOWFLAKE UI: Save failed")  # Also print to terminal
-                                        st.warning("⚠️ Snowflake save failed, but local save succeeded")
-                                except Exception as e:
-                                    logger.error(f"❌ SNOWFLAKE UI ERROR: {e}")
-                                    print(f"❌ SNOWFLAKE UI ERROR: {e}")  # Also print to terminal
-                                    import traceback
-                                    traceback.print_exc()  # Print full traceback to terminal
-                                    st.warning(f"⚠️ Could not save to Snowflake: {e}")
-                            else:
-                                logger.warning("⚠️ SNOWFLAKE UI: Skipping (feedback object not created)")
-                                print("⚠️ SNOWFLAKE UI: Skipping (feedback object not created)")  # Also print to terminal
-                                st.warning("⚠️ Skipping Snowflake save (feedback object not created)")
-                        else:
-                            logger.info("💡 SNOWFLAKE UI: Integration disabled")
-                            print("💡 SNOWFLAKE UI: Integration disabled")  # Also print to terminal
-                            st.info("💡 Snowflake integration disabled (set SNOWFLAKE_ENABLED=true to enable)")
-                    except NameError as e:
-                        import traceback
-                        traceback.print_exc()
-                        logger.error(f"❌ NameError in Snowflake save: {e}")
-                        print(f"❌ NameError in Snowflake save: {e}")  # Also print to terminal
-                        st.warning(f"⚠️ Snowflake save error: {e}")
+                        # Convert back to dict for JSON serialization
+                        feedback_data = feedback_obj.to_dict()
                     except Exception as e:
-                        logger.error(f"❌ Exception in Snowflake save: {type(e).__name__}: {e}")
-                        print(f"❌ Exception in Snowflake save: {type(e).__name__}: {e}")  # Also print to terminal
-                        st.warning(f"⚠️ Snowflake save error: {e}")
+                        print(f"❌ FEEDBACK SUBMISSION: Failed to create feedback object: {e}")
+                        st.error(f"Failed to create feedback object: {e}")
+                        feedback_data = feedback_dict
                     
-                    # Mark feedback as submitted to prevent resubmission
-                    st.session_state.feedback_submitted = True
+                    # Display the data being submitted
+                    st.json(feedback_data)
                     
-                    print("=" * 80)
-                    print(f"✅ FEEDBACK SUBMISSION: Completed successfully")
-                    print("=" * 80)
+                    # Save feedback to file - use PROJECT_DIR to ensure writability
+                    feedback_dir = FEEDBACK_DIR
+                    try:
+                        # Ensure directory exists with write permissions (777 for compatibility)
+                        feedback_dir.mkdir(parents=True, mode=0o777, exist_ok=True)
+                    except (PermissionError, OSError) as e:
+                        logger.warning(f"Could not create feedback directory at {feedback_dir}: {e}")
+                        # Fallback to relative path
+                        feedback_dir = Path("feedback")
+                        feedback_dir.mkdir(parents=True, mode=0o777, exist_ok=True)
                     
-                    # Log file location
-                    st.info(f"📁 Feedback saved to: {feedback_file}")
+                    feedback_file = feedback_dir / f"feedback_{st.session_state.conversation_id}_{int(time.time())}.json"
                     
-                except Exception as e:
-                    print(f"❌ FEEDBACK SUBMISSION: Error saving feedback: {e}")
-                    print(f"❌ FEEDBACK SUBMISSION: Error type: {type(e).__name__}")
-                    import traceback
-                    traceback.print_exc()
-                    st.error(f"❌ Error saving feedback: {e}")
-                    st.write(f"Debug error: {str(e)}")
-            
-            elif st.session_state.feedback_submitted:
-                st.success("✅ Feedback already submitted for this conversation!")
-                if st.button("🔄 Submit New Feedback", key="new_feedback_button"):
-                    st.session_state.feedback_submitted = False
-                    st.rerun()
+                    try:
+                        # Ensure parent directory exists before writing
+                        feedback_file.parent.mkdir(parents=True, mode=0o777, exist_ok=True)
+                        
+                        # Save to local file
+                        print(f"💾 FEEDBACK SAVE: Saving to local file: {feedback_file}")
+                        with open(feedback_file, 'w') as f:
+                            json.dump(feedback_data, f, indent=2, default=str)
+                        
+                        print(f"✅ FEEDBACK SAVE: Local file saved successfully")
+                        st.success("✅ Thank you for your feedback! It has been saved locally.")
+                        st.balloons()
+                        
+                        # Save to Snowflake if enabled and credentials available
+                        logger.info("🔄 FEEDBACK SAVE: Starting Snowflake save process...")
+                        logger.info(f"📊 FEEDBACK SAVE: feedback_obj={'exists' if feedback_obj else 'None'}")
+                        
+                        try:
+                            snowflake_enabled = os.getenv("SNOWFLAKE_ENABLED", "false").lower() == "true"
+                            logger.info(f"🔍 SNOWFLAKE CHECK: enabled={snowflake_enabled}")
+                            
+                            if snowflake_enabled:
+                                if feedback_obj:
+                                    try:
+                                        logger.info("📤 SNOWFLAKE UI: Attempting to save feedback to Snowflake...")
+                                        print("📤 SNOWFLAKE UI: Attempting to save feedback to Snowflake...")
+                                        
+                                        if save_to_snowflake(feedback_obj):
+                                            logger.info("✅ SNOWFLAKE UI: Successfully saved to Snowflake")
+                                            print("✅ SNOWFLAKE UI: Successfully saved to Snowflake")
+                                            st.success("✅ Feedback also saved to Snowflake!")
+                                        else:
+                                            logger.warning("⚠️ SNOWFLAKE UI: Save failed")
+                                            print("⚠️ SNOWFLAKE UI: Save failed")
+                                            st.warning("⚠️ Snowflake save failed, but local save succeeded")
+                                    except Exception as e:
+                                        logger.error(f"❌ SNOWFLAKE UI ERROR: {e}")
+                                        print(f"❌ SNOWFLAKE UI ERROR: {e}")
+                                        traceback.print_exc()
+                                        st.warning(f"⚠️ Could not save to Snowflake: {e}")
+                                else:
+                                    logger.warning("⚠️ SNOWFLAKE UI: Skipping (feedback object not created)")
+                                    print("⚠️ SNOWFLAKE UI: Skipping (feedback object not created)")
+                                    st.warning("⚠️ Skipping Snowflake save (feedback object not created)")
+                            else:
+                                logger.info("💡 SNOWFLAKE UI: Integration disabled")
+                                print("💡 SNOWFLAKE UI: Integration disabled")
+                                st.info("💡 Snowflake integration disabled (set SNOWFLAKE_ENABLED=true to enable)")
+                        except NameError as e:
+                            traceback.print_exc()
+                            logger.error(f"❌ NameError in Snowflake save: {e}")
+                            print(f"❌ NameError in Snowflake save: {e}")
+                            st.warning(f"⚠️ Snowflake save error: {e}")
+                        except Exception as e:
+                            logger.error(f"❌ Exception in Snowflake save: {type(e).__name__}: {e}")
+                            print(f"❌ Exception in Snowflake save: {type(e).__name__}: {e}")
+                            st.warning(f"⚠️ Snowflake save error: {e}")
+                        
+                        # Mark feedback as submitted to prevent resubmission
+                        st.session_state.feedback_submitted = True
+                        
+                        print("=" * 80)
+                        print(f"✅ FEEDBACK SUBMISSION: Completed successfully")
+                        print("=" * 80)
+                        
+                        # Log file location
+                        st.info(f"📁 Feedback saved to: {feedback_file}")
+                        
+                    except Exception as e:
+                        print(f"❌ FEEDBACK SUBMISSION: Error saving feedback: {e}")
+                        print(f"❌ FEEDBACK SUBMISSION: Error type: {type(e).__name__}")
+                        traceback.print_exc()
+                        st.error(f"❌ Error saving feedback: {e}")
+                        st.write(f"Debug error: {str(e)}")
+        else:
+            # Feedback already submitted - show success message and reset option
+            st.success("✅ Feedback already submitted for this conversation!")
+            col1, col2 = st.columns([1, 1])
+            with col1:
+                if st.button("🔄 Submit New Feedback", key="new_feedback_button", use_container_width=True):
+                    try:
+                        st.session_state.feedback_submitted = False
+                        st.rerun()
+                    except Exception as e:
+                        # Handle any Streamlit API exceptions gracefully
+                        logger.error(f"Error resetting feedback state: {e}")
+                        st.error(f"Error resetting feedback. Please refresh the page.")
+            with col2:
+                if st.button("📋 View Conversation", key="view_conversation_button", use_container_width=True):
+                    # Scroll to conversation - this is handled by the auto-scroll at bottom
+                    pass
     
-    # Display retrieval history stats
-    if st.session_state.rag_retrieval_history:
-        st.markdown("---")
-        st.markdown("#### 📊 Retrieval History")
+    # Example Questions Section
+    st.markdown("---")
+    st.markdown(
+        "<h3 class='example-questions-header'>💡 Example Questions</h3>",
+        unsafe_allow_html=True
+    )
+    st.markdown(
+        "<p class='example-questions-description'>Click on any question below to use it, or modify the editable examples:</p>",
+        unsafe_allow_html=True
+    )
+    
+    # Initialize example question state
+    if 'custom_question_1' not in st.session_state:
+        st.session_state.custom_question_1 = "How were administrative costs managed in the PDM implementation, and what issues arose with budget execution regarding staff salaries?"
+    if 'custom_question_2' not in st.session_state:
+        st.session_state.custom_question_2 = "What did the National Coordinator say about the release of funds for PDM administrative costs in the letter dated 29th September 2022 and how did the funding received affect the activities of the PDCs and PDM SACCOs in the FY 2022/23?"
+    
+    # Question 1: Filename insights (fixed, clickable)
+    st.markdown("#### 📄 Question 1: List insights from a specific file")
+    col1, col2 = st.columns([3, 1])
+    with col1:
+        example_q1 = "List couple of insights from the filename."
+        st.markdown(f"**Example:** `{example_q1}`")
+        st.info("💡 **Filter to apply:** Select a Filename from the sidebar panel before asking this question.")
+    with col2:
+        if st.button("📋 Use This Question", key="use_example_1", use_container_width=True):
+            st.session_state.pending_question = example_q1
+            st.session_state.input_counter = (st.session_state.get('input_counter', 0) + 1) % 1000
+            st.rerun()
+    
+    st.markdown("---")
+    
+    # Questions 2 & 3: Editable examples (collapsible, side by side)
+    with st.expander("#### ✏️ Customizable Questions (Edit and use)", expanded=False):
+        # Place questions side by side
+        col1, col2 = st.columns(2)
         
-        with st.expander(f"View {len(st.session_state.rag_retrieval_history)} retrieval entries", expanded=False):
-            for idx, entry in enumerate(st.session_state.rag_retrieval_history, 1):
-                st.markdown(f"**Retrieval #{idx}**")
-                
-                # Display the actual RAG query
-                rag_query_expansion = entry.get("rag_query_expansion", "No query available")
-                st.code(rag_query_expansion, language="text")
-                
-                # Display summary stats
-                st.json({
-                    "conversation_length": len(entry.get("conversation_up_to", [])),
-                    "documents_retrieved": len(entry.get("docs_retrieved", []))
-                })
-                st.markdown("---")
+        # Question 2
+        with col1:
+            st.markdown("**Question 2:**")
+            custom_q1 = st.text_area(
+                "Edit question 2:",
+                value=st.session_state.custom_question_1,
+                height=100,
+                key="edit_question_2",
+                help="Modify this question to fit your needs, then click 'Use This Question'",
+                label_visibility="collapsed"
+            )
+            if st.button("📋 Use Question 2", key="use_custom_1", use_container_width=True):
+                if custom_q1.strip():
+                    st.session_state.pending_question = custom_q1.strip()
+                    st.session_state.custom_question_1 = custom_q1.strip()
+                    st.session_state.input_counter = (st.session_state.get('input_counter', 0) + 1) % 1000
+                    st.rerun()
+                else:
+                    st.warning("Please enter a question first!")
+            st.caption("💡 Tip: Add specific details like dates, names, or amounts to get more precise answers")
+            st.info("💡 **Filter to apply:** Select District(s) and Year(s) from sidebar panel")
+        
+        # Question 3
+        with col2:
+            st.markdown("**Question 3:**")
+            custom_q2 = st.text_area(
+                "Edit question 3:",
+                value=st.session_state.custom_question_2,
+                height=100,
+                key="edit_question_3",
+                help="Modify this question to fit your needs, then click 'Use This Question'",
+                label_visibility="collapsed"
+            )
+            if st.button("📋 Use Question 3", key="use_custom_2", use_container_width=True):
+                if custom_q2.strip():
+                    st.session_state.pending_question = custom_q2.strip()
+                    st.session_state.custom_question_2 = custom_q2.strip()
+                    st.session_state.input_counter = (st.session_state.get('input_counter', 0) + 1) % 1000
+                    st.rerun()
+                else:
+                    st.warning("Please enter a question first!")
+            st.caption("💡 Tip: Use specific terms from the documents (e.g., 'PDM', 'SACCOs', 'FY 2022/23')")
+    
+
+    # Store selected question for next render (handled in input section above)
+    # This ensures the question populates the input field correctly
     
     # Auto-scroll to bottom
     st.markdown("""

multi_agent_chatbot.py

@@ -8,24 +8,26 @@ This system implements a 3-agent architecture:
 
 Each agent has specialized prompts and responsibilities.
 """
+import re
 import json
 import time
 import logging
+import traceback
 from pathlib import Path
 from datetime import datetime
 from dataclasses import dataclass
 from typing import Dict, List, Any, Optional, TypedDict
 
-
 from langchain_core.tools import tool
 from langgraph.graph import StateGraph, END
-from langchain_core.messages import HumanMessage, AIMessage, SystemMessage
 from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.messages import HumanMessage, AIMessage, SystemMessage
 
 
 from src.pipeline import PipelineManager
-from src.config.loader import load_config
 from src.llm.adapters import get_llm_client
+from src.config.paths import PROJECT_DIR, CONVERSATIONS_DIR
+from src.config.loader import load_config, get_embedding_model_for_collection
 
 
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
@@ -46,6 +48,7 @@ class QueryContext:
     needs_follow_up: bool = False
     follow_up_question: Optional[str] = None
 
+
 class MultiAgentState(TypedDict):
     """State for the multi-agent conversation flow"""
     conversation_id: str
@@ -61,6 +64,7 @@ class MultiAgentState(TypedDict):
     session_start_time: float
     last_ai_message_time: float
 
+
 class MultiAgentRAGChatbot:
     """Multi-agent RAG chatbot with specialized agents"""
     
@@ -112,7 +116,6 @@ class MultiAgentRAGChatbot:
             logger.info("✅ Pipeline manager initialized and models loaded")
         except Exception as e:
             logger.error(f"❌ Failed to initialize pipeline manager: {e}")
-            import traceback
             traceback.print_exc()
             raise RuntimeError(f"Pipeline manager initialization failed: {e}")
         
@@ -129,7 +132,6 @@ class MultiAgentRAGChatbot:
             raise  # Re-raise RuntimeError as-is
         except Exception as e:
             logger.error(f"❌ Error during vector store connection: {e}")
-            import traceback
             traceback.print_exc()
             raise RuntimeError(f"Vector store connection failed: {e}")
         
@@ -139,8 +141,8 @@ class MultiAgentRAGChatbot:
         # Build the multi-agent graph
         self.graph = self._build_graph()
         
-        # Conversations directory - use absolute path in /app to ensure writability
-        self.conversations_dir = Path("/app/conversations")
+        # Conversations directory - use PROJECT_DIR for local vs deployed compatibility
+        self.conversations_dir = CONVERSATIONS_DIR
         try:
             # Use 777 permissions for maximum compatibility (HF Spaces runs as different user)
             self.conversations_dir.mkdir(parents=True, mode=0o777, exist_ok=True)
@@ -158,9 +160,9 @@ class MultiAgentRAGChatbot:
     
     def _load_dynamic_data(self):
         """Load dynamic data from filter_options.json and add_district_metadata.py"""
-        # Load filter options
+        # Load filter options - use PROJECT_DIR relative path
         try:
-            fo = Path("src/config/filter_options.json")
+            fo = PROJECT_DIR / "src" / "config" / "filter_options.json"
             if fo.exists():
                 with open(fo) as f:
                     data = json.load(f)
@@ -178,7 +180,7 @@ class MultiAgentRAGChatbot:
             self.source_whitelist = ['Consolidated', 'Local Government', 'Ministry, Department and Agency']
             self.district_whitelist = ['Kampala', 'Gulu', 'Kalangala']
         
-        # Enrich district list from add_district_metadata.py
+        # Enrich district list from add_district_metadata.py (if available)
         try:
             from add_district_metadata import DistrictMetadataProcessor
             proc = DistrictMetadataProcessor()
@@ -590,7 +592,6 @@ Analyze this query using ONLY the exact values provided above:""")
             # Clean and parse JSON with better error handling
             try:
                 # Remove comments (// and /* */) from JSON
-                import re
                 # Remove single-line comments
                 content = re.sub(r'//.*?$', '', content, flags=re.MULTILINE)
                 # Remove multi-line comments
@@ -603,7 +604,6 @@ Analyze this query using ONLY the exact values provided above:""")
                 logger.error(f"❌ Raw content: {content[:200]}...")
                 
                 # Try to extract JSON from text if embedded
-                import re
                 json_match = re.search(r'\{.*\}', content, re.DOTALL)
                 if json_match:
                     try:
@@ -1178,7 +1178,6 @@ Generate a conversational response based on your knowledge:""")
                 
         except Exception as e:
             logger.error(f"Could not save conversation: {e}")
-            import traceback
             logger.error(f"Traceback: {traceback.format_exc()}")
     
 

smart_chatbot.py

@@ -26,6 +26,7 @@ from langchain_core.messages import HumanMessage, AIMessage, SystemMessage
 
 from src.pipeline import PipelineManager
 from src.config.loader import load_config
+from src.config.paths import PROJECT_DIR
 
 
 @dataclass
@@ -161,7 +162,7 @@ class IntelligentRAGChatbot:
 
         # Try to load district whitelist from filter_options.json
         try:
-            fo = Path("filter_options.json")
+            fo = PROJECT_DIR / "src" / "config" / "filter_options.json"
             if fo.exists():
                 with open(fo) as f:
                     data = json.load(f)
@@ -174,7 +175,7 @@ class IntelligentRAGChatbot:
         except Exception:
             self.district_whitelist = self.available_metadata['districts']
 
-        # Enrich whitelist from add_district_metadata.py if available
+        # Enrich whitelist from add_district_metadata.py if available (optional module)
         try:
             from add_district_metadata import DistrictMetadataProcessor
             proc = DistrictMetadataProcessor()
@@ -195,7 +196,7 @@ class IntelligentRAGChatbot:
         
         # Get dynamic year list from filter_options.json
         try:
-            fo = Path("filter_options.json")
+            fo = PROJECT_DIR / "src" / "config" / "filter_options.json"
             if fo.exists():
                 with open(fo) as f:
                     data = json.load(f)

src/config/paths.py

@@ -0,0 +1,59 @@
+"""
+Path configuration for local vs deployed environments.
+
+This module handles different paths for local development vs deployed (HF Spaces) environments.
+"""
+import os
+from pathlib import Path
+
+# Determine if we're in a deployed environment (HF Spaces/Docker) or local
+# Check for environment variable or Docker-like paths
+IS_DEPLOYED = (
+    os.getenv("DEPLOYED", "false").lower() == "true" or
+    os.path.exists("/app") or
+    os.getenv("SPACES_ID") is not None or
+    os.path.exists("/.dockerenv")
+)
+
+# PROJECT_DIR: Base directory for application files
+# In deployed: /app, in local: current working directory or project root
+if IS_DEPLOYED:
+    PROJECT_DIR = Path("/app")
+else:
+    # For local development, use current working directory or find project root
+    cwd = Path.cwd()
+    # Try to find project root (directory containing this src/ folder)
+    project_root = cwd
+    while project_root != project_root.parent:
+        if (project_root / "src" / "config").exists():
+            break
+        project_root = project_root.parent
+    PROJECT_DIR = project_root
+
+# Cache directories - different for local vs deployed
+# Local: Use default user cache locations (don't override)
+# Deployed: Use PROJECT_DIR/.cache
+if IS_DEPLOYED:
+    CACHE_DIR = PROJECT_DIR / ".cache"
+    HF_CACHE_DIR = CACHE_DIR / "huggingface"
+    STREAMLIT_CACHE_DIR = CACHE_DIR / "streamlit"
+else:
+    # For local, use default user cache (let libraries use their defaults)
+    HF_CACHE_DIR = None  # Will use HF defaults (~/.cache/huggingface)
+    STREAMLIT_CACHE_DIR = None  # Will use Streamlit defaults
+
+# Application directories
+FEEDBACK_DIR = PROJECT_DIR / "feedback"
+CONVERSATIONS_DIR = PROJECT_DIR / "conversations"
+STREAMLIT_CONFIG_DIR = PROJECT_DIR / ".streamlit"
+
+# Log the configuration
+if __name__ == "__main__":
+    print(f"IS_DEPLOYED: {IS_DEPLOYED}")
+    print(f"PROJECT_DIR: {PROJECT_DIR}")
+    print(f"HF_CACHE_DIR: {HF_CACHE_DIR}")
+    print(f"FEEDBACK_DIR: {FEEDBACK_DIR}")
+    print(f"CONVERSATIONS_DIR: {CONVERSATIONS_DIR}")
+
+
+

src/pipeline.py

@@ -1,5 +1,7 @@
 """Main pipeline orchestrator for the Audit QA system."""
+import os
 import time
+import traceback
 from pathlib import Path
 from dataclasses import dataclass
 from typing import Dict, Any, List, Optional
@@ -11,11 +13,21 @@ except ModuleNotFoundError as me:
     from langchain.schema import Document
 
 from .logging import log_error
-from .llm.adapters import LLMRegistry
+
 from .loader import chunks_to_documents
 from .vectorstore import VectorStoreManager
+from .reporting.service import ReportService
 from .retrieval.context import ContextRetriever
-from .config.loader import get_embedding_model_for_collection
+from .llm.adapters import LLMRegistry, get_llm_client
+from .llm.templates import DEFAULT_AUDIT_SYSTEM_PROMPT
+from .config.loader import load_config, get_embedding_model_for_collection
+from .retrieval.filter import get_available_metadata, infer_filters_from_query
+
+try:
+    from langchain_openai import ChatOpenAI
+    LANGCHAIN_OPENAI_AVAILABLE = True
+except ImportError:
+    LANGCHAIN_OPENAI_AVAILABLE = False
 
 
 
@@ -41,12 +53,13 @@ class PipelineManager:
         """
         Initialize the pipeline manager.
         """
+        self.chunks = None
+        self.llm_client = None
         self.config = config or {}
+        self.report_service = None
         self.vectorstore_manager = None
         self.context_retriever = None  # Initialize as None
-        self.llm_client = None
-        self.report_service = None
-        self.chunks = None
+    
         
         # Initialize components
         self._initialize_components()
@@ -118,13 +131,7 @@ class PipelineManager:
         try:
             # Load config if not provided
             if not self.config:
-                try:
-                    from src.config.loader import load_config
-                    self.config = load_config()
-                except ImportError:
-                    # Try alternate import path
-                    from src.config.loader import load_config
-                    self.config = load_config()
+                self.config = load_config()
             
             # Validate config structure
             if not isinstance(self.config, dict):
@@ -159,7 +166,6 @@ class PipelineManager:
                 print("✅ VectorStoreManager initialized successfully")
             except Exception as vs_error:
                 print(f"❌ Error initializing VectorStoreManager: {vs_error}")
-                import traceback
                 traceback.print_exc()
                 self.vectorstore_manager = None
                 raise  # Re-raise to be caught by outer try-except
@@ -175,40 +181,35 @@ class PipelineManager:
             except Exception as e:
                 try:
                     # Try direct instantiation with config
-                    from src.llm.adapters import get_llm_client
                     self.llm_client = get_llm_client("openai", self.config)
                     print("✅ LLM CLIENT: Initialized using direct get_llm_client function with config")
                 except Exception as e2:
                     print(f"❌ LLM CLIENT: Registry methods failed - {e2}")
                     # Try to create a simple LLM client directly
                     try:
-                        from langchain_openai import ChatOpenAI
-                        import os
-                        api_key = os.getenv("OPENAI_API_KEY") or os.getenv("OPENROUTER_API_KEY")
-                        if api_key:
-                            self.llm_client = ChatOpenAI(
-                                model="gpt-3.5-turbo",
-                                api_key=api_key,
-                                temperature=0.1,
-                                max_tokens=1000
-                            )
-                            print("✅ LLM CLIENT: Initialized using direct ChatOpenAI")
+                        if LANGCHAIN_OPENAI_AVAILABLE:
+                            api_key = os.getenv("OPENAI_API_KEY") or os.getenv("OPENROUTER_API_KEY")
+                            if api_key:
+                                self.llm_client = ChatOpenAI(
+                                    model="gpt-3.5-turbo",
+                                    api_key=api_key,
+                                    temperature=0.1,
+                                    max_tokens=1000
+                                )
+                                print("✅ LLM CLIENT: Initialized using direct ChatOpenAI")
+                            else:
+                                print("❌ LLM CLIENT: No API key available")
                         else:
-                            print("❌ LLM CLIENT: No API key available")
+                            print("❌ LLM CLIENT: langchain-openai not available")
                     except Exception as e3:
                         print(f"❌ LLM CLIENT: Direct instantiation also failed - {e3}")
                         self.llm_client = None
             
             # Load system prompt
-            from src.llm.templates import DEFAULT_AUDIT_SYSTEM_PROMPT
             self.system_prompt = DEFAULT_AUDIT_SYSTEM_PROMPT
             
             # Initialize report service
             try:
-                try:
-                    from src.reporting.service import ReportService
-                except ImportError:
-                    from src.reporting.service import ReportService
                 self.report_service = ReportService()
             except Exception as e:
                 print(f"Warning: Could not initialize report service: {e}")
@@ -216,7 +217,6 @@ class PipelineManager:
             
         except Exception as e:
             print(f"❌ Error initializing components: {e}")
-            import traceback
             traceback.print_exc()
             # Don't set vectorstore_manager to None if it was already set
             if not hasattr(self, 'vectorstore_manager') or self.vectorstore_manager is None:
@@ -337,7 +337,6 @@ class PipelineManager:
                     return False
             except Exception as init_error:
                 print(f"❌ Error initializing vector store manager: {init_error}")
-                import traceback
                 traceback.print_exc()
                 return False
         
@@ -352,7 +351,6 @@ class PipelineManager:
         except Exception as e:
             print(f"❌ Error connecting to vector store: {e}")
             log_error(e, {"component": "vectorstore_connection"})
-            import traceback
             traceback.print_exc()
             
             # If it's a dimension mismatch error, try with force_recreate
@@ -541,9 +539,6 @@ Answer:"""
             if auto_infer_filters and not any([reports, sources, subtype]):
                 print(f"🤖 AUTO-INFERRING FILTERS: No explicit filters provided, analyzing query...")
                 try:
-                    # Import get_available_metadata here to avoid circular imports
-                    from src.retrieval.filter import get_available_metadata, infer_filters_from_query
-                    
                     # Get available metadata
                     available_metadata = get_available_metadata(self.vectorstore_manager.get_vectorstore())