Update main.py

main.py

@@ -1,114 +1,61 @@
 import os
-import time
-import logging
+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 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
 
-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
-# ============================================================
+# ============================
+# Configuración de modelos
+# ============================
 
-# 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.")
+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
 
 
-# ============================================================
-# 3. GEOMETRÍA ICOSAÉDRICA RRF
-# ============================================================
+# ============================
+# Geometría icosaédrica Φ12.0
+# ============================
 
 phi = (1 + np.sqrt(5)) / 2
 nodes = np.array([
@@ -138,11 +85,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
 
@@ -171,7 +118,8 @@ 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)
@@ -200,7 +148,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):
@@ -217,7 +165,7 @@ def spatial_entropy(p):
     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()
 
@@ -247,9 +195,9 @@ def evolve_dirac_shell(psi0, H, dt=0.05, steps=200, record_every=20):
     }
 
 
-# ============================================================
-# 4. FEATURES RRF + META-LOGIT (QUALITY)
-# ============================================================
+# ============================
+# Core RRF: embeddings + features + scores
+# ============================
 
 def get_embedding(text: str) -> np.ndarray:
     emb = encoder.encode([text], convert_to_numpy=True, normalize_embeddings=True)
@@ -257,14 +205,16 @@ 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)
 
-    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
 
@@ -272,23 +222,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=200, record_every=20)
+    out = evolve_dirac_shell(psi0, H, dt=0.05, steps=100, record_every=25)
 
+    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 {
+    feats: Dict[str, float] = {
         "cosine_pa": cosine_pa,
         "len_ratio": len_ratio,
         "dirac_entropy_final": S_final,
@@ -298,12 +248,22 @@ def compute_rrf_features(prompt: str, answer: str) -> Dict[str, float]:
         "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, meta_logit_model) -> np.ndarray:
-    """
-    Adapta las features RRF al nº de features que espera el meta-logit.
-    """
-    base_keys = [
+
+def features_to_vector(feats: Dict[str, float]) -> np.ndarray:
+    keys = [
         "cosine_pa",
         "len_ratio",
         "dirac_entropy_final",
@@ -311,33 +271,21 @@ def features_to_vector(feats: dict, meta_logit_model) -> 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",
     ]
-    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])
+    return np.array([feats[k] for k in keys], dtype=float)
 
-    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_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, meta_logit).reshape(1, -1)
+    x = features_to_vector(feats).reshape(1, -1)
 
     proba = meta_logit.predict_proba(x)[0]
     p_good = float(proba[1])
@@ -345,9 +293,8 @@ def compute_scores_srff_crrf_ephi(prompt: str, answer: str):
     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 = {
@@ -360,7 +307,99 @@ def compute_scores_srff_crrf_ephi(prompt: str, answer: str):
 
 
 # ============================
-# FastAPI app
+# 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,
+    }
+
+
+# ============================
+# 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):
@@ -368,41 +407,43 @@ class EvaluateRequest(BaseModel):
     answer: str
     model_label: Optional[str] = None
 
+    class Config:
+        protected_namespaces = ()  # evitar warning por model_label
+
 
 class EvaluateResponse(BaseModel):
     scores: Dict[str, float]
     features: Dict[str, float]
     sim_summary: Dict[str, Any]
+    role_profile: Optional[Dict[str, Any]] = None
 
 
-# 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="Dirac-Resonant conceptual quality layer for LLM-generated text.",
-    version="1.0.0",
-)
+class RoleProfileInfo(BaseModel):
+    name: str
+    weights: Dict[str, float]
+
+
+class RoleProfilesResponse(BaseModel):
+    roles: List[RoleProfileInfo]
 
 
 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."
+        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)."
+        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
@@ -410,6 +451,7 @@ class RerankDocumentResult(BaseModel):
     score_final: float
     rank: int
 
+
 class RerankResponse(BaseModel):
     model_id: str
     alpha: float
@@ -417,14 +459,41 @@ class RerankResponse(BaseModel):
     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",
+)
+
+
+# ============================
+# Utilidades /v1/rerank
+# ============================
+
 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 = []
@@ -432,7 +501,6 @@ def _compute_rerank_scores(query: str, docs: List[str], alpha: float, norm_query
         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))
 
@@ -447,7 +515,6 @@ def _compute_rerank_scores(query: str, docs: List[str], alpha: float, norm_query
             }
         )
 
-    # 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):
@@ -463,32 +530,58 @@ def _compute_rerank_scores(query: str, docs: List[str], alpha: float, norm_query
     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,
-    )
+# ============================
+# Utilidades /v1/rrf_tutor
+# ============================
 
-    return RerankResponse(
-        model_id=ENCODER_MODEL_ID,
-        alpha=req.alpha,
-        query_embedding_norm=req.query_embedding_norm,
-        results=results,
+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"}
@@ -496,22 +589,38 @@ def root():
 
 @app.get("/health")
 def health():
-    return {"status": "ok"}
+    return {
+        "status": "ok",
+        "encoder_model_id": ENCODER_MODEL_ID,
+        "meta_logit_filename": META_LOGIT_FILENAME,
+        "N_sites": N,
+    }
+
+
+@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)
 
-        # 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))
+        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
@@ -531,180 +640,25 @@ def evaluate(req: EvaluateRequest):
             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")
 
 
-# === 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):
-    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]
-
-
-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]
-
-
-# ============================================================
-# 6. ENDPOINTS
-# ============================================================
-
-@app.middleware("http")
-async def log_requests(request: Request, call_next):
-    start_time = time.time()
-    response = None
-    try:
-        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}"
-        )
-
-
-@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,
-            )
-        )
-    return reranked
+@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, dependencies=[Depends(api_key_dependency)])
+@app.post("/v1/rerank", response_model=RerankResponse)
 def rerank_endpoint(req: RerankRequest):
     results = _compute_rerank_scores(
         query=req.query,
@@ -719,3 +673,39 @@ def rerank_endpoint(req: RerankRequest):
         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