| # OpenJev — zero-GPU CPU deploy kit |
|
|
| Runs the [OpenJev](https://huggingface.co/openjev/openjev) decision API |
| ([openjev-server](https://huggingface.co/spaces/openjev/openjev-server)) |
| **with no GPU at all**. It serves the exact same |
| `POST /v1/systemone` contract as the hosted server — a choice / yes-no / score |
| per question, with a probability for every option, read off the model's first |
| output position — by pointing the **official, unmodified** `openjev-server` at |
| [`llama.cpp`](https://github.com/ggml-org/llama.cpp) (CPU, GGUF) instead of vLLM. |
|
|
| | | hosted (reference) | this kit (zero GPU) | |
| |---|---|---| |
| | engine | vLLM + FP8 on 1× H100 | llama.cpp on CPU | |
| | weights | `openjev/openjev-FP8` (80 GB) | `openjev/openjev-GGUF` Q4_K_M (16.2 GB) | |
| | latency | ~125 ms | seconds (see [Benchmarks](#benchmarks)) | |
| | surface | `/v1/systemone` + ops | identical (official server, unchanged) | |
|
|
| ## Why this works (no code hacks) |
|
|
| `openjev-server`'s `vllm` backend is really *"any OpenAI-compatible server that |
| returns logprobs"*: |
|
|
| - it sends standard `/chat/completions` JSON (`logprobs`, `top_logprobs`, |
| `allowed_token_ids`, `max_tokens: 1`, `temperature: 0`); |
| - **exact readout** uses vLLM's `logprob_token_ids = [ids]` extension → |
| llama.cpp doesn't have it, so the backend's documented fallback kicks in: |
| top-K logprobs are matched **by label text** instead (see |
| `openjev_server/backends/vllm.py` → `_scores`, "old protocol"). |
|
|
| That single fallback is the whole trick: the official code path runs unmodified, |
| and `--force` only relaxes the startup probe's letter-mass check if llama.cpp's |
| text-matched logprobs ever look borderline for your quant. |
|
|
| ## What you get |
|
|
| - `POST /v1/systemone` — one request, any mix of `choice` / `noul` / `score` |
| - `POST /v1/prewarm`, `POST /v1/chat/completions` (passthrough) |
| - `GET /v1/version` · `GET /healthz` · `GET /readyz` · |
| `GET /metrics` (Prometheus) · `GET /docs` (OpenAPI) |
| - optional bearer auth via `OPENJEV_TOKEN` |
| - Persistent model storage (HF Spaces) — the 16.2 GB download survives restarts |
|
|
| ## Deploy on Hugging Face (zero GPU, free) |
|
|
| 1. **Duplicate the runtime Space** (needs a free HF account): |
| <https://huggingface.co/spaces/broadfield/openjev-cpu-run?duplicate=true> |
| - SDK: **Docker** · hardware: **CPU basic (free)** · persistent storage: |
| **30 GB** ($0.50/mo, required for `/data`) |
| 2. Wait for the build. The Docker image compiles llama.cpp CPU + installs |
| openjev-server and, on first boot, downloads the Q4 GGUF (~16.2 GB) into |
| `/data`. **Allow ~20–50 min on the first cold boot;** subsequent restarts |
| load straight from persistent storage. |
| 3. Try the API. By default the Space is public: |
| |
| ```bash |
| BASE=https://<your-username>-openjev-cpu-run.hf.space |
| |
| curl -s "$BASE/v1/systemone" -H 'Content-Type: application/json' -d '{ |
| "state": "Customer message: I was charged twice for my order last week and nobody has replied.", |
| "questions": { |
| "route": {"type": "choice", "instructions": "Which team should handle this?", |
| "criteria": {"billing": null, "shipping": null, "technical": null}}, |
| "angry": {"type": "noul", "instructions": "Is the customer angry?"}, |
| "urgency": {"type": "score", "instructions": "How urgent is this?", |
| "criteria": ["can wait", "this week", "today", "right now"]} |
| } |
| }' |
| ``` |
|
|
| ```json |
| { |
| "answers": { |
| "route": {"type": "choice", "choice": "billing", |
| "probabilities": {"billing": 0.9996, "shipping": 0.0002, "technical": 0.0002}, |
| "confidence": 0.9995}, |
| "angry": {"type": "noul", "noul": 0.56}, |
| "urgency": {"type": "score", "score": 2.04, |
| "legend": {"0": "can wait", "1": "this week", "2": "today", "3": "right now"}, |
| "probabilities": {"0": 0.02, "1": 0.13, "2": 0.64, "3": 0.21}, |
| "confidence": 0.71} |
| }, |
| "usage": {"input_tokens": 239, "output_tokens": 0} |
| } |
| ``` |
|
|
| > **Latency honesty right up front** — a 27B model on a shared free CPU is *not* |
| > 125 ms. Expect **~2–6 s per question** (single reader) on a 16-core Space with |
| > the Q4 quant. That's a real API — just not a high-QPS one. The reason this is |
| > still interesting: **a decision API only ever generates 1 token**, so the CPU |
| > is the *only* slow part, and it stays predictable. Raise `LLAMA_PARALLEL`, |
| > lower `LLAMA_CTX`, or use a different quant if your workload wants less of it. |
|
|
| ## Deploy locally (or on any VPS) |
|
|
| ```bash |
| git clone https://huggingface.co/datasets/broadfield/openjev-cpu-deploy-kit |
| cd openjev-cpu-deploy-kit |
| docker compose up --build -d |
| curl -s http://localhost:7860/v1/systemone ... # same payload as above |
| ``` |
|
|
| Or Docker directly: |
|
|
| ```bash |
| docker build -t openjev-cpu . |
| docker run -d -p 7860:7860 -v openjev-data:/data -e MODEL_FILE=OpenJev-Q4_K_M.gguf openjev-cpu |
| ``` |
|
|
| ## Env vars |
|
|
| | var | default | what it does | |
| |---|---|---| |
| | `MODEL_REPO` | `openjev/openjev-GGUF` | GGUF repo | |
| | `MODEL_FILE` | `OpenJev-Q4_K_M.gguf` | Q4_K_M · Q5_K_M (18.8 GB) · Q6_K (21.6 GB) · Q8_0 (27.9 GB) | |
| | `TOKENIZER_REPO` | `openjev/openjev` | tokenizer + chat template for openjev-server | |
| | `LLAMA_CTX` | `8192` | context window | |
| | `LLAMA_MAX_LOGPROBS` | `64` | top-K logprobs (must be ≥ number of options) | |
| | `LLAMA_PARALLEL` | `1` | concurrent sequences (scales memory) | |
| | `LLAMA_THREADS` / `LLAMA_THREADS_BATCH` | auto | pin core count, e.g. `8` / `8` | |
| | `OPENJEV_PORT` | `7860` | ingress (HF sets `$PORT`) | |
| | `OPENJEV_TOKEN` | empty | bearer token required on `/v1/*` | |
| | `OPENJEV_PROFILE` | `openjev` | `openjev` (published constants) or `uncalibrated` | |
| | `OPENJEV_SERVED_MODEL_NAME` | `openjev` | model id reported by `/v1/version` | |
|
|
| ## Benchmarks |
|
|
| Expected on a **free 16 vCPU CPU Space**, `OpenJev-Q4_K_M.gguf` |
| (27B, Qwen3-based → ~8-bit KV cache in the llama.cpp fork, 16.2 GB RAM): |
|
|
| | quant | file size | SPE (tokens/s, 8 threads) | RAM | 1-question latency* | |
| |---|---|---|---|---| |
| | Q4_K_M | 16.2 GB | 2–4 | ~17 GB | ~2–6 s | |
| | Q5_K_M | 18.8 GB | 1.5–3 | ~20 GB | ~3–8 s | |
| | Q6_K | 21.6 GB | 1.5–3 | ~23 GB | ~3–8 s | |
| |
| \* single question ≈ one forward pass: `(prompt_tokens + 1) / SPE`. A 240-token |
| state ⇒ ~4 s @ 3 SPE. Latency is directly linear in prompt length. |
|
|
| **The decision-API twist:** because `max_tokens: 1`, a *pipeline* of many |
| questions on one state shares ~all of the prefill. For batch agents, batch the |
| questions into one `/v1/systemone` call — every extra answer after the first is |
| nearly free: |
|
|
| | questions in one call | est. per-call latency @ 3 SPE | |
| |---|---| |
| | 1 | ~4 s | |
| | 4 | ~4.5 s | |
| | 10 | ~5.5 s (10 answers, still one pass) | |
|
|
| ## Calling it from code |
|
|
| ```python |
| import httpx |
| |
| r = httpx.post("http://localhost:7860/v1/systemone", json={ |
| "state": "Customer message: I was charged twice for my order last week and nobody has replied.", |
| "questions": { |
| "route": {"type": "choice", "instructions": "Which team should handle this?", |
| "criteria": {"billing": None, "shipping": None, "technical": None}}, |
| "angry": {"type": "noul", "instructions": "Is the customer angry?"}, |
| }, |
| }, timeout=60) |
| answers = r.json()["answers"] |
| print(answers["route"]["choice"], answers["route"]["probabilities"], answers["angry"]["noul"]) |
| ``` |
|
|
| ```typescript |
| const r = await fetch(`${BASE}/v1/systemone`, { |
| method: "POST", |
| headers: { "Content-Type": "application/json" }, |
| body: JSON.stringify({ |
| state: "Customer message: I was charged twice for my order last week and nobody has replied.", |
| questions: { |
| route: { type: "choice", instructions: "Which team should handle this?", |
| criteria: { billing: null, shipping: null, technical: null } }, |
| angry: { type: "noul", instructions: "Is the customer angry?" }, |
| }, |
| }), |
| }); |
| const { answers } = await r.json(); |
| ``` |
|
|
| ## Layout |
|
|
| ``` |
| Dockerfile # multi-stage: llama.cpp CPU + official openjev-server |
| entrypoint.sh # GGUF → /data, llama-server, then openjev serve |
| docker-compose.yml # local/VPS one-liner |
| bench.mjs # throughput + latency smoke bench against a running endpoint |
| runtime-baseline.md # the exact Docker Space spec we recommend |
| README.md # you are here |
| ``` |
|
|
| ## License & credit |
|
|
| - Model weights: **CC BY-NC 4.0** — OpenJev is an independent project, not |
| affiliated with TypeSafe (Jev is their product). |
| - `openjev-server`: Apache 2.0. |
| - This kit: Apache 2.0. llama.cpp: MIT. |
