Metadata-Version: 2.4
Name: redcrown
Version: 0.1.20
Summary: Localized model benchmarking with receipts: run head-to-head evals on your own data, locally, and turn them into shareable proof reports
License: Proprietary
Requires-Python: >=3.11
Description-Content-Type: text/markdown
Requires-Dist: pydantic>=2.9
Requires-Dist: pydantic-settings>=2.5
Requires-Dist: httpx>=0.27
Requires-Dist: aioboto3>=15
Requires-Dist: amazon-transcribe>=0.6
Requires-Dist: PyJWT>=2.9
Requires-Dist: cryptography>=43
Provides-Extra: server
Requires-Dist: fastapi>=0.115; extra == "server"
Requires-Dist: uvicorn[standard]>=0.30; extra == "server"
Requires-Dist: python-multipart>=0.0.30; extra == "server"
Requires-Dist: sse-starlette>=2.1; extra == "server"
Requires-Dist: asyncpg>=0.30; extra == "server"
Requires-Dist: stripe>=10; extra == "server"

# RedCrown

**Localized model benchmarking with receipts.** Run head-to-head evals across every
model, provider, and config on your own data, locally, then turn the results into
ranked, receipted proof you can hand to a client, a CFO, or a regulator.

> Agents and harnesses run benchmarks for free. RedCrown is the neutral layer that
> turns them into a decision you can defend, and keeps re-proving it as prices and
> models change. **Run anywhere, prove here.**

## Install

```bash
pip install redcrown
```

Unreleased source checkout functionality: `python -m redcrown.cli matrix-plan`
previews explicit model/prompt axes offline and optionally exports a new private
experiment file with `--output`. It never runs the experiment. See the
[matrix contract](../docs/contracts/r3-matrix-plan-v1.md) for the JSON schema,
bounds and separate execution boundary. Published 0.1.19 does not include it.

The unreleased hosted matrix workspace, private regression diagnosis, and
continuous-evaluation substrate remain disabled by default. Their scope,
validation, and separate rollout gates are in the
[R3–R5 local record](../docs/runbooks/2026-09-15-r3-r5-local.md).

Requires Python 3.11+. The CLI has a small dependency footprint; server extras
(`pip install "redcrown[server]"`) are only needed if you run the API yourself.

## Quickstart (no keys needed)

Try the bundled offline demo in about five seconds, no provider keys required:

```bash
redcrown eval --sample extract
```

This runs a small bundled extraction sample using stub outputs. The output says
**demo mode** because no real models are called. Connect your provider keys in
`~/.redcrown/credentials.json` (or via `redcrown login`) for real quality scores.

## Bring your own data (text tasks)

If you have a CSV or JSONL file of inputs, import it directly:

```bash
redcrown build-dataset --from-csv mydata.csv --task classify --out exp.json
redcrown eval exp.json --report-json out.json
```

**CSV/JSONL columns:**

| column | required | notes |
|--------|----------|-------|
| `input` | yes | the text sent to the model |
| `reference` | no | expected output (ground truth); omit to use the no-labels path below |
| `id` | no | stable row ID; auto-generated if absent |

**`--task` values:** `extract`, `classify`, `summarize`, `qa`

The importer fills in the provider scaffold for you. Edit `exp.json` to swap in
the candidates you want to compare before running.

## Score outputs you already have (no model calls)

If another harness produced the outputs, score them locally with a deterministic
metric. This command never connects to a provider or needs an API key:

```bash
redcrown score score-request.json --report-json scored.json
```

`score-request.json` uses `items` (`item_id`, `input`, `reference`) and
`candidates` (`id`, `label`, `outputs`) from the ScoreOutputsRequest schema. For
tabular workflows, keep the items in CSV and put one candidate output per JSONL
line:

```bash
redcrown score --items-csv items.csv --outputs-jsonl outputs.jsonl \
  --metric exact_match --quality-bar 0.8 --report-json scored.json
```

```json
{"candidate_id":"model-a","item_id":"row1","output":"billing","latency_ms":42}
```

CSV accepts `item_id` (or `id`), `input`, and `reference`. JSONL also accepts
`candidate_label`, `error`, `cost_usd`, and `latency_ms`. Omitted cost or latency
stays unknown rather than being treated as zero. The resulting file can be sent
to RedCrown with `redcrown push scored.json`.

## Check prompt/model changes locally

Starting with 0.1.19, export private evidence for offline regression checks:

```bash
redcrown score baseline-request.json --evidence-json baseline-evidence.json
redcrown score candidate-request.json --evidence-json candidate-evidence.json
redcrown check candidate-evidence.json --baseline baseline-evidence.json \
  --policy policy.json --format json
```

Use the same nonblank `experiment_id` and the same evaluation items/references
in both score requests. Each selected candidate needs a complete configuration
declaration, for example:

```json
{
  "experiment_id": "support-routing",
  "quality_metric": "exact_match",
  "items": [{"item_id": "one", "input": "Refund request", "reference": "billing"}],
  "candidates": [{
    "id": "external-a",
    "configuration": {
      "provider": "external-harness",
      "model": "routing-model-v1",
      "prompt": "Return the routing category.",
      "system_prompt": null,
      "params": {},
      "source_revision": null,
      "endpoint_revision": null
    },
    "outputs": [{"item_id": "one", "output": "billing"}]
  }]
}
```

All seven configuration fields are required; null declares an absent setting,
not an unknown one. RedCrown scores these supplied outputs but does not witness
their generation. Configuration assurance remains **declared**. Keep secrets
out of declarations and evidence files.

Example `policy.json` (choose thresholds for your own requirements):

```json
{
  "schema_version": 1,
  "requirements": {"quality": {"minimum": 0.85, "maximum_regression": 0.01}}
}
```

When a report has multiple candidates, specify `--candidate-id` and
`--baseline-candidate-id`; checks never select a winner automatically. Quality
gates require complete scored coverage. Missing or incompatible evidence cannot
silently pass. JSON is the supported policy format; YAML is deferred. Cost and
latency rules remain indeterminate until measurement provenance is supported.

`check` makes no network, provider, or authentication calls. Exit 0 means pass;
exit 2 means fail or indeterminate; exit 1 means a command, file, or policy error.
JSON, Markdown, and text results describe the same decision.

`eval --evidence-json` also exports private raw evidence; real evaluations may
call providers. Keep a stable `id` in the experiment across those evaluations.
`--report-json` remains the upload format for `push`; it is different from the
private raw format consumed by `check`. Keep private evidence out of public CI
artifacts. Select baseline and policy files from a trusted source.

## The exp.json schema

Every eval is a plain JSON file. Here is a minimal 2-candidate text example you
can copy, edit, and run:

```json
{
  "name": "classify-support-tickets",
  "quality_metric": "similarity",
  "quality_bar": 0.75,
  "reference_source": "labels",
  "pipeline": [
    {
      "id": "step1",
      "order": 1,
      "name": "classify",
      "input_type": "text",
      "output_type": "text",
      "input_binding": "dataset",
      "incumbent_candidate_id": "gpt4o-mini",
      "candidates": [
        {
          "id": "gpt4o-mini",
          "provider": "openai",
          "model": "gpt-4o-mini",
          "label": "GPT-4o Mini (incumbent)"
        },
        {
          "id": "gpt-oss-20b",
          "provider": "groq",
          "model": "openai/gpt-oss-20b",
          "label": "GPT-OSS 20B via Groq"
        }
      ]
    }
  ],
  "dataset": [
    {
      "id": "row1",
      "payload": { "kind": "text", "text": "My invoice is wrong." },
      "reference": "billing"
    },
    {
      "id": "row2",
      "payload": { "kind": "text", "text": "App crashes on login." },
      "reference": "bug"
    }
  ]
}
```

**Required fields:** `name`, `quality_metric`, `quality_bar`, `reference_source`,
`pipeline[].incumbent_candidate_id`, `pipeline[].candidates[].id`,
`pipeline[].candidates[].provider`, `pipeline[].candidates[].model`,
`dataset[].id`, `dataset[].payload.text`.

## No labels? Use the incumbent as reference

If you do not have labeled ground truth, leave `reference` off your dataset rows
and set `reference_source: "incumbent"`:

```json
{
  "reference_source": "incumbent",
  ...
  "dataset": [
    { "id": "row1", "payload": { "kind": "text", "text": "My invoice is wrong." } }
  ]
}
```

RedCrown scores every candidate against your current model's own output, so you
only need to beat or match what you run today. This is the fastest path to a cost
proof when you have real traffic but no labeled examples.

## Running a full eval

```bash
# run the fan-out locally, on your machine, with your keys
redcrown eval exp.json --report-json out.json

# (optional) sign in once per machine via device-code OAuth
redcrown login

# (optional) push the results to a shareable, no-login proof page
redcrown push out.json --proof-link
```

`redcrown eval` ranks every config on cost, quality, and latency against your own
ground truth and names the cheapest one that clears your quality bar. Example:

```
RANKED  transcription · cheapest config at or above your 0.85 quality bar
  deepgram · nova-3-medical    quality 0.883    $294/mo   winner, 40% cheaper
  aws · transcribe-standard    quality 0.879    $487/mo   incumbent
  openai · whisper-1           quality 0.820    $122/mo   below your bar
```

That run is published as a live, no-login proof page:
<https://app.redcrown.ai/proof/O9iYVdWuaYjaL6mnImeIsD6TB1W_S6h4Frbx04YqAYQ>

> **Note on `build-dataset primock57`:** this command downloads the PriMock57
> clinical-transcription corpus, which requires `git-lfs`. It is an audio eval
> designed for transcription benchmarking, not a general first step. Start with
> `redcrown eval --sample extract` or `build-dataset --from-csv` instead.

## Free by construction

Evals run on your machine with your own provider keys, so RedCrown never sees your
raw data and the run costs you nothing beyond your own inference. Only the results
you choose to `push` become a cloud proof. `--no-receipts` keeps raw outputs local
and uploads aggregates only.

## Already ran an eval elsewhere?

You do not have to run anything through RedCrown to get a proof. Take the results from
an eval you already ran, as a JSON in the RedCrown results format, and push them:

```bash
redcrown push results.json --proof-link
```

You get the same ranked, receipted, shareable report. The fastest path, with no install,
is the web app at <https://app.redcrown.ai/upload>.

## Eval your own OpenAI-compatible endpoint locally

If you have a private or self-hosted API that speaks the OpenAI chat-completion format,
point `redcrown eval` at it without ever uploading your endpoint secret:

```bash
export REDCROWN_CUSTOM_HTTP='{"base_url":"https://api.example.com/v1","auth_header_name":"Authorization","auth_value":"Bearer sk-...","body_style":"openai"}'
redcrown eval exp.json
```

Set a candidate in your `exp.json` with `"provider": "custom_http"` and any `"model"` string
your endpoint recognises. The JSON connection stays local; it is read directly from the env var
at eval time and is never persisted or uploaded.

## For coding agents (MCP)

Coding agents (Claude, Cursor, Codex) drive the whole loop over the hosted MCP server
at `mcp.redcrown.ai`: scaffold an experiment, run it, review outputs, and mint a proof.
The server is open source: <https://github.com/RedCrown-ai/redcrown-mcp>

## Links

- Site: <https://redcrown.ai>
- App: <https://app.redcrown.ai>
- MCP server (open source): <https://github.com/RedCrown-ai/redcrown-mcp>

## License

Proprietary. (c) RedCrown.ai
