Update app.py

app.py

@@ -11,7 +11,7 @@ import asyncio
 import random
 from typing import List, Optional, Union, Any, Dict
 
-# --- LIBRERÍAS DE TERCEROS ---
+# --- CONFIGURACIÓN DE ENTORNO ---
 if os.environ.get("MODELSCOPE_ENVIRONMENT") == "studio":
     from modelscope import patch_hub
     patch_hub()
@@ -20,6 +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 ---
 from config import CONFIG, ModelConfig
 from utils import (
     cleanMessages,
@@ -28,7 +29,6 @@ from utils import (
     format_bytes,
     log,
 )
-
 from huggingface_hub import hf_hub_download
 from loguru import logger
 from snowflake import SnowflakeGenerator
@@ -36,6 +36,7 @@ import numpy as np
 import torch
 import requests
 
+# --- IMPORTS OPCIONALES (Anti-Bias & Privacidad) ---
 try:
     from duckduckgo_search import DDGS
     HAS_DDG = True
@@ -58,7 +59,7 @@ from fastapi.staticfiles import StaticFiles
 from fastapi.middleware.gzip import GZipMiddleware
 from pydantic import BaseModel, Field, model_validator
 
-# --- INICIALIZACIÓN ---
+# --- SETUP INICIAL ---
 CompletionIdGenerator = SnowflakeGenerator(42, timestamp=1741101491595)
 
 if "cuda" in CONFIG.STRATEGY.lower() and not torch.cuda.is_available():
@@ -82,7 +83,7 @@ from api_types import (
     ChatCompletionChoice, ChatCompletionMessage
 )
 
-# --- MODEL STORAGE ---
+# --- ALMACENAMIENTO DE MODELOS ---
 class ModelStorage:
     MODEL_CONFIG: Optional[ModelConfig] = None
     model: Optional[RWKV] = None
@@ -115,7 +116,7 @@ for model_config in CONFIG.MODELS:
         torch.cuda.empty_cache()
         gc.collect()
 
-# --- CLASES Y TYPES ---
+# --- CLASES DE DATOS ---
 class ChatCompletionRequest(BaseModel):
     model: str = Field(default="rwkv-latest")
     messages: Optional[List[ChatMessage]] = Field(default=None)
@@ -138,49 +139,56 @@ class ChatCompletionRequest(BaseModel):
             raise ValueError("messages and prompt cannot coexist.")
         return data
 
-# --- COHERENCE ENGINE ---
-class CoherenceEngine:
+# --- MOTOR DE NEUTRALIDAD (CORE LOGIC) ---
+class NeutralityEngine:
     """
-    Ajusta dinámicamente los parámetros del modelo para asegurar coherencia y sentido.
+    Fuerza al modelo a adherirse estrictamente a los hechos y eliminar opiniones.
     """
-    @staticmethod
-    def optimize_parameters(request: ChatCompletionRequest, has_search_results: bool):
-        # 1. Si hay resultados de búsqueda, bajamos la temperatura para ser FACTUALES
-        if has_search_results:
-            logger.info("[COHERENCE] Search results detected. Switching to FACTUAL mode.")
-            # Temperatura baja para adherirse a los datos
-            request.temperature = 0.2 
-            # Top P bajo para eliminar palabras raras
-            request.top_p = 0.15
-            # Penalización alta para evitar repetir los hechos
-            request.presence_penalty = 0.5
-        else:
-            # Modo Conversación Normal
-            if request.temperature is None: request.temperature = 1.0
-            if request.top_p is None: request.top_p = 0.7
+    
+    # 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.
+""".strip()
 
-        # 2. Protección contra Loops (Repetición)
-        if request.penalty_decay is None:
-            request.penalty_decay = 0.996 # Standard decay
+    @staticmethod
+    def enforce_objective_params(request: ChatCompletionRequest):
+        """
+        Ajusta los parámetros de muestreo para eliminar la 'creatividad' (alucinaciones).
+        """
+        # 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.
+        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 format_search_prompt(query: str, results: List[dict]) -> str:
-        """Crea un prompt estructurado diseñado para que RWKV no se confunda."""
-        context = "Reference Information:\n"
+    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):
-            context += f"[{i+1}] {res['body']} (Source: {res['title']})\n"
+            # 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"
         
-        # Instrucción estricta para el modelo
         instruction = (
-            "\nINSTRUCTION: "
-            "Answer the user's question using ONLY the Reference Information above. "
-            "Do not make up facts. If the information is missing, say 'I don't know based on the search results'. "
-            "Write coherently and clearly.\n"
+            "\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
 
-# --- APP SETUP ---
-app = FastAPI(title="RWKV Intelligent Server")
+# --- MIDDLEWARE & APP ---
+app = FastAPI(title="RWKV Objective Server")
 
 app.add_middleware(
     CORSMiddleware,
@@ -191,48 +199,47 @@ app.add_middleware(
 )
 app.add_middleware(GZipMiddleware, minimum_size=1000, compresslevel=5)
 
-# --- MIDDLEWARE: FAKER IP ---
 @app.middleware("http")
-async def security_middleware(request: Request, call_next):
+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)
-    response = await call_next(request)
-    return response
+    return await call_next(request)
 
-# --- SEARCH LOGIC ---
+# --- BÚSQUEDA WEB NEUTRAL ---
 search_cache = collections.OrderedDict()
 
-def search_web(query: str, max_results: int = 4) -> str:
+def search_web_neutral(query: str, max_results: int = 5) -> str:
     if not HAS_DDG: return ""
     if query in search_cache: return search_cache[query]
 
-    logger.info(f"[SEARCH] Querying: {query}")
+    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 ""
         
-        # Usamos el CoherenceEngine para formatear
-        formatted_context = CoherenceEngine.format_search_prompt(query, results)
+        # Pasamos por el filtro de neutralidad
+        formatted = NeutralityEngine.sanitise_search_results(query, results)
         
-        # Cache simple
         if len(search_cache) > 50: search_cache.popitem(last=False)
-        search_cache[query] = formatted_context
-        return formatted_context
+        search_cache[query] = formatted
+        return formatted
     except Exception as e:
-        logger.error(f"[SEARCH] Error: {e}")
+        logger.error(f"[SEARCH-FAIL] {e}")
         return ""
 
-def should_search(msg: str, model: str) -> bool:
+def requires_external_facts(msg: str, model: str) -> bool:
+    # Si el usuario pide explícitamente el modo online o usa palabras clave de datos
     if ":online" in model: return True
-    keywords = ["buscar", "google", "actualidad", "noticia", "quien es", "precio", "clima", "search", "news"]
+    keywords = ["dato", "hecho", "cuanto", "cuando", "quien", "fact", "number", "price", "fecha", "estadistica"]
     return any(k in msg.lower() for k in keywords)
 
-# --- CORE GENERATION ---
+# --- GENERACIÓN CORE (RWKV) ---
 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)
-    tokens = [int(x) for x in tokens]
-    model_tokens += tokens
+    model_tokens.extend([int(x) for x in tokens])
     while len(tokens) > 0:
         out, model_state = MODEL_STORAGE[request.model].model.forward(tokens[: CONFIG.CHUNK_LEN], model_state)
         tokens = tokens[CONFIG.CHUNK_LEN :]
@@ -241,7 +248,7 @@ async def runPrefill(request: ChatCompletionRequest, ctx: str, model_tokens: Lis
 
 def generate(request: ChatCompletionRequest, out, model_tokens: List[int], model_state, max_tokens=2048):
     args = PIPELINE_ARGS(
-        temperature=max(0.1, request.temperature), # Evitar temp 0 absoluta
+        temperature=request.temperature,
         top_p=request.top_p,
         alpha_frequency=request.count_penalty,
         alpha_presence=request.presence_penalty,
@@ -273,18 +280,23 @@ def generate(request: ChatCompletionRequest, out, model_tokens: List[int], model
         cache_word_list.append(tmp)
         out_last = i + 1
         
-        if len(cache_word_list) > 5:
+        # Buffer de salida pequeño para fluidez
+        if len(cache_word_list) > 2:
             yield {"content": cache_word_list.pop(0), "finish_reason": None}
             
     yield {"content": "".join(cache_word_list), "finish_reason": "length"}
 
-# --- ENDPOINTS ---
+# --- MANEJO DE FLUJO DE CHAT ---
 async def chatResponseStream(request: ChatCompletionRequest, model_state: any, completionId: str, enableReasoning: bool):
-    # Prompt construction
-    prompt = f"{cleanMessages(request.messages, enableReasoning)}\n\nAssistant:{' <think' if enableReasoning else ''}"
+    # 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):
@@ -296,62 +308,69 @@ 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. Model Resolution
+    # 1. Resolución de Modelo y Alias
     raw_model = request.model
     model_key = request.model.split(":")[0]
     is_reasoning = ":thinking" in request.model
     if ":online" in model_key: model_key = model_key.replace(":online", "")
     
-    # Alias Mapping
-    target_model_name = model_key
+    target_model = model_key
     if "rwkv-latest" in model_key:
-        if is_reasoning and DEFAULT_REASONING_MODEL_NAME: target_model_name = DEFAULT_REASONING_MODEL_NAME
-        elif DEFALUT_MODEL_NAME: target_model_name = DEFALUT_MODEL_NAME
+        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_name not in MODEL_STORAGE:
-        raise HTTPException(404, f"Model {target_model_name} not found")
-        
-    request.model = target_model_name
-    
-    # 2. Defaults
-    default_sampler = MODEL_STORAGE[target_model_name].MODEL_CONFIG.DEFAULT_SAMPLER
+    if target_model not in MODEL_STORAGE:
+        raise HTTPException(404, f"Model {target_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. ADVANCED MECHANISM: SEARCH & CONTEXT INJECTION
-    has_search = False
-    if realRequest.messages and realRequest.messages[-1].role == "user":
-        last_msg = realRequest.messages[-1].content
-        if should_search(last_msg, raw_model):
-            context = search_web(last_msg)
-            if context:
-                has_search = True
-                # Inyectamos el contexto JUSTO antes del último mensaje del usuario
-                # Esto es crucial para la coherencia en RWKV
-                system_msg = ChatMessage(role="System", content=context)
-                realRequest.messages.insert(-1, system_msg)
+    # 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)
     
-    # 4. ADVANCED MECHANISM: COHERENCE OPTIMIZATION
-    # Aquí es donde ocurre la magia de "que tenga sentido"
-    CoherenceEngine.optimize_parameters(realRequest, has_search)
+    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}"
+        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} | Model: {realRequest.model} | Search: {has_search} | Temp: {realRequest.temperature}")
+    logger.info(f"[REQ] {completionId} | Mode: OBJECTIVE_FACTS | Temp: {realRequest.temperature}")
 
     if request.stream:
         return StreamingResponse(chatResponseStream(realRequest, None, completionId, is_reasoning), media_type="text/event-stream")
-    
-    # (Non-stream implementation simplified for brevity, usually streams used)
-    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")
 
 @app.get("/api/v1/models")
 async def list_models():
-    return {"object": "list", "data": [{"id": "rwkv-latest", "object": "model", "owned_by": "rwkv"}]}
+    return {"object": "list", "data": [{"id": "rwkv-latest", "object": "model"}]}
 
 app.mount("/", StaticFiles(directory="dist-frontend", html=True), name="static")