EdgeQuake: a Rust GraphRAG stack where exit code 78 means your schema is wrong

The API never migrates the database, and exit 78 is the signal

The upgrade section leads with a rule rather than a feature list. The API never migrates the database; schema changes are an explicit operator step. Three situations are then tabulated. A fresh install runs the migrate command once and then starts the API, with the local development target doing that for you. An upgrade from 0.22.0 or earlier takes a backup, a dry run, a migrate, a migrate with the drop confirmation flag, and one further migrate that applies a deferred migration before the API starts. The third row is the one worth remembering: a server that exits with code 78 means the schema is behind or newer than the binary, and the fix is to migrate and restart. Exiting rather than serving against a mismatched schema is the right default, and having the code documented is rarer than having the code at all.

Irreversible drops need a flag, a backup, and a restore-only rollback

Some of the schema history cannot be undone by rolling the binary back, and the page says so in those words. Irreversible drops, covering a key-value store and two vector-related migrations, require the drop confirmation flag and a backup, and after that point rollback is restore-only. That is a stronger position than most projects take, because it converts an accidental migration into a decision with a paper trail. The other half is a migration that asserts its own precondition: migration 142 checks that the leftovers it is about to remove are empty, aborts if rows remain, and stays deferred while any residue exists. Both behaviours only make sense alongside the schema train tracking, where each release note states which migration numbers it moves. By 0.30.0 that counter is at 165, having passed 162 and 163 in the previous minor release.

A patch release whose action item is to leave the previous one

The release notes for 0.26.1 carry a single operational instruction: pull the image for that version and do not stay on 0.26.0, because the earlier image still has the old command line interface. The feature itself is described as migration honesty, consisting of a drop-confirm alias, unknown apply flags that fail closed, and abort hints classified per drop type. So the release adds the flag you need for the previous release's irreversible drops, ships it one version late, and says so. Two other patches in the same series show the same pattern of telling you not to trust an earlier image: 0.26.3 says not to remain on 0.26.1 for a leftover copy removal, and 0.26.4 says to pull its image specifically to get the patched front end, which was a move to a current active long-term support line after critical remote code execution fixes in August.

The quickstart pins a branch and starts with authentication switched off

The install promise is that no Rust, no Node and no build are needed, and it is kept with a single command that pipes a shell script from the repository. The script's URL contains the branch name rather than a tag, so by default the install runs whatever is at the branch tip. A version can be pinned by passing it to the same script as an environment variable, and a second path downloads a compose file and brings the stack up directly. The page is candid about the default security posture: the quickstart runs with the dev mode flag set, which opens the API, and the instruction after it is that you are in with no login required. The same release notes that add enterprise single sign-on say the local development target stays with authentication off and that single sign-on is opt-in. For a headless machine the page gives a fully non-interactive form, and the interesting part is which variable names it uses:

# OpenAI
EDGEQUAKE_LLM_PROVIDER=openai \
  OPENAI_API_KEY=sk-... \
  docker compose -f docker-compose.quickstart.yml up -d

So the path of least resistance is deliberately unauthenticated, and the page says so rather than leaving you to find out.

Ports differ between the container path and the local path, on purpose

The service table gives two columns and a footnote that matters more than the table. Under the Docker quickstart the web UI is on port 3000, the REST API on 8080, the Swagger page on the API port, and the health endpoint beside it. Under the local development target the same four rows shift to 3010 and 8090, and the footnote explains that the local path picks free ports starting from those two numbers to avoid colliding with other stacks, with a status target reporting what actually got bound. The verification step is a health request piped through a JSON pretty printer:

curl -s http://localhost:8080/health | python3 -m json.tool

The port split is a small thing that signals a real constraint: this is a project that expects to run beside other stacks, which is also why there are four compose files at the repository root, two of them named after internal specification numbers.

Two directories hold specifications, and four compose files are named after spec ids

The repository root is large enough that the layout is the documentation. There are two directories that appear to cover the same ground, one named specifications and one named specs. There is a directory for specifications-driven operations such as a soak compose file and a proof compose file, both named after the spec numbers they exercise, which means the internal numbering is part of the public vocabulary of the repository. There are three client libraries plus a language model crate, a parsing crate and a document conversion crate published separately to a package registry at their own version numbers, so one EdgeQuake release corresponds to several published artifacts. Five root level markdown files read as process artefacts rather than user documentation, covering a deployment summary, a setup implementation note, a verification note and a resolved issues summary, alongside a mobile snapshot note. A directory of committed logs sits at the root as well, next to a legacy directory and a reference directory whose name begins with a sort key.

Five SDK versions bumped by rewriting a manifest line

Client libraries exist for Rust, Python, TypeScript, Java and Kotlin, and each has its own build, publish and version target in the makefile. The version target is where the design shows. Rather than reading one place, it takes a version argument and rewrites the version line of the SDK manifest in place, using a portable substitution helper that the file defines with a comment explaining it avoids the platform-specific in-place edit flag and works on both GNU and BSD sed by writing a temporary file and moving it into place. So a release is a version bump performed at least five times over, in addition to the version file at the root, the changelog and the container tag. Two other details in the same targets are worth a look. The Python build deletes its output directories and installs an upgraded build tool before building, and the publish target installs an upgraded upload tool before uploading, so the tools used to produce an artifact are fetched fresh at build time rather than pinned.

Editorial conclusion

EdgeQuake is worth an hour of reading if you run document retrieval infrastructure, because the operational discipline is more advanced than the marketing. Every release note names the specification numbers it implements and states exactly which numbers the schema train moves, a documented exit code tells you when the binary and the database disagree, irreversible drops require a flag and a backup, and the page repeatedly says that certain behaviours are honest about what they do not do. That is what a project looks like after a few thousand merged changes, and the release dates support the reading: three tagged releases in four days. The cost is comprehension. Five of the top level directories are process summaries and a snapshot note, two directories hold specifications, four compose files are named after internal spec ids, and the shorthand inside the notes assumes you already know the project. Four things to check before you deploy it. That the quickstart is the auth-free development path, since it runs with the dev mode flag and the page says no login is required. That you pin a version rather than a branch, because the default install fetches the branch tip. That you read the migration table for your own upgrade path rather than the happy one. And that you do not treat the pinned front end as the current one, since a later patch note tells you to pull the image specifically to get a patched web layer.

Frequently asked questions

Official sources

1. License: Apache-2.0
2. Project website
3. raphaelmansuy/edgequake on GitHub
4. README
5. Releases