README.md

# 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.