Upload 5 files

Dockerfile

@@ -1,108 +1,57 @@
 # ═══════════════════════════════════════════════════════════════════════════
-# OMNI-NEXUS · Worker BitNet b1.58 (ternario, 1.58 bits)
+# OMNI-NEXUS · Worker de chat  (reemplaza al de BitNet)
 # ═══════════════════════════════════════════════════════════════════════════
 #
-# POR QUÉ BITNET Y NO UN GGUF Q4 NORMAL
-# ─────────────────────────────────────
-# BitNet restringe cada peso a {-1, 0, +1}. Eso elimina las multiplicaciones
-# del matmul y las convierte en sumas y restas — que es exactamente donde una
-# CPU sin AVX potente deja de ser el cuello de botella.
+# POR QUÉ YA NO SE USA BITNET
+# ───────────────────────────
+# bitnet.cpp NO incluye servidor HTTP. Su submódulo de llama.cpp solo compila
+# `llama-cli`; el target `llama-server` no existe, de ahí el error
+# "No rule to make target 'llama-server'" que salía siempre.
+# Y `setup_env.py` moría con OOMKilled porque convierte el modelo con PyTorch
+# durante el build, cosa que no cabe en la RAM del builder de HF.
 #
-# Números oficiales de bitnet.cpp en x86: 2.37x-6.17x más rápido que fp16,
-# más 1.15x-2.1x extra con los kernels paralelos de enero 2026.
+# Esta imagen usa los binarios OFICIALES precompilados de llama.cpp — la misma
+# receta con la que tu Space `coder` ya arranca sin problemas. Cero compilación
+# de C++, build de 3-5 minutos en vez de 25.
 #
-# El detalle que decide todo: el paper reporta que la ventaja es MAYOR en
-# escenarios con hilos limitados. Un Space tiene 2 vCPU. Es el peor caso para
-# un Q4 normal y el mejor caso relativo para BitNet.
-#
-#   Modelo               Tamaño   tok/s en 2 vCPU (estimado)
-#   ─────────────────────────────────────────────────────────
-#   Llama 3.2 3B Q4_K_M   2.0 GB   8-12
-#   BitNet b1.58 2B i2_s  1.2 GB   18-30      ← este
-#
-# EL BUG QUE MATÓ TU "CEREBRO A"
-# ──────────────────────────────
-# Tu Dockerfile anterior documentaba que ggml-model-i2_s.gguf usa el tensor
-# type 36 (IQ4_NL_4_4), eliminado del llama.cpp oficial. Por eso tuviste que
-# recurrir a los binarios de ik_llama.cpp de Thireus.
-#
-# Aquí no hay ese problema: compilamos bitnet.cpp, que es el framework OFICIAL
-# de Microsoft para i2_s. No depende de que un fork de terceros siga publicando
-# binarios, y trae las optimizaciones de enero 2026 que ik_llama no tiene.
+# EL BUG DE libllama.so, RESUELTO
+# ───────────────────────────────
+# El zip oficial trae el binario Y sus librerías compartidas. Antes copiaba
+# solo el binario y por eso fallaba con "libllama.so: cannot open shared
+# object file". Ahora se copia el directorio COMPLETO y se registra con
+# ldconfig.
 # ═══════════════════════════════════════════════════════════════════════════
 
-# ── Etapa 1: compilar bitnet.cpp ───────────────────────────────────────────
-FROM python:3.11-slim AS builder
+FROM python:3.11-slim AS llama
 
 RUN apt-get update && apt-get install -y --no-install-recommends \
-        build-essential cmake git ca-certificates \
-        clang lld libomp-dev \
+        wget unzip ca-certificates \
     && rm -rf /var/lib/apt/lists/*
 
-WORKDIR /build
-
-# --recursive es obligatorio: bitnet.cpp lleva llama.cpp como submódulo con
-# los kernels ternarios parcheados encima.
-RUN git clone --recursive --depth 1 https://github.com/microsoft/BitNet.git bitnet
-
-WORKDIR /build/bitnet
+ARG LLAMA_RELEASE="b4585"
+RUN wget -q -O /tmp/l.zip \
+      "https://github.com/ggml-org/llama.cpp/releases/download/${LLAMA_RELEASE}/llama-${LLAMA_RELEASE}-bin-ubuntu-x64.zip" \
+    && mkdir -p /llama && unzip -q /tmp/l.zip -d /llama \
+    && echo "[LLAMA] contenido descargado:" && find /llama -name "llama-server" -o -name "*.so*" | head -20
 
-RUN pip install --no-cache-dir -r requirements.txt || true
-
-# Se compila con clang porque los kernels TL1/TL2 de BitNet usan intrínsecos
-# que gcc no vectoriza igual de bien.
-#
-# EL BUG REAL: -DLLAMA_BUILD_SERVER=ON no existe como flag en el CMake de
-# BitNet.cpp (es una opción del llama.cpp "vainilla", no del fork parcheado
-# que trae BitNet como submódulo). Como llama.cpp está incluido vía
-# add_subdirectory, CMake trata "server" como un target de EXAMPLES y los
-# examples están desactivados por defecto. Por eso "gmake: No rule to make
-# target 'llama-server'" — el target ni se generó.
-# El flag correcto es -DLLAMA_BUILD_EXAMPLES=ON (así lo hace el propio
-# setup_env.py oficial de Microsoft).
-#
-# Además, "cmake --build" con target "llama-server" produce un binario
-# enlazado dinámicamente contra libllama.so y libggml*.so, ubicadas dentro
-# del árbol de build. Copiar solo el binario al runtime (sin esas .so)
-# provoca en el arranque:
-#   "llama-server: error while loading shared libraries: libllama.so:
-#    cannot open shared object file: No such file or directory"
-# Por eso copiamos también todas las .so generadas.
-RUN cmake -B build \
-        -DCMAKE_BUILD_TYPE=Release \
-        -DCMAKE_C_COMPILER=clang \
-        -DCMAKE_CXX_COMPILER=clang++ \
-        -DGGML_NATIVE=OFF \
-        -DGGML_AVX2=ON \
-        -DGGML_FMA=ON \
-        -DLLAMA_BUILD_EXAMPLES=ON \
-    && cmake --build build --config Release -j"$(nproc)" --target llama-server \
-    && find build -name "llama-server" -type f -exec cp {} /build/llama-server \; \
-    && find build -name "lib*.so*" -type f -exec cp {} /build/ \; \
-    && chmod +x /build/llama-server \
-    && echo "[BUILD] bitnet.cpp compilado"
-
-# ── Etapa 2: descargar el modelo ternario ──────────────────────────────────
+# ── Modelo ─────────────────────────────────────────────────────────────────
 FROM python:3.11-slim AS fetcher
 
 RUN pip install --no-cache-dir huggingface_hub
 
-# Repo oficial de Microsoft, público y sin gating. Licencia MIT.
-# i2_s = cuantización ternaria nativa de BitNet (~1.2 GB para 2.4B params).
-ARG MODEL_REPO="microsoft/bitnet-b1.58-2B-4T-gguf"
-ARG MODEL_FILE="ggml-model-i2_s.gguf"
+# Llama 3.2 3B en Q4_K_M (~2 GB). En 2 vCPU da 8-12 tok/s.
+# Para más velocidad y menos calidad, cambia a 1B (~0.8 GB, 20-30 tok/s):
+#   MODEL_REPO=bartowski/Llama-3.2-1B-Instruct-GGUF
+#   MODEL_FILE=Llama-3.2-1B-Instruct-Q4_K_M.gguf
+ARG MODEL_REPO="bartowski/Llama-3.2-3B-Instruct-GGUF"
+ARG MODEL_FILE="Llama-3.2-3B-Instruct-Q4_K_M.gguf"
 ENV MODEL_REPO=${MODEL_REPO}
 ENV MODEL_FILE=${MODEL_FILE}
 
-RUN mkdir -p /models && python3 -c "\
-import os, sys; \
-from huggingface_hub import hf_hub_download; \
-p = hf_hub_download(repo_id=os.environ['MODEL_REPO'], filename=os.environ['MODEL_FILE'], local_dir='/models'); \
-gb = os.path.getsize(p)/1024**3; \
-print(f'[FETCH] {p} ({gb:.2f} GB)', flush=True); \
-sys.exit(0 if gb > 0.5 else 1)"
+COPY download_model.py /tmp/download_model.py
+RUN mkdir -p /models && python3 /tmp/download_model.py
 
-# ── Etapa 3: runtime ───────────────────────────────────────────────────────
+# ── Runtime ────────────────────────────────────────────────────────────────
 FROM python:3.11-slim AS runtime
 
 RUN apt-get update && apt-get install -y --no-install-recommends \
@@ -111,32 +60,35 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
 
 WORKDIR /app
 
-COPY --from=builder /build/llama-server /usr/local/bin/llama-server
-COPY --from=builder /build/*.so* /usr/local/lib/
+# Directorio COMPLETO, no solo el binario: así vienen las .so que necesita.
+COPY --from=llama /llama /opt/llama
 COPY --from=fetcher /models /models
 
-RUN chmod +x /usr/local/bin/llama-server && ldconfig
-
-# Necesario para que el loader dinámico encuentre libllama.so, libggml*.so.
-ENV LD_LIBRARY_PATH=/usr/local/lib:${LD_LIBRARY_PATH}
+# Localizar el binario donde sea que esté dentro del zip, enlazarlo, y
+# registrar sus librerías en el linker dinámico.
+RUN BIN="$(find /opt/llama -name 'llama-server' -type f | head -1)" \
+    && test -n "$BIN" || { echo "FATAL: llama-server no encontrado"; exit 1; } \
+    && chmod +x "$BIN" && ln -sf "$BIN" /usr/local/bin/llama-server \
+    && find /opt/llama -name "*.so*" -exec cp {} /usr/local/lib/ \; \
+    && ldconfig \
+    && echo "/usr/local/lib" > /etc/ld.so.conf.d/llama.conf && ldconfig \
+    && llama-server --version 2>&1 | head -3 || true
 
 RUN pip install --no-cache-dir \
         fastapi==0.115.6 \
         "uvicorn[standard]==0.34.0" \
         httpx==0.28.1
 
-# ── Configuración ──────────────────────────────────────────────────────────
-# N_THREADS=2 : son 2 vCPU reales; más hilos solo generan contención de caché.
-# N_CTX=4096  : el KV cache se reserva entero al arrancar. Con la cuantización
-#               q8_0 de abajo ocupa la mitad que en f16.
 ENV N_CTX=4096
 ENV N_THREADS=2
 ENV LLAMA_PORT=8080
 ENV PORT=7860
 ENV WORKER_ID=A
 ENV WORKER_KIND=chat
-ENV MODEL_NAME="bitnet-b1.58-2b"
+ENV MODEL_NAME="llama-3.2-3b"
+ENV CHAT_TEMPLATE=llama3
 ENV LLAMA_TIMEOUT=180.0
+ENV LD_LIBRARY_PATH="/usr/local/lib"
 
 COPY server.py start.sh ./
 RUN chmod +x start.sh

README.md

@@ -1,6 +1,6 @@
 ---
-title: Omni-Nexus Worker A (BitNet)
-emoji: ⚡
+title: Omni-Nexus Worker A
+emoji: 💬
 colorFrom: indigo
 colorTo: purple
 sdk: docker
@@ -8,18 +8,18 @@ app_port: 7860
 pinned: false
 ---
 
-# Omni-Nexus · Worker BitNet b1.58
+# Omni-Nexus · Worker de chat
 
-Nodo de inferencia ternario (1.58 bits) compatible con la API de OpenAI.
+Llama 3.2 3B (Q4_K_M) servido con API compatible con OpenAI.
 
-Cada peso vale {-1, 0, +1}, lo que convierte las multiplicaciones del matmul
-en sumas. La ventaja crece en escenarios con pocos hilos — justo el caso de
-un Space con 2 vCPU.
+Usa los binarios **oficiales precompilados** de llama.cpp: build de 3-5 min,
+sin compilar C++.
 
-| | 3B Q4_K_M | BitNet b1.58 2B |
-|---|---|---|
-| Tamaño | 2.0 GB | 1.2 GB |
-| tok/s en 2 vCPU | 8-12 | 18-30 |
+## Por qué ya no se usa BitNet
+
+bitnet.cpp no incluye servidor HTTP — su submódulo solo compila `llama-cli`.
+El target `llama-server` no existe. Y `setup_env.py` agota la RAM del builder
+de HF al convertir el modelo. No es parcheable.
 
 ## Uso
 
@@ -31,7 +31,7 @@ https://TU-USUARIO-ESTE-SPACE.hf.space/v1
 
 ## Variables
 
-| Variable | Valor | Nota |
-|---|---|---|
-| `WORKER_ID` | `A` | Identifica quién respondió |
-| `CHAT_TEMPLATE` | `llama3` | BitNet usa formato Llama 3, **no** ChatML |
+| Variable | Valor |
+|---|---|
+| `WORKER_ID` | `A` |
+| `CHAT_TEMPLATE` | `llama3` |

download_model.py

@@ -0,0 +1,19 @@
+"""Descarga el modelo. En archivo aparte porque `python3 -c` con ';' no
+admite try/except — ése fue el SyntaxError del Space de embeddings."""
+import os
+import sys
+
+from huggingface_hub import hf_hub_download
+
+repo = os.environ["MODEL_REPO"]
+fname = os.environ["MODEL_FILE"]
+
+try:
+    path = hf_hub_download(repo_id=repo, filename=fname, local_dir="/models")
+except Exception as exc:
+    print(f"[FETCH] FALLO al descargar {repo}/{fname}: {exc}", flush=True)
+    sys.exit(1)
+
+gb = os.path.getsize(path) / 1024 ** 3
+print(f"[FETCH] OK {path} ({gb:.2f} GB)", flush=True)
+sys.exit(0 if gb > 0.3 else 1)

start.sh

@@ -1,67 +1,37 @@
 #!/bin/bash
-# ═══════════════════════════════════════════════════════════════════════════
-# start.sh — Worker BitNet b1.58
-# ═══════════════════════════════════════════════════════════════════════════
 set -e
+N_CTX="${N_CTX:-4096}"; N_THREADS="${N_THREADS:-2}"
+LLAMA_PORT="${LLAMA_PORT:-8080}"; PORT="${PORT:-7860}"; WORKER_ID="${WORKER_ID:-A}"
 
-N_CTX="${N_CTX:-4096}"
-N_THREADS="${N_THREADS:-2}"
-LLAMA_PORT="${LLAMA_PORT:-8080}"
-PORT="${PORT:-7860}"
-WORKER_ID="${WORKER_ID:-A}"
-
-echo "[START] ═══════════════════════════════════════════"
-echo "[START] Omni-Nexus Worker ${WORKER_ID} — BitNet b1.58"
-echo "[START] ═══════════════════════════════════════════"
+echo "[START] Omni-Nexus Worker ${WORKER_ID} (chat)"
 
 GGUF=$(find /models -name "*.gguf" -type f | head -1)
-if [ -z "$GGUF" ]; then
-    echo "[START] FATAL: no hay .gguf en /models"; ls -lah /models 2>/dev/null; exit 1
+[ -z "$GGUF" ] && { echo "[START] FATAL: sin .gguf"; ls -lah /models; exit 1; }
+echo "[START] Modelo: $(du -h "$GGUF" | cut -f1)"
+
+# Verificación temprana: si faltan librerías, se ve AQUÍ y no a mitad del
+# arranque con un mensaje críptico.
+if ! llama-server --version >/dev/null 2>&1; then
+    echo "[START] FATAL: llama-server no ejecuta. Librerías:"
+    ldd "$(readlink -f "$(command -v llama-server)")" 2>&1 | grep -i "not found" || true
+    exit 1
 fi
-echo "[START] Modelo ternario: $(du -h "$GGUF" | cut -f1) — $GGUF"
-echo "[START] Hilos: ${N_THREADS} | Contexto: ${N_CTX}"
+echo "[START] llama-server OK"
 
 LOG=/tmp/llama.log; : > "$LOG"
 
-# --cache-type-k/v q8_0: cuantiza el KV cache. Reduce a la mitad la RAM del
-#   contexto con pérdida de calidad inapreciable. Es lo que permite tener
-#   4096 de contexto cómodamente en vez de recortar a 2048.
-# --cont-batching: permite solapar prefill y generación entre peticiones.
-# --mlock: evita que el kernel mande los pesos a swap. Con 16 GB y un modelo
-#   de 1.2 GB sobra memoria, así que fijarlo en RAM es gratis y elimina
-#   pausas aleatorias a mitad de generación.
-llama-server \
-    --model "$GGUF" \
-    --host 127.0.0.1 \
-    --port "$LLAMA_PORT" \
-    --ctx-size "$N_CTX" \
-    --threads "$N_THREADS" \
-    --n-gpu-layers 0 \
-    --cache-type-k q8_0 \
-    --cache-type-v q8_0 \
-    --cont-batching \
-    --parallel 1 \
-    --mlock \
-    2>&1 | tee "$LOG" | sed 's/^/[BITNET] /' &
-
-PID=$!
-echo "[START] PID=$PID — cargando (BitNet carga rápido: ~20-40s)"
+llama-server --model "$GGUF" --host 127.0.0.1 --port "$LLAMA_PORT" \
+    --ctx-size "$N_CTX" --threads "$N_THREADS" --n-gpu-layers 0 \
+    --cache-type-k q8_0 --cache-type-v q8_0 \
+    --cont-batching --parallel 1 \
+    2>&1 | tee "$LOG" | sed 's/^/[LLAMA] /' &
 
-MAX=300; T=0
+PID=$!; MAX=300; T=0
 while [ $T -lt $MAX ]; do
-    if ! kill -0 $PID 2>/dev/null; then
-        echo "[START] llama-server murió:"; tail -30 "$LOG" | sed 's/^/[CRASH] /'; exit 1
-    fi
-    if curl -sf "http://127.0.0.1:${LLAMA_PORT}/health" >/dev/null 2>&1; then
-        echo "[START] Worker ${WORKER_ID} ONLINE en ${T}s"; break
-    fi
-    sleep 5; T=$((T+5))
-    [ $((T % 30)) -eq 0 ] && echo "[START] ${T}/${MAX}s..."
+    kill -0 $PID 2>/dev/null || { echo "[START] murió:"; tail -30 "$LOG"; exit 1; }
+    curl -sf "http://127.0.0.1:${LLAMA_PORT}/health" >/dev/null 2>&1 && { echo "[START] ONLINE en ${T}s"; break; }
+    sleep 5; T=$((T+5)); [ $((T % 30)) -eq 0 ] && echo "[START] ${T}/${MAX}s..."
 done
+[ $T -ge $MAX ] && { echo "[START] FATAL: timeout"; tail -20 "$LOG"; exit 1; }
 
-if [ $T -ge $MAX ]; then
-    echo "[START] FATAL: timeout"; tail -20 "$LOG" | sed 's/^/[TIMEOUT] /'; exit 1
-fi
-
-echo "[START] FastAPI en :${PORT}"
 exec uvicorn server:app --host 0.0.0.0 --port "$PORT" --workers 1 --log-level info