Update app.py

app.py

@@ -1,44 +1,63 @@
 import os
+import sys
+import math
+from typing import Optional, Dict, Any, List
+
 import numpy as np
 from numpy.linalg import norm
 from scipy.linalg import expm
-from sentence_transformers import SentenceTransformer
-from huggingface_hub import hf_hub_download
-import joblib
 
-from fastapi import FastAPI
+from fastapi import FastAPI, HTTPException
 from pydantic import BaseModel, Field
-from typing import Optional, Dict, Any, List
 
-# NOTE: HF_TOKEN is expected to be set as an environment variable in a real deployment
-# For local testing, you might set it here or pass it directly
-HF_TOKEN = os.environ.get("HF_TOKEN", "") # Use environment variable, default to empty
-os.environ["HF_TOKEN"] = HF_TOKEN
+from sentence_transformers import SentenceTransformer
+from huggingface_hub import hf_hub_download
+import joblib
 
-ENCODER_MODEL_ID = "antonypamo/RRFSAVANTMADE"        # encoder RRF
-META_LOGIT_REPO = "antonypamo/RRFSavantMetaLogit"    # repo del meta-logit
-META_LOGIT_FILENAME = "logreg_rrf_savant.joblib"  # NUEVO archivo del meta-logit en HF
+from datasets import load_dataset  # 🔹 para /v1/rrf_tutor
 
-print("🔄 Cargando encoder RRFSAVANTMADE...")
-encoder = SentenceTransformer(ENCODER_MODEL_ID)
 
-print("🔄 Descargando meta-logit v2 desde HF Hub...")
-meta_logit_path = hf_hub_download(
-    repo_id=META_LOGIT_REPO,
-    filename=META_LOGIT_FILENAME,
-    token=os.environ.get("HF_TOKEN")
-)
+# ============================
+# Configuración de modelos
+# ============================
 
-print("🔄 Cargando modelo meta-logit v2...")
-meta_logit = joblib.load(meta_logit_path)
+HF_TOKEN = os.environ.get("HF_TOKEN", "")
 
-print("✅ Encoder y meta-logit v2 cargados correctamente.")
+ENCODER_MODEL_ID    = "antonypamo/RRFSAVANTMADE"
+META_LOGIT_REPO     = "antonypamo/RRFSavantMetaLogit"
+META_LOGIT_FILENAME = "logreg_rrf_savant_15.joblib"
+RRF_TUTOR_DATASET_ID = "antonypamo/savant_rrf1"
 
+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
 
-# =========================
-# Geometría icosaédrica
-# (Copied from cell lyVrwdhgIOlq)
-# =========================
+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=HF_TOKEN if HF_TOKEN else None,  # si 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
+# ============================
 
 phi = (1 + np.sqrt(5)) / 2
 nodes = np.array([
@@ -49,28 +68,30 @@ nodes = np.array([
 nodes /= norm(nodes, axis=1, keepdims=True)
 N = nodes.shape[0]  # 12 nodos
 
-# Pauli
 sigma_x = np.array([[0, 1], [1, 0]], dtype=complex)
 sigma_y = np.array([[0, -1j], [1j, 0]], dtype=complex)
 sigma_z = np.array([[1, 0], [0, -1]], dtype=complex)
 
+
 def kron_IN(M, N_sites):
     return np.kron(M, np.eye(N_sites, dtype=complex))
 
+
 def site_op(block_2x2, i, j, N_sites):
     K = np.zeros((N_sites, N_sites), dtype=complex)
     K[i, j] = 1.0
     return np.kron(K, block_2x2)
 
+
 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
 
@@ -78,6 +99,7 @@ def geodesic_kernel(nodes, sigma=0.618, alpha_log=0.10):
     row_sums[row_sums == 0] = 1.0
     return W / row_sums
 
+
 def u1_edge_phases(nodes, flux_vector=(0.0, 0.0, 0.0), q=1.0, gauge_scale=1.0):
     A = gauge_scale * np.asarray(flux_vector, dtype=float)
     midpoints = (nodes[:, None, :] + nodes[None, :, :]) / 2.0
@@ -85,6 +107,7 @@ def u1_edge_phases(nodes, flux_vector=(0.0, 0.0, 0.0), q=1.0, gauge_scale=1.0):
     theta = 0.5 * (theta - theta.T)
     return theta * q
 
+
 def build_dirac_hamiltonian(
     m=0.25,
     v=1.0,
@@ -92,7 +115,7 @@ def build_dirac_hamiltonian(
     alpha_log=0.10,
     q=1.0,
     flux_vector=(0.0, 0.0, 0.0),
-    gauge_scale=0.0
+    gauge_scale=0.0,
 ):
     W = geodesic_kernel(nodes, sigma=sigma, alpha_log=alpha_log)
 
@@ -103,10 +126,8 @@ def build_dirac_hamiltonian(
     else:
         U = np.ones((N, N), dtype=complex)
 
-    # Término de masa
     H = np.kron(np.eye(N, dtype=complex), m * sigma_z)
 
-    # Término cinético acoplado
     diff = nodes[:, None, :] - nodes[None, :, :]
     dist = norm(diff, axis=-1) + 1e-12
     d_hat = diff / dist[..., None]
@@ -121,28 +142,32 @@ def build_dirac_hamiltonian(
                  nvec[2] * sigma_z)
             H += v * W[i, j] * U[i, j] * site_op(S, i, j, N)
 
-    # Hermitizar por seguridad numérica
     H = 0.5 * (H + H.conj().T)
     return H
 
+
 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):
     S = kron_IN(sigma_z, N)
     return float(np.vdot(psi, S @ psi).real)
 
+
 def energy_expectation(psi, H):
     return float(np.vdot(psi, H @ psi).real)
 
+
 def spatial_entropy(p):
     p = np.clip(p, 1e-12, 1.0)
     return float(-np.sum(p * np.log(p)).real)
 
-def evolve_dirac_shell(psi0, H, dt=0.05, steps=200, record_every=20):
+
+def evolve_dirac_shell(psi0, H, dt=0.05, steps=100, record_every=25):
     U = expm(-1j * dt * H)
     psi = psi0.copy()
 
@@ -172,52 +197,51 @@ def evolve_dirac_shell(psi0, H, dt=0.05, steps=200, record_every=20):
     }
 
 
-# =========================
-# Feature extraction and scoring
-# (Copied from cell DiknqWJZIZ5q)
-# =========================
+# ============================
+# Core RRF: embeddings + features + scores
+# ============================
 
 def get_embedding(text: str) -> np.ndarray:
     emb = encoder.encode([text], convert_to_numpy=True, normalize_embeddings=True)
     return emb[0]
 
-def compute_rrf_features(prompt: str, answer: str) -> dict:
-    # Embeddings RRF
+
+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)
 
-    # Estado inicial ligado al texto (seed reproducible)
-    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,))
+    # 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,))
     vec /= np.sqrt(np.vdot(vec, vec))
     psi0 = vec
 
-    # Hamiltoniano Dirac Φ12.0
     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
+        gauge_scale=0.0,
     )
 
-    out = evolve_dirac_shell(psi0, H, dt=0.05, steps=200, record_every=20)
+    out = evolve_dirac_shell(psi0, H, dt=0.05, steps=100, record_every=25)
 
-    probs = out["probs"]
+    entropy = out["entropy"]
     energy = out["energy"]
     chir = out["chirality"]
-    entropy = out["entropy"]
 
-    S_initial = float(entropy[0])
     S_final = float(entropy[-1])
+    S_initial = float(entropy[0])
     S_delta = S_final - S_initial
     C_final = float(chir[-1])
     E_mean = float(np.mean(energy))
     E_std = float(np.std(energy))
 
-    return {
+    # Núcleo de 7 features
+    feats: Dict[str, float] = {
         "cosine_pa": cosine_pa,
         "len_ratio": len_ratio,
         "dirac_entropy_final": S_final,
@@ -227,7 +251,21 @@ def compute_rrf_features(prompt: str, answer: str) -> dict:
         "dirac_energy_std": E_std,
     }
 
-def features_to_vector(feats: dict) -> np.ndarray:
+    # 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_chirility_final"]) if "dirac_chirility_final" in feats else 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 = [
         "cosine_pa",
         "len_ratio",
@@ -236,24 +274,30 @@ def features_to_vector(feats: dict) -> 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)
 
-def compute_scores_srff_crrf_ephi(prompt: str, answer: str):
+
+def compute_scores_srff_crff_ephi(prompt: str, answer: str):
     feats = compute_rrf_features(prompt, answer)
     x = features_to_vector(feats).reshape(1, -1)
 
-    # meta-logit v2: pipeline (scaler + logistic regression)
     proba = meta_logit.predict_proba(x)[0]
     p_good = float(proba[1])
 
     SRRF = p_good
     CRRF = p_good * feats["cosine_pa"]
 
-    S_final = feats["dirac_entropy_final"]
-    S_max = np.log(N)
-    norm_entropy = float(S_final / S_max)
-
+    S_max = math.log(N)
+    norm_entropy = float(feats["dirac_entropy_final"] / S_max)
     E_phi = 0.5 * (SRRF + norm_entropy)
 
     scores = {
@@ -265,59 +309,406 @@ def compute_scores_srff_crrf_ephi(prompt: str, answer: str):
     return scores, feats
 
 
-# =========================
-# FastAPI App
-# (Copied from cell LwlyX4-LIgKK)
-# =========================
+# ============================
+# Role profiles
+# ============================
+
+ROLE_PROFILES: Dict[str, Dict[str, float]] = {
+    "default": {
+        "SRRF": 1.0,
+        "CRRF": 1.0,
+        "E_phi": 1.0,
+    },
+    "creative": {
+        "SRRF": 0.5,
+        "CRRF": 0.5,
+        "E_phi": 1.5,
+    },
+    "precise": {
+        "SRRF": 1.0,
+        "CRRF": 1.8,
+        "E_phi": 0.4,
+    },
+}
+
+
+def apply_role_profile(
+    scores: Dict[str, float],
+    role_name: Optional[str],
+) -> Dict[str, Any]:
+    if not role_name:
+        role_name = "default"
+
+    profile = ROLE_PROFILES.get(role_name, ROLE_PROFILES["default"])
+
+    composite = 0.0
+    weight_sum = 0.0
+    for key, w in profile.items():
+        if key in scores:
+            composite += w * scores[key]
+            weight_sum += abs(w)
+
+    if weight_sum > 0.0:
+        composite /= weight_sum
 
-app = FastAPI(
-    title="Savant RRF Φ12.0 API",
-    description="Evaluación conceptual resonante para texto generado por LLMs (SRRF / CRRF / E_phi).",
-    version="1.0.0",
-)
+    return {
+        "role": role_name,
+        "weights": profile,
+        "composite_score": composite,
+    }
 
-class EvaluateRequest(BaseModel):
-    prompt: str = Field(..., description="Pregunta / instrucción original.")
-    answer: str = Field(..., description="Respuesta generada por un LLM.")
-    model_label: Optional[str] = Field(
-        None, description="Etiqueta opcional del modelo que generó la respuesta."
+
+# ============================
+# RRF Tutor: carga de dataset savant_rrf1
+# ============================
+
+print(f"🔄 [Startup] Cargando dataset para RRF Tutor: {RRF_TUTOR_DATASET_ID}...", flush=True)
+try:
+    ds_rrf = load_dataset(RRF_TUTOR_DATASET_ID, split="train")
+    ds_rrf = ds_rrf.filter(
+        lambda ex: ex.get("prompt") is not None and ex.get("completion") is not None
+    )
+    print(f"✅ Dataset RRF Tutor cargado. Ejemplos útiles: {len(ds_rrf)}", flush=True)
+except Exception as e:
+    print(f"❌ Error cargando dataset RRF Tutor: {e}", file=sys.stderr, flush=True)
+    ds_rrf = None
+
+if ds_rrf is not None:
+    print("🔄 [Startup] Construyendo textos y embeddings para RRF Tutor...", flush=True)
+    rrf_corpus_texts: List[str] = []
+    rrf_corpus_prompts: List[str] = []
+    rrf_corpus_completions: List[str] = []
+
+    for ex in ds_rrf:
+        p = ex["prompt"]
+        c = ex["completion"]
+        rrf_corpus_prompts.append(p)
+        rrf_corpus_completions.append(c)
+        rrf_corpus_texts.append(p + "\n\n" + c)
+
+    rrf_corpus_embeds = encoder.encode(
+        rrf_corpus_texts,
+        convert_to_numpy=True,
+        show_progress_bar=True,
+        normalize_embeddings=True,
     )
+    print("✅ [RRF Tutor] Embeddings construidos.", flush=True)
+else:
+    rrf_corpus_texts = []
+    rrf_corpus_prompts = []
+    rrf_corpus_completions = []
+    rrf_corpus_embeds = np.zeros((0, 384), dtype=np.float32)
+    print("⚠️ [RRF Tutor] Dataset no disponible, el endpoint devolverá error si se usa.", flush=True)
+
+
+# ============================
+# FastAPI app & modelos
+# ============================
+
+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]
+    role_profile: Optional[Dict[str, Any]] = None
 
-@app.post("/evaluate", response_model=EvaluateResponse)
-def evaluate_endpoint(req: EvaluateRequest):
-    scores, feats = compute_scores_srff_crrf_ephi(req.prompt, req.answer)
 
-    # mini-sim extra para resumen diagnóstico simple
-    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
+class QualityRemoteRequest(EvaluateRequest):
+    pass
+
+
+class RoleProfileInfo(BaseModel):
+    name: str
+    weights: Dict[str, float]
+
+
+class RoleProfilesResponse(BaseModel):
+    roles: List[RoleProfileInfo]
+
+
+class RerankRequest(BaseModel):
+    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.",
     )
-    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
+    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]
+
+
+class RRFTutorRequest(BaseModel):
+    query: str = Field(..., description="Pregunta o fragmento de ecuación/idea RRF.")
+    max_examples: int = Field(
+        3, ge=1, le=8,
+        description="Número de ejemplos de savant_rrf1 a recuperar (1-8)."
+    )
+    include_raw_context: bool = Field(
+        False,
+        description="Si es true, devuelve los ejemplos recuperados."
+    )
+
+
+class RetrievedExample(BaseModel):
+    prompt: str
+    completion: str
+    score: float
 
-    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),
+class RRFTutorResponse(BaseModel):
+    answer: str
+    retrieved: Optional[List[RetrievedExample]] = None
+
+
+app = FastAPI(
+    title="Savant RRF Φ12.0 API",
+    description="Dirac-Resonant conceptual quality layer + reranking + RRF Tutor.",
+    version="1.1.0",
+)
+
+
+# ============================
+# Utilidades /v1/rerank
+# ============================
+
+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,
+            )
+        )
+    return reranked
+
+
+# ============================
+# Utilidades /v1/rrf_tutor
+# ============================
+
+def rrf_tutor_retrieve_examples(query: str, top_k: int = 3):
+    if rrf_corpus_embeds is None or len(rrf_corpus_embeds) == 0:
+        raise RuntimeError("Embeddings de RRF Tutor no están disponibles.")
+
+    q_emb = encoder.encode([query], convert_to_numpy=True, normalize_embeddings=True)[0]
+    sims = np.dot(rrf_corpus_embeds, q_emb)
+
+    top_k = min(top_k, len(rrf_corpus_embeds))
+    top_idx = np.argsort(-sims)[:top_k]
+
+    results = []
+    for idx in top_idx:
+        results.append(
+            {
+                "idx": int(idx),
+                "score": float(sims[idx]),
+                "prompt": rrf_corpus_prompts[idx],
+                "completion": rrf_corpus_completions[idx],
+            }
+        )
+    return results
+
+
+def rrf_tutor_build_answer(query: str, retrieved_examples):
+    if not retrieved_examples:
+        return (
+            "No encontré ejemplos relevantes en el dataset RRF Tutor para tu consulta. "
+            "Intenta reformular la pregunta o revisar la configuración del dataset."
+        )
+
+    best = retrieved_examples[0]
+    base_completion = best["completion"]
+
+    answer = (
+        "🔎 Respuesta basada en el ejemplo más cercano del corpus RRF:\n\n"
+        f"{base_completion}\n\n"
+        "💡 Nota: Esta es una versión mínima que reutiliza directamente la 'completion' "
+        "del ejemplo más similar en savant_rrf1. En una versión extendida, aquí se "
+        "conectaría un LLM pequeño (TinyLlama, etc.) que use varios ejemplos como "
+        "contexto para generar una explicación personalizada a tu `query`."
+    )
+    return answer
+
+
+# ============================
+# Endpoints
+# ============================
+
+@app.get("/")
+def root():
+    return {"message": "Savant RRF Φ12.0 API running", "docs": "/docs"}
+
+
+@app.get("/health")
+def health():
+    return {
+        "status": "ok",
+        "encoder_model_id": ENCODER_MODEL_ID,
+        "meta_logit_filename": META_LOGIT_FILENAME,
+        "N_sites": N,
     }
 
-    return EvaluateResponse(
-        scores=scores,
-        features=feats,
-        sim_summary=sim_summary,
+
+@app.get("/roles", response_model=RoleProfilesResponse)
+def list_roles():
+    roles = [
+        RoleProfileInfo(name=name, weights=weights)
+        for name, weights in ROLE_PROFILES.items()
+    ]
+    return RoleProfilesResponse(roles=roles)
+
+
+@app.post("/evaluate", response_model=EvaluateResponse)
+def evaluate(req: EvaluateRequest):
+    try:
+        scores, feats = compute_scores_srff_crff_ephi(req.prompt, req.answer)
+
+        role_profile = apply_role_profile(scores, req.model_label)
+
+        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,
+            role_profile=role_profile,
+        )
+    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")
+
+
+@app.post("/quality_remote", response_model=EvaluateResponse)
+def quality_remote(req: QualityRemoteRequest):
+    return evaluate(req)
+
+
+@app.post("/quality", response_model=EvaluateResponse)
+def quality_alias(req: QualityRemoteRequest):
+    """
+    Alias directo de /evaluate para compatibilidad con clientes previos.
+    """
+    return evaluate(req)
+
+
+@app.post("/v1/rerank", response_model=RerankResponse)
+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,
     )
+
+
+@app.post("/v1/rrf_tutor", response_model=RRFTutorResponse)
+def rrf_tutor_endpoint(body: RRFTutorRequest):
+    if not body.query or not body.query.strip():
+        raise HTTPException(status_code=400, detail="El campo 'query' no puede estar vacío.")
+
+    if ds_rrf is None or rrf_corpus_embeds is None or len(rrf_corpus_embeds) == 0:
+        raise HTTPException(
+            status_code=500,
+            detail="El dataset/embeddings de RRF Tutor no están disponibles en este momento."
+        )
+
+    try:
+        retrieved = rrf_tutor_retrieve_examples(body.query, top_k=body.max_examples)
+    except Exception as e:
+        raise HTTPException(
+            status_code=500,
+            detail=f"Error interno recuperando ejemplos RRF Tutor: {e}",
+        )
+
+    answer = rrf_tutor_build_answer(body.query, retrieved)
+
+    resp = RRFTutorResponse(answer=answer)
+
+    if body.include_raw_context:
+        resp.retrieved = [
+            RetrievedExample(
+                prompt=ex["prompt"],
+                completion=ex["completion"],
+                score=ex["score"],
+            )
+            for ex in retrieved
+        ]
+
+    return resp