Update main.py

main.py

@@ -1,55 +1,114 @@
 import os
-import sys
-import math
-from typing import Optional, Dict, Any
+import time
+import logging
+from typing import Optional, Dict, Any, List
 
 import numpy as np
 from numpy.linalg import norm
 from scipy.linalg import expm
-
-from fastapi import FastAPI, HTTPException
-from pydantic import BaseModel
-
 from sentence_transformers import SentenceTransformer
 from huggingface_hub import hf_hub_download
 import joblib
 
-# ============================
-# Configuración de modelos
-# ============================
-ENCODER_MODEL_ID   = "antonypamo/RRFSAVANTMADE"
-META_LOGIT_REPO    = "antonypamo/RRFSavantMetaLogit"
-META_LOGIT_FILENAME = "logreg_rrf_savant_15.joblib"
-
-print("🔄 [Startup] Cargando encoder RRFSAVANTMADE...", flush=True)
-try:
-    encoder = SentenceTransformer(ENCODER_MODEL_ID)
-    print("✅ [Startup] Encoder cargado.", flush=True)
-except Exception as e:
-    print(f"❌ [Startup] Error al cargar encoder: {e}", file=sys.stderr, flush=True)
-    raise
-
-print("🔄 [Startup] Descargando meta-logit desde HF Hub...", flush=True)
-try:
-    meta_logit_path = hf_hub_download(
-        repo_id=META_LOGIT_REPO,
-        filename=META_LOGIT_FILENAME,
-        token=os.environ.get("HF_TOKEN"),  # si el repo es público, puede ser None
-    )
-    print(f"🔄 [Startup] Cargando modelo meta-logit '{META_LOGIT_FILENAME}'...", flush=True)
-    meta_logit = joblib.load(meta_logit_path)
-    try:
-        print(f"🔎 [Startup] Meta-logit espera {meta_logit.n_features_in_} features.", flush=True)
-    except Exception:
-        print("⚠️ [Startup] No se pudo leer n_features_in_.", flush=True)
-    print("✅ [Startup] Meta-logit cargado.", flush=True)
-except Exception as e:
-    print(f"❌ [Startup] Error al cargar meta-logit: {e}", file=sys.stderr, flush=True)
-    raise
-
-# ============================
-# Geometría icosaédrica Φ12.0
-# ============================
+from fastapi import FastAPI, Depends, Header, HTTPException, status, Request
+from fastapi.responses import JSONResponse
+from pydantic import BaseModel
+
+
+# ============================================================
+# 0. LOGGING BÁSICO
+# ============================================================
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(levelname)s] %(message)s",
+)
+logger = logging.getLogger("savant-api")
+
+
+# ============================================================
+# 1. CONFIGURACIÓN Y API KEYS
+# ============================================================
+
+# HF token
+HF_TOKEN = os.environ.get("HF_TOKEN", "")
+os.environ["HF_TOKEN"] = HF_TOKEN
+
+# API keys (muy simple para MVP)
+# - SAVANT_API_KEY: una sola API key
+# - SAVANT_API_KEYS: lista separada por comas ("key1,key2,...")
+single_key = os.environ.get("SAVANT_API_KEY", "").strip()
+multi_keys = os.environ.get("SAVANT_API_KEYS", "")
+allowed_keys = set(k.strip() for k in multi_keys.split(",") if k.strip())
+if single_key:
+    allowed_keys.add(single_key)
+
+if not allowed_keys:
+    logger.warning("⚠️ No hay API keys configuradas. La API aceptará TODO tráfico (MODO ABIERTO).")
+else:
+    logger.info(f"🔐 API Keys configuradas: {len(allowed_keys)}")
+
+
+def api_key_dependency(
+    x_api_key: Optional[str] = Header(default=None, alias="x-api-key"),
+    authorization: Optional[str] = Header(default=None),
+):
+    """
+    Dependencia FastAPI para proteger endpoints con API key.
+    Acepta:
+    - Header: x-api-key: <KEY>
+    - Header: Authorization: Bearer <KEY>
+    """
+    if not allowed_keys:
+        # Modo abierto: no validamos nada (útil para testing / dev).
+        return
+
+    candidate = None
+    if x_api_key:
+        candidate = x_api_key.strip()
+    elif authorization and authorization.lower().startswith("bearer "):
+        candidate = authorization.split(" ", 1)[1].strip()
+
+    if not candidate or candidate not in allowed_keys:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Invalid or missing API key",
+        )
+
+
+# ============================================================
+# 2. CARGA DE MODELOS (ENCODER + META-LOGIT)
+# ============================================================
+
+ENCODER_MODEL_ID = "antonypamo/RRFSAVANTMADE"
+META_LOGIT_REPO = "antonypamo/RRFSavantMetaLogit"
+META_LOGIT_FILENAME = "logreg_rrf_savant_15.joblib"  # versión 15-features
+
+logger.info("===== Application Startup =====")
+logger.info("🔄 [Startup] Cargando encoder RRFSAVANTMADE...")
+
+encoder = SentenceTransformer(ENCODER_MODEL_ID)
+
+logger.info("✅ [Startup] Encoder cargado.")
+logger.info("🔄 [Startup] Descargando meta-logit desde HF Hub...")
+
+meta_logit_path = hf_hub_download(
+    repo_id=META_LOGIT_REPO,
+    filename=META_LOGIT_FILENAME,
+    token=HF_TOKEN if HF_TOKEN else None,
+)
+
+logger.info(f"🔄 [Startup] Cargando modelo meta-logit '{META_LOGIT_FILENAME}'...")
+meta_logit = joblib.load(meta_logit_path)
+
+n_features_expected = getattr(meta_logit, "n_features_in_", None)
+logger.info(f"🔎 [Startup] Meta-logit espera {n_features_expected} features.")
+logger.info("✅ [Startup] Meta-logit cargado.")
+
+
+# ============================================================
+# 3. GEOMETRÍA ICOSAÉDRICA RRF
+# ============================================================
 
 phi = (1 + np.sqrt(5)) / 2
 nodes = np.array([
@@ -79,11 +138,11 @@ def geodesic_kernel(nodes, sigma=0.618, alpha_log=0.10):
     diff = nodes[:, None, :] - nodes[None, :, :]
     dist = norm(diff, axis=-1)
 
-    W = np.exp(-(dist ** 2) / (sigma ** 2))
+    W = np.exp(-(dist**2) / (sigma**2))
     np.fill_diagonal(W, 0.0)
 
     if alpha_log > 0.0:
-        corr = 1.0 + alpha_log * np.log1p(dist ** 2)
+        corr = 1.0 + alpha_log * np.log1p(dist**2)
         corr[range(N), range(N)] = 1.0
         W = W / corr
 
@@ -112,8 +171,7 @@ def build_dirac_hamiltonian(
     W = geodesic_kernel(nodes, sigma=sigma, alpha_log=alpha_log)
 
     if gauge_scale != 0.0 and any(flux_vector):
-        theta = u1_edge_phases(nodes, flux_vector=flux_vector,
-                               q=q, gauge_scale=gauge_scale)
+        theta = u1_edge_phases(nodes, flux_vector=flux_vector, q=q, gauge_scale=gauge_scale)
         U = np.exp(1j * theta)
     else:
         U = np.ones((N, N), dtype=complex)
@@ -142,7 +200,7 @@ def site_probs(psi):
     N2 = psi.shape[0]
     n = N2 // 2
     psi_mat = psi.reshape(n, 2)
-    return np.sum(np.abs(psi_mat) ** 2, axis=1).real
+    return np.sum(np.abs(psi_mat)**2, axis=1).real
 
 
 def chirality(psi):
@@ -159,7 +217,7 @@ def spatial_entropy(p):
     return float(-np.sum(p * np.log(p)).real)
 
 
-def evolve_dirac_shell(psi0, H, dt=0.05, steps=100, record_every=25):
+def evolve_dirac_shell(psi0, H, dt=0.05, steps=200, record_every=20):
     U = expm(-1j * dt * H)
     psi = psi0.copy()
 
@@ -188,9 +246,10 @@ def evolve_dirac_shell(psi0, H, dt=0.05, steps=100, record_every=25):
         "record_every": record_every,
     }
 
-# ============================
-# Core RRF: embeddings + features + scores
-# ============================
+
+# ============================================================
+# 4. FEATURES RRF + META-LOGIT (QUALITY)
+# ============================================================
 
 def get_embedding(text: str) -> np.ndarray:
     emb = encoder.encode([text], convert_to_numpy=True, normalize_embeddings=True)
@@ -198,16 +257,14 @@ def get_embedding(text: str) -> np.ndarray:
 
 
 def compute_rrf_features(prompt: str, answer: str) -> Dict[str, float]:
-    # Embeddings
     e_p = get_embedding(prompt)
     e_a = get_embedding(answer)
 
     cosine_pa = float(np.dot(e_p, e_a))
     len_ratio = len(answer) / (len(prompt) + 1.0)
 
-    # Simulación Dirac shell determinista (semilla por prompt+answer)
-    rng = np.random.default_rng(abs(hash(prompt + answer)) % (2 ** 32))
-    vec = rng.normal(0, 1, (2 * N,)) + 1j * rng.normal(0, 1, (2 * N,))
+    rng = np.random.default_rng(abs(hash(prompt + answer)) % (2**32))
+    vec = rng.normal(0, 1, (2*N,)) + 1j * rng.normal(0, 1, (2*N,))
     vec /= np.sqrt(np.vdot(vec, vec))
     psi0 = vec
 
@@ -215,24 +272,23 @@ def compute_rrf_features(prompt: str, answer: str) -> Dict[str, float]:
         m=0.25, v=1.0, sigma=0.618,
         alpha_log=0.10, q=1.0,
         flux_vector=(0.0, 0.0, 0.0),
-        gauge_scale=0.0,
+        gauge_scale=0.0
     )
 
-    out = evolve_dirac_shell(psi0, H, dt=0.05, steps=100, record_every=25)
+    out = evolve_dirac_shell(psi0, H, dt=0.05, steps=200, record_every=20)
 
-    entropy = out["entropy"]
     energy = out["energy"]
     chir = out["chirality"]
+    entropy = out["entropy"]
 
-    S_final = float(entropy[-1])
     S_initial = float(entropy[0])
+    S_final = float(entropy[-1])
     S_delta = S_final - S_initial
     C_final = float(chir[-1])
     E_mean = float(np.mean(energy))
     E_std = float(np.std(energy))
 
-    # Núcleo de 7 features
-    feats: Dict[str, float] = {
+    return {
         "cosine_pa": cosine_pa,
         "len_ratio": len_ratio,
         "dirac_entropy_final": S_final,
@@ -242,22 +298,12 @@ def compute_rrf_features(prompt: str, answer: str) -> Dict[str, float]:
         "dirac_energy_std": E_std,
     }
 
-    # Derivadas para llegar a 15 (igual que en el CSV)
-    S_max = math.log(N)
-    feats["entropy_norm"]      = feats["dirac_entropy_final"] / S_max
-    feats["entropy_abs_delta"] = abs(feats["dirac_entropy_delta"])
-    feats["chirality_abs"]     = abs(feats["dirac_chirality_final"])
-    feats["energy_abs_mean"]   = abs(feats["dirac_energy_mean"])
-    feats["energy_std_sq"]     = feats["dirac_energy_std"] ** 2
-    feats["cosine_sq"]         = feats["cosine_pa"] ** 2
-    feats["len_log"]           = math.log1p(feats["len_ratio"])
-    feats["len_inv"]           = 1.0 / (1.0 + feats["len_ratio"])
-
-    return feats
 
-
-def features_to_vector(feats: Dict[str, float]) -> np.ndarray:
-    keys = [
+def features_to_vector(feats: dict, meta_logit_model) -> np.ndarray:
+    """
+    Adapta las features RRF al nº de features que espera el meta-logit.
+    """
+    base_keys = [
         "cosine_pa",
         "len_ratio",
         "dirac_entropy_final",
@@ -265,31 +311,43 @@ def features_to_vector(feats: Dict[str, float]) -> np.ndarray:
         "dirac_chirality_final",
         "dirac_energy_mean",
         "dirac_energy_std",
-        "entropy_norm",
-        "entropy_abs_delta",
-        "chirality_abs",
-        "energy_abs_mean",
-        "energy_std_sq",
-        "cosine_sq",
-        "len_log",
-        "len_inv",
     ]
-    return np.array([feats[k] for k in keys], dtype=float)
+    x_base = np.array([feats[k] for k in base_keys], dtype=float)
+
+    n_expected = getattr(meta_logit_model, "n_features_in_", x_base.shape[0])
+
+    if n_expected == x_base.shape[0]:
+        return x_base
+
+    x_full = np.zeros((n_expected,), dtype=float)
+
+    if hasattr(meta_logit_model, "feature_names_in_"):
+        feature_names = list(meta_logit_model.feature_names_in_)
+        for i, name in enumerate(feature_names):
+            if name in feats:
+                x_full[i] = float(feats[name])
+            else:
+                x_full[i] = 0.0
+    else:
+        n_copy = min(n_expected, x_base.shape[0])
+        x_full[:n_copy] = x_base[:n_copy]
 
+    return x_full
 
-def compute_scores_srff_crff_ephi(prompt: str, answer: str):
+
+def compute_scores_srff_crrf_ephi(prompt: str, answer: str):
     feats = compute_rrf_features(prompt, answer)
-    x = features_to_vector(feats).reshape(1, -1)
+    x = features_to_vector(feats, meta_logit).reshape(1, -1)
 
     proba = meta_logit.predict_proba(x)[0]
     p_good = float(proba[1])
 
-    # Definimos SRRF/CRRF/E_phi a partir de p_good y entropía
     SRRF = p_good
     CRRF = p_good * feats["cosine_pa"]
 
-    S_max = math.log(N)
-    norm_entropy = float(feats["dirac_entropy_final"] / S_max)
+    S_final = feats["dirac_entropy_final"]
+    S_max = np.log(N)
+    norm_entropy = float(S_final / S_max)
     E_phi = 0.5 * (SRRF + norm_entropy)
 
     scores = {
@@ -300,67 +358,174 @@ def compute_scores_srff_crff_ephi(prompt: str, answer: str):
     }
     return scores, feats
 
-# ============================
-# FastAPI app
-# ============================
+
+# ============================================================
+# 5. FASTAPI APP
+# ============================================================
+
+app = FastAPI(
+    title="Savant RRF Φ12.0 API",
+    description="Savant RRF Quality (/v1/quality) y Savant RRF Seek (/v1/rerank)",
+    version="1.0.0",
+)
+
+
+# ----------------- MODELOS Pydantic -----------------
 
 class EvaluateRequest(BaseModel):
     prompt: str
     answer: str
     model_label: Optional[str] = None
 
+
 class EvaluateResponse(BaseModel):
     scores: Dict[str, float]
     features: Dict[str, float]
     sim_summary: Dict[str, Any]
 
-app = FastAPI(
-    title="Savant RRF Φ12.0 API",
-    description="Dirac-Resonant conceptual quality layer for LLM-generated text.",
-    version="1.0.0",
-)
 
-@app.get("/")
-def root():
-    return {"message": "Savant RRF Φ12.0 API running", "docs": "/docs"}
+class RerankRequest(BaseModel):
+    query: str
+    documents: List[str]
+    alpha: float = 0.2
+    query_embedding_norm: bool = True
+
+
+class RerankDocumentResult(BaseModel):
+    id: int
+    score_cosine: float
+    score_log_rdf: float
+    score_final: float
+    rank: int
+
+
+class RerankResponse(BaseModel):
+    model_id: str
+    alpha: float
+    query_embedding_norm: bool
+    results: List[RerankDocumentResult]
 
-@app.get("/health")
-def health():
-    return {"status": "ok"}
 
-@app.post("/evaluate", response_model=EvaluateResponse)
-def evaluate(req: EvaluateRequest):
+# ============================================================
+# 6. ENDPOINTS
+# ============================================================
+
+@app.middleware("http")
+async def log_requests(request: Request, call_next):
+    start_time = time.time()
+    response = None
     try:
-        scores, feats = compute_scores_srff_crff_ephi(req.prompt, req.answer)
-
-        # resumen de una simulación adicional (fresca) solo para info
-        H = build_dirac_hamiltonian(
-            m=0.25, v=1.0, sigma=0.618,
-            alpha_log=0.10, q=1.0,
-            flux_vector=(0.0, 0.0, 0.0),
-            gauge_scale=0.0,
+        response = await call_next(request)
+        return response
+    finally:
+        process_time = (time.time() - start_time) * 1000
+        logger.info(
+            f"[Request] {request.method} {request.url.path} "
+            f"status={response.status_code if response else 'ERR'} "
+            f"time_ms={process_time:.2f}"
         )
-        rng = np.random.default_rng(abs(hash(req.prompt + req.answer + "sim")) % (2 ** 32))
-        vec = rng.normal(0, 1, (2 * N,)) + 1j * rng.normal(0, 1, (2 * N,))
-        vec /= np.sqrt(np.vdot(vec, vec))
-        psi0 = vec
-        sim = evolve_dirac_shell(psi0, H, dt=0.05, steps=60, record_every=20)
-
-        sim_summary = {
-            "entropy_initial": float(sim["entropy"][0]),
-            "entropy_final": float(sim["entropy"][-1]),
-            "chirality_initial": float(sim["chirality"][0]),
-            "chirality_final": float(sim["chirality"][-1]),
-            "energy_mean": float(np.mean(sim["energy"])),
-            "energy_std": float(np.std(sim["energy"])),
-            "N_sites": int(N),
-        }
-
-        return EvaluateResponse(
-            scores=scores,
-            features=feats,
-            sim_summary=sim_summary,
+
+
+@app.get("/health")
+def health_check():
+    return {
+        "status": "ok",
+        "encoder_model_id": ENCODER_MODEL_ID,
+        "meta_logit_filename": META_LOGIT_FILENAME,
+        "meta_logit_n_features": n_features_expected,
+        "N_sites": N,
+    }
+
+
+@app.post("/evaluate", response_model=EvaluateResponse, dependencies=[Depends(api_key_dependency)])
+def evaluate_endpoint(req: EvaluateRequest):
+    scores, feats = compute_scores_srff_crrf_ephi(req.prompt, req.answer)
+
+    H = build_dirac_hamiltonian(
+        m=0.25, v=1.0, sigma=0.618,
+        alpha_log=0.10, q=1.0,
+        flux_vector=(0.0, 0.0, 0.0),
+        gauge_scale=0.0
+    )
+    rng = np.random.default_rng(abs(hash(req.prompt + req.answer)) % (2**32))
+    vec = rng.normal(0, 1, (2*N,)) + 1j * rng.normal(0, 1, (2*N,))
+    vec /= np.sqrt(np.vdot(vec, vec))
+    psi0 = vec
+
+    sim = evolve_dirac_shell(psi0, H, dt=0.05, steps=100, record_every=25)
+
+    sim_summary = {
+        "entropy_initial": float(sim["entropy"][0]),
+        "entropy_final": float(sim["entropy"][-1]),
+        "chirality_initial": float(sim["chirality"][0]),
+        "chirality_final": float(sim["chirality"][-1]),
+        "energy_mean": float(np.mean(sim["energy"])),
+        "energy_std": float(np.std(sim["energy"])),
+        "N_sites": int(N),
+    }
+
+    return EvaluateResponse(
+        scores=scores,
+        features=feats,
+        sim_summary=sim_summary,
+    )
+
+
+@app.post("/v1/quality", response_model=EvaluateResponse, dependencies=[Depends(api_key_dependency)])
+def quality_v1_endpoint(req: EvaluateRequest):
+    # Alias directo de /evaluate
+    return evaluate_endpoint(req)
+
+
+def _compute_rerank_scores(query: str, docs: List[str], alpha: float, norm_query: bool) -> List[RerankDocumentResult]:
+    q_emb = encoder.encode([query], convert_to_numpy=True, normalize_embeddings=norm_query)[0]
+
+    results = []
+    for idx, text in enumerate(docs):
+        d_emb = encoder.encode([text], convert_to_numpy=True, normalize_embeddings=True)[0]
+        score_cosine = float(np.dot(q_emb, d_emb))
+
+        val = max(score_cosine, 0.0) + 1e-6
+        score_log_rdf = float(np.log1p(val))
+
+        score_final = (1.0 - alpha) * score_cosine + alpha * score_log_rdf
+
+        results.append(
+            {
+                "id": idx,
+                "score_cosine": score_cosine,
+                "score_log_rdf": score_log_rdf,
+                "score_final": score_final,
+            }
+        )
+
+    results_sorted = sorted(results, key=lambda r: r["score_final"], reverse=True)
+    reranked = []
+    for rank, r in enumerate(results_sorted, start=1):
+        reranked.append(
+            RerankDocumentResult(
+                id=r["id"],
+                score_cosine=r["score_cosine"],
+                score_log_rdf=r["score_log_rdf"],
+                score_final=r["score_final"],
+                rank=rank,
+            )
         )
-    except Exception as e:
-        print(f"❌ [Runtime] Error en /evaluate: {e}", file=sys.stderr, flush=True)
-        raise HTTPException(status_code=500, detail="Internal server error")
+    return reranked
+
+
+@app.post("/v1/rerank", response_model=RerankResponse, dependencies=[Depends(api_key_dependency)])
+def rerank_endpoint(req: RerankRequest):
+    results = _compute_rerank_scores(
+        query=req.query,
+        docs=req.documents,
+        alpha=req.alpha,
+        norm_query=req.query_embedding_norm,
+    )
+
+    return RerankResponse(
+        model_id=ENCODER_MODEL_ID,
+        alpha=req.alpha,
+        query_embedding_norm=req.query_embedding_norm,
+        results=results,
+    )