Update main.py

main.py

@@ -359,17 +359,207 @@ def compute_scores_srff_crrf_ephi(prompt: str, answer: str):
     return scores, feats
 
 
-# ============================================================
-# 5. FASTAPI APP
-# ============================================================
+# ============================
+# FastAPI app
+# ============================
+
+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]
+
+
+# Para poder reutilizar EvaluateRequest en /quality_remote
+class QualityRemoteRequest(EvaluateRequest):
+    """Mismo schema que EvaluateRequest, usado para el alias /quality_remote."""
+    pass
+
 
 app = FastAPI(
     title="Savant RRF Φ12.0 API",
-    description="Savant RRF Quality (/v1/quality) y Savant RRF Seek (/v1/rerank)",
+    description="Dirac-Resonant conceptual quality layer for LLM-generated text.",
     version="1.0.0",
 )
 
 
+class RerankRequest(BaseModel):
+    """
+    Petición para /v1/rerank
+    """
+    query: str = Field(..., description="Query de búsqueda o pregunta del usuario.")
+    documents: List[str] = Field(..., description="Lista de documentos candidatos a rerankear.")
+    alpha: float = Field(
+        0.2,
+        description="Peso de la corrección log_rdf en el score_final. 0 = solo cosine, 1 = solo log_rdf."
+    )
+    query_embedding_norm: bool = Field(
+        True,
+        description="Si True, normaliza el embedding de query (útil para cosine)."
+    )
+
+class RerankDocumentResult(BaseModel):
+    id: int = Field(..., description="Índice del documento en la lista de entrada.")
+    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]
+
+
+def _compute_rerank_scores(query: str, docs: List[str], alpha: float, norm_query: bool) -> List[RerankDocumentResult]:
+    """
+    Lógica base de reranking usando encoder RRF.
+    - score_cosine: similitud coseno query-doc
+    - score_log_rdf: pequeña corrección logarítmica basada en score_cosine
+    - score_final: mezcla convexa de ambos
+    """
+    # Embedding de query
+    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))
+
+        # Corrección log_rdf sencilla y estable (solo para cosenos positivos)
+        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,
+            }
+        )
+
+    # Ordenar por score_final descendente y asignar rank
+    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,
+            )
+        )
+    return reranked
+
+
+@app.post("/v1/rerank", response_model=RerankResponse)
+def rerank_endpoint(req: RerankRequest):
+    """
+    Endpoint Savant Seek style:
+    POST /v1/rerank
+    {
+        "query": "...",
+        "documents": ["doc1", "doc2", ...],
+        "alpha": 0.2,
+        "query_embedding_norm": true
+    }
+    """
+    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,
+    )
+    
+@app.get("/")
+def root():
+    return {"message": "Savant RRF Φ12.0 API running", "docs": "/docs"}
+
+
+@app.get("/health")
+def health():
+    return {"status": "ok"}
+
+
+@app.post("/evaluate", response_model=EvaluateResponse)
+def evaluate(req: EvaluateRequest):
+    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,
+        )
+        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,
+        )
+    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")
+
+
+# === SAVANT QUALITY_REMOTE PATCH (alias local de /evaluate) ===
+@app.post("/quality_remote", response_model=EvaluateResponse)
+def quality_remote(req: QualityRemoteRequest):
+    """
+    Alias de /evaluate para exponer la calidad RRF como /quality_remote.
+    Entrada:
+        {
+          "prompt": "...",
+          "answer": "...",
+          "model_label": "..."   # opcional
+        }
+    Salida:
+        El mismo JSON que /evaluate:
+        {
+          "scores": {...},
+          "features": {...},
+          "sim_summary": {...}
+        }
+    """
+    # Aquí simplemente reutilizamos la misma lógica de evaluate
+    return evaluate(req)
+
+
 # ----------------- MODELOS Pydantic -----------------
 
 class EvaluateRequest(BaseModel):