# 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): - 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://-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.