<div align="center">

Celmis

Self-hosted — from the alert your monitoring already sent, through to a pull request someone can review

celmis-labs.github.io · Documentation · Quick start · Results

</div>

An alert arrives from a service you run. Celmis already knows which repository that service is and who owns it, so the fix starts there: an embedded Claude Code session — on your subscription, inside your installation — edits the code, and the runner commits, pushes a branch and opens a pull request. On one measured finding that took 220 seconds, from whatever device the alert reached first.

Celmis does not watch your services. Grafana, or whatever you already run, does that and does it well. This is the part that comes after the alert: the walk from a firing rule to a diff someone can review.

To be exact, because the line is easy to blur. The application ingests no logs of its own — it starts from the alert. But the repository ships an optional observability overlay, and that does collect them:

docker compose -f docker-compose.yml -f docker-compose.observability.yml up -d

That brings up Prometheus, Loki, Promtail and Grafana. docker-compose.observability.yml is deliberately platform-wide rather than Celmis-only: Promtail tails the Docker daemon's container logs and labels each stream by container name, so every service on that host — all thirty of them, if you run thirty — shows up in Grafana's Loki explorer, filterable by container. Prometheus scrapes api:8000/metrics for Celmis's own counters alongside.

Every port binds to 127.0.0.1 and is reached over an SSH tunnel:

ssh -L 3100:localhost:3100 -L 9090:localhost:9090 you@your-server

That is not caution for its own sake. Loki has no authentication, so POST /loki/api/v1/push accepts writes from anyone who can reach it, and a log store strangers can write to is not a log store. GRAFANA_ADMIN_PASSWORD is required — the stack will not start without one.

That loop is the product. It closes because everything sits on one index: a symbol graph Celmis builds from your repositories once. The same index answers questions that cross repository boundaries, reviews pull requests, audits dependencies into a CycloneDX SBOM and a verifiable evidence pack, generates documentation, and serves fifty-one tools over MCP — surfaces worth having, and none of them the point on their own.

It runs on one machine under docker compose, with the model provider of your choice behind it, and nothing leaves your network except the calls you configure.

In the oldest telling, Kelmis was the smelter — one of the three Idaean Dactyls, alongside Damnameneus the hammer and Acmon the anvil, to whom the working of iron was credited. The index does the reducing here; the surfaces are what work the result.

What that buys you that a diff-only tool cannot

Ask a question that spans two repositories, and the answer quotes both:

That is not a search result. The gateway and the payments service are separate repositories with no shared code, and the answer traces the call chain between them — then notices, unprompted, that the Kafka topic name is hardcoded in both and that changing one silently breaks the other.

A reviewer that reads only the diff structurally cannot say that. It never had the other repository open.

---

Nine things people do with it

| | | |---|---| | You are a PM, a delivery lead or the client and want to know what state a group of projects is in, or how something actually works | Ask it. From any device, anywhere, without booking time from an engineer and without a meeting whose only output is a paragraph → Ask the code | | A new engineer has a question a senior would have to answer | Every one of those pulls someone experienced out of flow, at the moment they are already covering. The codebase answers instead, with file:line citations → Ask the code | | Two teams share an integration and neither can read the other's repository | Load it, grant the right to ask, and deny the paths that must stay private. They get answers; the credentials are refused at the source → Who can see what | | A customer or an auditor asks for your SBOM | One button, CycloneDX, plus an evidence pack whose manifest they recompute themselves — against a hash you publish where the pack is not → Dependencies, SBOM and the evidence pack | | A vulnerability lands in a dependency | Fix from here hands an embedded session the repository, the package and the finding. It edits, the runner pushes a branch and opens a PR → Fix from here | | A pull request needs reviewing | Agents read the diff — and, where the graph is built, who else calls what is being changed, including from another repository → Pull-request review | | Forty services need the same thing done to them | Write the sentence. Celmis shows which repositories it resolves to and waits for a second press, rather than finding them among forty and pressing a button forty times → Ask for work across repositories | | An alert fires at 02:00 and you are not at a desk | It lands in Celmis and goes out to the workspace's chat channel, and Fix from here opens a session already holding the alert. The runner opens the pull request → Alerts, and fixing from a phone | | Your own agent or editor needs to understand the codebase | Point it at /mcp/. Fifty-one tools over the same index, thirty-five of them read-only, under the same access rules — no second copy of your code anywhere → Connect Claude Code and other MCP clients |

The first three are the ones a code-review tool does not do at all, and they are the reason this is a platform rather than a reviewer: index once, then read that index from whichever side of the work you are standing on.

Three numbers

| | | |---|---| | 197 seconds | from git clone to six healthy services, measured on a clean server | | $0.118 | per pull request reviewed, on the model this ships with | | 17th of 50 | on the Martian Code Review Bench offline set, under all three judges |

That last one is deliberately unflattering, and it stays. It measures one of the surfaces below — pull-request review on isolated single-repository PRs — and that set has no sibling service for a symbol to have consumers in, so the thing this product is built around is not in the number at all. The table, the audit of every finding it scored false, and the command that reproduces both are in Results.

Table of contents

• What that buys you that a diff-only tool cannot
• Nine things people do with it
• Three numbers
• Quick start
• First user and admin
• Connect a repository
• Ask the code
• Pull-request review
• Dependencies, SBOM and the evidence pack
• Fix from here
• Alerts, and fixing from a phone
• Ask for work across repositories
• Who can see what
• Languages and formats
• Deterministic checks — no model, no false positives
• Connect Claude Code and other MCP clients
• Results
• Audit of the false positives
• Test repositories
• Configuration
• Operations
• Local development
• CLI reference
• Architecture
• Troubleshooting
• Project layout
• Provenance and rights

Quick start

What you need

| | | | |---|---|---| | Docker | 24+ with Compose v2 | Docker Desktop on macOS/Windows, the native engine on Linux | | A model API key | one of | Google Gemini, Anthropic, OpenAI, OpenRouter, Groq or Mistral. A free Gemini key is enough to evaluate: https://aistudio.google.com/app/apikey | | RAM | ~4 GB free | Measured on a real indexing run: 1.1 GB peak across all five containers, 565 MB at rest |

Postgres and Qdrant are bundled — no external cluster to provision. No Python or Node.js install is needed for the Docker flow.

Start it

git clone https://github.com/Celmis-labs/Celmis.git celmis
cd celmis

# Generates .env and fills every secret in the format each one needs.
# Idempotent: run it again after a pull and it fills only the new blanks.
./scripts/init-env.sh

docker compose --env-file .env up -d

# Wait for healthy — first boot pulls three images and applies migrations
docker compose ps

Open http://localhost.

Nothing is built here. The three images are pulled from the registry named by CELMIS_REGISTRY at the tag in CELMIS_TAG, for linux/amd64 and linux/arm64 — Apple Silicon and an ARM server both get a native image. Building them on the machine that runs them was measured at 485 seconds and 4.2GB of disk for api alone, which is why installing no longer means compiling.

Port 80, not 3000: a reverse proxy puts the app and its API on one origin and serves the API under /backend. That is not a deployment preference — the browser bundle asks for a relative path, which is the only way one published image can serve every installation instead of just the one it was built on.

To work ON Celmis rather than run it, add the dev overlay and you get local builds back:

docker compose -f docker-compose.yml -f docker-compose.dev.yml up -d --build

init-env.sh --check reports what is still empty without writing anything.

That is a render of the captured session, not a screen recording — the figures in it are the ones the run produced on 26 August 2026, and the compose output is verbatim from logs/03-up.log in the install report. It is drawn rather than photographed because a second stack cannot be brought up beside a running one: docker-compose.yml fixes container_name, so the names collide.

Stop

docker compose down       # stop, keep your data
docker compose down -v    # stop and DELETE every volume

---

First user and admin

The sign-up form on /login works as soon as the stack is healthy. That account is a normal user — signing up grants no admin rights, not even to the first person through the door.

Global admin comes from the environment instead: sign in with CELMIS_MASTER_EMAIL and CELMIS_MASTER_KEY (as the password), both in .env. Whoever runs the box is the admin, which is the model a self-hosted install wants rather than whoever reached the form first. The path does not exist unless both variables are set, and every use of it is written to the audit log.

To promote a normal account:

docker compose exec api analyzer auth make-admin you@example.com

A promoted account (or one an OIDC_ADMIN_ROLE makes admin) is a global admin: system status, ops, compliance, every workspace visible. It is not the superadmin — that is the master account alone, and it is the only one that can hand out the roles below that carry power.

Workspace roles

Every workspace is a ten