Update app.py

app.py

@@ -17,8 +17,12 @@ LLAMA_SERVER = "/opt/llama-cpp/llama-server"
 MODEL_DIR = "/app/models"
 SERVER_URL = "http://127.0.0.1:8080"
 LOG_FILE = "/app/startup.log"
+CPU_THREADS = int(os.getenv("CPU_THREADS", "8"))
+LLAMA_CTX = int(os.getenv("LLAMA_CTX", "4096"))
+LLAMA_MAX_TOKENS = int(os.getenv("LLAMA_MAX_TOKENS", "4096"))
 
 server_ready = False
+server_error = None
 
 def log(msg):
     stamp = datetime.now().strftime("%H:%M:%S")
@@ -29,7 +33,8 @@ def log(msg):
 
 def start_server():
     os.makedirs(MODEL_DIR, exist_ok=True)
-    log("Descargando modelo (solo CPU)...")
+    log(f"Configuración: CPU_THREADS={CPU_THREADS}, LLAMA_CTX={LLAMA_CTX}, LLAMA_MAX_TOKENS={LLAMA_MAX_TOKENS}")
+    log("Descargando modelo para inferencia CPU-only...")
     try:
         m_path = hf_hub_download(repo_id=MODEL_REPO, filename=MODEL_FILE, local_dir=MODEL_DIR)
         log(f"Modelo descargado en: {m_path}")
@@ -42,61 +47,115 @@ def start_server():
 
     env = os.environ.copy()
     env["LD_LIBRARY_PATH"] = "/usr/local/lib:" + env.get("LD_LIBRARY_PATH", "")
+    env["OMP_NUM_THREADS"] = str(CPU_THREADS)
+    env["OMP_PROC_BIND"] = "false"
 
-    # Comando CPU con TODO: 8 hilos, contexto 4096
+    # CPU-only: no GPU probing, no CUDA offload, tuned for 8 vCPU Spaces.
     cmd = [
         LLAMA_SERVER,
         "-m", m_path,
         "--host", "127.0.0.1",
         "--port", "8080",
-        "-c", "4096",       # 4k de contexto (sobra RAM con 32 GB)
-        "-ngl", "0",        # Sin GPU
-        "-t", "8",          # Aprovechar los 8 núcleos
+        "-c", str(LLAMA_CTX),
+        "-ngl", "0",
+        "-t", str(CPU_THREADS),
+        "-tb", str(CPU_THREADS),
         "-np", "1",
+        "-b", "512",
+        "-ub", "128",
+        "--threads-http", "2",
+        "--fit", "off",
+        "--no-mmap",
+        "--jinja",
     ]
-    log(f"Lanzando (CPU, 8 hilos): {' '.join(cmd)}")
+    log(f"Lanzando llama-server CPU-only: {' '.join(cmd)}")
     return subprocess.Popen(
         cmd, env=env,
         stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
         text=True, bufsize=1
     )
 
+def wait_until_ready(proc, timeout=900):
+    global server_ready, server_error
+    start = time.time()
+    while proc.poll() is None and time.time() - start < timeout:
+        try:
+            r = requests.get(f"{SERVER_URL}/health", timeout=2)
+            if r.status_code == 200:
+                server_ready = True
+                log("MOTOR EN LINEA (CPU-only)")
+                return
+        except Exception:
+            pass
+        time.sleep(2)
+    if proc.poll() is None:
+        server_error = "El motor no respondió al health-check dentro del tiempo esperado."
+    else:
+        server_error = f"El motor terminó antes de estar listo. Código: {proc.returncode}"
+
 def monitor_engine():
-    global server_ready
+    global server_error
     try:
         log("Arrancando monitor...")
         proc = start_server()
         log(f"PID llama-server: {proc.pid}")
+        threading.Thread(target=wait_until_ready, args=(proc,), daemon=True).start()
         for line in proc.stdout:
             line = line.strip()
             log(f"[llama] {line}")
-            if "HTTP server listening" in line:
-                server_ready = True
-                log("🔥 MOTOR EN LÍNEA (CPU 8C)")
         ret = proc.wait()
+        if ret != 0 and not server_error:
+            server_error = f"llama-server terminó con código {ret}"
         log(f"llama-server terminó con código: {ret}")
     except Exception as e:
+        server_error = str(e)
         log(f"EXCEPCIÓN MONITOR: {e}")
         log(traceback.format_exc())
 
 def respond(history):
     if not server_ready:
-        yield "Motor cargando... aún no está listo. Esto puede tardar un poco en CPU."
+        if server_error:
+            yield f"Motor no disponible: {server_error}"
+            return
+        yield "Motor cargando en CPU... puede tardar varios minutos la primera vez."
         return
 
-    api_messages = [{"role": "system", "content": "Eres ClarityGuard, un asistente neuroinclusivo. Responde con claridad y empatía."}]
+    api_messages = [{
+        "role": "system",
+        "content": (
+            "Eres ClarityGuard, un asistente neuroinclusivo. Responde con claridad, "
+            "empatía y estructura. Prioriza respuestas completas, pero evita repetir ideas "
+            "y termina con una conclusión o siguiente paso concreto."
+        ),
+    }]
     for m in history:
-        content = m["content"]
-        if isinstance(content, list):
-            content = " ".join(p.get("text", "") for p in content if isinstance(p, dict))
-        api_messages.append({"role": m["role"], "content": str(content)})
+        if isinstance(m, dict):
+            content = m.get("content", "")
+            if isinstance(content, list):
+                content = " ".join(p.get("text", "") for p in content if isinstance(p, dict))
+            api_messages.append({"role": m.get("role", "user"), "content": str(content)})
+            continue
+
+        if isinstance(m, (list, tuple)) and len(m) >= 2:
+            user_msg, assistant_msg = m[0], m[1]
+            if user_msg:
+                api_messages.append({"role": "user", "content": str(user_msg)})
+            if assistant_msg:
+                api_messages.append({"role": "assistant", "content": str(assistant_msg)})
 
     try:
         r = requests.post(
             f"{SERVER_URL}/v1/chat/completions",
-            json={"messages": api_messages, "stream": True, "temperature": 0.2, "max_tokens": 512},
-            stream=True, timeout=120
+            json={
+                "model": MODEL_FILE,
+                "messages": api_messages,
+                "stream": True,
+                "temperature": 0.2,
+                "max_tokens": LLAMA_MAX_TOKENS,
+            },
+            stream=True, timeout=600
         )
+        r.raise_for_status()
         full_text = ""
         for line in r.iter_lines():
             if not line:
@@ -117,7 +176,7 @@ def respond(history):
         yield f"Error: {e}"
 
 with gr.Blocks() as demo:
-    gr.Markdown("# 🔍 ClarityGuard (CPU 8 hilos)")
+    gr.Markdown("# ClarityGuard (CPU-only backup)")
     chatbot = gr.Chatbot(height=500)
     msg = gr.Textbox(placeholder="Escribe tu mensaje y presiona Enter...")
 
@@ -141,4 +200,4 @@ if __name__ == "__main__":
     with open(LOG_FILE, "w") as f:
         f.write("Iniciando...\n")
     threading.Thread(target=monitor_engine, daemon=True).start()
-    demo.launch(server_name="0.0.0.0", server_port=7860)
+    demo.launch(server_name="0.0.0.0", server_port=7860)