Update main.py

main.py

@@ -1,711 +1,272 @@
-import os
-import sys
-import math
+import os, sys, math
 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, Field
 
 from sentence_transformers import SentenceTransformer
 from huggingface_hub import hf_hub_download
-from datasets import load_dataset
 import joblib
 
 # ============================
-# Configuración de modelos
+# CONFIG
 # ============================
 
 HF_TOKEN = os.environ.get("HF_TOKEN", "")
 
-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
-
-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,
-    )
-    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
-
+ENCODER_MODEL_ID    = "antonypamo/RRFSAVANTMADE"
+META_LOGIT_REPO     = "antonypamo/RRFSavantMetaLogicV2"
+META_LOGIT_FILENAME = "logreg_rrf_savant.joblib"
+
+MAX_PROMPT_CHARS = 8000
+MAX_ANSWER_CHARS = 12000
+MAX_DOCS = 50
+MAX_DOC_CHARS = 6000
+
+PHI_NODES = [
+    "Φ0_seed",
+    "Φ1_geometric",
+    "Φ2_gauge_dirac",
+    "Φ3_log_gravity",
+    "Φ4_resonance",
+    "Φ5_memory_symbiosis",
+    "Φ6_alignment",
+    "Φ7_meta_agi",
+]
 
 # ============================
-# Geometría icosaédrica Φ12.0
+# STARTUP: MODELS
 # ============================
 
-phi = (1 + np.sqrt(5)) / 2
-nodes = np.array([
-    [0, 1, phi], [0, -1, phi], [0, 1, -phi], [0, -1, -phi],
-    [1, phi, 0], [-1, phi, 0], [1, -phi, 0], [-1, -phi, 0],
-    [phi, 0, 1], [phi, 0, -1], [-phi, 0, 1], [-phi, 0, -1]
-], dtype=float)
-nodes /= norm(nodes, axis=1, keepdims=True)
-N = nodes.shape[0]  # 12 nodos
-
-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))
-    np.fill_diagonal(W, 0.0)
-
-    if alpha_log > 0.0:
-        corr = 1.0 + alpha_log * np.log1p(dist ** 2)
-        corr[range(N), range(N)] = 1.0
-        W = W / corr
-
-    row_sums = W.sum(axis=1, keepdims=True)
-    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
-    theta = (midpoints @ A).astype(float)
-    theta = 0.5 * (theta - theta.T)
-    return theta * q
-
-
-def 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,
-):
-    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)
-        U = np.exp(1j * theta)
-    else:
-        U = np.ones((N, N), dtype=complex)
-
-    H = np.kron(np.eye(N, dtype=complex), m * sigma_z)
+print("🔄 Loading encoder...", flush=True)
+encoder = SentenceTransformer(ENCODER_MODEL_ID)
+print("✅ Encoder loaded", flush=True)
 
-    diff = nodes[:, None, :] - nodes[None, :, :]
-    dist = norm(diff, axis=-1) + 1e-12
-    d_hat = diff / dist[..., None]
-
-    for i in range(N):
-        for j in range(N):
-            if i == j or W[i, j] == 0:
-                continue
-            nvec = d_hat[i, j]
-            S = (nvec[0] * sigma_x +
-                 nvec[1] * sigma_y +
-                 nvec[2] * sigma_z)
-            H += v * W[i, j] * U[i, j] * site_op(S, i, j, N)
-
-    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
-
-
-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=100, record_every=25):
-    U = expm(-1j * dt * H)
-    psi = psi0.copy()
-
-    probs_hist = []
-    energy_hist = []
-    chir_hist = []
-    ent_hist = []
-
-    for t in range(steps + 1):
-        if t % record_every == 0:
-            p = site_probs(psi)
-            probs_hist.append(p)
-            energy_hist.append(energy_expectation(psi, H))
-            chir_hist.append(chirality(psi))
-            ent_hist.append(spatial_entropy(p))
-
-        psi = U @ psi
-        psi /= np.sqrt(np.vdot(psi, psi))
+print("🔄 Loading meta-logit V2...", flush=True)
+meta_logit_path = hf_hub_download(
+    repo_id=META_LOGIT_REPO,
+    filename=META_LOGIT_FILENAME,
+    token=HF_TOKEN or None,
+)
+meta_logit = joblib.load(meta_logit_path)
 
-    return {
-        "probs": np.array(probs_hist, dtype=float),
-        "energy": np.array(energy_hist, dtype=float),
-        "chirality": np.array(chir_hist, dtype=float),
-        "entropy": np.array(ent_hist, dtype=float),
-        "dt": dt,
-        "record_every": record_every,
-    }
+EXPECTED_FEATURES = getattr(meta_logit, "n_features_in_", 15)
+if EXPECTED_FEATURES != 15:
+    raise RuntimeError(f"Meta-logit expects {EXPECTED_FEATURES} features, expected 15.")
 
+print("✅ Meta-logit loaded (15D)", flush=True)
 
 # ============================
-# Core RRF: embeddings + features + scores
+# META-STATE FEATURE EXTRACTION
 # ============================
 
 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[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,))
-    vec /= np.sqrt(np.vdot(vec, vec))
-    psi0 = vec
-
-    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,
-    )
+    return encoder.encode(
+        [text],
+        convert_to_numpy=True,
+        normalize_embeddings=True,
+    )[0]
 
-    out = evolve_dirac_shell(psi0, H, dt=0.05, steps=100, record_every=25)
-
-    entropy = out["entropy"]
-    energy = out["energy"]
-    chir = out["chirality"]
-
-    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))
-
-    feats: Dict[str, float] = {
-        "cosine_pa": cosine_pa,
-        "len_ratio": len_ratio,
-        "dirac_entropy_final": S_final,
-        "dirac_entropy_delta": S_delta,
-        "dirac_chirality_final": C_final,
-        "dirac_energy_mean": E_mean,
-        "dirac_energy_std": E_std,
-    }
 
-    # Derivadas para llegar a 15 (igual que en tu CSV/meta-logit)
-    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 = [
-        "cosine_pa",
-        "len_ratio",
-        "dirac_entropy_final",
-        "dirac_entropy_delta",
-        "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 spectral_features(emb: np.ndarray) -> Dict[str, float]:
+    fft = np.fft.rfft(emb)
+    power = np.abs(fft) ** 2
 
+    total = power.sum() + 1e-12
+    dominant_idx = int(np.argmax(power))
 
-def compute_scores_srff_crff_ephi(prompt: str, answer: str):
-    feats = compute_rrf_features(prompt, answer)
-    x = features_to_vector(feats).reshape(1, -1)
+    phi = float(np.clip(total / (total + 1.0), 0.0, 1.0))
+    omega = float(np.clip(dominant_idx / len(power), 0.0, 1.0))
 
-    proba = meta_logit.predict_proba(x)[0]
-    p_good = float(proba[1])
+    S_RRF = float(np.mean(np.diff(power)))
+    C_RRF = float(power[dominant_idx] / total)
 
-    SRRF = p_good
-    CRRF = p_good * feats["cosine_pa"]
+    coherence = float(0.5 * (1.0 - np.std(power) / (np.mean(power) + 1e-12)) + 0.5 * C_RRF)
 
-    S_max = math.log(N)
-    norm_entropy = float(feats["dirac_entropy_final"] / S_max)
-    E_phi = 0.5 * (SRRF + norm_entropy)
+    hamiltonian_energy = float(np.dot(emb, emb))
+    dominant_frequency = float(dominant_idx)
 
-    scores = {
-        "SRRF": SRRF,
-        "CRRF": CRRF,
-        "E_phi": E_phi,
-        "p_good": p_good,
+    return {
+        "phi": phi,
+        "omega": omega,
+        "coherence": coherence,
+        "S_RRF": S_RRF,
+        "C_RRF": C_RRF,
+        "hamiltonian_energy": hamiltonian_energy,
+        "dominant_frequency": dominant_frequency,
     }
-    return scores, feats
-
 
-# ============================
-# 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
-
-    return {
-        "role": role_name,
-        "weights": profile,
-        "composite_score": composite,
-    }
+def closest_phi_node(feats: Dict[str, float]) -> int:
+    # Deterministic ontology mapping
+    if feats["coherence"] > 0.85 and feats["phi"] > 0.6:
+        return 4  # Φ4_resonance
+    if feats["hamiltonian_energy"] > 50:
+        return 2  # Φ2_gauge_dirac
+    if feats["omega"] < 0.2:
+        return 0  # Φ0_seed
+    if feats["coherence"] < 0.4:
+        return 5  # Φ5_memory_symbiosis
+    if feats["phi"] < 0.3:
+        return 6  # Φ6_alignment
+    return 7  # Φ7_meta_agi
+
+
+def rrf_state_to_vector(prompt: str, answer: str) -> np.ndarray:
+    emb = get_embedding(prompt + "\n" + answer)
+    feats = spectral_features(emb)
+
+    phi_idx = closest_phi_node(feats)
+    phi_one_hot = [1.0 if i == phi_idx else 0.0 for i in range(8)]
+
+    vector = [
+        feats["phi"],
+        feats["omega"],
+        feats["coherence"],
+        feats["S_RRF"],
+        feats["C_RRF"],
+        feats["hamiltonian_energy"],
+        feats["dominant_frequency"],
+        *phi_one_hot,
+    ]
 
+    return np.array(vector, dtype=float), feats, PHI_NODES[phi_idx]
 
 # ============================
-# RRF Tutor: carga de dataset savant_rrf1
+# FASTAPI
 # ============================
 
-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)
-
+app = FastAPI(
+    title="Savant RRF Φ12.0 API",
+    version="2.0.0",
+    description="Meta-state RRF quality evaluation + rerank",
+)
 
 # ============================
-# FastAPI app & modelos
+# SCHEMAS
 # ============================
 
 class EvaluateRequest(BaseModel):
     prompt: str
     answer: str
-    model_label: Optional[str] = None
-
-    class Config:
-        protected_namespaces = ()  # evitar warning por model_label
 
 
 class EvaluateResponse(BaseModel):
+    p_good: float
     scores: Dict[str, float]
     features: Dict[str, float]
-    sim_summary: Dict[str, Any]
-    role_profile: Optional[Dict[str, Any]] = None
-
-
-class QualityRemoteRequest(EvaluateRequest):
-    pass
-
-
-class RoleProfileInfo(BaseModel):
-    name: str
-    weights: Dict[str, float]
-
-
-class RoleProfilesResponse(BaseModel):
-    roles: List[RoleProfileInfo]
+    phi_node: str
 
 
 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.",
-    )
-    query_embedding_norm: bool = Field(
-        True,
-        description="Si True, normaliza el embedding de query (útil para cosine).",
-    )
+    query: str
+    documents: List[str]
+    alpha: float = 0.2
 
 
-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
+class RerankDocument(BaseModel):
+    id: int
+    score: 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
-
-
-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",
-)
-
+    results: List[RerankDocument]
 
 # ============================
-# Utilidades /v1/rerank
+# MANIFEST / HEALTH
 # ============================
 
-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))
+@app.get("/manifest")
+def manifest():
+    return {
+        "model": "RRFSavantMetaLogicV2",
+        "version": "Φ12.0",
+        "encoder": ENCODER_MODEL_ID,
+        "meta_logit_repo": META_LOGIT_REPO,
+        "features": 15,
+        "feature_order": [
+            "phi", "omega", "coherence", "S_RRF", "C_RRF",
+            "hamiltonian_energy", "dominant_frequency",
+            *PHI_NODES
+        ],
+    }
 
-        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
 
+@app.get("/health")
+def health():
+    return {"status": "ok"}
 
 # ============================
-# Utilidades /v1/rrf_tutor
+# /EVALUATE
 # ============================
 
-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
-
+@app.post("/evaluate", response_model=EvaluateResponse)
+def evaluate(req: EvaluateRequest):
+    if len(req.prompt) > MAX_PROMPT_CHARS or len(req.answer) > MAX_ANSWER_CHARS:
+        raise HTTPException(413, "Payload too large")
 
-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."
-        )
+    x, feats, phi_node = rrf_state_to_vector(req.prompt, req.answer)
+    proba = meta_logit.predict_proba(x.reshape(1, -1))[0]
+    p_good = float(proba[1])
 
-    best = retrieved_examples[0]
-    base_completion = best["completion"]
+    scores = {
+        "SRRF": p_good,
+        "CRRF": p_good * feats["coherence"],
+        "E_phi": 0.5 * (p_good + feats["phi"]),
+    }
 
-    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 EvaluateResponse(
+        p_good=p_good,
+        scores=scores,
+        features=feats,
+        phi_node=phi_node,
     )
-    return answer
 
 
+@app.post("/quality", response_model=EvaluateResponse)
+def quality_alias(req: EvaluateRequest):
+    return evaluate(req)
+
 # ============================
-# Endpoints
+# /v1/rerank (BATCHED)
 # ============================
 
-@app.get("/")
-def root():
-    return {"message": "Savant RRF Φ12.0 API running", "docs": "/docs"}
+@app.post("/v1/rerank", response_model=RerankResponse)
+def rerank(req: RerankRequest):
+    if len(req.documents) > MAX_DOCS:
+        raise HTTPException(413, "Too many documents")
 
+    texts = [req.query] + req.documents
+    for d in req.documents:
+        if len(d) > MAX_DOC_CHARS:
+            raise HTTPException(413, "Document too large")
 
-@app.get("/health")
-def health():
-    return {
-        "status": "ok",
-        "encoder_model_id": ENCODER_MODEL_ID,
-        "meta_logit_filename": META_LOGIT_FILENAME,
-        "N_sites": N,
-    }
+    embs = encoder.encode(
+        texts,
+        convert_to_numpy=True,
+        normalize_embeddings=True,
+    )
 
+    q_emb = embs[0]
+    d_embs = embs[1:]
 
-@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)
+    scores = d_embs @ q_emb
+    ranked_idx = np.argsort(-scores)
 
-
-@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,
+    results = [
+        RerankDocument(
+            id=int(i),
+            score=float(scores[i]),
+            rank=r + 1,
         )
-    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 de /evaluate para compatibilidad con clientes anteriores."""
-    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,
-    )
+        for r, i in enumerate(ranked_idx)
+    ]
 
     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