deploy latency-bounded interactive pool

Exact source: ttracx/thoxroute@755605a45facd12e12c947d4cab7b886d80bd218

Dockerfile

@@ -1,10 +1,3 @@
-# THOX Rust Coder — llama.cpp via the conda-forge PREBUILT binary.
-#
-# Do not try to compile llama-cpp-python on an HF Space. It does not fit the
-# build timeout -- not in the Spaces pip step, and not in a Docker builder stage
-# either, even at -j16 with tests/examples/server/tools disabled. Docker buys a
-# glibc-linked extension, not build time. conda-forge ships a prebuilt linux-64
-# glibc binary: correct ABI, no compile, ~2 minute build.
 FROM mambaorg/micromamba:2.9-debian12
 
 USER root
@@ -12,22 +5,33 @@ RUN mkdir -p /app && chown 1000:1000 /app
 USER $MAMBA_USER
 
 RUN micromamba install -y -n base -c conda-forge \
-        python=3.11 \
-        pip \
+        python=3.11.15 \
+        pip=26.2.1 \
         llama-cpp-python=0.3.34 \
+        fastapi=0.141.1 \
+        pydantic=2.13.4 \
+        uvicorn=0.52.3 \
     && micromamba clean --all --yes
 
 ARG MAMBA_DOCKERFILE_ACTIVATE=1
 
 COPY --chown=$MAMBA_USER:$MAMBA_USER requirements.txt /tmp/requirements.txt
-RUN pip install --no-cache-dir -r /tmp/requirements.txt
+RUN pip install --no-cache-dir -r /tmp/requirements.txt && pip check
 
 ENV HF_HOME=/home/mambauser/.cache/huggingface \
-    GRADIO_SERVER_NAME=0.0.0.0 \
-    GRADIO_SERVER_PORT=7860
+    PORT=7860 \
+    THOX_FAST_MODEL_REPO=Qwen/Qwen2.5-0.5B-Instruct-GGUF \
+    THOX_FAST_MODEL_REVISION=9217f5db79a29953eb74d5343926648285ec7e67 \
+    THOX_FAST_MODEL_FILE=qwen2.5-0.5b-instruct-q4_k_m.gguf \
+    THOX_FAST_POOL_SIZE=2 \
+    THOX_MAX_OUTPUT_TOKENS=128
+
+# Bake the immutable public interactive model into the image. A RUNNING Space
+# therefore cannot report ready while still waiting on a first-request download.
+RUN python -c "from huggingface_hub import hf_hub_download; hf_hub_download('Qwen/Qwen2.5-0.5B-Instruct-GGUF', 'qwen2.5-0.5b-instruct-q4_k_m.gguf', revision='9217f5db79a29953eb74d5343926648285ec7e67')"
 
 WORKDIR /app
 COPY --chown=$MAMBA_USER:$MAMBA_USER app.py /app/app.py
 
 EXPOSE 7860
-CMD ["python", "app.py"]
+CMD ["python", "/app/app.py"]

README.md

@@ -1,53 +1,20 @@
 ---
-title: THOX Rust Coder
-emoji: 🦀
-colorFrom: gray
-colorTo: red
+title: THOX Interactive and Rust Coder
+emoji: "⚡"
+colorFrom: indigo
+colorTo: purple
 sdk: docker
 app_port: 7860
-pinned: false
 license: apache-2.0
-models:
-  - Em-80/Qwen3-coder-REAP-25B-A3B-Rust-GGUF
 ---
 
-# THOX Rust Coder — Qwen3-Coder-REAP-25B-A3B-Rust
+# THOX interactive and specialist model service
 
-Hosted Rust coding model, served as GGUF through llama.cpp.
+This Space exposes one OpenAI-compatible endpoint:
 
-```bash
-curl -s -X POST https://thox-ai-thoxrustcoder.hf.space/v1/chat/completions \
-  -H 'Content-Type: application/json' \
-  -d '{"messages":[{"role":"user","content":"Write a Rust fn to parse semver."}],
-       "max_tokens":256}'
-```
+- `thox-fast-chat`: eagerly loaded, bounded, interactive Qwen2.5 0.5B target;
+- `thox-rust-coder`: lazily loaded 25B/3B-active Rust-specialist target.
 
-`GET /healthz` · `POST /v1/chat/completions` (OpenAI-shaped, ThoxRoute-registerable)
-
-## "3B active" is not a memory budget
-
-This is MoE: **25B total, ~3B active per token.** The two numbers govern
-different resources, and conflating them leads to picking a tier that cannot
-load the model:
-
-| | sized by |
-|---|---|
-| **memory** | **25B total** — every expert stays resident, since the router may pick any of them on any token |
-| **compute** | **~3B active** — decode costs about what a 3B dense model costs |
-
-Q4_K_M is therefore **15.1 GB**, not "3B-worth". What MoE buys is speed per
-resident byte — which is precisely what makes a CPU tier viable: 25B-sized
-memory, 3B-sized arithmetic.
-
-Runs on `cpu-upgrade` (8 vCPU / 32 GB). Throughput is measured and reported in
-every response under `thox_perf`, and in the UI — no throughput claim appears in
-this README that was not taken from this Space.
-
-## License — verified, not assumed
-
-| repo | license | checked |
-|---|---|---|
-| `Em-80/Qwen3-coder-REAP-25B-A3B-Rust-GGUF` | **Apache-2.0** | ungated, public |
-
-Apache-2.0 permits hosting, commercial use and redistribution. Verified against
-the model repo's own metadata before this Space was published.
+`GET /healthz` is ready only after the two-instance interactive pool is loaded.
+The interactive model is pinned to immutable model revision
+`9217f5db79a29953eb74d5343926648285ec7e67` and baked into the image.

app.py

@@ -1,196 +1,312 @@
-"""THOX Rust Coder — hosted Qwen3-Coder-REAP-25B-A3B-Rust (GGUF).
-
-SIZING: "3B active" IS NOT A MEMORY BUDGET
-------------------------------------------
-This is a Mixture-of-Experts model: 25B total parameters, ~3B active per token.
-Those two numbers govern different resources and it is easy to conflate them:
-
-    active params (~3B)  -> COMPUTE per token.  Decode is as cheap as a 3B dense.
-    total params (25B)   -> MEMORY.  Every expert must be resident, because the
-                            router may select any of them on any token.
-
-So a Q4_K_M GGUF is **15.1 GB of RAM/VRAM**, not "3B-worth". You cannot fit this
-on a tier sized for a 3B model. What MoE buys you here is speed-per-byte, not a
-smaller footprint -- which is exactly why a CPU tier is viable at all: we pay
-25B-sized memory but only 3B-sized arithmetic.
-
-TIER
-----
-Starts on `cpu-upgrade` (8 vCPU / 32 GB, ~$0.03/hr). That fits Q4_K_M with room
-for the KV cache, and the 3B active path keeps CPU decode tolerable. If measured
-throughput is too slow to be a useful coding assistant, escalate to a GPU tier --
-but escalate on a MEASUREMENT, not on the assumption that 25B implies a GPU.
-"""
-
-from __future__ import annotations
-
-import os
-import time
-import uuid
-
-import gradio as gr
-from fastapi import FastAPI
-from huggingface_hub import hf_hub_download
-from pydantic import BaseModel
-
-MODEL_REPO = os.environ.get("THOX_MODEL_REPO", "Em-80/Qwen3-coder-REAP-25B-A3B-Rust-GGUF")
-MODEL_FILE = os.environ.get("THOX_MODEL_FILE", "Qwen3-Coder-REAP-25B-A3B-Rust-Q4_K_M.gguf")
-N_CTX = int(os.environ.get("THOX_N_CTX", "8192"))
-
-SYSTEM = (
-    "You are THOX Rust Coder. You write correct, idiomatic Rust. Prefer showing "
-    "compiling code over prose. If a request is ambiguous, state the assumption "
-    "you made in one line, then give the code."
-)
-
-_llm = None
-
-
-def _usable_cpus() -> int:
-    """Threads from the cgroup quota, not the host.
-
-    `os.cpu_count()` reports the HOST's core count inside a container. On a
-    sibling Space this oversubscribed a 2-vCPU cgroup ~8x and cost ~290x
-    throughput -- the model ran slower than the edge device it was meant to
-    offload. Read the quota.
-    """
-    try:
-        quota, period = open("/sys/fs/cgroup/cpu.max").read().split()
-        if quota != "max":
-            return max(1, int(int(quota) / int(period)))
-    except Exception:
-        pass
-    try:
-        q = int(open("/sys/fs/cgroup/cpu/cpu.cfs_quota_us").read())
-        p = int(open("/sys/fs/cgroup/cpu/cpu.cfs_period_us").read())
-        if q > 0:
-            return max(1, q // p)
-    except Exception:
-        pass
-    try:
-        return max(1, len(os.sched_getaffinity(0)))
-    except Exception:
-        return os.cpu_count() or 2
-
-
-def llm():
-    global _llm
-    if _llm is None:
-        from llama_cpp import Llama
-
-        path = hf_hub_download(MODEL_REPO, MODEL_FILE,
-                               token=os.environ.get("HF_TOKEN"))
-        _llm = Llama(
-            model_path=path,
-            n_ctx=N_CTX,
-            n_threads=_usable_cpus(),
-            # -1 offloads every layer when a GPU is present, and is simply
-            # ignored on a CPU build -- so the same image works on both tiers.
-            n_gpu_layers=int(os.environ.get("THOX_GPU_LAYERS", "-1")),
-            verbose=False,
-        )
-    return _llm
-
-
-def generate(messages, max_tokens=512, temperature=0.2):
-    t0 = time.time()
-    # create_chat_completion uses the chat template embedded in the GGUF, rather
-    # than a hand-rolled one. Qwen3-Coder is ChatML, but reading it from the file
-    # means a re-quant with a different template does not silently break output.
-    out = llm().create_chat_completion(
-        messages=messages, max_tokens=max_tokens, temperature=temperature,
-    )
-    dt = time.time() - t0
-    text = out["choices"][0]["message"]["content"]
-    n = out.get("usage", {}).get("completion_tokens") or 0
-    return text, n, dt
-
-
-api = FastAPI()
-
-
-class Msg(BaseModel):
-    role: str
-    content: str
-
-
-class ChatRequest(BaseModel):
-    model: str | None = None
-    messages: list[Msg]
-    max_tokens: int | None = 512
-    temperature: float | None = 0.2
-
-
-@api.get("/healthz")
-def healthz():
-    return {
-        "status": "ok",
-        "model": MODEL_REPO,
-        "file": MODEL_FILE,
-        "role": "thox-rust-coder",
-        "n_ctx": N_CTX,
-        "threads": _usable_cpus(),
-        "loaded": _llm is not None,
-    }
-
-
-@api.post("/v1/chat/completions")
-def chat_completions(req: ChatRequest):
-    msgs = [m.model_dump() for m in req.messages]
-    if not any(m["role"] == "system" for m in msgs):
-        msgs = [{"role": "system", "content": SYSTEM}] + msgs
-    text, n, dt = generate(msgs, req.max_tokens or 512, req.temperature or 0.2)
-    return {
-        "id": "chatcmpl-" + uuid.uuid4().hex[:12],
-        "object": "chat.completion",
-        "created": int(time.time()),
-        "model": "thox-rust-coder",
-        "choices": [{"index": 0, "finish_reason": "stop",
-                     "message": {"role": "assistant", "content": text}}],
-        "usage": {"completion_tokens": n},
-        "thox_perf": {"tok_per_s": round(n / dt, 1) if dt else None,
-                      "seconds": round(dt, 2)},
-    }
-
-
-def ui(prompt, max_tokens):
-    text, n, dt = generate(
-        [{"role": "system", "content": SYSTEM}, {"role": "user", "content": prompt}],
-        int(max_tokens),
-    )
-    tps = n / dt if dt else 0
-    return text, f"{n} tok in {dt:.1f}s = {tps:.1f} tok/s"
-
-
-demo = gr.Interface(
-    fn=ui,
-    inputs=[gr.Textbox(label="Prompt", lines=4,
-                       value="Write a Rust function that parses a semver string "
-                             "into (major, minor, patch), returning Result."),
-            gr.Slider(64, 2048, value=512, step=64, label="max tokens")],
-    # gradio 5.50's gr.Code has a fixed language allow-list and "rust" is NOT
-    # on it -- passing it raises ValueError at import and the Space exits 1.
-    # No highlighting is better than no Space.
-    outputs=[gr.Code(label="THOX Rust Coder"),
-             gr.Textbox(label="Measured")],
-    title="THOX Rust Coder — Qwen3-Coder-REAP-25B-A3B-Rust",
-    description=(
-        "Rust-specialised MoE coder, Apache-2.0, served as GGUF.\n\n"
-        "`POST /v1/chat/completions` (OpenAI-shaped, ThoxRoute-registerable) · "
-        "`GET /healthz`\n\n"
-        "**25B total / ~3B active.** Memory is sized by the 25B (all experts stay "
-        "resident); speed is sized by the 3B. That combination is what makes a "
-        "CPU tier viable."
-    ),
-)
-
-app = gr.mount_gradio_app(api, demo, path="/")
-
-
-if __name__ == "__main__":
-    # Defining `app` does not serve it -- without this the process exits 0 and
-    # the Space reports RUNTIME_ERROR with no traceback to read.
-    import uvicorn
-
-    uvicorn.run(app, host="0.0.0.0",
-                port=int(os.environ.get("GRADIO_SERVER_PORT", 7860)))
+"""OpenAI-compatible THOX interactive and specialist model service.
+
+The interactive model is intentionally small and eagerly loaded so readiness
+means a user request can start generating immediately.  The 25B Rust-specialist
+model remains lazy because loading it takes roughly 100 seconds on cpu-upgrade
+and it is not part of the interactive latency contract.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import queue
+import threading
+import time
+import uuid
+from contextlib import asynccontextmanager
+from collections.abc import Iterator
+from dataclasses import dataclass
+from typing import Any
+
+from fastapi import FastAPI, HTTPException
+from fastapi.responses import StreamingResponse
+from huggingface_hub import hf_hub_download
+from pydantic import BaseModel, ConfigDict, Field, field_validator
+
+FAST_MODEL_ID = "thox-fast-chat"
+FAST_MODEL_REPO = os.environ.get(
+    "THOX_FAST_MODEL_REPO", "Qwen/Qwen2.5-0.5B-Instruct-GGUF"
+)
+FAST_MODEL_REVISION = os.environ.get(
+    "THOX_FAST_MODEL_REVISION", "9217f5db79a29953eb74d5343926648285ec7e67"
+)
+FAST_MODEL_FILE = os.environ.get(
+    "THOX_FAST_MODEL_FILE", "qwen2.5-0.5b-instruct-q4_k_m.gguf"
+)
+CODER_MODEL_ID = "thox-rust-coder"
+CODER_MODEL_REPO = os.environ.get(
+    "THOX_CODER_MODEL_REPO", "Em-80/Qwen3-coder-REAP-25B-A3B-Rust-GGUF"
+)
+CODER_MODEL_REVISION = os.environ.get("THOX_CODER_MODEL_REVISION", "main")
+CODER_MODEL_FILE = os.environ.get(
+    "THOX_CODER_MODEL_FILE", "Qwen3-Coder-REAP-25B-A3B-Rust-Q4_K_M.gguf"
+)
+N_CTX = int(os.environ.get("THOX_N_CTX", "4096"))
+FAST_POOL_SIZE = max(1, min(int(os.environ.get("THOX_FAST_POOL_SIZE", "2")), 4))
+MAX_OUTPUT_TOKENS = max(
+    1, min(int(os.environ.get("THOX_MAX_OUTPUT_TOKENS", "128")), 512)
+)
+MAX_MESSAGES = 64
+MAX_MESSAGE_CHARS = 65_536
+MAX_REQUEST_CHARS = 131_072
+
+SYSTEM = (
+    "You are THOX Fast Chat, a concise privacy-first assistant. Follow the "
+    "user's requested output format exactly. Never claim that cloud inference "
+    "ran locally or on-device."
+)
+
+
+def _usable_cpus() -> int:
+    """Return the container CPU quota instead of the misleading host count."""
+
+    try:
+        quota, period = open("/sys/fs/cgroup/cpu.max", encoding="utf-8").read().split()
+        if quota != "max":
+            return max(1, int(int(quota) / int(period)))
+    except (OSError, ValueError):
+        pass
+    try:
+        quota = int(
+            open("/sys/fs/cgroup/cpu/cpu.cfs_quota_us", encoding="utf-8").read()
+        )
+        period = int(
+            open("/sys/fs/cgroup/cpu/cpu.cfs_period_us", encoding="utf-8").read()
+        )
+        if quota > 0:
+            return max(1, quota // period)
+    except (OSError, ValueError):
+        pass
+    try:
+        return max(1, len(os.sched_getaffinity(0)))
+    except (AttributeError, OSError):
+        return os.cpu_count() or 2
+
+
+def _download(repo: str, filename: str, revision: str) -> str:
+    return hf_hub_download(
+        repo_id=repo,
+        filename=filename,
+        revision=revision,
+        token=os.environ.get("HF_TOKEN") or None,
+    )
+
+
+def _new_llama(path: str, *, threads: int):
+    from llama_cpp import Llama
+
+    return Llama(
+        model_path=path,
+        n_ctx=N_CTX,
+        n_threads=threads,
+        n_gpu_layers=int(os.environ.get("THOX_GPU_LAYERS", "-1")),
+        verbose=False,
+    )
+
+
+@dataclass
+class Lease:
+    model: Any
+    release: Any
+
+
+class Runtime:
+    """Own bounded model capacity without sharing one llama context concurrently."""
+
+    def __init__(self) -> None:
+        fast_path = _download(FAST_MODEL_REPO, FAST_MODEL_FILE, FAST_MODEL_REVISION)
+        usable = _usable_cpus()
+        per_model_threads = max(1, usable // FAST_POOL_SIZE)
+        self._fast: queue.LifoQueue[Any] = queue.LifoQueue(maxsize=FAST_POOL_SIZE)
+        for _ in range(FAST_POOL_SIZE):
+            self._fast.put(_new_llama(fast_path, threads=per_model_threads))
+        self._coder = None
+        self._coder_lock = threading.Lock()
+
+    def acquire(self, model_id: str) -> Lease:
+        if model_id == FAST_MODEL_ID:
+            try:
+                model = self._fast.get_nowait()
+            except queue.Empty as exc:
+                raise HTTPException(status_code=429, detail="interactive capacity busy") from exc
+            return Lease(model=model, release=lambda: self._fast.put(model))
+        if model_id == CODER_MODEL_ID:
+            if not self._coder_lock.acquire(blocking=False):
+                raise HTTPException(status_code=429, detail="specialist capacity busy")
+            try:
+                if self._coder is None:
+                    path = _download(
+                        CODER_MODEL_REPO, CODER_MODEL_FILE, CODER_MODEL_REVISION
+                    )
+                    self._coder = _new_llama(path, threads=_usable_cpus())
+            except Exception:
+                self._coder_lock.release()
+                raise
+            return Lease(model=self._coder, release=self._coder_lock.release)
+        raise HTTPException(status_code=404, detail="model not found")
+
+    @property
+    def interactive_available(self) -> int:
+        return self._fast.qsize()
+
+
+class Msg(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    role: str = Field(pattern=r"^(system|user|assistant|tool)$")
+    content: str = Field(min_length=1, max_length=MAX_MESSAGE_CHARS)
+
+
+class ChatRequest(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    model: str = FAST_MODEL_ID
+    messages: list[Msg] = Field(min_length=1, max_length=MAX_MESSAGES)
+    max_tokens: int = Field(default=64, ge=1, le=4096)
+    temperature: float = Field(default=0.2, ge=0.0, le=2.0)
+    stream: bool = False
+
+    @field_validator("messages")
+    @classmethod
+    def bound_aggregate_prompt(cls, messages: list[Msg]) -> list[Msg]:
+        if sum(len(message.content) for message in messages) > MAX_REQUEST_CHARS:
+            raise ValueError("aggregate prompt is too large")
+        return messages
+
+
+runtime: Runtime | None = None
+
+
+@asynccontextmanager
+async def lifespan(_: FastAPI):
+    global runtime
+    runtime = Runtime()
+    try:
+        yield
+    finally:
+        runtime = None
+
+
+api = FastAPI(
+    title="THOX interactive model service", version="1.0.0", lifespan=lifespan
+)
+
+
+def _messages(req: ChatRequest) -> list[dict[str, str]]:
+    messages = [message.model_dump() for message in req.messages]
+    if not any(message["role"] == "system" for message in messages):
+        messages.insert(0, {"role": "system", "content": SYSTEM})
+    return messages
+
+
+def _max_tokens(req: ChatRequest) -> int:
+    return min(req.max_tokens, MAX_OUTPUT_TOKENS)
+
+
+def _runtime() -> Runtime:
+    if runtime is None:
+        raise HTTPException(status_code=503, detail="model runtime is not ready")
+    return runtime
+
+
+@api.get("/")
+@api.get("/healthz")
+def healthz() -> dict[str, Any]:
+    active = _runtime()
+    return {
+        "status": "ready",
+        "interactive_model": FAST_MODEL_ID,
+        "interactive_model_repo": FAST_MODEL_REPO,
+        "interactive_model_revision": FAST_MODEL_REVISION,
+        "interactive_pool_size": FAST_POOL_SIZE,
+        "interactive_available": active.interactive_available,
+        "specialist_model": CODER_MODEL_ID,
+        "max_output_tokens": MAX_OUTPUT_TOKENS,
+        "n_ctx": N_CTX,
+        "threads": _usable_cpus(),
+    }
+
+
+def _completion_id() -> str:
+    return "chatcmpl-" + uuid.uuid4().hex[:16]
+
+
+def _stream_completion(req: ChatRequest, lease: Lease) -> Iterator[bytes]:
+    completion_id = _completion_id()
+    created = int(time.time())
+    try:
+        chunks = lease.model.create_chat_completion(
+            messages=_messages(req),
+            max_tokens=_max_tokens(req),
+            temperature=req.temperature,
+            stream=True,
+        )
+        for chunk in chunks:
+            choice = chunk.get("choices", [{}])[0]
+            payload = {
+                "id": completion_id,
+                "object": "chat.completion.chunk",
+                "created": created,
+                "model": req.model,
+                "choices": [
+                    {
+                        "index": 0,
+                        "delta": choice.get("delta") or {},
+                        "finish_reason": choice.get("finish_reason"),
+                    }
+                ],
+            }
+            yield f"data: {json.dumps(payload, separators=(',', ':'))}\n\n".encode()
+        yield b"data: [DONE]\n\n"
+    finally:
+        lease.release()
+
+
+@api.post("/v1/chat/completions")
+def chat_completions(req: ChatRequest):
+    lease = _runtime().acquire(req.model)
+    if req.stream:
+        return StreamingResponse(
+            _stream_completion(req, lease),
+            media_type="text/event-stream",
+            headers={"Cache-Control": "no-cache", "X-Accel-Buffering": "no"},
+        )
+
+    started = time.monotonic()
+    try:
+        result = lease.model.create_chat_completion(
+            messages=_messages(req),
+            max_tokens=_max_tokens(req),
+            temperature=req.temperature,
+        )
+    finally:
+        lease.release()
+    elapsed = time.monotonic() - started
+    choice = result["choices"][0]
+    usage = result.get("usage") or {}
+    return {
+        "id": _completion_id(),
+        "object": "chat.completion",
+        "created": int(time.time()),
+        "model": req.model,
+        "choices": [
+            {
+                "index": 0,
+                "finish_reason": choice.get("finish_reason") or "stop",
+                "message": choice["message"],
+            }
+        ],
+        "usage": {
+            "prompt_tokens": int(usage.get("prompt_tokens") or 0),
+            "completion_tokens": int(usage.get("completion_tokens") or 0),
+            "total_tokens": int(usage.get("total_tokens") or 0),
+        },
+        "thox_perf": {"seconds": round(elapsed, 3)},
+    }
+
+
+if __name__ == "__main__":
+    import uvicorn
+
+    uvicorn.run(api, host="0.0.0.0", port=int(os.environ.get("PORT", "7860")))

requirements.txt

@@ -1,14 +1 @@
-# llama-cpp-python is deliberately ABSENT.
-#
-# It is installed from conda-forge in the Dockerfile as a prebuilt, glibc-linked
-# linux-64 binary. Two pip routes both fail on an HF Space:
-#   * PyPI is sdist-only        -> compiles -> `Job timeout`
-#   * abetlen's CPU wheel index -> musl-linked -> builds green, RUNNING, /healthz
-#                                  ok, then HTTP 500 at the first dlopen
-# See thoxllm-factory/docs/SPACE_PINS.md.
-
-gradio==5.50.0
-fastapi
-pydantic>=2
-uvicorn
-huggingface_hub>=0.28
+huggingface_hub==1.6.0