Docker (all-in-one)
The fastest way to get Classifyre running: one image carrying the whole stack — the API, the web UI, the Python scan workers, PostgreSQL and the identity server for sign-in — with nothing to provision and nothing to connect.
docker run -d --name classifyre \ -p 3000:3000 \ --shm-size=1g \ -v classifyre-pgdata:/var/lib/postgresql/data \ -v classifyre-data:/var/lib/classifyre \ -v classifyre-uv-cache:/cache/uv \ classifyre/all-in-one:0.9.0Then open localhost:3000. The first boot initialises the database and creates a workspace, which takes a few minutes on a laptop.
This is also a reasonable way to run Classifyre for a single investigator. For a team, or for anything that has to survive a machine dying, use the Helm chart instead — it runs the same images as separate, independently scalable workloads.
What is inside the image
| Process | Port | What it is |
|---|---|---|
| Caddy | 3000 | the only published port; routes to the two servers below |
| Web UI | 3100 (internal) | Next.js, and this documentation at /docs |
| API + worker | 8000 (internal) | REST, WebSockets, job queues, embeddings, and the parent of every scan |
| Identity server (Keycloak) | 8180 (internal) | sign-in, people, groups and tenants; reached through the web UI at /iam |
| PostgreSQL 18 + pgvector | 5432 (internal) | all data, the identity server’s too |
They are supervised by s6-overlay,
which restarts anything that dies and makes docker stop and docker restart
behave as expected. Only port 3000 is reachable — PostgreSQL binds to loopback
inside the container’s own network namespace and is never exposed.
The scan workers are not a service: the API starts one process per scan and it exits with the scan, the same lifecycle Kubernetes gives them as Jobs.
The image ships a small embedding model (Xenova/all-MiniLM-L6-v2) already
baked in, so semantic search and duplicate review work offline from the first
scan.
Requirements
| Memory | 4 GB minimum, 8 GB recommended. The container refuses to start below 4 GB rather than failing halfway through your first scan. |
| CPU | 2 cores minimum. Scans are CPU-bound. |
| Disk | ~10 GB for the image and database, plus room for what you scan. |
| Shared memory | --shm-size=1g. Without it, large queries fail with could not resize shared memory segment. |
On macOS and Windows, Docker Desktop caps what containers may use and often defaults to 2 GB — below the floor. Raise it under Settings → Resources → Memory and restart Docker.
Both linux/amd64 and linux/arm64 are published, so Apple Silicon runs
natively with no emulation.
Run it
The command above. The first boot initialises the database, applies the
migrations, sets up sign-in and creates a workspace called default — a few
minutes on a laptop. Follow it with docker logs -f classifyre: it ends with
Classifyre is ready.
Sign in
Open localhost:3000 and sign in as classifyre, password
classifyre. That account is the first tenant’s admin, so it sees every
workspace and can give others access. Change the password right away: account
menu (top right) → Your account → Account security → Signing in →
Update. The identity server keeps it; restarts and upgrades never reset
it. To add people and groups, see Getting started with
sign-in.
Connect a source
Point it at something you already run — a database, an S3 bucket, a Confluence space, a Git repository, or a folder you mounted. Credentials are encrypted at rest. See configuring sources.
Switch on detectors
Enable the pre-built packs you care about. They work on the first scan with no model setup.
Run a scan, open a case
Findings land ranked by importance. Group them into inquiries and cases, or add an AI provider and let the autopilot work them between scans.
Scanning a folder on your machine
Bind-mount it, then point a source at the path inside the container:
docker run -d --name classifyre \
-p 3000:3000 --shm-size=1g \
-v classifyre-pgdata:/var/lib/postgresql/data \
-v classifyre-data:/var/lib/classifyre \
-v classifyre-uv-cache:/cache/uv \
-v "$HOME/Documents/case-files:/data/case-files:ro" \
classifyre/all-in-one:latestIn the UI: Sources → New → Mounted Folder, path /data/case-files. See
Mounted Folder.
Mount read-only (:ro) unless you have a reason not to. Classifyre only ever
reads from a folder source, and :ro makes that the filesystem’s guarantee
rather than the application’s.
Where the data lives
Three volumes, and you want all three:
| Volume | Holds | If you drop it |
|---|---|---|
/var/lib/postgresql/data | the database | everything is lost |
/var/lib/classifyre | scan logs, the credential encryption key, the sign-in secrets | stored credentials become unreadable and the tenant databases no longer open |
/cache/uv | optional Python dependencies and file-format readers, installed on first use | they are downloaded again after every upgrade |
Configuration
Everything is an environment variable, and everything has a working default.
Pass them with -e NAME=value, or with --env-file.
Core
| Variable | Default | Purpose |
|---|---|---|
PORT_HTTP | 3000 | Port inside the container. Usually easier to remap with -p 8080:3000. |
CLASSIFYRE_BOOTSTRAP_NAMESPACE | default | Slug of the workspace created on first boot. Set to "" to create your own. |
CLASSIFYRE_MASKED_CONFIG_KEY | generated | Encrypts stored source credentials and MCP tokens. |
TELEMETRY_DISABLED / DO_NOT_TRACK | unset | Set either to 1 to disable telemetry. |
CORS_ORIGIN | same-origin | Only needed if the UI is served from another host. |
Sign-in
Sign-in is always on. The image sets up one tenant, default, with one admin,
and serves the identity server under /iam of the same address.
| Variable | Default | Purpose |
|---|---|---|
CLASSIFYRE_URL | http://localhost:3000 | The address people open. The identity server signs tokens for it and only sends people back to it: set it when you publish another port (-p 8080:3000 → http://localhost:8080) or a host name. |
CLASSIFYRE_ADMIN_USER | classifyre | The first admin, made on the first start. Also the identity server’s own administrator. |
CLASSIFYRE_ADMIN_PASSWORD | classifyre | Their first password. Change it in the app afterwards; setting this later changes nothing. |
CLASSIFYRE_ADMIN_EMAIL | [email protected] | Their email. |
CLASSIFYRE_IAM_HEAP_MB | 512 | The identity server’s Java heap. |
The identity server’s client secrets and the key every tenant database’s
password is made from are generated on the first start and kept in
/var/lib/classifyre/iam.secrets.
Everyone signs in, starting with the seeded admin, who can add people and groups in the identity console (see Access). For a team, prefer the Helm chart.
Database
Leave unset to use the PostgreSQL inside the image.
| Variable | Default | Purpose |
|---|---|---|
DATABASE_URL | bundled | Set it and the bundled server never starts. |
POSTGRES_DB | classifyre | Database name (bundled server only). |
PGDATA | /var/lib/postgresql/data | Data directory (bundled server only). |
CLASSIFYRE_AUTO_MIGRATE | true | false skips migrations at startup. |
An external server must have pgvector available, and the user needs
CREATEDB and CREATEROLE: Classifyre makes a control database
(classifyre_control), one database per tenant with its own role, and the
identity server’s database iam next to the one you name. See
PostgreSQL.
-e DATABASE_URL="postgresql://user:[email protected]:5432/classifyre?sslmode=require"Object storage
Scan logs are written to disk by default. Point them at S3-compatible storage to keep them when the container is disposable. See S3 object storage.
| Variable | Default | Purpose |
|---|---|---|
S3_BUCKET | unset | Setting this switches scan logs from disk to S3. |
S3_ENDPOINT | AWS | Required for MinIO, R2, Backblaze, and anything non-AWS. |
S3_REGION | us-east-1 | |
S3_ACCESS_KEY_ID / S3_SECRET_ACCESS_KEY | unset | Omit both to use the ambient credential chain. |
S3_FORCE_PATH_STYLE | true | Required by MinIO and most self-hosted providers. |
S3_LOG_PREFIX | runner-logs/ | Key prefix. |
Embeddings
| Variable | Default | Purpose |
|---|---|---|
EMBEDDING_PROVIDER | transformers-js | openai-compatible to use a remote service. |
EMBEDDING_BASE_URL / EMBEDDING_API_KEY | unset | The remote endpoint, when using openai-compatible. |
EMBEDDING_MODEL | Xenova/all-MiniLM-L6-v2 | Changing it re-embeds everything. |
EMBEDDING_ALLOW_REMOTE_MODELS | false | true allows downloading a different local model. |
See embeddings for what changing the model costs.
AI providers for LLM detectors and the autopilot are not environment variables. They are per-workspace settings configured in the UI under Settings → AI providers, with their keys encrypted at rest.
File-format readers
Readers for some table formats — Avro, Vortex, the geospatial formats, and the
Delta Lake and Iceberg table readers — are downloaded the first time a scan
needs one, into /cache/uv, and reused after that. A host without internet
access needs a mirror of the extension repository, or the readers copied into
the cache directory ahead of time.
| Variable | Default | Purpose |
|---|---|---|
CLASSIFYRE_DUCKDB_EXTENSION_REPOSITORY | the public repository | Where readers are downloaded from — an internal mirror for offline hosts. |
CLASSIFYRE_DUCKDB_EXTENSION_DIR | /cache/uv/duckdb-extensions | Where they are kept. |
When a reader can’t be downloaded, the run reports it as unavailable for that file, rather than as a file that failed to parse.
Resources
The container measures the memory and CPU it was given and sizes itself at startup. Override only with reason.
| Variable | Purpose |
|---|---|
CLASSIFYRE_NODE_HEAP_MB | Node heap ceiling. Bigger is usually worse — a larger ceiling means more garbage accrues before a major GC. |
PG_SHARED_BUFFERS, PG_WORK_MEM, PG_EFFECTIVE_CACHE_SIZE | PostgreSQL memory. |
MAX_CONCURRENT_RUNNERS | Scans running at once. |
AUTO_SCHEDULE_MAX_CONCURRENT | Automatic scans in flight before the adaptive scheduler holds back. |
MAX_RUNNERS_PER_SOURCE | Finished runs kept per source. |
CLASSIFYRE_MAX_POOL_WORKERS | Detector worker processes per scan. |
CLASSIFYRE_MIN_MEMORY_MB | The 4 GB startup floor. |
The three scan limits can also be set per workspace in Settings → General → Scan limits; a value saved there overrides the variable for that workspace (see Settings).
The startup log prints what it chose:
[classifyre] memory=8192MB cpus=4 shm=1024MB
[classifyre] node heap=2048MB rss guard=4928MB
[classifyre] postgres shared_buffers=512MB work_mem=16MB effective_cache_size=4096MB
[classifyre] scans: 1 concurrent, 4 worker(s) eachUpgrades
docker pull classifyre/all-in-one:latest
docker rm -f classifyre
# …then the same `docker run`, with the same volumesData lives in the volumes, so it carries over, and migrations run automatically on the first boot of the new version. Pin a version tag to control when that happens. Downgrades are not supported — migrations only go forwards. See upgrade & versioning.
From a version without sign-in (0.7 and older): the new image signs you
in as classifyre and starts with an empty default workspace; your
workspaces are still in the database, out of sight. Copy them into the
tenant once:
docker exec classifyre sh -c 'cd /app/api && node dist/src/admin.js workspaces copy --to-tenant default --all'.
See Workspaces made without sign-in.
Backup
Three things, and you need all of them:
docker exec classifyre pg_dumpall -U postgres > classifyre.sql
docker exec classifyre cat /var/lib/classifyre/masked-config.key
docker exec classifyre cat /var/lib/classifyre/iam.secretspg_dumpall takes every database: the control database, each tenant’s and
the identity server’s.
Without the key, a restored dump still holds every stored source credential —
encrypted, and permanently unreadable. Keep it where you would keep a
password, and restore it with -e CLASSIFYRE_MASKED_CONFIG_KEY=….
Troubleshooting
Won’t start
The container exits saying there is not enough memory: Docker is capping it
below 4 GB. Raise Settings → Resources → Memory in Docker Desktop and
restart Docker, or check for a --memory flag.
Moving to Kubernetes
The Helm chart runs the same images this one is composed from.