Draft an adverse-event case

# Assemble Decosa pharmacovigilance intake on this machine

You are setting up self-hosted adverse event case intake for a drug safety team (a marketing authorisation holder or a CRO
running intake for one). It reads a report as it arrived (an email, a web form, a call recording, or a scanned MedWatch or
CIOMS form, in English, German, French, Spanish, Italian, Dutch, Polish, Portuguese or Czech) and returns a draft case:
- E2B(R3)-shaped fields, each quoted to its source line (and the reporter's own words when the report was translated);
- the four minimum criteria, the seriousness criteria per event, and expectedness against the reference label we send;
- day 0 and the US 15-day and EU 15- and 90-day dates, with the arithmetic and the rule;
- free-text coding suggestions (no MedDRA is shipped), follow-up questions in the reporter's language, an optional
  narrative with every sentence checked, and signed case and decision records.

Work step by step, show me each command before running anything that needs sudo, and stop if a check fails.

**Before anything else, remind me:**
- Adverse event reports hold health data about patients. On this box nothing leaves the machine: the recognisers, the
  translation model, the document reader, the language model and the checks all run here. Never point it at a hosted
- This is a triage and drafting aid, not a validated safety database and not regulatory advice. The safety physician
  decides validity, seriousness, expectedness and causality. It submits nothing to FAERS or EudraVigilance.

Repeat both points in your final summary.

## Step 0: set up with a coding agent, rehearse on mock data, then go private

This prompt is for a coding agent running on the machine that will host the service. We recommend Claude Code with
Claude Opus 5.5; any capable coding agent works. Work in this order:

1. Set up on mock data only. During the whole setup you (the agent) work with the synthetic sample bundle below and
   nothing else. Do not ask me for real data, and do not open, read, list or copy files that hold real data, even to
   "test with something realistic".
2. Rehearse. When the steps below are done and the service is healthy, fetch the mock-data bundle for this tool,
   https://decosa.ai/samples/pv-intake.zip (1.0 MB, 18 checks, synthetic or openly licensed: see `licence` in expected.json),
   show me what is in it, and run the rehearsal against the local API:
   `docker compose exec api python scripts/rehearse.py pv-intake` (the api image carries the same bundle under /app/rehearsal/pv-intake/;
   with no key set, the script asks the local API for a short demo token). From a decosa-api checkout instead:
   `python scripts/rehearse.py pv-intake --bundle pv-intake.zip --base-url http://127.0.0.1:<PORT>`.
   It sends the mock inputs to the local API and prints PASS or FAIL for each expected property (for example: "with day 0 on 2 Sep 2026, the US 15-day report is due 17 Sep 2026 (no model)", "the email is a valid case (all four minimum criteria)", "it is serious (hospitalisation, quoted)"). Show me
   the full output. Every check must pass. If one fails, fix the install and run it again; never edit `expected.json`
   to make a check pass.
3. Stop there. Once the rehearsal passes, tell me, and I will run my own data against the local API myself, on this
   machine.

For the person running this: a coding agent that runs in the cloud sees everything in its context, including files it
reads, command output and anything pasted into the chat. Keep real data out of the chat and out of anything the agent
can read. Switch to your own data only after the rehearsal has passed and the agent's work is done.

## What you are building

| service | image | model | port |
|---|---|---|---|
| `llm` | `vllm/vllm-openai:v0.29.0` | `nvidia/Qwen3.8-27B-NVFP4` @ `482ca0f3832238542f8f5295dde86b5f22711d80`, Apache-2.0 | internal 8000 |
| `mt` | `vllm/vllm-openai:v0.29.0` | `tencent/Hy-MT2-7B` @ `9b0eb4e8f001def3e5ff6469a0ac96fdb39ec223`, Apache-2.0 | internal 8000 |
| `diarize` | built from `decosa-api/services/diarize` | `OpenMOSS-Team/MOSS-Transcribe-Diarize`, Apache-2.0 | internal 8092 |
| `parser` | `vllm/vllm-openai:v0.29.0` | `PaddlePaddle/PaddleOCR-VL-1.6` @ `c5630abae1d940eafe0697512a0325494b02ab42`, Apache-2.0 | internal 8498 |
| `docreader` | built from `decosa-api/services/docreader` | `docling-project/docling-layout-heron` (MIT + Apache-2.0) | internal 8497 |
| `api` | `${DECOSA_REGISTRY}/decosa-api:<tag>` (no GPU) | none | `127.0.0.1:8445` |

Optional, only for calls that are not in English: `speech`, built from `decosa-api/services/lang` (Qwen3-ASR-1.7B,
Apache-2.0, port 8492). Without it, those calls go to `diarize`, which is weaker outside English.

## 1. Check the GPU, driver and Docker

1. Run `nvidia-smi`. I need one NVIDIA GPU with at least 80 GB for everything on one card: Qwen about 20 GB of weights plus
   KV cache, Hy-MT2-7B about 18 GB, the diarizer about 3 GB, the parser and layout model about 6 GB. Driver 580 or newer.
   On Hopper (H100) use `LLM_MODEL=Qwen/Qwen3.8-27B-FP8` and `LLM_REVISION=main` (not measured). With two cards, put `mt`
   and `diarize` on the second one.
2. Check `docker --version`, `docker compose version` and `docker run --rm --gpus all ubuntu nvidia-smi`. If Docker or
   the NVIDIA Container Toolkit is missing, install them from the official Docker and NVIDIA repositories, run
   `sudo nvidia-ctk runtime configure --runtime=docker` and restart Docker.
3. Confirm about 110 GB of free disk and that `ffmpeg` is in the api image (`docker run --rm <api image> ffmpeg -version`);
   the api decodes MP3, OGG and FLAC calls with it.

## 2. Get the images, weights and source

- `${DECOSA_REGISTRY}/decosa-api:<tag>` is **publishing soon**. If the pull fails, clone `decosa-api` into
  `~/decosa-pv/decosa-api` (access required), check out the newest release tag that contains `decosa_api/verticals/pv/`
  (`main` until one does), and build `docker build -f docker/api/Dockerfile -t decosa-api:local .`. Clone it either way:
  `diarize` and `docreader` are built from it.
- `hf download tencent/Hy-MT2-7B --revision 9b0eb4e8f001def3e5ff6469a0ac96fdb39ec223 --local-dir ~/models/Hy-MT2-7B`.

## 3. Write the compose file

Create `~/decosa-pv/docker-compose.yml`:

```yaml
name: decosa-pv
x-gpu: &gpu { resources: { reservations: { devices: [ { driver: nvidia, device_ids: ["0"], capabilities: [gpu] } ] } } }
x-health: &health { interval: 15s, timeout: 5s, retries: 20 }
services:
  llm:
    image: vllm/vllm-openai:v0.29.0
    deploy: *gpu
    ipc: host
    volumes: [hf-cache:/root/.cache/huggingface]
    command: ["nvidia/Qwen3.8-27B-NVFP4", "--revision", "482ca0f3832238542f8f5295dde86b5f22711d80", "--served-model-name", "qwen3.8-27b",
              "--max-model-len", "32768", "--gpu-memory-utilization", "0.45", "--max-num-seqs", "16", "--kv-cache-dtype", "fp8_e4m3",
              "--seed", "0", "--host", "0.0.0.0", "--port", "8000"]
    healthcheck: { <<: *health, test: ["CMD", "python3", "-c", "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8000/health', timeout=4)"], start_period: 900s }
  mt:
    image: vllm/vllm-openai:v0.29.0
    deploy: *gpu
    ipc: host
    # vLLM 0.29 serves Hy-MT2 through its Transformers backend; CUDA-graph capture fails there, hence --enforce-eager
    command: ["/model", "--served-model-name", "hy-mt2-7b", "--max-model-len", "8192", "--gpu-memory-utilization", "0.20",
              "--max-num-seqs", "16", "--enforce-eager", "--generation-config", "vllm", "--host", "0.0.0.0", "--port", "8000"]
    volumes: ["~/models/Hy-MT2-7B:/model:ro"]
    healthcheck: { <<: *health, test: ["CMD", "python3", "-c", "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8000/health', timeout=4)"], start_period: 600s }
  diarize:
    build:
      context: ./decosa-api/services/diarize
      dockerfile_inline: |
        FROM pytorch/pytorch:2.8.0-cuda12.8-cudnn9-runtime
        WORKDIR /app
        COPY requirements.txt .
        RUN pip install --no-cache-dir -r requirements.txt
        COPY server.py .
        CMD ["python", "server.py"]
    deploy: *gpu
    environment: { DIARIZE_HOST: 0.0.0.0, DIARIZE_PORT: "8092", DIARIZE_DEVICE: "cuda:0", HF_HOME: /root/.cache/huggingface }
    volumes: [hf-cache:/root/.cache/huggingface]
    healthcheck: { <<: *health, test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8092/health', timeout=4)"], start_period: 600s }
  parser:
    image: vllm/vllm-openai:v0.29.0
    deploy: *gpu
    ipc: host
    volumes: [hf-cache:/root/.cache/huggingface]
    command: ["PaddlePaddle/PaddleOCR-VL-1.6", "--revision", "c5630abae1d940eafe0697512a0325494b02ab42", "--trust-remote-code",
              "--max-model-len", "8192", "--gpu-memory-utilization", "0.05", "--max-num-seqs", "16", "--no-enable-prefix-caching",
              "--mm-processor-cache-gb", "0", "--generation-config", "vllm", "--host", "0.0.0.0", "--port", "8498"]
    healthcheck: { <<: *health, test: ["CMD", "python3", "-c", "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8498/health', timeout=4)"], start_period: 600s }
  docreader:
    build: { context: ./decosa-api/services/docreader }
    deploy: *gpu
    depends_on: { parser: { condition: service_healthy } }
    environment: { DOCREADER_PARSER_URL: "http://parser:8498/v1", DOCREADER_PARSER_MODEL: PaddlePaddle/PaddleOCR-VL-1.6, DOCLING_DEVICE: cuda }
    volumes: [hf-cache:/models]
  api:
    image: ${DECOSA_REGISTRY}/decosa-api:<tag>          # or decosa-api:local
    depends_on: { llm: { condition: service_healthy }, mt: { condition: service_healthy }, diarize: { condition: service_healthy } }
    environment:
      DECOSA_HOST: 0.0.0.0
      DECOSA_PORT: "8445"
      DECOSA_LLM_ROUTE: direct                  # local model only; receipts are signed by this box's key
      DECOSA_LLM_URL: http://llm:8000/v1
      DECOSA_LLM_MODEL: qwen3.8-27b
      DECOSA_LOCAL_SIGNING: "on"                # Ed25519 key created under /data on first start
      DECOSA_LANG_MT_URL: http://mt:8000/v1
      DECOSA_LANG_MT_MODEL: hy-mt2-7b
      DECOSA_DIARIZE_URL: http://diarize:8092
      DECOSA_DOCREADER_URL: http://docreader:8497
      DECOSA_LANG_SPEECH_URL: http://speech:8492  # only if you add the optional speech service
      DECOSA_SESSIONS_PER_IP_HOUR: "1000"
      DECOSA_BUDGET_LLM_TOKENS: "400000"         # per session; a report uses about 3,000 to 6,000 generated tokens
      DECOSA_SESSION_TTL_S: "28800"
      DECOSA_LLM_TIMEOUT_S: "300"
    ports: ["127.0.0.1:8445:8445"]
    volumes: [decosa-data:/data]
    healthcheck: { <<: *health, test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8445/healthz', timeout=4)"], start_period: 20s }
volumes: { hf-cache: {}, decosa-data: {} }
```

Use the named volume `decosa-data` exactly as written: a root-owned host bind mount makes the API fail on
`/data/keys.sqlite`. Run `docker compose up -d --build` and poll `docker compose ps` until every service is healthy (the
LLM takes 5 to 10 minutes the first time). `curl -s localhost:8445/pv/info | jq .blocks` should show the language pack,
the document reader and the diarizer.

## 4. Smoke test on the bundled synthetic reports

```bash
API=localhost:8445
tok() { curl -s $API/demo/session -H 'content-type: application/json' -d '{"vertical":"pv-intake"}' | jq -r .token; }
curl -s $API/pv/clock -H 'content-type: application/json' -d '{"day0":"2026-09-02","serious":true,"unexpected":true,"today":"2026-09-09"}' | jq '.rows[] | {id, applies, deadline}'
for s in email-angioedema call-febrile-neutropenia email-de-no-patient; do
  curl -s $API/pv/intake -H "authorization: Bearer $(tok)" -H 'content-type: application/json' -d "{\"sample_id\":\"$s\",\"draft_narrative\":false}" > /tmp/$s.json
  jq "{sample: \"$s\", valid: .criteria.valid, missing: .criteria.missing, serious: .seriousness.serious, unexpected: .expectedness.unexpected, day0: .clock.day0, first: .clock.primary.deadline, asr: .intake.asr.model, followups: [.followups[].question_in_reporter_language // .followups[].question][0:2]}" /tmp/$s.json
done
jq '{record}' /tmp/email-angioedema.json | curl -s $API/record/verify -H 'content-type: application/json' -d @- | jq '{ok, summary}'
```

Pass if: the clock gives 2026-09-17 for `us_15` and `eu_15`; the email is valid, serious and unexpected with day 0
**2026-09-02** (the day the sales representative was told, not the 8 Sep received date) and first deadline 2026-09-17;
the call is transcribed by the diarizer, valid, serious and unexpected, with day 0 2026-09-15 and deadline 2026-09-30;
the German email is not valid (`missing: ["patient"]`) with follow-up questions in German; and the record verifies.
Each run takes about one to four minutes on a busy GPU.

## 5. Run a real report

```bash
jq -n --rawfile t report.txt --rawfile l label.txt '{report: {kind: "email", text: $t, received_date: "2026-09-20"},
  product: {name: "Your product", type: "drug", label: $l}, regions: ["us","eu"]}' > req.json
curl -s $API/pv/intake -H "authorization: Bearer $(tok)" -H 'content-type: application/json' -d @req.json > case.json
jq -r .case_md case.json > case.md; jq .e2b case.json > e2b-draft.json; jq .record case.json > case-record.json
```

A call: `report: {kind: "call", audio_b64: "<base64 WAV/MP3/OGG/FLAC>", language: "en"}`. A scan:
`report: {kind: "document", file_b64: "<base64 PDF or image>", media_type: "application/pdf"}`. The received date is the
first day anyone at the company or acting for it had the report. Limits: 12,000 characters of text, 16 MB of audio,
12 MB per document, 8,000 characters of label.

## 6. Point tools at the local API

- Base URL `http://localhost:8445`; for a web app set `NEXT_PUBLIC_DECOSA_API=http://localhost:8445`.
- `POST /pv/intake` returns JSON, or Server-Sent Events with `Accept: text/event-stream`. `POST /pv/decide` signs the
  safety physician's decision; `POST /pv/clock` computes dates without a model.
- Keep the case record and the decision record with the case. Anyone can re-check them with `POST /record/verify` against
  the key at `GET /attest/signing-key`.
- Keep the API on 127.0.0.1; for other users, put a TLS reverse proxy with authentication in front, and run the box under
  your quality system (access control, audit trail, backups). The records are evidence of what the draft said; they do
  not make this a validated system.

## 7. Keep the direct route

`DECOSA_LLM_ROUTE=gateway` would send report text to the hosted Decosa
API. Leave it off: this box holds health data.

Finish with a summary: what is running, the health output, the smoke-test results, and the reminders above.