Update app.py via admin tool

app.py

@@ -1,835 +1,393 @@
 import gradio as gr
-import os
 import csv
+import os
+import re
 from datetime import datetime, timedelta
 from huggingface_hub import Repository
-import threading
-import time
-import json
+from RAG_Learning_Assistant_with_Streaming import RAGLearningAssistant
 
-
-# Configuration
-DATA_STORAGE_REPO = "CIV3283/Data_Storage"
+# Configuration for Student Space
+# find name of space
+def get_space_name():
+    space_id = os.environ.get("SPACE_ID", None)
+    if space_id:
+        # SPACE_ID usually "username/space-name"，we only need space-name
+        return space_id.split("/")[-1]
+STUDENT_SPACE_NAME = get_space_name()  # get space name automatically
+DATA_STORAGE_REPO = "CIV3283/Data_Storage"  # Centralized data storage repo
 DATA_BRANCH_NAME = "data_branch"
-LOCAL_DATA_DIR = "temp_data_storage"
-MIN_IDLE_MINUTES = 10  # Minimum idle time required for space assignment
-ALLOCATION_LOCK_DURATION = 5  # Lock duration in minutes
+LOCAL_DATA_DIR = "temp_data_repo"
+
+# Session timeout configuration (in minutes)
+SESSION_TIMEOUT_MINUTES = 30  # Adjust this value as needed
+
+# File names in data storage
+KNOWLEDGE_FILE = "knowledge_base.md"
+VECTOR_DB_FILE = "vector_database.csv"
+METADATA_FILE = "vector_metadata.json"
+VECTORIZER_FILE = "vectorize_knowledge_base.py"
+
+# Student-specific log files (with space name prefix)
+QUERY_LOG_FILE = f"{STUDENT_SPACE_NAME}_query_log.csv"
+FEEDBACK_LOG_FILE = f"{STUDENT_SPACE_NAME}_feedback_log.csv"
+
+# Environment variables
+HF_HUB_TOKEN = os.environ.get("HF_HUB_TOKEN", None)
+if HF_HUB_TOKEN is None:
+    raise ValueError("Set HF_HUB_TOKEN in Space Settings -> Secrets")
+
+OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY", None)
+if OPENAI_API_KEY is None:
+    raise ValueError("Set OPENAI_API_KEY in Space Settings -> Secrets")
 
-# 缓存配置 - 全部改为内存存储
-CACHE_UPDATE_INTERVAL = 600  # 10分钟 = 600秒
-DATA_SYNC_INTERVAL = 600    # 数据同步间隔，10分钟 = 600秒
-CACHE_LOCK = threading.Lock()
-ALLOCATION_LOCK = threading.Lock()
+MODEL = "gpt-4.1-nano-2025-04-14"
 
-# 全局内存存储
-class MemoryAllocationStore:
-    """内存中的分配记录存储"""
-    def __init__(self):
-        self._allocations = {}  # {space_name: {'student_id': str, 'allocated_time': datetime, 'expires_at': datetime}}
-        self._lock = threading.Lock()
-        self._cleanup_interval = 60  # 每分钟清理一次过期记录
+def check_session_validity(check_id):
+    """
+    Check if the current session is valid based on:
+    1. If user ID matches last query → Allow continue
+    2. If user ID doesn't match → Check time interval:
+       - If time interval is small → Block (previous user just finished)
+       - If time interval is large → Allow (assistant has been idle)
+    
+    Returns:
+        tuple: (is_valid: bool, error_message: str)
+    """
+    try:
+        filepath = os.path.join(LOCAL_DATA_DIR, QUERY_LOG_FILE)
         
-        # 启动后台清理线程
-        self._start_cleanup_thread()
-    
-    def _start_cleanup_thread(self):
-        """启动后台清理过期分配记录的线程"""
-        def cleanup_worker():
-            while True:
-                time.sleep(self._cleanup_interval)
-                self._cleanup_expired_allocations()
+        # If no log file exists, this is the first query - allow it
+        if not os.path.exists(filepath):
+            print(f"[check_session_validity] No existing log file, allowing first query for student {check_id}")
+            return True, ""
         
-        cleanup_thread = threading.Thread(target=cleanup_worker, daemon=True)
-        cleanup_thread.start()
-        print("[MemoryAllocationStore] Background cleanup thread started")
-    
-    def _cleanup_expired_allocations(self):
-        """清理过期的分配记录"""
-        with self._lock:
-            current_time = datetime.now()
-            expired_spaces = []
-            
-            for space_name, alloc_info in self._allocations.items():
-                if alloc_info['expires_at'] <= current_time:
-                    expired_spaces.append(space_name)
-            
-            for space_name in expired_spaces:
-                del self._allocations[space_name]
-                if expired_spaces:  # 只在有过期记录时打印
-                    print(f"[MemoryAllocationStore] Cleaned up expired allocation: {space_name}")
-    
-    def add_allocation(self, space_name, student_id):
-        """添加新的分配记录"""
-        with self._lock:
-            current_time = datetime.now()
-            expires_at = current_time + timedelta(minutes=ALLOCATION_LOCK_DURATION)
-            
-            self._allocations[space_name] = {
-                'student_id': student_id,
-                'allocated_time': current_time,
-                'expires_at': expires_at
-            }
-            
-            print(f"[MemoryAllocationStore] Added allocation: {space_name} -> {student_id} (expires at {expires_at.strftime('%H:%M:%S')})")
-    
-    def get_active_allocations(self):
-        """��取所有有效的分配记录"""
-        with self._lock:
-            current_time = datetime.now()
-            active_allocations = {}
+        # Read the last record from the CSV file
+        with open(filepath, 'r', encoding='utf-8') as csvfile:
+            reader = csv.reader(csvfile)
+            rows = list(reader)
             
-            for space_name, alloc_info in self._allocations.items():
-                if alloc_info['expires_at'] > current_time:
-                    active_allocations[space_name] = alloc_info.copy()
+            # If only header exists, this is effectively the first query
+            if len(rows) <= 1:
+                print(f"[check_session_validity] Only header in log file, allowing first query for student {check_id}")
+                return True, ""
             
-            return active_allocations
-    
-    def is_allocated(self, space_name):
-        """检查指定空间是否被分配"""
-        with self._lock:
-            if space_name not in self._allocations:
-                return False, None
-            
-            alloc_info = self._allocations[space_name]
-            current_time = datetime.now()
+            # Get the last record (most recent query)
+            last_record = rows[-1]
             
-            if alloc_info['expires_at'] > current_time:
-                return True, alloc_info['student_id']
-            else:
-                # 过期了，删除记录
-                del self._allocations[space_name]
-                return False, None
-    
-    def get_status_summary(self):
-        """获取分配状态摘要"""
-        with self._lock:
-            current_time = datetime.now()
-            active_count = 0
-            summary = []
-            
-            for space_name, alloc_info in self._allocations.items():
-                if alloc_info['expires_at'] > current_time:
-                    active_count += 1
-                    remaining_minutes = (alloc_info['expires_at'] - current_time).total_seconds() / 60
-                    summary.append(f"{space_name} -> {alloc_info['student_id']} ({remaining_minutes:.1f}min left)")
-            
-            return {
-                'active_count': active_count,
-                'total_stored': len(self._allocations),
-                'summary': summary
-            }
-
-# 全局数据管理器
-class DataManager:
-    def __init__(self):
-        self.repo = None
-        self.available_spaces = []
-        self.last_data_sync = None
-        self._sync_lock = threading.Lock()
-        self._sync_thread = None
-        self._stop_event = threading.Event()
-        self.initialized = False
-    
-    def initialize(self):
-        """初始化数据管理器 - 只在启动时调用一次"""
-        if self.initialized:
-            return True
-        
-        try:
-            print("[DataManager] Initializing data manager...")
+            # CSV format: [student_space, student_id, timestamp, search_info, query_and_response, thumb_feedback]
+            if len(last_record) < 3:
+                print(f"[check_session_validity] Invalid last record format, allowing query")
+                return True, ""
             
-            # 初始化仓库连接
-            self.repo = Repository(
-                local_dir=LOCAL_DATA_DIR,
-                clone_from=DATA_STORAGE_REPO,
-                revision=DATA_BRANCH_NAME,
-                repo_type="space",
-                use_auth_token=os.environ.get("HF_HUB_TOKEN")
-            )
+            last_student_id = last_record[1]
+            last_timestamp_str = last_record[2]
             
-            # 配置git用户
-            self.repo.git_config_username_and_email("git_user", f"load_distributor")
-            self.repo.git_config_username_and_email("git_email", f"loaddistributor@takeiteasy.space")
+            print(f"[check_session_validity] Last record - Student ID: {last_student_id}, Timestamp: {last_timestamp_str}")
+            print(f"[check_session_validity] Current request - Student ID: {check_id}")
             
-            # 初始数据同步
-            self._sync_data()
+            # If student ID matches, allow continuation
+            if last_student_id == check_id:
+                print(f"[check_session_validity] Same user, allowing continuation for student {check_id}")
+                return True, ""
             
-            # 启动后台同步线程
-            self._start_background_sync()
-            
-            self.initialized = True
-            print("[DataManager] Data manager initialized successfully")
-            return True
-            
-        except Exception as e:
-            print(f"[DataManager] Initialization failed: {e}")
-            return False
-    
-    def _start_background_sync(self):
-        """启动后台数据同步线程"""
-        if self._sync_thread and self._sync_thread.is_alive():
-            return
-        
-        self._stop_event.clear()
-        self._sync_thread = threading.Thread(target=self._background_sync_worker, daemon=True)
-        self._sync_thread.start()
-        print("[DataManager] Background sync thread started")
-    
-    def _background_sync_worker(self):
-        """后台同步工作线程"""
-        while not self._stop_event.is_set():
+            # If student ID doesn't match, check time interval
             try:
-                # 等待指定间隔或停止信号
-                if self._stop_event.wait(timeout=DATA_SYNC_INTERVAL):
-                    break
+                last_timestamp = datetime.strptime(last_timestamp_str, '%Y-%m-%d %H:%M:%S')
+                current_timestamp = datetime.now()
+                time_diff = current_timestamp - last_timestamp
                 
-                print("[DataManager] Starting scheduled data sync...")
-                self._sync_data()
-                print("[DataManager] Scheduled data sync completed")
+                print(f"[check_session_validity] Different user - Time difference: {time_diff.total_seconds()} seconds ({time_diff.total_seconds()/60:.1f} minutes)")
                 
-            except Exception as e:
-                print(f"[DataManager] Error in background sync: {e}")
-                if not self._stop_event.wait(timeout=60):  # 1分钟后重试
-                    continue
-    
-    def _sync_data(self):
-        """同步数据 - 拉取最新数据并更新可用空间列表"""
-        with self._sync_lock:
-            try:
-                start_time = time.time()
-                print("[DataManager] Syncing data from remote repository...")
-                
-                # 拉取最新数据
-                self.repo.git_pull(rebase=True)
-                
-                # 更新可用空间列表
-                self.available_spaces = self._get_available_spaces()
-                self.last_data_sync = datetime.now()
+                # If time difference is small, block access (previous user just finished)
+                if time_diff <= timedelta(minutes=SESSION_TIMEOUT_MINUTES):
+                    error_msg = "⚠️ The assistant is currently being used by another user. Please return to the load distributor page."
+                    print(f"[check_session_validity] Blocking access - Previous user ({last_student_id}) used assistant {time_diff.total_seconds()/60:.1f} minutes ago")
+                    return False, error_msg
                 
-                elapsed_time = time.time() - start_time
-                print(f"[DataManager] Data sync completed in {elapsed_time:.2f}s, found {len(self.available_spaces)} spaces")
+                # If time difference is large, allow access (assistant has been idle)
+                print(f"[check_session_validity] Assistant has been idle for {time_diff.total_seconds()/60:.1f} minutes, allowing new user {check_id}")
+                return True, ""
                 
-            except Exception as e:
-                print(f"[DataManager] Error syncing data: {e}")
-    
-    def _get_available_spaces(self):
-        """获取可用空间列表"""
-        available_spaces = set()
-        try:
-            for filename in os.listdir(LOCAL_DATA_DIR):
-                if filename.endswith('_query_log.csv') and '_Student_' in filename:
-                    space_name = filename.replace('_query_log.csv', '')
-                    available_spaces.add(space_name)
-            return sorted(list(available_spaces))
-        except Exception as e:
-            print(f"[DataManager] Error getting available spaces: {e}")
-            return []
+            except ValueError as e:
+                print(f"[check_session_validity] Error parsing timestamp: {e}")
+                # If we can't parse the timestamp, allow the query to proceed
+                return True, ""
     
-    def get_available_spaces(self):
-        """获取可用空间列表 - 不触发数据同步"""
-        if not self.initialized:
-            raise Exception("DataManager not initialized")
-        return self.available_spaces.copy()
-    
-    def get_repo(self):
-        """获取仓库对象"""
-        if not self.initialized:
-            raise Exception("DataManager not initialized")
-        return self.repo
-    
-    def get_repo_dir(self):
-        """获取仓库本地目录"""
-        if not self.initialized:
-            raise Exception("DataManager not initialized")
-        return LOCAL_DATA_DIR
-    
-    def stop(self):
-        """停止后台同步"""
-        if self._sync_thread:
-            self._stop_event.set()
-            print("[DataManager] Background sync thread stopping...")
+    except Exception as e:
+        print(f"[check_session_validity] Error checking session validity: {e}")
+        import traceback
+        print(f"[check_session_validity] Traceback: {traceback.format_exc()}")
+        # On error, allow the query to proceed to avoid blocking legitimate users
+        return True, ""
 
-class SpaceActivityCache:
-    """内存中的空间活动缓存"""
-    def __init__(self, data_manager):
-        self.data_manager = data_manager
-        self._cache_data = {}
-        self._last_update = None
-        self._update_thread = None
-        self._stop_event = threading.Event()
-        
-        # 启动时立即更新一次缓存
-        self._update_cache()
+def init_data_storage_repo():
+    """Initialize connection to centralized data storage repository"""
+    try:
+        repo = Repository(
+            local_dir=LOCAL_DATA_DIR,
+            clone_from=DATA_STORAGE_REPO,
+            revision=DATA_BRANCH_NAME,
+            repo_type="space",
+            use_auth_token=HF_HUB_TOKEN
+        )
+        # Configure git user
+        repo.git_config_username_and_email("git_user", f"Student_Space_{STUDENT_SPACE_NAME}")
+        repo.git_config_username_and_email("git_email", f"{STUDENT_SPACE_NAME}@student.space")
+        
+        # Pull latest changes
+        print(f"[init_data_storage_repo] Pulling latest changes from {DATA_STORAGE_REPO}...")
+        repo.git_pull(rebase=True)
+        
+        print(f"[init_data_storage_repo] Successfully connected to data storage repo: {DATA_STORAGE_REPO}")
+        print(f"[init_data_storage_repo] Local directory: {LOCAL_DATA_DIR}")
+        print(f"[init_data_storage_repo] Branch: {DATA_BRANCH_NAME}")
+        
+        # Check if required files exist
+        required_files = [KNOWLEDGE_FILE, VECTOR_DB_FILE, METADATA_FILE]
+        for file_name in required_files:
+            file_path = os.path.join(LOCAL_DATA_DIR, file_name)
+            if os.path.exists(file_path):
+                print(f"[init_data_storage_repo] Found required file: {file_name}")
+            else:
+                print(f"[init_data_storage_repo] Warning: Missing required file: {file_name}")
         
-        # 启动后台更新线程
-        self.start_background_updates()
-    
-    def start_background_updates(self):
-        """启动后台缓存更新线程"""
-        if self._update_thread and self._update_thread.is_alive():
-            return
+        return repo
         
-        self._stop_event.clear()
-        self._update_thread = threading.Thread(target=self._background_update_worker, daemon=True)
-        self._update_thread.start()
-        print("[SpaceActivityCache] Background update thread started")
+    except Exception as e:
+        print(f"[init_data_storage_repo] Error initializing repository: {e}")
+        import traceback
+        print(f"[init_data_storage_repo] Traceback: {traceback.format_exc()}")
+        return None
+
+def commit_student_logs(commit_message: str):
+    """Commit student logs to data storage repository with conflict resolution"""
+    if repo is None:
+        print("[commit_student_logs] Error: Repository not initialized")
+        return False
     
-    def stop_background_updates(self):
-        """停止后台更新线程"""
-        if self._update_thread:
-            self._stop_event.set()
-            print("[SpaceActivityCache] Background update thread stopping...")
+    max_retries = 3
+    retry_count = 0
     
-    def _background_update_worker(self):
-        """后台更新工作线程"""
-        while not self._stop_event.is_set():
-            try:
-                # 等待指定间隔或停止信号
-                if self._stop_event.wait(timeout=CACHE_UPDATE_INTERVAL):
-                    break
-                
-                print("[SpaceActivityCache] Starting scheduled cache update...")
-                self._update_cache()
-                print("[SpaceActivityCache] Scheduled cache update completed")
-                
-            except Exception as e:
-                print(f"[SpaceActivityCache] Error in background update: {e}")
-                if not self._stop_event.wait(timeout=60):  # 1分钟后重试
-                    continue
-    
-    def _update_cache(self):
-        """更新缓存数据"""
+    while retry_count < max_retries:
         try:
-            print("[SpaceActivityCache] Updating activity cache...")
-            start_time = time.time()
-            
-            # 从数据管理器获取可用空间（不触发数据同步）
-            available_spaces = self.data_manager.get_available_spaces()
-            repo_dir = self.data_manager.get_repo_dir()
+            # Check if log files exist before adding
+            query_log_path = os.path.join(LOCAL_DATA_DIR, QUERY_LOG_FILE)
+            feedback_log_path = os.path.join(LOCAL_DATA_DIR, FEEDBACK_LOG_FILE)
             
-            new_cache_data = {
-                'last_updated': datetime.now().isoformat(),
-                'update_interval_seconds': CACHE_UPDATE_INTERVAL,
-                'spaces': {}
-            }
+            files_to_add = []
+            if os.path.exists(query_log_path):
+                files_to_add.append(QUERY_LOG_FILE)
+                print(f"[commit_student_logs] Found query log: {query_log_path}")
             
-            # 为每个空间读取最后活动时间
-            for space_name in available_spaces:
-                csv_file = os.path.join(repo_dir, f"{space_name}_query_log.csv")
-                last_activity, status = self._get_last_activity_from_file(csv_file)
-                
-                new_cache_data['spaces'][space_name] = {
-                    'last_activity': last_activity.isoformat() if last_activity != datetime.min else None,
-                    'status': status,
-                    'cache_update_time': datetime.now().isoformat()
-                }
-                
-                print(f"[SpaceActivityCache] {space_name}: {status}")
+            if os.path.exists(feedback_log_path):
+                files_to_add.append(FEEDBACK_LOG_FILE)
+                print(f"[commit_student_logs] Found feedback log: {feedback_log_path}")
             
-            # 线程安全地更新缓存
-            with CACHE_LOCK:
-                self._cache_data = new_cache_data
-                self._last_update = datetime.now()
+            if not files_to_add:
+                print("[commit_student_logs] No log files to commit")
+                return False
             
-            elapsed_time = time.time() - start_time
-            print(f"[SpaceActivityCache] Cache updated in {elapsed_time:.2f}s, {len(available_spaces)} spaces processed")
+            # Add files individually
+            for file_name in files_to_add:
+                print(f"[commit_student_logs] Adding file: {file_name}")
+                repo.git_add(pattern=file_name)
             
-        except Exception as e:
-            print(f"[SpaceActivityCache] Error updating cache: {e}")
-            import traceback
-            print(f"[SpaceActivityCache] Traceback: {traceback.format_exc()}")
-    
-    def _get_last_activity_from_file(self, csv_file_path):
-        """从文件读取最后活动时间"""
-        try:
-            if not os.path.exists(csv_file_path):
-                return datetime.min, "file_not_found"
-            
-            # 检查文件大小
-            file_size = os.path.getsize(csv_file_path)
-            if file_size <= 100:
-                return datetime.min, "empty_or_header_only"
-            
-            # 使用CSV reader读取最后一行
-            with open(csv_file_path, 'r', encoding='utf-8') as f:
-                csv_reader = csv.reader(f)
+            # Check if there are changes to commit
+            try:
+                import subprocess
+                result = subprocess.run(
+                    ["git", "status", "--porcelain"], 
+                    cwd=LOCAL_DATA_DIR,
+                    capture_output=True, 
+                    text=True,
+                    check=True
+                )
                 
-                # 跳过header
-                try:
-                    header = next(csv_reader)
-                except StopIteration:
-                    return datetime.min, "empty_file"
+                if not result.stdout.strip():
+                    print("[commit_student_logs] No changes to commit")
+                    return True
                 
-                # 读取所有行，获取最后一行
-                rows = []
-                try:
-                    for row in csv_reader:
-                        if row:  # 跳过空行
-                            rows.append(row)
-                except Exception as csv_error:
-                    print(f"[SpaceActivityCache] CSV parsing error for {csv_file_path}: {csv_error}")
-                    return datetime.min, "csv_parse_error"
-            
-            if not rows:
-                return datetime.min, "no_data_rows"
-            
-            # 解析最后一行的时间戳
-            last_row = rows[-1]
-            if len(last_row) >= 3:
-                timestamp_str = last_row[2].strip()  # timestamp column
-                try:
-                    parsed_time = datetime.strptime(timestamp_str, '%Y-%m-%d %H:%M:%S')
-                    return parsed_time, f"active_last_at_{parsed_time.strftime('%Y-%m-%d_%H:%M:%S')}"
-                except ValueError as ve:
-                    print(f"[SpaceActivityCache] Date parsing error for '{timestamp_str}': {ve}")
-                    return datetime.min, "date_parse_error"
-            else:
-                return datetime.min, "invalid_row_format"
+                print(f"[commit_student_logs] Changes detected: {result.stdout.strip()}")
                 
-        except Exception as e:
-            print(f"[SpaceActivityCache] Error reading {csv_file_path}: {e}")
-            return datetime.min, "read_error"
-    
-    def get_space_activity(self, space_name):
-        """获取指定空间的活动信息"""
-        with CACHE_LOCK:
-            if not self._cache_data or 'spaces' not in self._cache_data:
-                print("[SpaceActivityCache] No cache available, updating immediately...")
-                self._update_cache()
+            except Exception as status_error:
+                print(f"[commit_student_logs] Warning: Could not check git status: {status_error}")
             
-            spaces_data = self._cache_data.get('spaces', {})
-            space_info = spaces_data.get(space_name, {})
+            # Commit changes locally first
+            print(f"[commit_student_logs] Attempt {retry_count + 1}/{max_retries}: Committing locally: {commit_message}")
+            repo.git_commit(commit_message)
             
-            if not space_info:
-                return datetime.min, "not_in_cache"
+            # Now try to pull and push
+            print("[commit_student_logs] Pulling latest changes...")
+            repo.git_pull(rebase=True)
             
-            # 解析时间戳
-            last_activity_str = space_info.get('last_activity')
-            if last_activity_str:
-                try:
-                    last_activity = datetime.fromisoformat(last_activity_str)
-                except:
-                    last_activity = datetime.min
-            else:
-                last_activity = datetime.min
+            # Push changes
+            print("[commit_student_logs] Pushing to remote...")
+            repo.git_push()
             
-            status = space_info.get('status', 'unknown')
-            return last_activity, status
-    
-    def get_all_spaces_activity(self):
-        """获取所有空间的活动信息"""
-        with CACHE_LOCK:
-            if not self._cache_data or 'spaces' not in self._cache_data:
-                print("[SpaceActivityCache] No cache available, updating immediately...")
-                self._update_cache()
+            print(f"[commit_student_logs] Success: {commit_message}")
+            return True
             
-            result = {}
-            spaces_data = self._cache_data.get('spaces', {})
+        except Exception as e:
+            error_msg = str(e)
+            print(f"[commit_student_logs] Attempt {retry_count + 1} failed: {error_msg}")
             
-            for space_name, space_info in spaces_data.items():
-                last_activity_str = space_info.get('last_activity')
-                if last_activity_str:
+            # Check if it's a push conflict or pull conflict
+            if ("rejected" in error_msg and "fetch first" in error_msg) or ("cannot pull with rebase" in error_msg):
+                print("[commit_student_logs] Detected Git conflict, will retry...")
+                retry_count += 1
+                
+                if retry_count < max_retries:
+                    # Try to reset and start fresh
                     try:
-                        last_activity = datetime.fromisoformat(last_activity_str)
-                    except:
-                        last_activity = datetime.min
+                        print("[commit_student_logs] Resetting repository state for retry...")
+                        # Reset to remote state
+                        repo.git_reset("--hard", "HEAD~1")  # Undo the commit
+                        repo.git_pull(rebase=True)  # Get latest changes
+                        
+                        # Wait a bit before retrying to avoid rapid conflicts
+                        import time
+                        wait_time = retry_count * 2  # 2, 4, 6 seconds
+                        print(f"[commit_student_logs] Waiting {wait_time} seconds before retry...")
+                        time.sleep(wait_time)
+                        continue
+                        
+                    except Exception as reset_error:
+                        print(f"[commit_student_logs] Reset failed: {reset_error}")
+                        # If reset fails, try alternative approach
+                        try:
+                            # Alternative: stash changes and pull
+                            repo.git_stash()
+                            repo.git_pull(rebase=True)
+                            repo.git_stash("pop")
+                            continue
+                        except Exception as stash_error:
+                            print(f"[commit_student_logs] Stash approach failed: {stash_error}")
+                            return False
                 else:
-                    last_activity = datetime.min
-                
-                result[space_name] = {
-                    'last_activity': last_activity,
-                    'status': space_info.get('status', 'unknown')
-                }
-            
-            return result
-    
-    def get_cache_info(self):
-        """获取缓存状态信息"""
-        with CACHE_LOCK:
-            if self._cache_data and 'last_updated' in self._cache_data:
-                last_updated_str = self._cache_data['last_updated']
-                try:
-                    last_updated = datetime.fromisoformat(last_updated_str)
-                    age_minutes = (datetime.now() - last_updated).total_seconds() / 60
-                    return {
-                        'last_updated': last_updated,
-                        'age_minutes': age_minutes,
-                        'spaces_count': len(self._cache_data.get('spaces', {})),
-                        'is_fresh': age_minutes < (CACHE_UPDATE_INTERVAL / 60) * 1.5
-                    }
-                except:
-                    pass
-            
-            return {
-                'last_updated': None,
-                'age_minutes': float('inf'),
-                'spaces_count': 0,
-                'is_fresh': False
-            }
+                    print("[commit_student_logs] Max retries reached, giving up")
+                    return False
+            else:
+                # Other types of errors, don't retry
+                print(f"[commit_student_logs] Non-conflict error, not retrying: {error_msg}")
+                return False
     
-    def force_update(self):
-        """强制立即更新缓存"""
-        print("[SpaceActivityCache] Force updating cache...")
-        self._update_cache()
+    print("[commit_student_logs] Failed after all retry attempts")
+    return False
 
-# 新增：本地防撞车机制
-class LocalAllocationTracker:
-    def __init__(self):
-        self._recent_allocations = {}  # {space_name: {'student_id': str, 'timestamp': datetime}}
-        self._lock = threading.Lock()
-        self._cleanup_interval = 600  # 清理间隔（秒）
-        self._allocation_ttl = 60   # 本地分配记录的生存时间（秒）
+def save_student_query_to_csv(query, search_info, response, check_id, thumb_feedback=None):
+    """Save student query record to centralized CSV file"""
+    try:
+        # Validate check_id
+        if not check_id:
+            print("[save_student_query_to_csv] Error: No valid check_id provided")
+            return False
         
-        # 启动后台清理线程
-        self._start_cleanup_thread()
-    
-    def _start_cleanup_thread(self):
-        """启动后台线程定期清理过期的本地分配记录"""
-        def cleanup_worker():
-            while True:
-                time.sleep(self._cleanup_interval)
-                self._cleanup_expired_allocations()
+        # Ensure the local data directory exists
+        os.makedirs(LOCAL_DATA_DIR, exist_ok=True)
         
-        cleanup_thread = threading.Thread(target=cleanup_worker, daemon=True)
-        cleanup_thread.start()
-        print("[LocalAllocationTracker] Background cleanup thread started")
-    
-    def _cleanup_expired_allocations(self):
-        """清理过期的本地分配记录"""
-        with self._lock:
-            current_time = datetime.now()
-            expired_spaces = []
-            
-            for space_name, alloc_info in self._recent_allocations.items():
-                if (current_time - alloc_info['timestamp']).total_seconds() > self._allocation_ttl:
-                    expired_spaces.append(space_name)
-            
-            for space_name in expired_spaces:
-                del self._recent_allocations[space_name]
-                if expired_spaces:  # 只在有过期记录时打印
-                    print(f"[LocalAllocationTracker] Cleaned up expired allocation: {space_name}")
-    
-    def is_recently_allocated_locally(self, space_name):
-        """检查空间是否在本地被最近分配过"""
-        with self._lock:
-            if space_name not in self._recent_allocations:
-                return False, None
-            
-            alloc_info = self._recent_allocations[space_name]
-            current_time = datetime.now()
-            elapsed_seconds = (current_time - alloc_info['timestamp']).total_seconds()
-            
-            if elapsed_seconds > self._allocation_ttl:
-                # 过期了，删除记录
-                del self._recent_allocations[space_name]
-                print(f"[LocalAllocationTracker] Expired local allocation removed: {space_name}")
-                return False, None
-            
-            print(f"[LocalAllocationTracker] Space {space_name} recently allocated locally to {alloc_info['student_id']} ({elapsed_seconds:.1f}s ago)")
-            return True, alloc_info['student_id']
-    
-    def record_local_allocation(self, space_name, student_id):
-        """记录本地分配"""
-        with self._lock:
-            self._recent_allocations[space_name] = {
-                'student_id': student_id,
-                'timestamp': datetime.now()
-            }
-            print(f"[LocalAllocationTracker] Locally recorded allocation: {space_name} -> {student_id}")
-    
-    def get_recent_allocations_summary(self):
-        """获取最近本地分配的摘要（用于调试）"""
-        with self._lock:
-            current_time = datetime.now()
-            summary = []
-            for space_name, alloc_info in self._recent_allocations.items():
-                elapsed = (current_time - alloc_info['timestamp']).total_seconds()
-                summary.append(f"{space_name} -> {alloc_info['student_id']} ({elapsed:.1f}s ago)")
-            return summary
-
-# 全局实例
-data_manager = DataManager()
-activity_cache = None
-local_tracker = LocalAllocationTracker()
-memory_allocation_store = MemoryAllocationStore()
-
-def init_system():
-    """初始化整个系统 - 只在启动时调用一次"""
-    global activity_cache
-    
-    print("[init_system] Initializing load distributor system...")
-    
-    # 初始化数据管理器
-    if not data_manager.initialize():
-        raise Exception("Failed to initialize data manager")
-    
-    # 初始化活动缓存
-    activity_cache = SpaceActivityCache(data_manager)
-    
-    print("[init_system] System initialization completed")
-
-def analyze_space_activity_cached():
-    """使用缓存的空间活动分析 - 完全使用内存数据"""
-    global activity_cache
-    
-    if activity_cache is None:
-        raise Exception("Activity cache not initialized")
-    
-    # 从数据管理器获取可用空间列表（不触发数据同步）
-    available_spaces = data_manager.get_available_spaces()
-    
-    space_activity = []
-    current_time = datetime.now()
-    
-    # 获取缓存信息
-    cache_info = activity_cache.get_cache_info()
-    print(f"[analyze_space_activity_cached] Using cache (age: {cache_info['age_minutes']:.1f} min, fresh: {cache_info['is_fresh']})")
-    
-    # 获取所有空间的缓存活动数据
-    all_spaces_activity = activity_cache.get_all_spaces_activity()
-    
-    # 从内存获取分配记录 - 不再读取文件
-    active_allocations = memory_allocation_store.get_active_allocations()
-    
-    print(f"[analyze_space_activity_cached] Analyzing {len(available_spaces)} spaces using cached data...")
-    print(f"[analyze_space_activity_cached] Memory allocations: {len(active_allocations)} active")
-    
-    for space_name in available_spaces:
-        # 从缓存获取活动信息
-        cached_info = all_spaces_activity.get(space_name)
+        filepath = os.path.join(LOCAL_DATA_DIR, QUERY_LOG_FILE)
+        file_exists = os.path.isfile(filepath)
         
-        if cached_info:
-            last_activity = cached_info['last_activity']
-            cached_status = cached_info['status']
-        else:
-            # 缓存中没有这个空间，可能是新空间
-            last_activity = datetime.min
-            cached_status = "not_in_cache"
+        print(f"[save_student_query_to_csv] Saving to: {filepath}")
+        print(f"[save_student_query_to_csv] File exists: {file_exists}")
+        print(f"[save_student_query_to_csv] Student ID: {check_id}")
         
-        # Calculate idle time in minutes
-        if last_activity == datetime.min or 'empty' in cached_status or 'not_found' in cached_status:
-            idle_minutes = float('inf')  # Never used
-            status = "Never used"
-            last_activity_str = "Never"
-        else:
-            idle_minutes = (current_time - last_activity).total_seconds() / 60
-            status = f"Idle for {idle_minutes:.1f} minutes (cached)"
-            last_activity_str = last_activity.strftime('%Y-%m-%d %H:%M:%S')
+        with open(filepath, 'a', newline='', encoding='utf-8') as csvfile:
+            writer = csv.writer(csvfile)
+            if not file_exists:
+                print("[save_student_query_to_csv] Writing header row")
+                writer.writerow(['student_space', 'student_id', 'timestamp', 'search_info', 'query_and_response', 'thumb_feedback'])
+            
+            timestamp = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+            query_and_response = f"Query: {query}\nResponse: {response}"
+            writer.writerow([STUDENT_SPACE_NAME, check_id, timestamp, search_info, query_and_response, thumb_feedback or ""])
         
-        # 检查内存中的分配记录
-        is_recently_allocated_memory = space_name in active_allocations
-        if is_recently_allocated_memory:
-            alloc_info = active_allocations[space_name]
-            minutes_until_free = (alloc_info['expires_at'] - current_time).total_seconds() / 60
-            status += f" (Allocated in memory to {alloc_info['student_id']}, free in {minutes_until_free:.1f} min)"
+        print(f"[save_student_query_to_csv] Query saved to local file: {filepath}")
         
-        # Check if space is recently allocated (local)
-        is_recently_allocated_local, local_student = local_tracker.is_recently_allocated_locally(space_name)
-        if is_recently_allocated_local:
-            status += f" (Recently allocated locally to {local_student})"
+        # Commit student logs to data storage
+        print("[save_student_query_to_csv] Attempting to commit to remote repository...")
+        commit_success = commit_student_logs(f"Add query log from student {check_id} at {timestamp}")
         
-        space_activity.append({
-            'space_name': space_name,
-            'last_activity': last_activity,
-            'last_activity_str': last_activity_str,
-            'idle_minutes': idle_minutes,
-            'status': status,
-            'is_recently_allocated_memory': is_recently_allocated_memory,
-            'is_recently_allocated_local': is_recently_allocated_local,
-            'cached_status': cached_status
-        })
+        if commit_success:
+            print("[save_student_query_to_csv] Successfully committed to remote repository")
+        else:
+            print("[save_student_query_to_csv] Failed to commit to remote repository")
         
-        print(f"[analyze_space_activity_cached] {space_name}: {status}")
-    
-    # Sort by idle time (most idle first)
-    space_activity.sort(key=lambda x: x['idle_minutes'], reverse=True)
-    
-    return space_activity
-
-def create_status_display(space_activity):
-    """Create formatted status display for all spaces with proper line breaks"""
-    status_display = "📊 **Current Space Status (sorted by availability):**<br><br>"
-    
-    # 显示内存分配记录摘要
-    memory_summary = memory_allocation_store.get_status_summary()
-    if memory_summary['active_count'] > 0:
-        status_display += f"🧠 **Memory Allocations ({memory_summary['active_count']} active):**<br>"
-        for alloc in memory_summary['summary']:
-            status_display += f"&nbsp;&nbsp;&nbsp;• {alloc}<br>"
-        status_display += "<br>"
-    
-    # 显示本地分配记录摘要
-    local_summary = local_tracker.get_recent_allocations_summary()
-    if local_summary:
-        status_display += "🔒 **Recent Local Allocations:**<br>"
-        for alloc in local_summary:
-            status_display += f"&nbsp;&nbsp;&nbsp;• {alloc}<br>"
-        status_display += "<br>"
-    
-    for i, space in enumerate(space_activity, 1):
-        status_display += f"{i}. **{space['space_name']}**<br>"
-        status_display += f"&nbsp;&nbsp;&nbsp;• Status: {space['status']}<br>"
-        status_display += f"&nbsp;&nbsp;&nbsp;• Last activity: {space['last_activity_str']}<br><br>"
-    
-    return status_display
+        return True
+    except Exception as e:
+        print(f"[save_student_query_to_csv] Error: {e}")
+        import traceback
+        print(f"[save_student_query_to_csv] Traceback: {traceback.format_exc()}")
+        return False
 
-def select_space_with_enhanced_collision_avoidance_cached(space_activity, student_id):
-    """使用缓存的增强防撞空间选择函数 - 完全使用内存存储"""
-    
-    print(f"[select_space_with_enhanced_collision_avoidance_cached] Starting selection for student: {student_id}")
-    
-    # 第一步：过滤掉不符合基本条件的空间
-    basic_available_spaces = []
-    for space in space_activity:
-        # 检查基本条件 - 使用内存分配记录
-        if (space['idle_minutes'] >= MIN_IDLE_MINUTES and 
-            not space['is_recently_allocated_memory'] and 
-            not space['is_recently_allocated_local']):
-            basic_available_spaces.append(space)
-    
-    print(f"[select_space_with_enhanced_collision_avoidance_cached] Basic available spaces: {len(basic_available_spaces)}")
-    
-    if not basic_available_spaces:
-        # 生成详细的错误信息
-        idle_spaces = [s for s in space_activity if s['idle_minutes'] >= MIN_IDLE_MINUTES]
-        memory_allocated = [s for s in space_activity if s['is_recently_allocated_memory']]
-        local_allocated = [s for s in space_activity if s['is_recently_allocated_local']]
-        
-        error_parts = []
-        if not idle_spaces:
-            error_parts.append(f"all spaces used within {MIN_IDLE_MINUTES} minutes")
-        if memory_allocated:
-            error_parts.append(f"{len(memory_allocated)} spaces allocated in memory")
-        if local_allocated:
-            error_parts.append(f"{len(local_allocated)} spaces locally allocated")
+def update_latest_student_query_feedback(feedback_type, check_id):
+    """Update thumb feedback for the latest student query in CSV"""
+    try:
+        # Validate check_id
+        if not check_id:
+            print("[update_latest_student_query_feedback] Error: No valid check_id provided")
+            return False
         
-        error_msg = (
-            f"🚫 **All learning assistants are currently busy**\n\n"
-            f"Blocking conditions: {', '.join(error_parts)}\n\n"
-            f"**Please try again in 1-2 minutes.**"
-        )
+        filepath = os.path.join(LOCAL_DATA_DIR, QUERY_LOG_FILE)
+        if not os.path.exists(filepath):
+            print("[update_latest_student_query_feedback] Error: Query log file not found")
+            return False
         
-        print(f"[select_space_with_enhanced_collision_avoidance_cached] No available spaces: {error_msg}")
-        raise gr.Error(error_msg, duration=10)
-    
-    # 第二步：选择最优空间并进行最终验证
-    selected_space = basic_available_spaces[0]  # 已经按idle_time排序
-    space_name = selected_space['space_name']
-    
-    print(f"[select_space_with_enhanced_collision_avoidance_cached] Preliminary selection: {space_name}")
-    
-    # 第三步：最终防撞车检查 - 再次验证本地分配状态
-    is_local_conflict, conflicting_student = local_tracker.is_recently_allocated_locally(space_name)
-    if is_local_conflict:
-        print(f"[select_space_with_enhanced_collision_avoidance_cached] COLLISION DETECTED! {space_name} recently allocated to {conflicting_student}")
+        # Read existing data
+        rows = []
+        with open(filepath, 'r', encoding='utf-8') as csvfile:
+            reader = csv.reader(csvfile)
+            rows = list(reader)
         
-        # 寻找替代空间
-        alternative_spaces = [s for s in basic_available_spaces[1:] 
-                            if not local_tracker.is_recently_allocated_locally(s['space_name'])[0]]
+        # Update the last row (most recent query)
+        if len(rows) > 1:  # Ensure there's at least one data row beyond header
+            rows[-1][5] = feedback_type  # thumb_feedback column (index 5 for student format)
+            
+            # Write back to file
+            with open(filepath, 'w', newline='', encoding='utf-8') as csvfile:
+                writer = csv.writer(csvfile)
+                writer.writerows(rows)
+            
+            print(f"[update_latest_student_query_feedback] Updated feedback: {feedback_type}")
+            
+            # Commit the update
+            timestamp = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+            commit_student_logs(f"Update feedback from student {check_id}: {feedback_type} at {timestamp}")
+            return True
         
-        if alternative_spaces:
-            selected_space = alternative_spaces[0]
-            space_name = selected_space['space_name']
-            print(f"[select_space_with_enhanced_collision_avoidance_cached] Using alternative space: {space_name}")
-        else:
-            error_msg = (
-                f"🚫 **Collision detected and no alternatives available**\n\n"
-                f"The system detected a potential conflict with another student's allocation.\n\n"
-                f"**Please try again in 10-15 seconds.**"
-            )
-            print(f"[select_space_with_enhanced_collision_avoidance_cached] No alternatives available")
-            raise gr.Error(error_msg, duration=8)
-    
-    # 第四步：立即记录本地分配（在写入内存之前）
-    local_tracker.record_local_allocation(space_name, student_id)
-    print(f"[select_space_with_enhanced_collision_avoidance_cached] Local allocation recorded BEFORE memory write")
-    
-    # 第五步：记录到内存存储 - 不再写入文件或推送到远程
-    memory_allocation_store.add_allocation(space_name, student_id)
-    print(f"[select_space_with_enhanced_collision_avoidance_cached] Allocation recorded in memory only")
-    
-    # 第六步：生成结果（使用带缓存信息的状态显示）
-    status_display = create_status_display_with_cache_info(space_activity)
-    redirect_url = f"https://huggingface.co/spaces/CIV3283/{space_name}/?check={student_id}"
-    
-    print(f"[select_space_with_enhanced_collision_avoidance_cached] Final allocation: {space_name} -> {student_id}")
-    
-    return redirect_to_space(redirect_url, selected_space, status_display)
+        return False
+    except Exception as e:
+        print(f"[update_latest_student_query_feedback] Error: {e}")
+        return False
 
-def redirect_to_space(redirect_url, selected_space, status_display):
-    """Display redirect information with manual click option"""
-    
-    if selected_space['idle_minutes'] == float('inf'):
-        idle_info = "Never used (completely fresh)"
-    else:
-        idle_info = f"{selected_space['idle_minutes']:.1f} minutes"
-    
-    # Modified HTML structure - Access section first, then analysis
-    redirect_html = f"""
-    <div style="max-width: 900px; margin: 0 auto; padding: 20px; font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;">
-        <div style="text-align: center; margin-bottom: 30px; padding: 25px; background: linear-gradient(135deg, #28a745, #20c997); color: white; border-radius: 12px; box-shadow: 0 4px 6px rgba(0,0,0,0.1);">
-            <h1 style="margin: 0 0 15px 0; font-size: 28px;">🎯 Learning Assistant Assigned</h1>
-            <h2 style="margin: 0 0 10px 0; font-weight: normal; font-size: 24px;">{selected_space['space_name']}</h2>
-            <p style="margin: 0; font-size: 18px; opacity: 0.9;">
-                ✨ This space was idle for: <strong>{idle_info}</strong>
-            </p>
-        </div>
+def save_student_comment_feedback(comment, check_id):
+    """Save student comment feedback to centralized feedback file"""
+    try:
+        # Validate check_id
+        if not check_id:
+            print("[save_student_comment_feedback] Error: No valid check_id provided")
+            return False
         
-        <div style="text-align: center; margin-bottom: 30px; padding: 25px; background: linear-gradient(135deg, #2196f3, #1976d2); color: white; border-radius: 12px; box-shadow: 0 4px 6px rgba(33,150,243,0.3);">
-            <h2 style="margin-top: 0; color: white;">🚀 Access Your Learning Assistant</h2>
-            <p style="color: rgba(255,255,255,0.9); font-size: 16px; margin-bottom: 25px;">
-                Click the button below to access your assigned learning assistant.
-            </p>
-            
-            <a href="{redirect_url}" 
-               target="_blank"
-               style="display: inline-block; background: rgba(255,255,255,0.15); color: white; 
-                      padding: 15px 30px; font-size: 18px; font-weight: bold; text-decoration: none; 
-                      border-radius: 25px; border: 2px solid rgba(255,255,255,0.3);
-                      transition: all 0.3s ease; margin-bottom: 20px;"
-               onmouseover="this.style.background='rgba(255,255,255,0.25)'; this.style.transform='translateY(-2px)'"
-               onmouseout="this.style.background='rgba(255,255,255,0.15)'; this.style.transform='translateY(0px)'">
-                ➤ Open Learning Assistant
-            </a>
+        filepath = os.path.join(LOCAL_DATA_DIR, FEEDBACK_LOG_FILE)
+        file_exists = os.path.isfile(filepath)
+        
+        with open(filepath, 'a', newline='', encoding='utf-8') as csvfile:
+            writer = csv.writer(csvfile)
+            if not file_exists:
+                writer.writerow(['student_space', 'student_id', 'timestamp', 'comment'])
             
-            <p style="margin: 15px 0 0 0; color: rgba(255,255,255,0.8); font-size: 14px;">
-                💡 Left-click the button above or right-click it and select "Open in new tab"
-            </p>
-        </div>
+            timestamp = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+            writer.writerow([STUDENT_SPACE_NAME, check_id, timestamp, comment])
         
-        <div style="background: #f8f9fa; padding: 25px; border-radius: 12px; margin-bottom: 25px; border-left: 4px solid #28a745;">
-            <h3 style="margin-top: 0; color: #333;">📊 Space Selection Analysis</h3>
-            <div style="background: white; padding: 20px; border-radius: 8px; font-size: 14px; line-height: 1.8; border: 1px solid #e9ecef;">
-{status_display}
-            </div>
-            <p style="margin-bottom: 0; color: #666; font-size: 14px; margin-top: 15px;">
-                <strong>Enhanced Selection Algorithm:</strong> Spaces idle for ≥{MIN_IDLE_MINUTES} minutes, not allocated in memory, and not locally allocated are eligible. The system uses pure memory storage for real-time collision avoidance.
-            </p>
-        </div>
+        print(f"[save_student_comment_feedback] Saved comment to {filepath}")
         
-        <div style="text-align: center; padding: 20px; background: #f1f3f4; border-radius: 8px; margin-top: 20px;">
-            <p style="margin: 0; color: #5f6368; font-size: 14px;">
-                🔄 Need a different assistant? <a href="javascript:location.reload()" style="color: #1976d2; text-decoration: none;">Refresh this page</a> to get reassigned.
-            </p>
-        </div>
-    </div>
-    """
-    
-    return gr.HTML(redirect_html)
-
-def load_balance_user_cached(student_id):
-    """使用缓存的负载均衡函数 - 完全使用内存存储"""
-    print(f"[load_balance_user_cached] Starting cached load balancing for student ID: {student_id}")
-    
-    # 检查系统是否已初始化
-    if not data_manager.initialized:
-        raise gr.Error("🚫 System not properly initialized. Please contact administrator.", duration=8)
-    
-    # 使用缓存版本的分析函数（不触发数据同步）
-    space_activity = analyze_space_activity_cached()
-    
-    # Select space with enhanced collision avoidance
-    return select_space_with_enhanced_collision_avoidance_cached(space_activity, student_id)
+        # Commit student logs
+        commit_student_logs(f"Add comment feedback from student {check_id} at {timestamp}")
+        
+        return True
+    except Exception as e:
+        print(f"[save_student_comment_feedback] Error: {e}")
+        return False
 
 def get_url_params(request: gr.Request):
     """Extract URL parameters from request"""
@@ -837,344 +395,246 @@ def get_url_params(request: gr.Request):
         query_params = dict(request.query_params)
         check_id = query_params.get('check', None)
         if check_id:
-            return f"Load Distributor", check_id
+            return f"RAG Learning Assistant - Student", check_id
         else:
-            return "Load Distributor", None
-    return "Load Distributor", None
+            return "RAG Learning Assistant - Student", None
+    return "RAG Learning Assistant - Student", None
 
-def create_status_display_with_cache_info(space_activity):
-    """创建包含缓存信息的状态显示"""
-    global activity_cache
+def chat_response(message, history, search_info_display, check_id, has_query):
+    """Process user input and return streaming response"""
+    if not message.strip():
+        return history, search_info_display, has_query
     
-    # 获取缓存状态
-    cache_info = activity_cache.get_cache_info() if activity_cache else None
-    
-    status_display = "📊 **Current Space Status (sorted by availability):**<br><br>"
+    # Check access permission first
+    if not check_id:
+        print(f"[chat_response] Access denied: No valid check ID provided")
+        # Raise error dialog for access denial
+        raise gr.Error(
+            "⚠️ Access Restricted\n\n"
+            "Please access this system through the link provided in Moodle.\n\n"
+            "If you are a student in this course:\n"
+            "1. Go to your Moodle course page\n"
+            "2. Find the 'CivASK' link\n"
+            "3. Click the link to access the system\n\n"
+            "If you continue to experience issues, please contact your instructor.",
+            duration=8
+        )
     
-    # 显示缓存信息
-    if cache_info:
-        if cache_info['is_fresh']:
-            cache_status = f"✅ Fresh (updated {cache_info['age_minutes']:.1f} min ago)"
+    # NEW: Check session validity before proceeding
+    session_valid, error_message = check_session_validity(check_id)
+    if not session_valid:
+        print(f"[chat_response] Session invalid for student {check_id}")
+        raise gr.Error(error_message, duration=10)
+    
+    # Valid access and valid session - proceed with normal AI conversation
+    print(f"[chat_response] Valid access and session for student ID: {check_id}")
+    
+    # Convert to messages format if needed
+    if history and isinstance(history[0], list):
+        # Convert from tuples to messages format
+        messages_history = []
+        for user_msg, assistant_msg in history:
+            messages_history.append({"role": "user", "content": user_msg})
+            if assistant_msg:
+                messages_history.append({"role": "assistant", "content": assistant_msg})
+        history = messages_history
+    
+    # Add user message
+    history.append({"role": "user", "content": message})
+    history.append({"role": "assistant", "content": ""})
+    
+    search_info_collected = False
+    search_info_content = ""
+    content_part = ""
+    
+    # Process streaming response
+    for chunk in assistant.generate_response_stream(message):
+        if not search_info_collected:
+            if "**Response:**" in chunk:  # Support English markers
+                search_info_content += chunk
+                search_info_collected = True
+                yield history, search_info_content, has_query
+            else:
+                search_info_content += chunk
+                yield history, search_info_content, has_query
         else:
-            cache_status = f"⚠️ Stale (updated {cache_info['age_minutes']:.1f} min ago)"
-        
-        status_display += f"🔄 **Cache Status:** {cache_status}<br>"
-        status_display += f"📋 **Cached Spaces:** {cache_info['spaces_count']}<br><br>"
-    
-    # 显示内存分配记录摘要
-    memory_summary = memory_allocation_store.get_status_summary()
-    if memory_summary['active_count'] > 0:
-        status_display += f"🧠 **Memory Allocations ({memory_summary['active_count']} active):**<br>"
-        for alloc in memory_summary['summary']:
-            status_display += f"&nbsp;&nbsp;&nbsp;• {alloc}<br>"
-        status_display += "<br>"
-    
-    # 显示本地分配记录摘要
-    local_summary = local_tracker.get_recent_allocations_summary()
-    if local_summary:
-        status_display += "🔒 **Recent Local Allocations:**<br>"
-        for alloc in local_summary:
-            status_display += f"&nbsp;&nbsp;&nbsp;• {alloc}<br>"
-        status_display += "<br>"
-    
-    for i, space in enumerate(space_activity, 1):
-        status_display += f"{i}. **{space['space_name']}**<br>"
-        status_display += f"&nbsp;&nbsp;&nbsp;• Status: {space['status']}<br>"
-        status_display += f"&nbsp;&nbsp;&nbsp;• Last activity: {space['last_activity_str']}<br>"
-        
-        # 显示缓存状态（可选）
-        if 'cached_status' in space:
-            status_display += f"&nbsp;&nbsp;&nbsp;• Cache: {space['cached_status']}<br>"
-        
-        status_display += "<br>"
-    
-    return status_display
-
-def handle_user_access_cached(request: gr.Request):
-    """使用缓存的用户访问处理"""
-    title, check_id = get_url_params(request)
+            content_part += chunk
+            # Update the last assistant message
+            history[-1]["content"] = content_part
+            yield history, search_info_content, has_query
     
-    if not check_id:
-        # No student ID provided
-        error_html = """
-        <div style="max-width: 600px; margin: 50px auto; padding: 30px; text-align: center; 
-                    background: #fff3cd; border: 1px solid #ffeaa7; border-radius: 12px;">
-            <h2 style="color: #856404;">⚠️ Invalid Access</h2>
-            <p style="color: #856404; font-size: 16px; line-height: 1.6;">
-                This load distributor requires a valid student ID parameter.<br><br>
-                <strong>Please access this system through the official link provided in Moodle.</strong>
-            </p>
-        </div>
-        """
-        return title, gr.HTML(error_html)
-    
-    # Valid student ID - perform cached load balancing
-    try:
-        result = load_balance_user_cached(check_id)
-        return title, result
-    except Exception as e:
-        # Handle any errors during load balancing
-        error_html = f"""
-        <div style="max-width: 600px; margin: 50px auto; padding: 30px; text-align: center; 
-                    background: #f8d7da; border: 1px solid #f5c6cb; border-radius: 12px;">
-            <h2 style="color: #721c24;">🚫 Load Balancing Error</h2>
-            <p style="color: #721c24; font-size: 16px; line-height: 1.6;">
-                {str(e)}<br><br>
-                Please try again in a few moments or contact your instructor if the problem persists.
-            </p>
-        </div>
-        """
-        return title, gr.HTML(error_html)
-
-# 管理功能
-def get_cache_status():
-    """获取缓存状态（用于调试或管理）"""
-    global activity_cache
-    if activity_cache:
-        return activity_cache.get_cache_info()
-    return {"error": "Cache not initialized"}
-
-def force_cache_update():
-    """强制更新缓存（用于调试或管理）"""
-    global activity_cache
-    if activity_cache:
-        activity_cache.force_update()
-        return {"status": "Cache updated"}
-    return {"error": "Cache not initialized"}
-
-def get_data_manager_status():
-    """获取数据管理器状态"""
-    return {
-        "initialized": data_manager.initialized,
-        "last_sync": data_manager.last_data_sync.isoformat() if data_manager.last_data_sync else None,
-        "spaces_count": len(data_manager.available_spaces),
-        "repo_connected": data_manager.repo is not None
-    }
-
-def force_data_sync():
-    """强制数据同步"""
+    # After streaming is complete, save to CSV (only for valid access)
     try:
-        data_manager._sync_data()
-        return {"status": "Data sync completed"}
+        print(f"[chat_response] Saving student query to CSV...")
+        print(f"Student Space: {STUDENT_SPACE_NAME}")
+        print(f"Student ID: {check_id}")
+        print(f"Query: {message}")
+        
+        save_success = save_student_query_to_csv(message, search_info_content, content_part, check_id)
+        if save_success:
+            print(f"[chat_response] Student query saved successfully")
+            has_query = True  # Mark that we have a query to rate
+        else:
+            print(f"[chat_response] Failed to save student query")
+        
     except Exception as e:
-        return {"error": str(e)}
+        print(f"[chat_response] Error saving student query: {e}")
+    
+    return history, search_info_content, has_query
 
-def get_memory_allocation_status():
-    """获取内存分配状态"""
-    return memory_allocation_store.get_status_summary()
+# Global variables
+repo = None
+assistant = None
 
-def clear_memory_allocations():
-    """清除所有内存分配记录（管理功能）"""
-    try:
-        with memory_allocation_store._lock:
-            cleared_count = len(memory_allocation_store._allocations)
-            memory_allocation_store._allocations.clear()
-        return {"status": f"Cleared {cleared_count} memory allocations"}
-    except Exception as e:
-        return {"error": str(e)}
-
-# 添加可选的管理界面（用于调试）
-def create_admin_interface():
-    """创建管理界面（可选）- 增强版本"""
-    with gr.Blocks(title="CIV3283 Load Distributor - Admin") as admin_interface:
-        gr.Markdown("# 🔧 CIV3283 Load Distributor - Admin Panel")
-        
-        with gr.Tab("Cache Management"):
-            with gr.Row():
-                cache_status_btn = gr.Button("📊 Check Cache Status", variant="secondary")
-                force_cache_update_btn = gr.Button("🔄 Force Cache Update", variant="primary")
-            
-            cache_info_display = gr.JSON(label="Cache Information")
-            cache_status_message = gr.Markdown("")
-            
-        with gr.Tab("Data Management"):
-            with gr.Row():
-                data_status_btn = gr.Button("📊 Check Data Manager Status", variant="secondary")
-                force_data_sync_btn = gr.Button("🔄 Force Data Sync", variant="primary")
-            
-            data_info_display = gr.JSON(label="Data Manager Information")
-            data_status_message = gr.Markdown("")
-        
-        with gr.Tab("Memory Allocation"):
-            with gr.Row():
-                memory_status_btn = gr.Button("🧠 Check Memory Allocations", variant="secondary")
-                clear_memory_btn = gr.Button("🗑️ Clear All Memory Allocations", variant="stop")
-            
-            memory_info_display = gr.JSON(label="Memory Allocation Information")
-            memory_status_message = gr.Markdown("")
-        
-        def check_cache_status():
-            try:
-                status = get_cache_status()
-                if 'error' in status:
-                    return status, "❌ Cache not available"
-                else:
-                    age_min = status.get('age_minutes', 0)
-                    spaces_count = status.get('spaces_count', 0)
-                    is_fresh = status.get('is_fresh', False)
-                    
-                    if is_fresh:
-                        message = f"✅ Cache is fresh ({age_min:.1f} min old, {spaces_count} spaces)"
-                    else:
-                        message = f"⚠️ Cache is stale ({age_min:.1f} min old, {spaces_count} spaces)"
-                    
-                    return status, message
-            except Exception as e:
-                return {"error": str(e)}, f"❌ Error checking cache: {str(e)}"
-        
-        def force_update():
-            try:
-                result = force_cache_update()
-                if 'error' in result:
-                    return result, "❌ Failed to update cache"
-                else:
-                    # 获取更新后的状态
-                    status = get_cache_status()
-                    return status, "✅ Cache updated successfully"
-            except Exception as e:
-                return {"error": str(e)}, f"❌ Error updating cache: {str(e)}"
-        
-        def check_data_status():
-            try:
-                status = get_data_manager_status()
-                if status['initialized']:
-                    last_sync = status['last_sync']
-                    if last_sync:
-                        sync_time = datetime.fromisoformat(last_sync)
-                        age_minutes = (datetime.now() - sync_time).total_seconds() / 60
-                        message = f"✅ Data manager active (last sync: {age_minutes:.1f} min ago, {status['spaces_count']} spaces)"
-                    else:
-                        message = "⚠️ Data manager initialized but no sync recorded"
-                else:
-                    message = "❌ Data manager not initialized"
-                return status, message
-            except Exception as e:
-                return {"error": str(e)}, f"❌ Error checking data manager: {str(e)}"
-        
-        def force_sync():
-            try:
-                result = force_data_sync()
-                if 'error' in result:
-                    return result, "❌ Failed to sync data"
-                else:
-                    # 获取更新后的状态
-                    status = get_data_manager_status()
-                    return status, "✅ Data sync completed successfully"
-            except Exception as e:
-                return {"error": str(e)}, f"❌ Error syncing data: {str(e)}"
-        
-        def check_memory_status():
-            try:
-                status = get_memory_allocation_status()
-                active_count = status['active_count']
-                total_stored = status['total_stored']
+def main():
+    """Main function to initialize and launch the student application"""
+    global repo, assistant
+    
+    # Initialize data storage repository connection
+    repo = init_data_storage_repo()
+    
+    # Initialize RAG assistant with centralized data storage directory
+    print(f"[main] Initializing RAG assistant with data directory: {LOCAL_DATA_DIR}")
+    print(f"[main] Session timeout set to: {SESSION_TIMEOUT_MINUTES} minutes")
+    assistant = RAGLearningAssistant(
+        api_key=OPENAI_API_KEY, 
+        model=MODEL, 
+        vector_db_path=LOCAL_DATA_DIR  # Pass the data storage repo directory
+    )
+    
+    print(f"[main] RAG assistant initialized successfully")
+    print(f"[main] Student space: {STUDENT_SPACE_NAME}")
+    print(f"[main] Data storage repo: {DATA_STORAGE_REPO}")
+    print(f"[main] Query log file: {QUERY_LOG_FILE}")
+    print(f"[main] Feedback log file: {FEEDBACK_LOG_FILE}")
+    
+    # Create interface
+    with gr.Blocks(title=f"RAG Assistant - {STUDENT_SPACE_NAME}") as interface:
+        check_id_state = gr.State("1")
+        has_query_state = gr.State(False)  # Track if there's a query to rate
+        title_display = gr.Markdown(f"# RAG Learning Assistant - {STUDENT_SPACE_NAME}", elem_id="title")
+        
+        # Only Query Check functionality for students
+        with gr.Row():
+            with gr.Column(scale=4):
+                chatbot = gr.Chatbot(label="Ask Your Questions", height=500, type="messages", render_markdown=True, latex_delimiters=[
+                                                                                                                        { "left": "$$", "right": "$$", "display": True },
+                                                                                                                        { "left": "$", "right": "$", "display": False },
+                                                                                                                        { "left": "\(", "right": "\)", "display": False },
+                                                                                                                        { "left": "\[", "right": "\]", "display": True }])
+                msg = gr.Textbox(placeholder="Type your message here...", label="Your Message", show_label=True)
                 
-                if active_count > 0:
-                    message = f"🧠 {active_count} active allocations ({total_stored} total in memory)"
-                else:
-                    message = "✅ No active memory allocations"
+                # Feedback buttons row
+                with gr.Row():
+                    thumbs_up_btn = gr.Button("👍 Good Answer", variant="secondary", size="sm")
+                    thumbs_down_btn = gr.Button("👎 Poor Answer", variant="secondary", size="sm")
                 
-                return status, message
-            except Exception as e:
-                return {"error": str(e)}, f"❌ Error checking memory allocations: {str(e)}"
-        
-        def clear_memory():
-            try:
-                result = clear_memory_allocations()
-                if 'error' in result:
-                    return result, "❌ Failed to clear memory allocations"
+                feedback_status = gr.Textbox(label="Feedback Status", interactive=False, lines=1)
+                
+                # Comment section
+                with gr.Row():
+                    comment_input = gr.Textbox(placeholder="Share your comments or suggestions...", label="Comments", lines=2)
+                    submit_comment_btn = gr.Button("Submit Comment", variant="outline")
+            
+            with gr.Column(scale=1):
+                search_info = gr.Markdown(label="Search Analysis Information", value="")
+        
+        # Event handlers
+        def init_from_url(request: gr.Request):
+            title, check_id = get_url_params(request)
+            print(f"[init_from_url] Extracted check_id: {check_id}")
+            return f"# {title}", check_id, False  # Reset has_query state
+        
+        # Feedback handlers
+        def handle_thumbs_up(check_id, has_query):
+            if not check_id:
+                raise gr.Error(
+                    "⚠️ Access Restricted\n\n"
+                    "Please access this system through the CivASK link provided in Moodle to use the feedback features.",
+                    duration=5
+                )
+            
+            print(f"[handle_thumbs_up] Student: {STUDENT_SPACE_NAME}, check_id: {check_id}")
+            
+            # Check if student query log exists and has queries
+            filepath = os.path.join(LOCAL_DATA_DIR, QUERY_LOG_FILE)
+            if os.path.exists(filepath):
+                with open(filepath, 'r', encoding='utf-8') as csvfile:
+                    reader = csv.reader(csvfile)
+                    rows = list(reader)
+                    if len(rows) > 1:  # Has header + at least one data row
+                        success = update_latest_student_query_feedback("thumbs_up", check_id)
+                        return "👍 Thank you for your positive feedback!" if success else "Failed to save feedback"
+            
+            return "No query to rate yet"
+        
+        def handle_thumbs_down(check_id, has_query):
+            if not check_id:
+                raise gr.Error(
+                    "⚠️ Access Restricted\n\n"
+                    "Please access this system through the CivASK link provided in Moodle to use the feedback features.",
+                    duration=5
+                )
+            
+            print(f"[handle_thumbs_down] Student: {STUDENT_SPACE_NAME}, check_id: {check_id}")
+            
+            # Check if student query log exists and has queries
+            filepath = os.path.join(LOCAL_DATA_DIR, QUERY_LOG_FILE)
+            if os.path.exists(filepath):
+                with open(filepath, 'r', encoding='utf-8') as csvfile:
+                    reader = csv.reader(csvfile)
+                    rows = list(reader)
+                    if len(rows) > 1:  # Has header + at least one data row
+                        success = update_latest_student_query_feedback("thumbs_down", check_id)
+                        return "👎 Thank you for your feedback. We'll work to improve!" if success else "Failed to save feedback"
+            
+            return "No query to rate yet"
+        
+        def handle_comment_submission(comment, check_id):
+            if not check_id:
+                raise gr.Error(
+                    "⚠️ Access Restricted\n\n"
+                    "Please access this system through the CivASK link provided in Moodle to submit comments.",
+                    duration=5
+                )
+            
+            if comment.strip():
+                success = save_student_comment_feedback(comment.strip(), check_id)
+                if success:
+                    return "💬 Thank you for your comment!", ""
                 else:
-                    # 获取更新后的状态
-                    status = get_memory_allocation_status()
-                    return status, f"✅ {result['status']}"
-            except Exception as e:
-                return {"error": str(e)}, f"❌ Error clearing memory: {str(e)}"
-        
-        # Cache tab event handlers
-        cache_status_btn.click(
-            fn=check_cache_status,
-            outputs=[cache_info_display, cache_status_message]
-        )
-        
-        force_cache_update_btn.click(
-            fn=force_update,
-            outputs=[cache_info_display, cache_status_message]
+                    return "Failed to save comment", comment
+            return "Please enter a comment", comment
+        
+        interface.load(fn=init_from_url, outputs=[title_display, check_id_state, has_query_state])
+        
+        # Query events
+        msg.submit(
+            chat_response, 
+            [msg, chatbot, search_info, check_id_state, has_query_state], 
+            [chatbot, search_info, has_query_state]
+        ).then(lambda: "", outputs=[msg])
+        
+        # Feedback events
+        thumbs_up_btn.click(
+            handle_thumbs_up,
+            inputs=[check_id_state, has_query_state],
+            outputs=[feedback_status]
         )
         
-        # Data tab event handlers
-        data_status_btn.click(
-            fn=check_data_status,
-            outputs=[data_info_display, data_status_message]
+        thumbs_down_btn.click(
+            handle_thumbs_down,
+            inputs=[check_id_state, has_query_state],
+            outputs=[feedback_status]
         )
         
-        force_data_sync_btn.click(
-            fn=force_sync,
-            outputs=[data_info_display, data_status_message]
-        )
-        
-        # Memory tab event handlers
-        memory_status_btn.click(
-            fn=check_memory_status,
-            outputs=[memory_info_display, memory_status_message]
-        )
-        
-        clear_memory_btn.click(
-            fn=clear_memory,
-            outputs=[memory_info_display, memory_status_message]
+        submit_comment_btn.click(
+            handle_comment_submission,
+            inputs=[comment_input, check_id_state],
+            outputs=[feedback_status, comment_input]
         )
     
-    return admin_interface
+    interface.launch()
 
-# 修改后的主Gradio界面
-def create_main_interface():
-    """创建主要的用户界面"""
-    with gr.Blocks(title="CIV3283 Load Distributor") as interface:
-        title_display = gr.Markdown("# 🔄 CIV3283 Learning Assistant Load Distributor", elem_id="title")
-        content_display = gr.HTML("")
-        
-        # 主要的负载均衡逻辑 - 页面加载时执行
-        interface.load(
-            fn=handle_user_access_cached,
-            outputs=[title_display, content_display]
-        )
-    
-    return interface
-
-# 修改后的main函数
 if __name__ == "__main__":
-    import sys
-    
-    try:
-        # 系统初始化 - 只在启动时执行一次
-        print("🚀 Initializing CIV3283 Load Distributor System...")
-        init_system()
-        print("✅ System initialization completed successfully")
-        print("🧠 Using pure memory storage for allocations (no file I/O during user access)")
-        
-        # 检查是否需要管理界面
-        enable_admin = "--admin" in sys.argv or os.environ.get("ENABLE_ADMIN", "false").lower() == "true"
-        
-        if enable_admin:
-            print("🔧 Starting with admin interface enabled")
-            # 创建带管理界面的组合界面
-            main_interface = create_main_interface()
-            admin_interface = create_admin_interface()
-            
-            # 使用TabbedInterface组合两个界面
-            combined_interface = gr.TabbedInterface(
-                [main_interface, admin_interface],
-                ["🎯 Load Distributor", "🔧 Admin Panel"],
-                title="CIV3283 Load Distributor System"
-            )
-            combined_interface.launch()
-        else:
-            print("🎯 Starting main interface only")
-            # 只启动主界面
-            main_interface = create_main_interface()
-            main_interface.launch()
-            
-    except Exception as e:
-        print(f"❌ System initialization failed: {e}")
-        import traceback
-        print(f"Traceback: {traceback.format_exc()}")
-        raise
+    main()