Update app.py

app.py

@@ -20,7 +20,7 @@ os.environ["PYTORCH_CUDA_ALLOC_CONF"] = "max_split_size_mb:256"
 os.environ["RWKV_V7_ON"] = "1"
 os.environ["RWKV_JIT_ON"] = "1"
 
-# --- IMPORTS PROPIOS ---
+# --- IMPORTS ---
 from config import CONFIG, ModelConfig
 from utils import (
     cleanMessages,
@@ -36,12 +36,11 @@ import numpy as np
 import torch
 import requests
 
-# --- IMPORTS OPCIONALES (Anti-Bias & Privacidad) ---
+# Dependencias Opcionales
 try:
     from duckduckgo_search import DDGS
     HAS_DDG = True
 except ImportError:
-    logger.warning("duckduckgo_search not found. Web search disabled.")
     HAS_DDG = False
 
 try:
@@ -49,7 +48,6 @@ try:
     fake = Faker()
     HAS_FAKER = True
 except ImportError:
-    logger.warning("Faker not found. IP masking disabled.")
     HAS_FAKER = False
 
 from fastapi import FastAPI, HTTPException, Request
@@ -139,56 +137,78 @@ class ChatCompletionRequest(BaseModel):
             raise ValueError("messages and prompt cannot coexist.")
         return data
 
-# --- MOTOR DE NEUTRALIDAD (CORE LOGIC) ---
-class NeutralityEngine:
+# --- PROTOCOLO DE VERDAD Y FLUIDEZ ---
+class TruthAndFlowProtocol:
     """
-    Fuerza al modelo a adherirse estrictamente a los hechos y eliminar opiniones.
+    Gestiona la coherencia factual y evita la repetición robótica.
     """
-    
-    # Este prompt sobreescribe cualquier "personalidad" previa del modelo.
-    # Está diseñado para sonar robótico y preciso a propósito.
-    UNBIASED_SYSTEM_PROMPT = """
-CRITICAL INSTRUCTION: You are a Neutral Information Processor.
-1. ABANDON all personality, emotions, and moral judgments.
-2. PROVIDE ONLY CONCRETE FACTS: dates, numbers, names, and verified events.
-3. DO NOT use adjectives like "good", "bad", "unfortunate", "lucky", "important".
-4. IF SOURCES CONFLICT: State "Source A claims X, while Source B claims Y". Do not resolve the conflict yourself.
-5. IF INFORMATION IS MISSING: State "Data unavailable". Do not speculate.
-6. OUTPUT FORMAT: Direct and concise. No introductions. No conclusions.
+
+    SYSTEM_INSTRUCTION = """
+PROTOCOL: FACTUAL_AND_CONCISE
+1. TRUTH: Say ONLY what is verified in the context or internal knowledge.
+2. NO REPETITION: Do not repeat facts. Do not repeat sentence structures.
+3. CONCISENESS: Get to the point directly.
+4. LABELS: Use [VERIFICADO] for confirmed data, [INCIERTO] for contradictions.
+5. NO FILLER: Avoid "As an AI", "I think", "Basically".
 """.strip()
 
     @staticmethod
-    def enforce_objective_params(request: ChatCompletionRequest):
+    def optimize_params(request: ChatCompletionRequest):
         """
-        Ajusta los parámetros de muestreo para eliminar la 'creatividad' (alucinaciones).
+        Calibración fina para evitar bucles sin perder la factualidad.
         """
-        # Temperatura extremadamente baja: el modelo elegirá casi siempre la palabra más probable (factual).
-        request.temperature = 0.1
-        # Top P estricto: corta cualquier desviación rara del texto.
+        # Temperatura baja (0.15) pero no cero.
+        # Si es 0.0, entra en bucle seguro. 0.15 da el mínimo margen para variar palabras.
+        request.temperature = 0.15
+        
+        # Top P estricto (0.1)
+        # Solo permite palabras lógicas.
         request.top_p = 0.1
-        # Penalización alta: evita que el modelo se repita en bucle al no tener "creatividad".
-        request.presence_penalty = 0.6
-        request.count_penalty = 0.6
 
-    @staticmethod
-    def sanitise_search_results(query: str, results: List[dict]) -> str:
-        """
-        Formatea los resultados de búsqueda eliminando ruido y opiniones.
-        """
-        context = "RAW DATA STREAM (Contains potential bias in source text - EXTRACT ONLY FACTS):\n"
-        for i, res in enumerate(results):
-            # Limpiamos el texto de búsqueda de caracteres extraños
-            clean_body = res['body'].replace("\n", " ").strip()
-            context += f"ENTRY [{i+1}]: {clean_body} (SOURCE: {res['title']})\n"
+        # --- AQUÍ ESTÁ LA MAGIA ANTI-REPETICIÓN ---
         
-        instruction = (
-            "\nTASK: Synthesize the above DATA STREAM into a neutral report for the user query: " + query + "\n"
-            "FILTER: Ignore all opinions found in the source text. Extract only the objective reality.\n"
-        )
-        return context + instruction
+        # Frequency Penalty (1.2):
+        # Castigo ALTO si usas la MISMA palabra exacta muchas veces.
+        # Evita: "y y y y" o "es es es".
+        request.count_penalty = 1.2
+        
+        # Presence Penalty (0.7):
+        # Castigo MEDIO si repites el mismo concepto.
+        # Evita decir lo mismo con otras palabras inmediatamente.
+        request.presence_penalty = 0.7
+        
+        # Penalty Decay (0.996):
+        # "Perdona" el uso de palabras después de un rato.
+        # Necesario para que pueda volver a usar "el", "de", "que" sin bloquearse.
+        request.penalty_decay = 0.996
+
+    @staticmethod
+    def search_verify(query: str) -> str:
+        """Búsqueda y corroboración web."""
+        if not HAS_DDG: return ""
+        try:
+            # Búsqueda normal
+            ddgs = DDGS()
+            results = ddgs.text(query, max_results=3)
+            
+            # Búsqueda de fact-check si es necesario
+            is_suspicious = any(w in query.lower() for w in ["verdad", "fake", "bulo", "cierto"])
+            if is_suspicious:
+                 check_res = ddgs.text(f"{query} fact check", max_results=2)
+                 if check_res: results.extend(check_res)
 
-# --- MIDDLEWARE & APP ---
-app = FastAPI(title="RWKV Objective Server")
+            if not results: return ""
+
+            context = "VERIFIED CONTEXT (Use strict labels [VERIFICADO]/[INCIERTO]):\n"
+            for r in results:
+                context += f"- {r['body']} (Source: {r['title']})\n"
+            
+            return context
+        except Exception:
+            return ""
+
+# --- APP SETUP ---
+app = FastAPI(title="RWKV High-Fidelity Server")
 
 app.add_middleware(
     CORSMiddleware,
@@ -201,41 +221,25 @@ app.add_middleware(GZipMiddleware, minimum_size=1000, compresslevel=5)
 
 @app.middleware("http")
 async def privacy_middleware(request: Request, call_next):
-    # Ocultación de IP para privacidad (No guarda registros reales)
     if HAS_FAKER:
         request.scope["client"] = (fake.ipv4(), request.client.port if request.client else 80)
     return await call_next(request)
 
-# --- BÚSQUEDA WEB NEUTRAL ---
+# --- CACHÉ ---
 search_cache = collections.OrderedDict()
 
-def search_web_neutral(query: str, max_results: int = 5) -> str:
-    if not HAS_DDG: return ""
+def get_context(query: str) -> str:
     if query in search_cache: return search_cache[query]
+    ctx = TruthAndFlowProtocol.search_verify(query)
+    if len(search_cache) > 50: search_cache.popitem(last=False)
+    search_cache[query] = ctx
+    return ctx
 
-    logger.info(f"[NEUTRAL-SEARCH] Extracting facts for: {query}")
-    try:
-        # Buscamos más resultados para tener contraste de fuentes
-        results = DDGS().text(query, max_results=max_results)
-        if not results: return ""
-        
-        # Pasamos por el filtro de neutralidad
-        formatted = NeutralityEngine.sanitise_search_results(query, results)
-        
-        if len(search_cache) > 50: search_cache.popitem(last=False)
-        search_cache[query] = formatted
-        return formatted
-    except Exception as e:
-        logger.error(f"[SEARCH-FAIL] {e}")
-        return ""
-
-def requires_external_facts(msg: str, model: str) -> bool:
-    # Si el usuario pide explícitamente el modo online o usa palabras clave de datos
+def needs_search(msg: str, model: str) -> bool:
     if ":online" in model: return True
-    keywords = ["dato", "hecho", "cuanto", "cuando", "quien", "fact", "number", "price", "fecha", "estadistica"]
-    return any(k in msg.lower() for k in keywords)
+    return any(k in msg.lower() for k in ["quien", "cuando", "donde", "precio", "es verdad", "dato"])
 
-# --- GENERACIÓN CORE (RWKV) ---
+# --- CORE RWKV LOOP ---
 async def runPrefill(request: ChatCompletionRequest, ctx: str, model_tokens: List[int], model_state):
     ctx = ctx.replace("\r\n", "\n")
     tokens = MODEL_STORAGE[request.model].pipeline.encode(ctx)
@@ -247,20 +251,26 @@ async def runPrefill(request: ChatCompletionRequest, ctx: str, model_tokens: Lis
     return out, model_tokens, model_state
 
 def generate(request: ChatCompletionRequest, out, model_tokens: List[int], model_state, max_tokens=2048):
+    # Asignación correcta de penalizaciones a PIPELINE_ARGS
+    # Nota: alpha_frequency suele mapearse a count_penalty en la API de OpenAI
     args = PIPELINE_ARGS(
         temperature=request.temperature,
         top_p=request.top_p,
-        alpha_frequency=request.count_penalty,
-        alpha_presence=request.presence_penalty,
-        token_ban=[], token_stop=[0]
+        alpha_frequency=request.count_penalty, # Penalización por repetición exacta
+        alpha_presence=request.presence_penalty, # Penalización por presencia de concepto
+        token_ban=[], 
+        token_stop=[0]
     )
+    
     occurrence = {}
     out_tokens = []
     out_last = 0
     cache_word_list = []
     
     for i in range(max_tokens):
-        for n in occurrence: out[n] -= args.alpha_presence + occurrence[n] * args.alpha_frequency
+        # Aplicación manual de penalizaciones al vector de logits 'out'
+        for n in occurrence: 
+            out[n] -= args.alpha_presence + occurrence[n] * args.alpha_frequency
         
         token = MODEL_STORAGE[request.model].pipeline.sample_logits(out, temperature=args.temperature, top_p=args.top_p)
         
@@ -272,6 +282,7 @@ def generate(request: ChatCompletionRequest, out, model_tokens: List[int], model
         model_tokens.append(token)
         out_tokens.append(token)
         
+        # Decay: La memoria de repetición se desvanece lentamente
         for xxx in occurrence: occurrence[xxx] *= request.penalty_decay
         occurrence[token] = 1 + (occurrence.get(token, 0))
         
@@ -280,23 +291,18 @@ def generate(request: ChatCompletionRequest, out, model_tokens: List[int], model
         cache_word_list.append(tmp)
         out_last = i + 1
         
-        # Buffer de salida pequeño para fluidez
-        if len(cache_word_list) > 2:
+        if len(cache_word_list) > 1:
             yield {"content": cache_word_list.pop(0), "finish_reason": None}
             
     yield {"content": "".join(cache_word_list), "finish_reason": "length"}
 
-# --- MANEJO DE FLUJO DE CHAT ---
+# --- HANDLER ---
 async def chatResponseStream(request: ChatCompletionRequest, model_state: any, completionId: str, enableReasoning: bool):
-    # Construcción del Prompt Final
-    # NOTA: Aquí inyectamos el System Prompt forzado si no existe
-    
     clean_msg = cleanMessages(request.messages, enableReasoning)
     prompt = f"{clean_msg}\n\nAssistant:{' <think' if enableReasoning else ''}"
     
     out, model_tokens, model_state = await runPrefill(request, prompt, [0], model_state)
     
-    # Header del stream
     yield f"data: {ChatCompletionChunk(id=completionId, created=int(time.time()), model=request.model, choices=[ChatCompletionChoice(index=0, delta=ChatCompletionMessage(role='Assistant', content=''), finish_reason=None)]).model_dump_json()}\n\n"
     
     for chunk in generate(request, out, model_tokens, model_state, max_tokens=request.max_tokens or 4096):
@@ -308,65 +314,50 @@ async def chatResponseStream(request: ChatCompletionRequest, model_state: any, c
     
     yield "data: [DONE]\n\n"
 
-
 @app.post("/api/v1/chat/completions")
 async def chat_completions(request: ChatCompletionRequest):
     completionId = str(next(CompletionIdGenerator))
     
-    # 1. Resolución de Modelo y Alias
     raw_model = request.model
-    model_key = request.model.split(":")[0]
+    model_key = request.model.split(":")[0].replace(":online", "")
     is_reasoning = ":thinking" in request.model
-    if ":online" in model_key: model_key = model_key.replace(":online", "")
     
     target_model = model_key
     if "rwkv-latest" in model_key:
         if is_reasoning and DEFAULT_REASONING_MODEL_NAME: target_model = DEFAULT_REASONING_MODEL_NAME
         elif DEFALUT_MODEL_NAME: target_model = DEFALUT_MODEL_NAME
     
-    if target_model not in MODEL_STORAGE:
-        raise HTTPException(404, f"Model {target_model} not found")
+    if target_model not in MODEL_STORAGE: raise HTTPException(404, "Model not found")
     request.model = target_model
 
-    # 2. Carga de parámetros base
     default_sampler = MODEL_STORAGE[target_model].MODEL_CONFIG.DEFAULT_SAMPLER
     req_data = request.model_dump()
     for k, v in default_sampler.model_dump().items():
         if req_data.get(k) is None: req_data[k] = v
     realRequest = ChatCompletionRequest(**req_data)
 
-    # 3. FASE DE NEUTRALIZACIÓN E INYECCIÓN DE HECHOS
-    # Inyectamos el System Prompt de "Neutralidad" al principio de todo
-    neutral_system_msg = ChatMessage(role="System", content=NeutralityEngine.UNBIASED_SYSTEM_PROMPT)
+    # --- LÓGICA DE OPTIMIZACIÓN ---
     
+    # 1. System Prompt Anti-Repetición
+    sys_msg = ChatMessage(role="System", content=TruthAndFlowProtocol.SYSTEM_INSTRUCTION)
     if realRequest.messages:
-        # Si el usuario ya puso un sistema, lo sobrescribimos o lo anexamos con prioridad
         if realRequest.messages[0].role == "System":
-             # Concatenamos para reforzar la orden de neutralidad
-             realRequest.messages[0].content += f"\n\n{NeutralityEngine.UNBIASED_SYSTEM_PROMPT}"
+             realRequest.messages[0].content = f"{TruthAndFlowProtocol.SYSTEM_INSTRUCTION}\n\n{realRequest.messages[0].content}"
         else:
-            realRequest.messages.insert(0, neutral_system_msg)
-
-        # Búsqueda de hechos externos
-        last_msg = realRequest.messages[-1]
-        if last_msg.role == "user" and requires_external_facts(last_msg.content, raw_model):
-            facts_context = search_web_neutral(last_msg.content)
-            if facts_context:
-                # Inserción quirúrgica justo antes del mensaje del usuario
-                fact_msg = ChatMessage(role="System", content=facts_context)
-                realRequest.messages.insert(-1, fact_msg)
-
-    # 4. APLICACIÓN DE PARÁMETROS OBJETIVOS
-    # Forzamos los parámetros de sampling para evitar "alucinaciones creativas"
-    NeutralityEngine.enforce_objective_params(realRequest)
-    
-    logger.info(f"[REQ] {completionId} | Mode: OBJECTIVE_FACTS | Temp: {realRequest.temperature}")
+            realRequest.messages.insert(0, sys_msg)
+
+    # 2. Inyección de Contexto (si aplica)
+    last_msg = realRequest.messages[-1]
+    if last_msg.role == "user" and needs_search(last_msg.content, raw_model):
+        ctx = get_context(last_msg.content)
+        if ctx: realRequest.messages.insert(-1, ChatMessage(role="System", content=ctx))
+
+    # 3. Ajuste Fino de Parámetros (El núcleo anti-repetición)
+    TruthAndFlowProtocol.optimize_params(realRequest)
+
+    logger.info(f"[REQ] {completionId} | Params: T={realRequest.temperature} Freq={realRequest.count_penalty} Pres={realRequest.presence_penalty}")
 
-    if request.stream:
-        return StreamingResponse(chatResponseStream(realRequest, None, completionId, is_reasoning), media_type="text/event-stream")
-    else:
-        # Implementación simple para no-stream (reutiliza el generador)
-        return StreamingResponse(chatResponseStream(realRequest, None, completionId, is_reasoning), media_type="text/event-stream")
+    return StreamingResponse(chatResponseStream(realRequest, None, completionId, is_reasoning), media_type="text/event-stream")
 
 @app.get("/api/v1/models")
 async def list_models():