broadfield/openjev-cpu-deploy-kit

OpenJev — zero-GPU CPU deploy kit

Runs the OpenJev decision API (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 (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)
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:

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"]}
  }
}'

{
  "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)

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:

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

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"])

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.