Base DB added

app.py

@@ -13,6 +13,12 @@ for sub in ["src", "src/display", "src/submission", "src/leaderboard", "src/audi
     if os.path.exists(p):
         sys.path.insert(0, p)
 
+# DB Integration
+try:
+    from src.db import mongo_get_all_certificates, mongo_save_certificate
+except ImportError:
+    from db import mongo_get_all_certificates, mongo_save_certificate
+
 # About
 try:
     from src.about import CITATION_BUTTON_LABEL, CITATION_BUTTON_TEXT, INTRODUCTION_TEXT, TITLE
@@ -84,7 +90,9 @@ def seed_demo_results():
     if not os.path.exists(EVAL_RESULTS_PATH):
         os.makedirs(EVAL_RESULTS_PATH, exist_ok=True)
 
-    if not os.listdir(EVAL_RESULTS_PATH):
+    # Check if we already have records in MongoDB or local disk
+    existing_docs = mongo_get_all_certificates()
+    if not existing_docs and not os.listdir(EVAL_RESULTS_PATH):
         mock_cert = {
             "status": "ok",
             "config": {
@@ -128,8 +136,10 @@ def seed_demo_results():
                 "disclaimer": "Diagnostic signal only.",
             },
         }
+        # Save to local and MongoDB Atlas
         with open(os.path.join(EVAL_RESULTS_PATH, "Qwen__Qwen2.5-0.5B-Instruct_main.json"), "w", encoding="utf-8") as f:
             json.dump(mock_cert, f, indent=2)
+        mongo_save_certificate(mock_cert)
 
 
 seed_demo_results()
@@ -289,10 +299,7 @@ with demo:
         with gr.Accordion("📙 Methodology & Limitations", open=False):
             gr.Textbox(value=CITATION_BUTTON_TEXT, label=CITATION_BUTTON_LABEL, lines=8, show_copy_button=True)
 
-# if __name__ == "__main__":
-#     demo.launch()
-
+if __name__ == "__main__":
+    demo.launch()
 # if __name__ == "__main__":
 #     demo.launch(server_name="0.0.0.0", server_port=7860)
-if __name__ == "__main__":
-    demo.launch()

requirements.txt

@@ -12,4 +12,6 @@ tokenizers>=0.15.0
 accelerate
 datasets
 python-dateutil
-apscheduler
+apscheduler
+pymongo>=4.6.0
+dnspython>=2.4.0

src/db.py

@@ -0,0 +1,94 @@
+import os
+from typing import Dict, List, Optional
+
+try:
+    import pymongo
+    HAS_PYMONGO = True
+except ImportError:
+    HAS_PYMONGO = False
+
+# MongoDB Connection String from Atlas
+DEFAULT_URI = None
+MONGODB_URI = os.environ.get("MONGODB_URI", DEFAULT_URI)
+DB_NAME = os.environ.get("MONGODB_DB_NAME", "llm_xray_db")
+COLLECTION_NAME = "audit_certificates"
+
+_mongo_client = None
+
+def get_db_collection():
+    global _mongo_client
+    if not HAS_PYMONGO:
+        return None
+    try:
+        if _mongo_client is None:
+            _mongo_client = pymongo.MongoClient(
+                MONGODB_URI,
+                serverSelectionTimeoutMS=4000,
+                connectTimeoutMS=4000,
+            )
+        db = _mongo_client[DB_NAME]
+        return db[COLLECTION_NAME]
+    except Exception as e:
+        print(f"[MongoDB] Connection warning: {e}", flush=True)
+        return None
+
+
+def mongo_save_certificate(cert: Dict) -> bool:
+    """Saves or updates an audit certificate in MongoDB."""
+    col = get_db_collection()
+    if col is None:
+        return False
+    try:
+        config = cert.get("config", {})
+        model_name = config.get("model_name", "unknown")
+        model_sha = config.get("model_sha", "main")
+        doc_id = f"{model_name}__{model_sha}".replace("/", "__")
+
+        doc = dict(cert)
+        doc["_id"] = doc_id
+        doc["model_name"] = model_name
+        doc["model_sha"] = model_sha
+
+        col.replace_one({"_id": doc_id}, doc, upsert=True)
+        print(f"[MongoDB] ✅ Successfully persisted audit certificate for '{model_name}'", flush=True)
+        return True
+    except Exception as e:
+        print(f"[MongoDB] ⚠️ Could not save certificate to MongoDB: {e}", flush=True)
+        return False
+
+
+def mongo_get_certificate(clean_model_name: str) -> Optional[Dict]:
+    """Retrieves an audit certificate by model name from MongoDB."""
+    col = get_db_collection()
+    if col is None or not clean_model_name:
+        return None
+    try:
+        # Search by exact name, normalized id, or regex
+        doc = col.find_one({
+            "$or": [
+                {"config.model_name": clean_model_name},
+                {"model_name": clean_model_name},
+                {"_id": {"$regex": f"^{clean_model_name.replace('/', '__')}", "$options": "i"}}
+            ]
+        })
+        if doc:
+            doc.pop("_id", None)
+            return doc
+    except Exception as e:
+        print(f"[MongoDB] ⚠️ Error retrieving '{clean_model_name}': {e}", flush=True)
+    return None
+
+
+def mongo_get_all_certificates() -> List[Dict]:
+    """Recalls all saved certificates from MongoDB."""
+    col = get_db_collection()
+    if col is None:
+        return []
+    try:
+        docs = list(col.find({}))
+        for d in docs:
+            d.pop("_id", None)
+        return docs
+    except Exception as e:
+        print(f"[MongoDB] ⚠️ Error loading all certificates: {e}", flush=True)
+        return []

src/leaderboard/read_evals.py

@@ -2,6 +2,11 @@ import json
 import os
 from dataclasses import dataclass
 
+try:
+    from src.db import mongo_get_all_certificates
+except ImportError:
+    from db import mongo_get_all_certificates
+
 try:
     from src.display.formatting import make_clickable_model
 except ImportError:
@@ -43,14 +48,8 @@ class EvalResult:
     sample_adequate: bool = True
 
     @classmethod
-    def init_from_json_file(cls, json_filepath):
-        try:
-            with open(json_filepath, "r", encoding="utf-8") as fp:
-                data = json.load(fp)
-        except Exception:
-            return None
-
-        if data.get("status") not in ("ok", None):
+    def init_from_dict(cls, data: dict):
+        if not isinstance(data, dict) or data.get("status") not in ("ok", None):
             return None
 
         config = data.get("config", {})
@@ -135,8 +134,16 @@ class EvalResult:
             precision=precision_enum,
         )
 
+    @classmethod
+    def init_from_json_file(cls, json_filepath):
+        try:
+            with open(json_filepath, "r", encoding="utf-8") as fp:
+                data = json.load(fp)
+            return cls.init_from_dict(data)
+        except Exception:
+            return None
+
     def to_dict(self):
-        # "T" column hyperlinks directly to the model HF repo
         symbol_link = f'<a href="https://huggingface.co/{self.full_model}" target="_blank" title="View on Hugging Face" style="text-decoration: none;">{self.model_type.value.symbol}</a>'
         
         data_dict = {
@@ -159,16 +166,28 @@ class EvalResult:
 
 
 def get_raw_eval_results(results_path: str, requests_path: str = "") -> list[EvalResult]:
+    seen_evals = set()
     results = []
-    if not os.path.exists(results_path):
-        return results
-    for root, _, files in os.walk(results_path):
-        for file in files:
-            if file.endswith(".json"):
-                try:
-                    res = EvalResult.init_from_json_file(os.path.join(root, file))
-                    if res is not None:
-                        results.append(res)
-                except Exception as e:
-                    print(f"Error reading {file}: {e}")
+
+    # 1. Recall directly from MongoDB Atlas
+    mongo_docs = mongo_get_all_certificates()
+    for doc in mongo_docs:
+        res = EvalResult.init_from_dict(doc)
+        if res and res.eval_name not in seen_evals:
+            seen_evals.add(res.eval_name)
+            results.append(res)
+
+    # 2. Merge any local disk files
+    if os.path.exists(results_path):
+        for root, _, files in os.walk(results_path):
+            for file in files:
+                if file.endswith(".json"):
+                    try:
+                        res = EvalResult.init_from_json_file(os.path.join(root, file))
+                        if res is not None and res.eval_name not in seen_evals:
+                            seen_evals.add(res.eval_name)
+                            results.append(res)
+                    except Exception as e:
+                        print(f"Error reading {file}: {e}")
+
     return results

src/submission/submit.py

@@ -21,6 +21,12 @@ def gpu_decorator(duration=120):
         return fn
     return decorator
 
+# Database integration
+try:
+    from src.db import mongo_get_certificate, mongo_save_certificate
+except ImportError:
+    from db import mongo_get_certificate, mongo_save_certificate
+
 # Engine import
 try:
     from src.audit.engine import AuditError, check_feasibility, run_full_audit
@@ -120,30 +126,44 @@ def clean_model_name(raw_name: str) -> str:
 
 def get_certificate_by_model_name(model_name: str) -> dict:
     clean_name = clean_model_name(model_name)
-    if not clean_name or not os.path.exists(EVAL_RESULTS_PATH):
+    if not clean_name:
         return {}
 
-    safe_prefix = clean_name.replace("/", "__")
-    for f in os.listdir(EVAL_RESULTS_PATH):
-        if f.startswith(safe_prefix) and f.endswith(".json"):
-            try:
-                with open(os.path.join(EVAL_RESULTS_PATH, f), "r", encoding="utf-8") as fp:
-                    return json.load(fp)
-            except Exception:
-                continue
+    # 1. Check MongoDB first
+    cert = mongo_get_certificate(clean_name)
+    if cert and cert.get("status") == "ok":
+        return cert
+
+    # 2. Local filesystem fallback
+    if os.path.exists(EVAL_RESULTS_PATH):
+        safe_prefix = clean_name.replace("/", "__")
+        for f in os.listdir(EVAL_RESULTS_PATH):
+            if f.startswith(safe_prefix) and f.endswith(".json"):
+                try:
+                    with open(os.path.join(EVAL_RESULTS_PATH, f), "r", encoding="utf-8") as fp:
+                        return json.load(fp)
+                except Exception:
+                    continue
     return {}
 
 
 def _save_cert(model_id: str, revision: str, cert: dict) -> str:
+    # 1. Save to local disk cache
     os.makedirs(EVAL_RESULTS_PATH, exist_ok=True)
     safe_name = model_id.replace("/", "__") + f"_{revision}.json"
     out_path = os.path.join(EVAL_RESULTS_PATH, safe_name)
-    with open(out_path, "w", encoding="utf-8") as f:
-        json.dump(cert, f, indent=2)
+    try:
+        with open(out_path, "w", encoding="utf-8") as f:
+            json.dump(cert, f, indent=2)
+    except Exception as e:
+        print(f"Local file write error: {e}", flush=True)
+
+    # 2. Persist permanently to MongoDB Atlas
+    mongo_save_certificate(cert)
+
     return out_path
 
 
-# Pure, pickleable function signature for ZeroGPU multiprocessing
 @gpu_decorator(duration=120)
 def execute_direct_xray_audit(model_id: str, revision: str = "main", trust_remote_code: bool = False) -> dict:
     now_str = datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%S")
@@ -162,7 +182,6 @@ def execute_direct_xray_audit(model_id: str, revision: str = "main", trust_remot
             _save_cert(model_id, revision, cert)
             return cert
 
-        # Run multi-layer audit (logs automatically stream to console with flush=True)
         result = run_full_audit(
             model_id=model_id,
             revision=revision,
@@ -216,18 +235,17 @@ def audit_or_search_model(url_or_id: str, trust_remote_code: bool = False):
         )
         return
 
-    # Check for existing cert first (instant load)
+    # Check for existing cert in MongoDB / local cache
     existing_cert = get_certificate_by_model_name(clean_model)
     if existing_cert and existing_cert.get("status") == "ok":
         yield (
-            styled_message(f"Loaded existing audit certificate for <b>{clean_model}</b>."),
+            styled_message(f"Loaded existing audit certificate for <b>{clean_model}</b> from MongoDB."),
             current_df,
             current_top3,
             render_audit_details_panel(existing_cert),
         )
         return
 
-    # Initial loading feedback
     yield (
         styled_loading(f"Connecting to HF Hub for <b>{clean_model}</b>...", "Requesting ZeroGPU slice & downloading model weights..."),
         current_df,
@@ -240,7 +258,6 @@ def audit_or_search_model(url_or_id: str, trust_remote_code: bool = False):
 
     def _worker():
         try:
-            # Arguments are pure primitives (str, str, bool) -> 100% pickleable on ZeroGPU
             result_holder["cert"] = execute_direct_xray_audit(
                 clean_model, "main", trust_remote_code=trust_remote_code
             )
@@ -258,13 +275,12 @@ def audit_or_search_model(url_or_id: str, trust_remote_code: bool = False):
     thread = threading.Thread(target=_worker, daemon=True)
     thread.start()
 
-    # Informative UI stage cycle while ZeroGPU finishes audit
     stages = [
         "Downloading model weights and tokenizer tensors...",
         "Layer A: Performing SVD Spectral Tomography across weight tensors...",
         "Layer B: Streaming activations and calculating operator covariance...",
         "Layer C: Running empirical factual probe battery...",
-        "Finalizing operator risk and registering certificate...",
+        "Finalizing operator risk and registering certificate to MongoDB...",
     ]
     stage_idx = 0
 
@@ -296,7 +312,7 @@ def audit_or_search_model(url_or_id: str, trust_remote_code: bool = False):
         )
     else:
         yield (
-            styled_message(f"🎉 <b>Audit Complete for {clean_model}!</b> Certificate registered below."),
+            styled_message(f"🎉 <b>Audit Complete for {clean_model}!</b> Persisted in MongoDB Atlas."),
             updated_df,
             updated_top3,
             updated_panel,