Configuration

Lampo needs no configuration: start it and it works. To change something, set an environment variable or put the setting in a config.json file. The environment wins over the file, and both are read when the app starts, so restart it after a change.

Most people only ever touch a few settings:

Every other setting is in the tables below, grouped by topic, with its default.

config.json

Lampo uses the first of these files that exists:

1. the file named by LAMPO_CONFIG;
2. config.json in the app's own folder (where you cloned it);
3. ~/.video-review/config.json (in the folder named by LAMPO_HOME, when that is set).

A config.json for your own machine might be:

{
  "user": "Alex",
  "browse_root": "~/work",
  "data_dir": "~/Reviews/data"
}

Folders in it may start with ~, and a relative folder counts from the file's own folder. A file that isn't valid JSON is ignored as a whole: the app then starts with the defaults.

The app's Settings page holds what people change while it runs: their profile, theme, language and API tokens, the export of their own data (and on a hosted server, deleting their account), and for admins the users, invites, webhooks and, on a hosted server, the workspace's name (its owners also delete it there). It also shows what the settings on this page add up to (the speech engine, Auto-check's dictionary, ready-to-copy agent configs, the version, the legal pages), but it doesn't change them.

Where data lives

A store is three folders:

• data holds the reviews, notes and screenshots: the files agents read. Back it up.
• versions holds the bytes of every version of every video. It can't be rebuilt: back it up.
• cache holds posters, waveforms, playback copies, analysis, transcripts and the speech model. It is rebuilt when needed, so it is safe to delete while the app is stopped, except for cache/uploads/ (uploads in progress).

Where the store is, first match wins:

The cache goes next to data the same way; a data folder with another name gets a cache named after it, ending in -cache. With LAMPO_DATA, the cache is the one in the app's folder (when that has a data folder) or in ~/.video-review.

You can move single folders too:

• LAMPO_CACHE or cache_dir in config.json puts the cache anywhere;
• versions_dir in config.json puts the versions anywhere (not with LAMPO_DATA, which always keeps its own);
• LAMPO_HOME moves ~/.video-review as a whole, its config.json included. The Docker image sets LAMPO_HOME=/data, so one volume holds everything.

LAMPO_DATA is how tests and the demo get a store of their own: its versions never mix with another store's.

Settings

Every variable is named LAMPO_…. Its older spelling, VR_… (the command was vr before it was lampo), is still read wherever the LAMPO_ one is unset or empty, so an env file from before works unchanged; where both are set, LAMPO_ wins. The checks at start name a setting the way you wrote it. A setting given in both spellings with different values is named once in the log at start (names only, never the values), and so is an empty LAMPO_ setting that leaves its VR_ one in force: remove the older line, or give the new one a value. LAMPO_SERVER and LAMPO_TOKEN come as a pair: both LAMPO_ when either is set, else both VR_, so one server's token never goes to another.

Running the app

To start it on your machine:

npm start      # http://localhost:4747, signed in as you (builds the UI on first start)
npm run dev    # the same with hot reload, for work on the UI
npm run lan    # also on your Wi-Fi: prints a link with an access token for your phone

A phone on your network opens the printed link once; from then on a cookie lets it in. The machine itself needs nothing. For phones away from home, run a hosted server.

Hosting

These matter on a server other people reach. Setting one up: server-mode.md and docker.md.

Uploads and disk

Uploads are also refused above 240 frames per second and under 32 pixels on a side; those limits are fixed.

Where renders live (hosted)

On your machine renders always stay on disk. A hosted server can keep them in Bunny Storage or any S3-compatible bucket instead; the steps are in server-mode.md. In config.json these settings sit in a storage section (example under Details).

Accounts and sign-up

Legal pages

Lampo links your own pages; it never writes them. Each must be an http(s) URL, or the server refuses to start. None is required, except the terms and the privacy policy for an open sign-up. The withdrawal and cancellation pages matter only where a billing provider sells plans (server-mode.md).

Email

A hosted server emails invites, sign-up confirmations, password resets and account notices (email.md). In config.json these settings sit in a mail section.

Notifications

Webhooks tell Slack, Discord or any other service about client activity (sharing.md). One can come from the environment, more from config.json (a webhooks list), and admins add others in Settings → Notifications. Hooks from config.json or the environment belong to the first workspace; every other workspace adds its own there.

Voice notes and transcripts

What each option does, and how to pick a model: speech.md. In config.json these sit in an stt section.

Auto-check

Words the spelling check should accept (brand names, product names) go in data/qa-dictionary.txt, one per line.

Footage search

What it indexes and when: footage.md. A workspace's own switch is lampo footage on / off.

Agents

The lampo CLI and the stdio MCP server

These are read on the machine where the agent works.

Tools

For people working on Lampo

Language

The app is in English for everyone; the browser's language doesn't change it. Anyone can switch to German in Settings → Appearance → Language. It switches in place, without a reload. The choice is kept on their account, so their other devices follow, and it applies before the first paint. In German the team's pages say "du"; review links, the folder room and the printout say "Sie", as an agency writes to a client. Clients have no Settings, so on their own devices they see review links in English for now.

What agents read (lampo, the MCP server, INBOX.md, events) stays in English: it is a data contract.

To add UI text, write it in English through t('…') (or <T k="…"> for a sentence with markup), run npm run i18n, and translate the new keys in web/src/i18n/de.ts (de.client.ts for the client pages). The typecheck names every key that is missing.

Switching changes the words in place, without a reload. So words that live outside a component (a module's labels or options) go through perLang(() => …) from web/src/i18n/index.ts, and a memo'd component or a useMemo with words in it reads useLang() (web/src/i18n/T.tsx); test/unit/i18n.test.ts finds words worked out when a module loads.

Other files in data

Besides the reviews, data holds a few files the app writes and reads by itself. Back them up with the rest of data. What's in each: data-format.md.

• qa-dictionary.txt: words Auto-check's spelling check should accept, one per line. The only one you edit by hand.
• users.json, invites.json and secret.key: accounts, pending invites, and the key that signs sign-in cookies. Readable only by the app's user.
• avatars/: profile pictures (with Bunny or S3 storage, in the bucket instead).
• shares.json and share-secret.key: review links, and the key their tokens are sealed with.
• webhooks.json: webhooks added in Settings → Notifications.
• push/: the key that signs push notifications and the devices that receive them. Deleting the key turns notifications off on every device until people turn them on again.
• for-you.json: what each person cleared from their inbox (Got it, kept 30 days) or put aside (Later).
• oauth/: apps connected through sign-in, and their tokens.
• account-links.json and mail/: emailed one-time links (hashed) and the emails waiting to go out (sealed).
• publish/: posts of final videos and the publishing connections, their keys and tokens sealed (publishing.md).
• On a hosted server: workspaces.json (each workspace and its members), links.json (which workspace a review link belongs to), w/<id>/ (every workspace but the first), backups/ (copies made before the move to workspaces) and erasures.jsonl (the accounts and workspaces deleted, by id: what to delete again after restoring a backup, server-mode.md).

Details

• Sizes are written like 20GB, 500 MB, 1e9, or plain bytes. Units count in thousands: a GB is 10⁹ bytes (GiB is read the same way).

• On and off: LAMPO_STT_PREFETCH, LAMPO_WEBHOOK_ALLOW_PRIVATE, LAMPO_ALLOW_NO_PUBLIC_URL, LAMPO_ALLOW_HTTP, LAMPO_ONBOARDING and LAMPO_ONBOARDING_SAMPLE are off for 0, false, no or off, and on for anything else. LAMPO_LAN needs exactly 1, LAMPO_REMOTE exactly 0, LAMPO_S3_PRESIGN turns off only with false, and LAMPO_STYLEGUIDE only with 0.

• Numbers: 0 or something that isn't a number falls back to the default (LAMPO_MEDIA_TIMEOUT, LAMPO_MAX_SIDE, LAMPO_MAX_DURATION, the session days); so does a LAMPO_AGENT_RUN_TIMEOUT outside 1 to 86400.

• Timeouts: ffprobe runs get 30 seconds, and the playback copy of a long render gets 3 seconds per second of video when that is more than LAMPO_MEDIA_TIMEOUT.

• trust_proxy from older setups: true or a hop count means loopback, uniquelocal now, and the server warns at start. Name the proxy's address or subnet to be exact.

• mode: only server switches; anything else means your own machine.

• Old speech keys: a whisper_language from the days of the Python engine becomes stt.languages (that language, then English). whisper_python and whisper_model are ignored.

• Storage in config.json, for example S3:

  {
    "mode": "server",
    "public_url": "https://review.example.com",
    "storage": {
      "kind": "s3",
      "s3": {
        "endpoint": "https://<account>.r2.cloudflarestorage.com",
        "bucket": "review",
        "access_key_id": "…",
        "secret_access_key": "…"
      },
      "work_cache_bytes": 20000000000
    }
  }

  Variables layer over this section key by key, so a secret can come from the environment while the rest stays in the file.