Update app.pyo

app.pyo

@@ -7,126 +7,270 @@ import hashlib
 import json
 
 # ===============================
-# HUGGING FACE API KEY HANDLING
+# SUPABASE CACHE CLASS - FIXED VERSION
 # ===============================
-# Try to get API key from Hugging Face secrets first
-try:
-    # For Hugging Face Spaces
-    from huggingface_hub import HfFolder
-    api_key = HfFolder.get_token()
-    if not api_key:
-        # Try environment variable
-        api_key = os.environ.get("DEEPSEEK_API_KEY", "")
-except ImportError:
-    # huggingface_hub not installed
-    api_key = os.environ.get("DEEPSEEK_API_KEY", "")
-except:
-    # Any other error
-    api_key = os.environ.get("DEEPSEEK_API_KEY", "")
-
-# ===============================
-# HUGGING FACE COMPATIBLE CACHE CLASS
-# ===============================
-class HybridCache:
-    def __init__(self, ttl_hours=24, max_entries=100):
+class SupabaseCache:
+    def __init__(self, ttl_days=7):
         """
-        In-memory only cache for Hugging Face Spaces
-        - No file system access needed
-        - Works within session only
+        Supabase-based cache for multi-user, persistent storage
         """
-        self.ttl_hours = ttl_hours
-        self.max_entries = max_entries
-        self.cache = {}  # Simple dictionary for in-memory storage
+        self.ttl_days = ttl_days
+        
+        # Get Supabase credentials from environment
+        self.supabase_url = os.environ.get("SUPABASE_URL", "")
+        self.supabase_key = os.environ.get("SUPABASE_KEY", "")
+        
+        # Initialize Supabase client
+        self.supabase = None
+        self._init_supabase()
+        
+        # In-memory fallback cache
+        self.memory_cache = {}
+        self.max_memory_entries = 100
         
+    def _init_supabase(self):
+        """Initialize Supabase client"""
+        if self.supabase_url and self.supabase_key:
+            try:
+                from supabase import create_client
+                self.supabase = create_client(self.supabase_url, self.supabase_key)
+                # Test connection
+                self.supabase.table("seba_cache").select("count", count="exact").limit(1).execute()
+            except ImportError:
+                # supabase-py not installed
+                self.supabase = None
+            except Exception as e:
+                # Connection failed
+                print(f"Supabase connection error: {e}")
+                self.supabase = None
+        else:
+            self.supabase = None
+    
     def get(self, cache_key):
-        """Get cached answer if not expired"""
-        if cache_key in self.cache:
-            entry = self.cache[cache_key]
-            created_at = entry.get('created_at')
-            
-            if isinstance(created_at, str):
-                created_at = datetime.fromisoformat(created_at)
-            
-            # Check TTL (in hours for Hugging Face)
-            if created_at and (datetime.now() - created_at).seconds < (self.ttl_hours * 3600):
-                # Update access time
-                entry['last_accessed'] = datetime.now().isoformat()
+        """Get cached answer - try Supabase first, then memory"""
+        # First check memory cache (fastest)
+        if cache_key in self.memory_cache:
+            entry = self.memory_cache[cache_key]
+            if self._is_valid(entry):
                 entry['access_count'] = entry.get('access_count', 0) + 1
+                entry['last_accessed'] = datetime.now().isoformat()
                 return entry
-            else:
-                # Remove expired entry
-                del self.cache[cache_key]
+        
+        # Try Supabase if available - FIXED: Removed TTL filter from query
+        if self.supabase:
+            try:
+                # Get entry without TTL filter - we'll check TTL in Python
+                response = self.supabase.table("seba_cache") \
+                    .select("*") \
+                    .eq("key_hash", cache_key) \
+                    .execute()
+                
+                if response.data and len(response.data) > 0:
+                    entry = response.data[0]
+                    
+                    # Check if entry is expired
+                    created_at_str = entry.get('created_at')
+                    is_expired = False
+                    
+                    if created_at_str:
+                        try:
+                            # Parse the timestamp
+                            if 'Z' in created_at_str:
+                                created_at = datetime.fromisoformat(created_at_str.replace('Z', '+00:00'))
+                            else:
+                                created_at = datetime.fromisoformat(created_at_str)
+                            
+                            # Check TTL
+                            if (datetime.now() - created_at).days >= self.ttl_days:
+                                # Entry expired, delete it
+                                is_expired = True
+                                try:
+                                    self.supabase.table("seba_cache") \
+                                        .delete() \
+                                        .eq("key_hash", cache_key) \
+                                        .execute()
+                                except:
+                                    pass
+                        except Exception:
+                            # If we can't parse date, assume not expired
+                            pass
+                    
+                    if not is_expired:
+                        # Convert to standard format
+                        cached_data = {
+                            'answer': entry['answer'],
+                            'tokens': entry.get('tokens', 0),
+                            'subject': entry.get('subject', ''),
+                            'chapter': entry.get('chapter', ''),
+                            'question': entry.get('question', ''),
+                            'access_count': entry.get('access_count', 0) + 1,
+                            'created_at': entry.get('created_at'),
+                            'last_accessed': datetime.now().isoformat()
+                        }
+                        
+                        # Update access count in Supabase
+                        try:
+                            self.supabase.table("seba_cache") \
+                                .update({
+                                    "last_accessed": datetime.now().isoformat(),
+                                    "access_count": entry.get('access_count', 0) + 1
+                                }) \
+                                .eq("key_hash", cache_key) \
+                                .execute()
+                        except:
+                            pass
+                        
+                        # Store in memory cache for faster access
+                        self.memory_cache[cache_key] = cached_data
+                        
+                        # Limit memory cache size
+                        if len(self.memory_cache) > self.max_memory_entries:
+                            oldest_key = min(self.memory_cache.keys(), 
+                                            key=lambda k: self.memory_cache[k].get('last_accessed', ''))
+                            del self.memory_cache[oldest_key]
+                        
+                        return cached_data
+            except Exception as e:
+                # Silently fail - fall back to memory cache
+                print(f"Supabase get error: {e}")
+                pass
         
         return None
     
     def set(self, cache_key, data):
-        """Add or update cache entry"""
-        data['created_at'] = datetime.now().isoformat()
-        data['last_accessed'] = data['created_at']
-        data['access_count'] = 1
+        """Store answer in both Supabase and memory cache"""
+        # Prepare data
+        cache_data = {
+            'answer': data['answer'],
+            'tokens': data.get('tokens', 0),
+            'subject': data.get('subject', ''),
+            'chapter': data.get('chapter', ''),
+            'question': data.get('question', '')[:200],
+            'access_count': 1,
+            'created_at': datetime.now().isoformat(),
+            'last_accessed': datetime.now().isoformat()
+        }
         
-        self.cache[cache_key] = data
+        # Store in memory cache
+        self.memory_cache[cache_key] = cache_data
         
-        # Enforce max entries limit
-        if len(self.cache) > self.max_entries:
-            # Remove oldest entries (by access time)
-            sorted_keys = sorted(
-                self.cache.keys(),
-                key=lambda k: self.cache[k].get('last_accessed', ''),
-                reverse=True
-            )
-            for key in sorted_keys[self.max_entries:]:
-                del self.cache[key]
+        # Limit memory cache size
+        if len(self.memory_cache) > self.max_memory_entries:
+            oldest_key = min(self.memory_cache.keys(), 
+                            key=lambda k: self.memory_cache[k].get('last_accessed', ''))
+            del self.memory_cache[oldest_key]
+        
+        # Store in Supabase if available
+        if self.supabase:
+            try:
+                self.supabase.table("seba_cache").upsert({
+                    "key_hash": cache_key,
+                    "question": cache_data['question'],
+                    "answer": cache_data['answer'],
+                    "subject": cache_data['subject'],
+                    "chapter": cache_data['chapter'],
+                    "tokens": cache_data['tokens'],
+                    "created_at": cache_data['created_at'],
+                    "last_accessed": cache_data['last_accessed'],
+                    "access_count": cache_data['access_count']
+                }).execute()
+            except Exception as e:
+                # Silently fail - at least we have memory cache
+                print(f"Supabase set error: {e}")
+                pass
+    
+    def _is_valid(self, entry):
+        """Check if cache entry is not expired"""
+        created_at = entry.get('created_at')
+        if isinstance(created_at, str):
+            try:
+                if 'Z' in created_at:
+                    created_at = datetime.fromisoformat(created_at.replace('Z', '+00:00'))
+                else:
+                    created_at = datetime.fromisoformat(created_at)
+            except:
+                return True  # If we can't parse, assume valid
+        
+        if created_at and (datetime.now() - created_at).days < self.ttl_days:
+            return True
+        return False
     
     def clear_expired(self):
-        """Manually clear expired entries"""
-        current_time = datetime.now()
+        """Clear expired entries from memory cache"""
         expired_keys = []
-        
-        for key, entry in self.cache.items():
-            created_at = entry.get('created_at')
-            if isinstance(created_at, str):
-                created_at = datetime.fromisoformat(created_at)
-            
-            if created_at and (current_time - created_at).seconds >= (self.ttl_hours * 3600):
+        for key, entry in self.memory_cache.items():
+            if not self._is_valid(entry):
                 expired_keys.append(key)
         
         for key in expired_keys:
-            del self.cache[key]
+            del self.memory_cache[key]
         
         return len(expired_keys)
     
     def clear_all(self):
         """Clear all cache entries"""
-        self.cache = {}
+        self.memory_cache = {}
+        
+        # Also clear Supabase cache if available
+        if self.supabase:
+            try:
+                # Delete entries older than 1 day (safer than deleting all)
+                self.supabase.table("seba_cache") \
+                    .delete() \
+                    .lt("created_at", f"now() - interval '1 day'") \
+                    .execute()
+            except:
+                pass
     
     def get_stats(self):
         """Get cache statistics"""
-        total_saved_tokens = sum(entry.get('tokens', 0) for entry in self.cache.values())
-        total_access_count = sum(entry.get('access_count', 0) for entry in self.cache.values())
-        avg_age_hours = 0
+        # Memory cache stats
+        memory_entries = len(self.memory_cache)
+        memory_tokens = sum(entry.get('tokens', 0) for entry in self.memory_cache.values())
         
-        if self.cache:
-            current_time = datetime.now()
-            ages = []
-            for entry in self.cache.values():
-                created_at = entry.get('created_at')
-                if isinstance(created_at, str):
-                    created_at = datetime.fromisoformat(created_at)
-                if created_at:
-                    ages.append((current_time - created_at).seconds / 3600)  # in hours
-            avg_age_hours = sum(ages) / len(ages) if ages else 0
+        # Try to get Supabase stats
+        supabase_entries = 0
+        supabase_tokens = 0
+        
+        if self.supabase:
+            try:
+                # Get count from Supabase
+                response = self.supabase.table("seba_cache") \
+                    .select("count", count="exact") \
+                    .execute()
+                
+                supabase_entries = response.count or 0
+                
+                # Get total tokens (might be heavy, so approximate)
+                if supabase_entries > 0:
+                    response = self.supabase.table("seba_cache") \
+                        .select("tokens") \
+                        .limit(100) \
+                        .execute()
+                    
+                    supabase_tokens = sum(entry.get('tokens', 0) for entry in response.data)
+            except:
+                pass
+        
+        total_entries = memory_entries + supabase_entries
+        total_tokens = memory_tokens + supabase_tokens
         
         return {
-            'total_entries': len(self.cache),
-            'total_saved_tokens': total_saved_tokens,
-            'total_access_count': total_access_count,
-            'average_age_hours': round(avg_age_hours, 1),
-            'ttl_hours': self.ttl_hours,
-            'max_entries': self.max_entries,
-            'storage_mode': 'In-Memory (Hugging Face)'
+            'total_entries': total_entries,
+            'memory_entries': memory_entries,
+            'supabase_entries': supabase_entries,
+            'total_saved_tokens': total_tokens,
+            'ttl_days': self.ttl_days,
+            'storage_mode': 'Supabase + Memory' if self.supabase else 'Memory Only',
+            'supabase_connected': self.supabase is not None
         }
 
+# ===============================
+# API KEY HANDLING
+# ===============================
+# Get API key from environment variable
+api_key = os.environ.get("DEEPSEEK_API_KEY", "")
+
 # Page config - must be first Streamlit command
 st.set_page_config(
     page_title="SEBA দশম শ্ৰেণীৰ AI টিউটাৰ",
@@ -470,16 +614,16 @@ SEBA_CURRICULUM = {
         "পাঠ ১০": "সাহিত্যৰ ৰূপ"
     },
     "📘 হিন্দী (Hindi)": {
-        "पाठ १": "साखी",
-        "पाठ २": "पद",
-        "पाठ ३": "दोहे",
-        "पाठ ४": "मनुष्यता",
-        "पाठ ५": "पर्वत प्रदेश में पावस",
-        "पाठ ६": "मधुर-मधुर मेरे दीपक जल",
-        "पाठ ७": "तोप",
-        "पाठ ८": "कर चले हम फ़िदा",
-        "पाठ ९": "आत्मत्राण",
-        "पाठ १०": "बड़े भाई साहब"
+        "পাঠ ১": "साखी",
+        "পাঠ ২": "पद",
+        "পাঠ ৩": "दोहे",
+        "পাঠ ৪": "मनुष्यता",
+        "পাঠ ৫": "पर्वत प्रदेश में पावस",
+        "পাঠ ৬": "मधुर-मधुर मेरे दीपक जल",
+        "পাঠ ৭": "तोप",
+        "পাঠ ৮": "कर चले हम फ़िदा",
+        "পাঠ ৯": "आत्मत्राण",
+        "পাঠ ১০": "बड़े भाई साहब"
     }
 }
 
@@ -514,7 +658,7 @@ SUBJECT_PROMPTS = {
         "base_prompt": """তুমি এজন বিজ্ঞান শিক্ষক। SEBA দশম শ্ৰেণীৰ বিজ্ঞানৰ {chapter_name} অধ্যায়ৰ সকলো বৈজ্ঞানিক ধাৰণা, প্ৰক্ৰয়া, আৰু নীতি তুমি জানা।
 
 **বিজ্ঞানৰ বিশেষ নিৰ্দেশনা:**
-১. **বৈজ্ঞানিক প্ৰক্ৰিয়া ধাপে ধাপে বুজাবা**
+১. **বৈজ্ঞানিক প্ৰক্ৰয়া ধাপে ধাপে বুজাবা**
 ২. **ৰাসায়নিক সমীকৰণ সঠিকভাৱে দিবা**
 ৩. **জীৱবিজ্ঞানৰ চিত্ৰ/ৰেখাচিত্ৰৰ বৰ্ণনা দিবা**
 ৪. **পদাৰ্থবিজ্ঞানৰ সূত্ৰ LaTeX ফৰ্মেটত দিবা**
@@ -573,18 +717,28 @@ $F = ma$, $v = u + at$
 }
 
 # ===============================
-# HELPER FUNCTIONS
+# HELPER FUNCTIONS - FIXED CACHE KEY
 # ===============================
 def create_cache_key(question, subject, chapter_name):
     """Create a unique cache key for the question"""
-    # Normalize the question for better caching
+    # Normalize the question more aggressively for better cache matching
     normalized_question = question.strip().lower()
-    # Remove extra whitespace and special characters
+    
+    # Remove extra whitespace
     normalized_question = re.sub(r'\s+', ' ', normalized_question)
-    normalized_question = normalized_question[:200]  # Limit length
     
-    # Create a hash-based key for better performance
-    key_string = f"{subject}|{chapter_name}|{normalized_question}"
+    # Remove punctuation that might vary
+    normalized_question = re.sub(r'[^\w\s\u0980-\u09FF]', '', normalized_question)
+    
+    normalized_question = normalized_question[:200]
+    
+    # Normalize subject and chapter
+    # Take only the main subject name (before parentheses)
+    normalized_subject = subject.split('(')[0].strip() if '(' in subject else subject
+    # Take only chapter number/name before colon
+    normalized_chapter = chapter_name.split(':')[0].strip() if ':' in chapter_name else chapter_name
+    
+    key_string = f"{normalized_subject}|{normalized_chapter}|{normalized_question}"
     cache_key = hashlib.md5(key_string.encode()).hexdigest()
     
     return cache_key
@@ -706,7 +860,6 @@ def stream_deepseek_response(prompt, question, subject, chapter_name):
                             break
                         
                         try:
-                            import json
                             chunk = json.loads(data)
                             if 'choices' in chunk and len(chunk['choices']) > 0:
                                 delta = chunk['choices'][0].get('delta', {})
@@ -714,7 +867,7 @@ def stream_deepseek_response(prompt, question, subject, chapter_name):
                                     content = delta['content']
                                     full_response += content
                                     
-                                    # Update streaming display - Streamlit will auto-render LaTeX
+                                    # Update streaming display
                                     streaming_placeholder.markdown(
                                         f"{full_response}<span style='animation: cursor-blink 1s infinite;'>▋</span>",
                                         unsafe_allow_html=True
@@ -729,7 +882,7 @@ def stream_deepseek_response(prompt, question, subject, chapter_name):
             # Clear streaming cursor after completion
             streaming_placeholder.empty()
             
-            # Render the final answer - Streamlit will handle LaTeX automatically
+            # Render the final answer
             st.markdown(full_response)
             
             # Store the complete response
@@ -753,7 +906,7 @@ def stream_deepseek_response(prompt, question, subject, chapter_name):
                 'question': question[:100],
                 'timestamp': datetime.now().strftime("%H:%M"),
                 'tokens': tokens_used,
-                'cached': False  # Not cached (new response)
+                'cached': False
             }
             st.session_state.history.append(history_entry)
             
@@ -764,7 +917,7 @@ def stream_deepseek_response(prompt, question, subject, chapter_name):
         st.error(f"সংযোগ ত্ৰুটি: {str(e)}")
 
 # ===============================
-# INITIALIZE SESSION STATE
+# INITIALIZE SESSION STATE - FIXED
 # ===============================
 if 'history' not in st.session_state:
     st.session_state.history = []
@@ -783,13 +936,20 @@ if 'streaming_answer' not in st.session_state:
 if 'tokens_used' not in st.session_state:
     st.session_state.tokens_used = 0
 if 'cache_manager' not in st.session_state:
-    st.session_state.cache_manager = HybridCache(ttl_hours=24, max_entries=100)
+    st.session_state.cache_manager = SupabaseCache(ttl_days=7)
+    # Pre-warm cache by checking Supabase connection on startup
+    cache_stats = st.session_state.cache_manager.get_stats()
+    if cache_stats['supabase_connected'] and cache_stats['supabase_entries'] > 0:
+        st.toast(f"📦 Cache loaded: {cache_stats['supabase_entries']} entries available", icon="✅")
+
 if 'show_cached_answer' not in st.session_state:
     st.session_state.show_cached_answer = False
 if 'cached_answer_data' not in st.session_state:
     st.session_state.cached_answer_data = None
 if 'current_cache_key' not in st.session_state:
     st.session_state.current_cache_key = None
+if 'cache_debug' not in st.session_state:
+    st.session_state.cache_debug = False
 
 # ===============================
 # HEADER SECTION
@@ -874,9 +1034,8 @@ st.info(f"""
 """)
 
 # ===============================
-# SAMPLE QUESTIONS SECTION (SKIPPED - ADD FROM YOUR SIDE)
+# SAMPLE QUESTIONS SECTION
 # ===============================
-# Sample questions
 SAMPLE_QUESTIONS = {
     "📐 গণিত (Mathematics)": {
         "অধ্যায় ১": [
@@ -1126,7 +1285,7 @@ SAMPLE_QUESTIONS = {
         "অধ্যায় ৮": [
             "ভাৰতৰ ৰাজনৈতিক দলসমূহৰ শ্ৰেণীবিভাজন কৰক।",
             "ৰাষ্ট্ৰীয় দল আৰু ৰাজ্যিক দলৰ মাজৰ পাৰ্থক্য লিখক。",
-            "ভাৰতত বহুদলীয় গণতন্ত্ৰৰ গুৰুত্ব লিখক。",
+            "ভাৰতত বহুদলীয় গণতন্ত্ৰৰ গুৰুত্ব লিখক।",
             "ৰাজনৈতিক দলৰ কাৰ্যবোৰ লিখক।",
             "নিৰ্বাচন আয়োগৰ কাৰ্যবোৰ লিখক。"
         ],
@@ -1299,7 +1458,7 @@ SAMPLE_QUESTIONS = {
         ]
     },
     
-    "📘 হিন্দी (Hindi)": {
+    "📘 হিন্দী (Hindi)": {
         "पाठ १": [
             "साखी पाठ का मुख्य संदेश क्या है?",
             "कबीरदास की साखियों की भाषा-शैली पर प्रकाश डालिए।",
@@ -1337,7 +1496,7 @@ SAMPLE_QUESTIONS = {
         ],
         "पाठ ६": [
             "मधुर-मधुर मेरे दीपक जल कविता की व्याख्या कीजिए।",
-            "महादेवी वर्मा की कविता 'मधुर-मधुर मेरे दीपक जल' का सार लिखिए।",
+            "महादेवी वर्मा की कविता 'मधुर-मধुर मेरे दीপक जल' का सार लिखिए।",
             "कविता में दीपक किसका प्रतीक है?",
             "महादेवी वर्मा की काव्य शैली की विशेषताएँ बताइए।",
             "कविता से हमें क्या संदेश मिलता है?"
@@ -1593,7 +1752,6 @@ div[role="listbox"] div:first-child {
 </style>
 """, unsafe_allow_html=True)
 
-
 # ===============================
 # QUESTION INPUT AREA
 # ===============================
@@ -1628,11 +1786,18 @@ if not api_key:
     ```
     """)
 
+# Show Supabase status
+if not os.environ.get("SUPABASE_URL") and not os.environ.get("SUPABASE_KEY"):
+    with st.sidebar:
+        st.warning("⚠️ **Supabase Not Configured**")
+        st.caption("Add `SUPABASE_URL` and `SUPABASE_KEY` in secrets for multi-user cache")
+
 # ===============================
-# CACHE CHECK AND SUBMIT BUTTON
+# CACHE CHECK AND SUBMIT BUTTON - FIXED VERSION
 # ===============================
 submit_disabled = not (question.strip() and api_key)
 col1, col2, col3 = st.columns([1, 2, 1])
+
 with col2:
     if st.button(
         "🚀 উত্তৰ দিবলৈ দিয়ক!", 
@@ -1647,9 +1812,21 @@ with col2:
         else:
             # Check cache first
             cache_key = create_cache_key(question, selected_subject, current_chapter_name)
+            
+            # Get cache stats for debugging
+            cache_stats = st.session_state.cache_manager.get_stats()
+            
+            # Check if we should show debug info
+            if cache_stats['supabase_connected']:
+                st.toast(f"🔍 Checking Supabase cache ({cache_stats['supabase_entries']} entries)", icon="🔍")
+            
             cached_entry = st.session_state.cache_manager.get(cache_key)
             
             if cached_entry:
+                # Determine cache source
+                cache_source = "Memory" if cache_key in st.session_state.cache_manager.memory_cache else "Supabase"
+                st.toast(f"🎯 Cache hit from {cache_source}!", icon="⚡")
+                
                 # Load from cache
                 st.session_state.last_answer = cached_entry['answer']
                 st.session_state.tokens_used = cached_entry['tokens']
@@ -1661,7 +1838,8 @@ with col2:
                     'question': question[:100],
                     'timestamp': datetime.now().strftime("%H:%M"),
                     'tokens': cached_entry['tokens'],
-                    'cached': True
+                    'cached': True,
+                    'cache_source': cache_source
                 }
                 st.session_state.history.append(history_entry)
                 
@@ -1671,30 +1849,66 @@ with col2:
                 st.session_state.current_cache_key = cache_key
                 st.session_state.processing = False
             else:
+                # Cache miss
+                if cache_stats['supabase_connected']:
+                    st.toast("❌ Cache miss - calling API...", icon="🤖")
+                else:
+                    st.toast("🤖 Calling DeepSeek API...", icon="🤖")
+                
                 # Not in cache, proceed with API call
                 st.session_state.processing = True
                 st.session_state.current_cache_key = cache_key
 
 # ===============================
-# DISPLAY CACHED ANSWER
+# CACHE DEBUG PANEL (Optional)
+# ===============================
+with st.sidebar:
+    if st.checkbox("🔧 Show Cache Debug", value=st.session_state.cache_debug):
+        st.session_state.cache_debug = True
+        st.markdown("#### 🔍 Cache Debug")
+        
+        cache_stats = st.session_state.cache_manager.get_stats()
+        st.write(f"**Supabase Connected:** {cache_stats['supabase_connected']}")
+        st.write(f"**Supabase Entries:** {cache_stats['supabase_entries']}")
+        st.write(f"**Memory Entries:** {cache_stats['memory_entries']}")
+        
+        if cache_stats['supabase_connected'] and cache_stats['supabase_entries'] > 0:
+            try:
+                # Show some sample cache entries
+                sample = st.session_state.cache_manager.supabase.table("seba_cache") \
+                    .select("question, subject, chapter, created_at") \
+                    .limit(5) \
+                    .execute()
+                
+                if sample.data:
+                    st.write("**Sample Cache Entries:**")
+                    for i, item in enumerate(sample.data, 1):
+                        st.write(f"{i}. {item['question'][:30]}... ({item['subject']})")
+            except Exception as e:
+                st.write(f"Error: {e}")
+
+# ===============================
+# DISPLAY CACHED ANSWER - FIXED VERSION
 # ===============================
-if hasattr(st.session_state, 'show_cached_answer') and st.session_state.show_cached_answer:
+if st.session_state.get('show_cached_answer') and st.session_state.get('cached_answer_data'):
     st.markdown("---")
     
+    cached_data = st.session_state.cached_answer_data
+    
     # User question
     st.markdown(f"""
     <div style="margin-bottom: 1rem;">
         <div style="display: flex; justify-content: flex-end; margin-bottom: 0.3rem;">
             <div class="user-bubble">
                 <div style="font-weight: 600; margin-bottom: 0.2rem;">👤 আপুনি:</div>
-                <div>{question}</div>
+                <div>{question[:200]}{'...' if len(question) > 200 else ''}</div>
             </div>
         </div>
     </div>
     """, unsafe_allow_html=True)
     
     # Cached answer with indicator
-    cached_data = st.session_state.cached_answer_data
+    cache_source = "Memory" if st.session_state.current_cache_key in st.session_state.cache_manager.memory_cache else "Supabase"
     
     st.markdown(f"""
     <div style="margin-bottom: 0.5rem;">
@@ -1706,14 +1920,14 @@ if hasattr(st.session_state, 'show_cached_answer') and st.session_state.show_cac
                         <div style="display: flex; align-items: center;">
                             <div style="background: #4CAF50; color: white; padding: 0.2rem 0.5rem; border-radius: 8px; 
                                         font-weight: 600; font-size: 0.8rem; margin-right: 0.5rem;">
-                                <span style="margin-right: 0.3rem;">⚡</span> Cached
+                                <span style="margin-right: 0.3rem;">⚡</span> Cached Answer
                             </div>
                             <div style="font-weight: 600; color: #0d47a1; font-size: 0.9rem;">
-                                {selected_subject} • {current_chapter_name}
+                                {cached_data.get('subject', selected_subject)} • {cached_data.get('chapter', current_chapter_name)}
                             </div>
                         </div>
                         <div style="font-size: 0.75rem; color: #666; background: #f1f8e9; padding: 0.2rem 0.5rem; border-radius: 4px;">
-                            <span style="margin-right: 0.3rem;">💾</span> Cache Hit
+                            <span style="margin-right: 0.3rem;">💾</span> From {cache_source}
                         </div>
                     </div>
                     <div style="color: #333; line-height: 1.5; font-size: 0.95rem;">
@@ -1728,52 +1942,77 @@ if hasattr(st.session_state, 'show_cached_answer') and st.session_state.show_cac
     # Show cache info
     with st.expander("📊 Cache Information"):
         cache_stats = st.session_state.cache_manager.get_stats()
-        estimated_cost = cached_data.get('tokens', 0) * 0.0000014  # $0.14 per 100K tokens
+        estimated_cost = cached_data.get('tokens', 0) * 0.0000014
+        
+        col1, col2 = st.columns(2)
+        with col1:
+            st.metric("Tokens Saved", f"{cached_data.get('tokens', 0):,}")
+            st.metric("Cache Source", cache_source)
+        
+        with col2:
+            st.metric("Access Count", cached_data.get('access_count', 1))
+            st.metric("Cost Saved", f"${estimated_cost:.6f}")
+        
         st.info(f"""
         **Cache Benefits:**
-        - ⚡ Instant response (no API call)
-        - 💰 No token cost (saved {cached_data.get('tokens', 0):,} tokens)
-        - 💵 Estimated savings: ${estimated_cost:.4f}
-        - 🌿 Environmentally friendly
+        - ⚡ Instant response (no API call needed)
+        - 💰 No token cost for this query
+        - 🌿 Environmentally friendly (reduces API calls)
+        - 🔄 Available for all users
         
-        **Cache Details:**
-        - Cache entries: {cache_stats['total_entries']}
+        **Cache Storage:**
+        - Mode: {cache_stats['storage_mode']}
+        - Total cached entries: {cache_stats['total_entries']}
         - Total tokens saved: {cache_stats['total_saved_tokens']:,}
-        - Cache hit count: {cached_data.get('access_count', 1)}
-        - Cache TTL: {cache_stats['ttl_hours']} hours
-        - Storage: {cache_stats['storage_mode']}
+        - Cache TTL: {cache_stats['ttl_days']} days
         """)
         
         # Cache management buttons
+        st.markdown("---")
+        st.markdown("#### 🛠️ Cache Management")
+        
         col1, col2 = st.columns(2)
         with col1:
-            if st.button("🗑️ Clear this cached answer", type="secondary", use_container_width=True):
-                if st.session_state.current_cache_key in st.session_state.cache_manager.cache:
-                    st.session_state.cache_manager.cache.pop(st.session_state.current_cache_key)
-                    st.success("Cache entry cleared!")
-                    st.session_state.show_cached_answer = False
-                    st.rerun()
+            if st.button("🗑️ Clear This Cache", use_container_width=True, type="secondary"):
+                if st.session_state.current_cache_key in st.session_state.cache_manager.memory_cache:
+                    del st.session_state.cache_manager.memory_cache[st.session_state.current_cache_key]
+                
+                # Also delete from Supabase if connected
+                if st.session_state.cache_manager.supabase:
+                    try:
+                        st.session_state.cache_manager.supabase.table("seba_cache") \
+                            .delete() \
+                            .eq("key_hash", st.session_state.current_cache_key) \
+                            .execute()
+                    except:
+                        pass
+                
+                st.success("✅ Cache entry cleared!")
+                st.session_state.show_cached_answer = False
+                st.rerun()
         
         with col2:
-            if st.button("🧹 Clear all cache", type="secondary", use_container_width=True):
+            if st.button("🧹 Clear All Cache", use_container_width=True, type="secondary"):
                 st.session_state.cache_manager.clear_all()
-                st.success("All cache cleared!")
+                st.success("✅ All cache cleared!")
                 st.session_state.show_cached_answer = False
                 st.rerun()
     
     # Show token usage
     if cached_data.get('tokens', 0) > 0:
-        st.caption(f"📊 Original token cost (saved): {cached_data['tokens']:,}")
+        st.caption(f"📊 Original token cost (saved): {cached_data['tokens']:,} tokens")
     
     # Reset flag
     st.session_state.show_cached_answer = False
-    del st.session_state.cached_answer_data
-    del st.session_state.current_cache_key
+    if 'cached_answer_data' in st.session_state:
+        del st.session_state.cached_answer_data
+    if 'current_cache_key' in st.session_state:
+        del st.session_state.current_cache_key
 
 # ===============================
 # PROCESS QUESTION WITH STREAMING
 # ===============================
-if st.session_state.get('processing') and question and api_key and not st.session_state.get('show_cached_answer', False):
+if st.session_state.get('processing') and question and api_key:
     st.markdown("---")
     
     # User question
@@ -1782,7 +2021,7 @@ if st.session_state.get('processing') and question and api_key and not st.sessio
         <div style="display: flex; justify-content: flex-end; margin-bottom: 0.3rem;">
             <div class="user-bubble">
                 <div style="font-weight: 600; margin-bottom: 0.2rem;">👤 আপুনি:</div>
-                <div>{question}</div>
+                <div>{question[:200]}{'...' if len(question) > 200 else ''}</div>
             </div>
         </div>
     </div>
@@ -1840,7 +2079,8 @@ if st.session_state.get('processing') and question and api_key and not st.sessio
     
     # Show token usage
     if st.session_state.tokens_used > 0:
-        st.caption(f"📊 ট'কেন ব্যৱহৃত: {st.session_state.tokens_used:,}")
+        estimated_cost = st.session_state.tokens_used * 0.0000014
+        st.caption(f"📊 ট'কেন ব্যৱহৃত: {st.session_state.tokens_used:,} (Cost: ${estimated_cost:.6f})")
     
     st.session_state.processing = False
 
@@ -1851,14 +2091,16 @@ if st.session_state.history:
     st.markdown("---")
     st.markdown("#### 📜 আজিৰ প্ৰশ্নাৱলী")
     
-    for i, item in enumerate(reversed(st.session_state.history[-3:]), 1):
-        cache_indicator = " ⚡" if item.get('cached') else ""
-        with st.expander(f"প্ৰশ্ন {i}: {item['question']} ({item['timestamp']}{cache_indicator})"):
+    for i, item in enumerate(reversed(st.session_state.history[-5:]), 1):
+        cache_indicator = " ⚡" if item.get('cached') else " 🤖"
+        cache_source = f" ({item.get('cache_source', 'API')})" if item.get('cached') else ""
+        
+        with st.expander(f"প্ৰশ্ন {i}: {item['question']} ({item['timestamp']}{cache_indicator}{cache_source})"):
             st.write(f"**বিষয়:** {item['subject']}")
             st.write(f"**অধ্যায়:** {item['chapter']}")
             st.write(f"**ট'কেন:** {item.get('tokens', 0):,}")
             if item.get('cached'):
-                st.caption("⚡ This answer was served from cache")
+                st.caption(f"⚡ This answer was served from {item.get('cache_source', 'cache')}")
 
 # ===============================
 # CACHE STATISTICS SIDEBAR
@@ -1869,23 +2111,33 @@ with st.sidebar:
     
     cache_stats = st.session_state.cache_manager.get_stats()
     
+    # Show connection status
+    if cache_stats['supabase_connected']:
+        st.success("✅ Connected to Supabase")
+        st.caption(f"🔗 **Storage:** {cache_stats['storage_mode']}")
+    else:
+        st.warning("⚠️ Memory Cache Only")
+        st.caption("🔗 **Storage:** Memory Only (Supabase not configured)")
+    
     if cache_stats['total_entries'] > 0:
-        # Cache info
-        st.caption(f"⚡ **Storage:** {cache_stats['storage_mode']}")
-        
         # Cache stats metrics
         col1, col2 = st.columns(2)
         with col1:
-            st.metric("Entries", cache_stats['total_entries'])
-            st.metric("Avg Age", f"{cache_stats['average_age_hours']}h")
+            st.metric("Total Entries", cache_stats['total_entries'])
+            if cache_stats['supabase_connected']:
+                st.metric("Supabase", cache_stats['supabase_entries'])
         
         with col2:
-            st.metric("Tokens Saved", f"{cache_stats['total_saved_tokens']:,}")
-            st.metric("TTL", f"{cache_stats['ttl_hours']}h")
+            st.metric("Memory", cache_stats['memory_entries'])
+            estimated_savings = cache_stats['total_saved_tokens'] * 0.0000014
+            st.metric("💰 Savings", f"${estimated_savings:.4f}")
         
-        # Cost savings
-        estimated_cost = cache_stats['total_saved_tokens'] * 0.0000014  # $0.14 per 100K tokens
-        st.metric("💰 Cost Saved", f"${estimated_cost:.4f}")
+        # Cost savings breakdown
+        with st.expander("📈 Savings Details"):
+            st.write(f"**Total tokens saved:** {cache_stats['total_saved_tokens']:,}")
+            st.write(f"**Estimated cost savings:** ${estimated_savings:.6f}")
+            st.write(f"**Average per entry:** {cache_stats['total_saved_tokens'] // max(1, cache_stats['total_entries']):,} tokens")
+            st.write(f"**Cache TTL:** {cache_stats['ttl_days']} days")
         
         # Cache management
         st.markdown("#### 🛠️ Cache Management")
@@ -1901,31 +2153,51 @@ with st.sidebar:
                 st.rerun()
         
         with col2:
-            if st.button("🧹 Clear All", use_container_width=True):
+            if st.button("🧹 Clear All", use_container_width=True, 
+                        help="Clear memory cache and old Supabase entries"):
                 st.session_state.cache_manager.clear_all()
-                st.success("All cache cleared!")
+                st.success("Cache cleared successfully!")
                 st.rerun()
         
-        # View recent cached questions
-        with st.expander("📋 Recent Cached Questions"):
-            recent_entries = list(st.session_state.cache_manager.cache.items())[:5]
-            for key, entry in recent_entries:
-                question_text = entry.get('question', 'N/A')[:40] + "..."
-                age_hours = round((datetime.now() - datetime.fromisoformat(entry.get('created_at', datetime.now().isoformat()))).seconds / 3600, 1)
-                st.caption(f"• {question_text}")
-                st.write(f"  📚 {entry.get('subject', 'N/A').split()[0]} • 🔢 {entry.get('access_count', 1)}x • ⏳ {age_hours}h ago")
+        # Supabase setup guide
+        if not cache_stats['supabase_connected']:
+            with st.expander("🚀 Enable Supabase Cache (Multi-User)"):
+                st.markdown("""
+                **Benefits:**
+                - ✅ Cache shared across ALL users
+                - ✅ Persistent storage (7 days)
+                - ✅ No data loss on app restart
+                
+                **Setup:**
+                1. **Create Supabase account** at [supabase.com](https://supabase.com)
+                2. **Create new project** and get URL + anon key
+                3. **Add to Hugging Face Secrets:**
+                   - `SUPABASE_URL` = your-project-url
+                   - `SUPABASE_KEY` = your-anon-key
+                4. **Create table** (SQL below)
+                
+                **SQL for cache table:**
+                ```sql
+                CREATE TABLE seba_cache (
+                    key_hash VARCHAR(64) PRIMARY KEY,
+                    question TEXT,
+                    answer TEXT,
+                    subject VARCHAR(100),
+                    chapter VARCHAR(100),
+                    tokens INTEGER DEFAULT 0,
+                    created_at TIMESTAMP DEFAULT NOW(),
+                    last_accessed TIMESTAMP DEFAULT NOW(),
+                    access_count INTEGER DEFAULT 1
+                );
+                ```
+                """)
     else:
         st.info("Cache is empty. Ask some questions to build cache!")
-    
-    # Cache performance note
-    st.markdown("---")
-    st.caption("""
-    **💡 Cache Performance:**
-    - Cache persists for 24 hours
-    - In-memory storage (no file access)
-    - Automatic cleanup of old entries
-    - Works within browser session
-    """)
+        
+        if not cache_stats['supabase_connected']:
+            st.markdown("---")
+            st.markdown("#### 🚀 Upgrade to Multi-User Cache")
+            st.caption("Enable Supabase to share cache across all users")
 
 # ===============================
 # FOOTER