Fix multiuser concurrency bottleneck and update HF deployment docs

NITDAA_HF_DEPLOYMENT_GUIDE.md

@@ -10,10 +10,13 @@ This document outlines the specific steps and constraints required to deploy the
 - Hardware allocation: Free Tier (2 vCPU, 16GB Disk, 12GB RAM).
 
 ## 2. HuggingFace Secrets Configuration
-To enable dynamic Dataset Synchronization, you must configure the following variable in your Space's Settings under **Variables and Secrets**:
-- `HF_TOKEN`: A HuggingFace access token with "Read" and "Write" permissions to the `Sam-max1/he-data` and `Sam-max1/mat_data` datasets.
+To enable dynamic Dataset Synchronization, you must configure the following variable:
+- `HF_TOKEN`: A HuggingFace access token with "Read" and "Write" permissions to the `Sam-max1/he-data` and `Sam-max1/mat_data` datasets. This token is available via the system keyring or environment variables.
 - `ADMIN_MODE`: Set to `0` to completely lock down the UI for public usage.
 
+## 2.1 Minimalist Deployment Rule
+Nitdaa must always contain **only the bare minimum files required** to run the application in HF and the bare minimum files to be pushed to HF. Exclude all extraneous assets, development scripts, or unnecessary documentation from the Hugging Face repository.
+
 ## 3. Deployment Steps
 1. Clone the `nitdaa` folder locally.
 2. Initialize a git repository pointing to your HF Space remote.

app.py

@@ -131,23 +131,9 @@ _jobs: dict[str, dict] = {}
 _active_graph_tasks = 0
 _session_uploads: dict[str, int] = {}
 
-# Global query queue to prevent LLM overload
-import queue as _global_queue
-_llm_query_queue = _global_queue.Queue()
-
-def _query_worker():
-    while True:
-        task = _llm_query_queue.get()
-        if task is None: break
-        func, args = task
-        try:
-            func(*args)
-        except Exception as e:
-            log.exception("Query worker error")
-        finally:
-            _llm_query_queue.task_done()
-
-threading.Thread(target=_query_worker, daemon=True).start()
+# Global thread pool to allow concurrent RAG execution
+from concurrent.futures import ThreadPoolExecutor
+_query_executor = ThreadPoolExecutor(max_workers=8)
 
 # Auto-ingest background progress tracker
 _auto_ingest_status: dict = {
@@ -879,7 +865,8 @@ def query_start():
             _query_jobs[job_id]["done"] = True
             log_query_summary(token, remote_addr, q, top_k or 10, 0, False, str(e))
 
-    _llm_query_queue.put((_run, ()))
+    _query_executor.submit(_run)
+    
     return jsonify({"job_id": job_id})
 
 @app.route("/api/query/stream/<job_id>")

pipeline/graph_store.py

@@ -9,38 +9,48 @@ sys.path.insert(0, os.path.dirname(os.path.dirname(__file__)))
 import config
 
 _db = None
-_conn = None
 _db_lock = threading.Lock()
 _schema_initialized = False
-
+_local = threading.local()
 
 def _get_conn():
-    global _db, _conn, _schema_initialized
+    global _db, _schema_initialized
     if not getattr(config, 'GRAPH_AVAILABLE', True):
         return None
+        
+    if hasattr(_local, 'conn') and _local.conn is not None:
+        return _local.conn
     
     with _db_lock:
-        if _conn is not None:
-            return _conn
-        try:
-            import kuzu
-            # Ensure parent path exists
-            os.makedirs(os.path.dirname(config.KUZU_DB_PATH), exist_ok=True)
-            _db = kuzu.Database(config.KUZU_DB_PATH)
-            _conn = kuzu.Connection(_db)
-            print(f"[GraphStore] Connected to Kuzu at {config.KUZU_DB_PATH}")
-            if not _schema_initialized:
-                _init_schema()
-                _schema_initialized = True
-        except Exception as e:
-            print(f"[GraphStore] Kuzu initialization failed. ({e})")
-            _conn = None
-    return _conn
+        if _db is None:
+            try:
+                import kuzu
+                os.makedirs(os.path.dirname(config.KUZU_DB_PATH), exist_ok=True)
+                _db = kuzu.Database(config.KUZU_DB_PATH)
+                print(f"[GraphStore] Connected to Kuzu at {config.KUZU_DB_PATH}")
+                
+                # Use a temporary connection to initialize schema
+                tmp_conn = kuzu.Connection(_db)
+                if not _schema_initialized:
+                    _init_schema(tmp_conn)
+                    _schema_initialized = True
+            except Exception as e:
+                print(f"[GraphStore] Kuzu initialization failed. ({e})")
+                return None
 
+    try:
+        import kuzu
+        _local.conn = kuzu.Connection(_db)
+        return _local.conn
+    except Exception as e:
+        print(f"[GraphStore] Failed to create thread-local Kuzu connection. ({e})")
+        return None
 
-def _init_schema():
+
+def _init_schema(conn=None):
     """Create node and relationship tables for Kuzu."""
-    conn = _conn
+    if not conn:
+        conn = _get_conn()
     if not conn:
         return