Upload 4 files

Dockerfile

@@ -0,0 +1,127 @@
+# ═══════════════════════════════════════════════════════════════════════════
+# OMNI-NEXUS · Worker BitNet b1.58 (ternario, 1.58 bits)
+# ═══════════════════════════════════════════════════════════════════════════
+#
+# 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.
+#
+# 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.
+#
+# 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.
+# ═══════════════════════════════════════════════════════════════════════════
+
+# ── Etapa 1: compilar bitnet.cpp ───────────────────────────────────────────
+FROM python:3.11-slim AS builder
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+        build-essential cmake git ca-certificates \
+        clang lld libomp-dev \
+    && 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
+
+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.
+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_SERVER=ON \
+    && cmake --build build --config Release -j"$(nproc)" --target llama-server \
+    && find build -name "llama-server" -type f -exec cp {} /build/llama-server \; \
+    && chmod +x /build/llama-server \
+    && echo "[BUILD] bitnet.cpp compilado"
+
+# ── Etapa 2: descargar el modelo ternario ──────────────────────────────────
+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"
+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)"
+
+# ── Etapa 3: runtime ───────────────────────────────────────────────────────
+FROM python:3.11-slim AS runtime
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+        curl ca-certificates libgomp1 libstdc++6 \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+COPY --from=builder /build/llama-server /usr/local/bin/llama-server
+COPY --from=fetcher /models /models
+
+RUN chmod +x /usr/local/bin/llama-server
+
+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 LLAMA_TIMEOUT=180.0
+
+COPY server.py start.sh ./
+RUN chmod +x start.sh
+
+EXPOSE 7860
+
+HEALTHCHECK --interval=30s --timeout=15s --start-period=240s --retries=5 \
+    CMD curl -f http://localhost:7860/health || exit 1
+
+CMD ["./start.sh"]

README.md

@@ -0,0 +1,37 @@
+---
+title: Omni-Nexus Worker A (BitNet)
+emoji: ⚡
+colorFrom: indigo
+colorTo: purple
+sdk: docker
+app_port: 7860
+pinned: false
+---
+
+# Omni-Nexus · Worker BitNet b1.58
+
+Nodo de inferencia ternario (1.58 bits) compatible con la API de 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.
+
+| | 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 |
+
+## Uso
+
+`Odysseus → Settings → Add Local Models (Endpoint)`:
+
+```
+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 |

server.py

@@ -0,0 +1,277 @@
+"""
+OMNI-NEXUS · Worker de cómputo elástico
+=======================================
+Envuelve llama.cpp en una API compatible con OpenAI para que Odysseus lo
+vea como un endpoint local más, sin modificar nada del proyecto.
+
+Endpoints:
+    GET  /health              → estado (lo usa el healthcheck de HF)
+    GET  /v1/models           → catálogo (lo usa Odysseus al añadir el endpoint)
+    POST /v1/chat/completions → inferencia, con y sin streaming
+    GET  /warm                → despierta el Space sin gastar inferencia
+
+Nota sobre /warm: los Spaces gratuitos se suspenden tras un rato inactivos y
+tardan ~60-90 s en volver. El router del gateway llama a /warm para levantar
+el siguiente worker mientras el actual trabaja, así el usuario no percibe el
+arranque en frío.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import time
+import uuid
+from typing import Any, AsyncIterator, Dict, List, Optional
+
+import httpx
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import StreamingResponse
+from pydantic import BaseModel, Field
+
+LLAMA_URL = f"http://127.0.0.1:{os.getenv('LLAMA_PORT', '8080')}"
+WORKER_ID = os.getenv("WORKER_ID", "A")
+N_CTX = int(os.getenv("N_CTX", "4096"))
+TIMEOUT = float(os.getenv("LLAMA_TIMEOUT", "180.0"))
+MODEL_NAME = os.getenv("MODEL_NAME", "omni-nexus/worker")
+
+# Plantilla de chat. BitNet b1.58-2B-4T se entrenó con el formato de Llama 3,
+# no con ChatML. Usar la plantilla equivocada degrada mucho la calidad sin dar
+# ningún error visible — el modelo simplemente responde peor. Por eso es una
+# variable explícita y no una suposición.
+CHAT_TEMPLATE = os.getenv("CHAT_TEMPLATE", "llama3").lower()
+
+app = FastAPI(title=f"Omni-Nexus Worker {WORKER_ID}", version="1.0.0")
+
+# CORS abierto: el endpoint se consume desde el navegador de Odysseus.
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+_stats = {"requests": 0, "tokens": 0, "started_at": time.time()}
+
+
+# ---------------------------------------------------------------------------
+# Modelos de entrada (subconjunto del esquema OpenAI que Odysseus usa)
+# ---------------------------------------------------------------------------
+class Message(BaseModel):
+    role: str
+    content: Any = ""
+
+
+class ChatRequest(BaseModel):
+    model: Optional[str] = None
+    messages: List[Message]
+    temperature: float = 0.7
+    top_p: float = 0.95
+    max_tokens: Optional[int] = Field(default=1024)
+    stream: bool = False
+    stop: Optional[List[str]] = None
+
+
+# ---------------------------------------------------------------------------
+def _flatten(content: Any) -> str:
+    """El contenido puede venir como string o como lista de bloques."""
+    if isinstance(content, str):
+        return content
+    if isinstance(content, list):
+        parts = []
+        for block in content:
+            if isinstance(block, dict) and block.get("type") == "text":
+                parts.append(block.get("text", ""))
+            elif isinstance(block, str):
+                parts.append(block)
+        return "\n".join(parts)
+    return str(content or "")
+
+
+def _prompt_llama3(messages: List[Message]) -> str:
+    """Formato Llama 3 — el correcto para BitNet b1.58-2B-4T."""
+    out = ["<|begin_of_text|>"]
+    for m in messages:
+        role = m.role if m.role in ("system", "user", "assistant") else "user"
+        out.append(
+            f"<|start_header_id|>{role}<|end_header_id|>\n\n"
+            f"{_flatten(m.content)}<|eot_id|>"
+        )
+    out.append("<|start_header_id|>assistant<|end_header_id|>\n\n")
+    return "".join(out)
+
+
+def _prompt_chatml(messages: List[Message]) -> str:
+    """Formato ChatML — Qwen 2.5 y buena parte de los instruct actuales."""
+    out = []
+    for m in messages:
+        role = m.role if m.role in ("system", "user", "assistant") else "user"
+        out.append(f"<|im_start|>{role}\n{_flatten(m.content)}<|im_end|>")
+    out.append("<|im_start|>assistant\n")
+    return "\n".join(out)
+
+
+def to_prompt(messages: List[Message]) -> str:
+    if CHAT_TEMPLATE == "chatml":
+        return _prompt_chatml(messages)
+    return _prompt_llama3(messages)
+
+
+# Se incluyen los stops de ambas plantillas: sobra un par de tokens en la
+# lista y evita que un cambio de modelo deje basura al final de la respuesta.
+STOP_TOKENS = [
+    "<|eot_id|>", "<|start_header_id|>", "<|end_header_id|>",
+    "<|im_end|>", "<|im_start|>", "</s>", "<|end_of_text|>",
+]
+
+
+# ---------------------------------------------------------------------------
+@app.get("/health")
+async def health():
+    llama_ok = False
+    try:
+        async with httpx.AsyncClient(timeout=5.0) as c:
+            r = await c.get(f"{LLAMA_URL}/health")
+            llama_ok = r.status_code == 200
+    except Exception:
+        pass
+    return {
+        "status": "ok" if llama_ok else "starting",
+        "worker": WORKER_ID,
+        "llama": llama_ok,
+        "ctx": N_CTX,
+        "template": CHAT_TEMPLATE,
+        "kind": os.getenv("WORKER_KIND", "chat"),
+        "uptime_s": round(time.time() - _stats["started_at"]),
+        "requests": _stats["requests"],
+    }
+
+
+@app.get("/warm")
+async def warm():
+    """Despierta el Space sin gastar inferencia. Responde apenas el proceso vive."""
+    return {"worker": WORKER_ID, "awake": True, "ts": time.time()}
+
+
+@app.get("/v1/models")
+async def models():
+    return {
+        "object": "list",
+        "data": [
+            {
+                "id": MODEL_NAME,
+                "object": "model",
+                "created": int(_stats["started_at"]),
+                "owned_by": f"omni-nexus-worker-{WORKER_ID}",
+                "context_length": N_CTX,
+            }
+        ],
+    }
+
+
+@app.post("/v1/chat/completions")
+async def chat(req: ChatRequest):
+    prompt = to_prompt(req.messages)
+    payload = {
+        "prompt": prompt,
+        "temperature": req.temperature,
+        "top_p": req.top_p,
+        "n_predict": req.max_tokens or 1024,
+        "stop": STOP_TOKENS + (req.stop or []),
+        "stream": req.stream,
+        "cache_prompt": True,  # reutiliza el KV cache entre turnos: gran ahorro
+    }
+    _stats["requests"] += 1
+
+    if req.stream:
+        return StreamingResponse(
+            _stream(payload, req.model), media_type="text/event-stream"
+        )
+
+    try:
+        async with httpx.AsyncClient(timeout=TIMEOUT) as c:
+            r = await c.post(f"{LLAMA_URL}/completion", json=payload)
+            r.raise_for_status()
+            data = r.json()
+    except httpx.TimeoutException:
+        raise HTTPException(504, detail=f"Worker {WORKER_ID}: timeout de inferencia")
+    except Exception as exc:
+        raise HTTPException(502, detail=f"Worker {WORKER_ID}: {exc}")
+
+    text = (data.get("content") or "").strip()
+    for tok in STOP_TOKENS:
+        text = text.replace(tok, "")
+
+    n_out = data.get("tokens_predicted", 0)
+    n_in = data.get("tokens_evaluated", 0)
+    _stats["tokens"] += n_out
+
+    return {
+        "id": f"chatcmpl-{uuid.uuid4().hex[:12]}",
+        "object": "chat.completion",
+        "created": int(time.time()),
+        "model": req.model or MODEL_NAME,
+        "choices": [
+            {
+                "index": 0,
+                "message": {"role": "assistant", "content": text.strip()},
+                "finish_reason": "stop",
+            }
+        ],
+        "usage": {
+            "prompt_tokens": n_in,
+            "completion_tokens": n_out,
+            "total_tokens": n_in + n_out,
+        },
+        "_worker": WORKER_ID,
+    }
+
+
+async def _stream(payload: Dict[str, Any], model: Optional[str]) -> AsyncIterator[str]:
+    cid = f"chatcmpl-{uuid.uuid4().hex[:12]}"
+    created = int(time.time())
+
+    def frame(delta: Dict[str, Any], finish: Optional[str] = None) -> str:
+        return "data: " + json.dumps(
+            {
+                "id": cid,
+                "object": "chat.completion.chunk",
+                "created": created,
+                "model": model or MODEL_NAME,
+                "choices": [{"index": 0, "delta": delta, "finish_reason": finish}],
+            }
+        ) + "\n\n"
+
+    yield frame({"role": "assistant", "content": ""})
+
+    try:
+        async with httpx.AsyncClient(timeout=TIMEOUT) as c:
+            async with c.stream("POST", f"{LLAMA_URL}/completion", json=payload) as r:
+                async for line in r.aiter_lines():
+                    if not line.startswith("data: "):
+                        continue
+                    try:
+                        chunk = json.loads(line[6:])
+                    except json.JSONDecodeError:
+                        continue
+                    piece = chunk.get("content", "")
+                    if piece:
+                        _stats["tokens"] += 1
+                        yield frame({"content": piece})
+                    if chunk.get("stop"):
+                        break
+    except Exception as exc:
+        yield frame({"content": f"\n[worker {WORKER_ID}: {exc}]"})
+
+    yield frame({}, finish="stop")
+    yield "data: [DONE]\n\n"
+
+
+@app.get("/")
+async def root():
+    return {
+        "name": f"Omni-Nexus Worker {WORKER_ID}",
+        "usage": "Añádelo en Odysseus → Settings → Add Local Models con la URL /v1",
+        "endpoints": ["/health", "/warm", "/v1/models", "/v1/chat/completions"],
+    }

start.sh

@@ -0,0 +1,67 @@
+#!/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}"
+
+echo "[START] ═══════════════════════════════════════════"
+echo "[START] Omni-Nexus Worker ${WORKER_ID} — BitNet b1.58"
+echo "[START] ═══════════════════════════════════════════"
+
+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
+fi
+echo "[START] Modelo ternario: $(du -h "$GGUF" | cut -f1) — $GGUF"
+echo "[START] Hilos: ${N_THREADS} | Contexto: ${N_CTX}"
+
+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)"
+
+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..."
+done
+
+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