Update app.py

app.py

@@ -3,10 +3,10 @@ KG Embedding Server — FastAPI on HuggingFace Spaces
 Session-based: client syncs once → server holds FAISS index in RAM
 """
 
-from fastapi import FastAPI
+from fastapi import FastAPI, HTTPException
 from pydantic import BaseModel
 from typing import Dict, Any, Optional
-import math, contextlib, uuid
+import contextlib
 from io import StringIO
 
 app = FastAPI(title="KG Embedding Server")
@@ -14,13 +14,18 @@ app = FastAPI(title="KG Embedding Server")
 # ══════════════════════════════════════════════════════
 #  GLOBALS
 # ══════════════════════════════════════════════════════
-_model = None
-_use_st = False
-_sessions: Dict[str, Dict[str, Any]] = {}   # session_id → {nodes, index}
+_model   = None
+_use_st  = False
+_faiss   = None
+_np      = None
+_sessions: Dict[str, Dict[str, Any]] = {}
+
 
 @app.on_event("startup")
 def load_model():
-    global _model, _use_st
+    global _model, _use_st, _faiss, _np
+
+    # sentence-transformers
     try:
         from sentence_transformers import SentenceTransformer
         with contextlib.redirect_stdout(StringIO()), contextlib.redirect_stderr(StringIO()):
@@ -30,9 +35,27 @@ def load_model():
     except Exception as e:
         print(f"[Server] ST unavailable: {e}")
 
+    # faiss
+    try:
+        import faiss as _faiss_mod
+        _faiss = _faiss_mod
+        print("[Server] faiss loaded ✓")
+    except Exception as e:
+        print(f"[Server] faiss unavailable: {e}")
+
+    # numpy
+    try:
+        import numpy as np
+        _np = np
+        print("[Server] numpy loaded ✓")
+    except Exception as e:
+        print(f"[Server] numpy unavailable: {e}")
+
+
 # ══════════════════════════════════════════════════════
-#  MODELS
+#  REQUEST / RESPONSE MODELS
 # ══════════════════════════════════════════════════════
+
 class NodePayload(BaseModel):
     id: int
     title: str
@@ -62,6 +85,8 @@ class SearchResponse(BaseModel):
 class HealthResponse(BaseModel):
     status: str
     model_loaded: bool
+    faiss_loaded: bool
+
 
 # ══════════════════════════════════════════════════════
 #  ENDPOINTS
@@ -69,46 +94,58 @@ class HealthResponse(BaseModel):
 
 @app.get("/health", response_model=HealthResponse)
 def health():
-    return {"status": "ok", "model_loaded": _use_st}
+    return {
+        "status":       "ok",
+        "model_loaded": _use_st,
+        "faiss_loaded": _faiss is not None,
+    }
+
 
 @app.post("/sync", response_model=SyncResponse)
 def sync(req: SyncRequest):
-    """Client uploads nodes once → server builds FAISS index in RAM."""
-    try:
-        import faiss
-        import numpy as np
-    except ImportError:
-        raise Exception("faiss not installed on server")
-
+    """
+    Client uploads all nodes once.
+    Server generates embeddings + builds FAISS index in RAM.
+    """
     if not _use_st or _model is None:
-        return SyncResponse(status="no_model", count=0)
+        raise HTTPException(503, "sentence-transformers not loaded")
+    if _faiss is None or _np is None:
+        raise HTTPException(503, "faiss / numpy not loaded")
 
     texts = [f"{n.title} {n.content}" for n in req.nodes]
+
     if not texts:
         _sessions[req.session_id] = {"nodes": [], "index": None}
         return SyncResponse(status="ok", count=0)
 
+    # embed كل الـ nodes دفعة واحدة مع تطبيع (cosine = dot product بعدين)
     with contextlib.redirect_stdout(StringIO()), contextlib.redirect_stderr(StringIO()):
         vecs = _model.encode(texts, show_progress_bar=False, normalize_embeddings=True)
 
-    vecs = np.array(vecs, dtype="float32")
-    dim  = vecs.shape[1]
+    vecs  = _np.array(vecs, dtype="float32")
+    dim   = vecs.shape[1]
 
-    index = faiss.IndexFlatIP(dim)   # cosine sim (vectors already normalized)
+    # IndexFlatIP = exact inner product (= cosine بعد normalize)
+    index = _faiss.IndexFlatIP(dim)
     index.add(vecs)
 
     _sessions[req.session_id] = {
-        "nodes": [n.dict() for n in req.nodes],
+        "nodes": [{"id": n.id, "title": n.title} for n in req.nodes],
         "index": index,
     }
-    print(f"[Server] Session {req.session_id[:8]}… → {len(texts)} nodes indexed ✓")
+
+    print(f"[Server] /sync → session={req.session_id[:8]}… | {len(texts)} nodes indexed ✓")
     return SyncResponse(status="ok", count=len(texts))
 
 
 @app.post("/search", response_model=SearchResponse)
 def search(req: SearchRequest):
-    """Embed query only, FAISS search against cached index."""
-    import numpy as np
+    """
+    Embed query only → FAISS ANN search against cached index.
+    Zero candidate transfer per search.
+    """
+    if not _use_st or _model is None:
+        raise HTTPException(503, "sentence-transformers not loaded")
 
     session = _sessions.get(req.session_id)
     if not session or session["index"] is None:
@@ -117,8 +154,9 @@ def search(req: SearchRequest):
     with contextlib.redirect_stdout(StringIO()), contextlib.redirect_stderr(StringIO()):
         qvec = _model.encode([req.query], normalize_embeddings=True)
 
-    qvec = np.array(qvec, dtype="float32")
+    qvec = _np.array(qvec, dtype="float32")
     k    = min(req.top_k, len(session["nodes"]))
+
     scores, indices = session["index"].search(qvec, k)
 
     results = []
@@ -126,11 +164,13 @@ def search(req: SearchRequest):
         if idx >= 0:
             results.append(SearchResult(
                 node_id=session["nodes"][idx]["id"],
-                score=float(score)
+                score=float(score),
             ))
+
     return SearchResponse(results=results)
 
 
 @app.get("/ping")
 def ping():
+    """Keep-alive — اعمل cron job يبعته كل 4 دقايق."""
     return {"pong": True}