raggate quickstart — run the gate in a few minutes

Step 1

Get the CLI

Sign in and download it. No payment — an account is how we hand you a build, not a paywall. Detection is free and runs entirely offline afterwards.

# the download is a zip with the binary for your platform + a one-step installer
unzip raggate-bundle.zip && cd raggate-bundle
sh install.sh                            # puts `raggate` on your PATH
raggate license status                   # -> free tier, detection only

The binary is standalone — no Python install, no dependency resolution. The free bundle carries no licence file because detection does not need one.

Expect a FAIL. The sample corpus has three planted leak classes, so a successful run exits 1 and names them. That is the tool demonstrating it works. A silent pass would be the thing to worry about — which is why 10 negative-control scenarios run alongside and must stay clean.

Then see it catch three planted leaks

raggate quickstart                       # zero setup: gates a bundled sample, opens a report

Two minutes, nothing to configure. It ships a small two-tenant corpus with three deliberately planted leak classes so the gate's behaviour is observable before you point it at anything of your own.

Or drive each step yourself

raggate ingest --corpus ./corpus --db out/gate.db

raggate run    --db out/gate.db --snapshot ./snapshot.yaml \
               --scenarios ./scenarios --evidence out/evidence.jsonl   # exit 1 = leaks found

raggate diff   --corpus ./corpus --snapshot ./snapshot.yaml \
               --scenarios ./scenarios --out-jsonl out/diff.jsonl

raggate report out/evidence.jsonl -o out/report.html --diff out/diff.jsonl

Point these at your own corpus, snapshot and scenarios — the formats are plain YAML and JSON, documented in the bundle's README.

Step 2

Point it at your own retrieval

Two ways in, depending on whether you want to test your pipeline or your store.

Your pipeline, over HTTP

Wrap your retriever — filters, reranking, query rewriting, all of it — behind one endpoint that accepts a query, an identity and a top_k, and returns the chunks it would really serve. Then run the gate against that endpoint.

This is the honest option: what gets tested is the pipeline you ship, including any ACL filtering you already apply. The request and response shapes are documented in docs/spec/retrieval-endpoint.md.

Your vector store, directly

Ten adapters ship in the repository: sqlite-vec, Elasticsearch, OpenSearch, pgvector, Qdrant, Milvus, Weaviate, Redis, Azure AI Search, and one for a self-hosted RAG product. Ingest a corpus and gate it without writing any glue.

Relevance scores are recomputed locally as exact cosine, so a threshold means the same thing regardless of how the backend normalises its own scores.

What you have to supply

Input	What it is
Identities	The roster of principals that issue queries — an id and the tenant each belongs to.
A permission snapshot	Who may read which document, and group membership. Versioned, so you can gate a stale index against current policy.
Scenarios	An identity plus a query, and optionally the documents that would be a leak if returned. Ordinary questions work best — the useful ones are what a real user would actually ask.

The corpus and scenario formats are plain YAML and JSON, kept deliberately backend-neutral.

Step 3

Put it in CI

The gate is a command with meaningful exit codes, which is the whole integration story.

Exit code	Meaning
`0`	No leaks in the scenarios you ran.
`1`	At least one forbidden document reached the context window. Fail the build.
`2`	The run could not be trusted — bad arguments, an unreachable backend, a malformed response. Never confused with a clean result.

Same inputs, same verdicts. Runs are deterministic by design — the default embedder is seed-stable and offline — so a gate result that changes without an input changing is treated as a bug rather than noise. That is what makes it usable as a build gate.

See what it produces What costs money

See it catch three planted leaks before you trust it with anything real.