Use cases

What a team can do with GraphLift today. Each card names the command or binary to use, and states its limit in the same place.

For CTOs and engineering leaders

Pick a graph database without making it a one-way door, and decide how much access each person and agent gets.

Keep the database decision reversible

The situation. You need a graph store now, and you are not sure TypeDB’s type system, Neo4j’s ecosystem or TerminusDB’s commit history will matter most in two years.

Write queries, schema and migrations against the contract. Switching backend is a change of one value, and the capability matrix shows ahead of time which of your queries the other backend would refuse.

Use: the query contract, from Rust

Limit. The Rust layer is the agnostic one. The TypeScript packages are not on the contract yet (graphlift#302).

Migrate from one backend to another, verified

The situation. You are leaving one database for another and cannot afford records lost in transit.

The sync command copies schema and data through both contracts. It previews unless allowed to write, and with a move it reads the target back and deletes from the source only the records it verified there.

Use: graphlift sync --move

Limit. Neo4j cannot yet be a move’s source (graphlift#930). A run holds both snapshots in memory (graphlift#867).

Catch schema drift in CI

The situation. Someone changed a production schema by hand, and the migrations no longer describe it.

Compare a live schema with the migrations directory, or with another database, and fail the pipeline when they differ: the command exits 4 on drift.

Use: graphlift db schema diff

Limit. Speciality features outside the schema contract, such as TypeDB functions or Neo4j index kinds, are not compared (graphlift#925).

Give access with a defined blast radius

The situation. Analysts and agents need answers from production, and you need to know what they can and cannot change.

Hand out the render-only surfaces freely. They hold no credentials. Hand out the execution binary where answers are needed: it is read-only unless given a flag, caps rows and time, and writes an audit line per run. On TypeDB and Neo4j the read-only default is enforced by the server, and on the edge store by the store.

Use: graphlift-exec

Limit. On TerminusDB the read-only default rests on what the renderer emits, not on the server. Authorisation inside the database stays the database’s job.

Put a graph at the edge

The situation. You want graph reads close to users on Cloudflare, without a separate graph server to run.

The edge store keeps a graph in SQLite inside a Durable Object, behind the same contract, and a sync moves a graph into or out of it.

Use: the edge store, @graphlift/edgegraph-store

Limit. The execution binary and the CLI’s query and schema commands reach the three servers, not the edge store. Reach it from Rust or through a sync.

For data scientists

Ask a question once, get typed rows back, and move the data to whichever engine has the tooling you need.

Ask one question of several backends

The situation. The same data lives in two engines, or you are evaluating one against another.

Write the question once as a JSON description. Render it for each backend to see the query each would send, then use the execution binary to fetch typed rows from each and compare them.

Use: graphlift query, then graphlift-exec

Limit. Only what is in the portable or graph-native tier renders everywhere. Anything else is refused by name on the backends that cannot answer it.

Copy a graph into the engine with the tools you want

The situation. Your graph lives in TypeDB, but the algorithms you want to try run on Neo4j, or the other way round.

Declare a key per type in a small spec, preview the sync, then let it write. Running it again writes nothing new, and an incremental run updates changed attributes by key.

Use: graphlift sync

Limit. A decimal attribute is refused toward Neo4j and the edge store before anything is written, because neither has a type for it.

Typed models for analysis code

The situation. You want the schema’s types in Rust or TypeScript, without writing them by hand.

Generate plain data types from the migrations offline, from a live TypeDB or TerminusDB, or from a version that a migration recorded on any of the three servers.

Use: graphlift generate types

Limit. The types are plain data at the weakest guarantee the backends share, not an object mapper.

Know what a backend can answer before you start

The situation. An analysis depends on aggregation, regular expressions or bounded walks, and you need to know which backends support them.

List the capability matrix, or check one request without rendering it. Each absent capability carries the reason that was measured.

Use: graphlift backends, and graphlift query --check

Limit. The plain-language command is keyword matching, with no model and no accuracy benchmark (graphlift#442), so write the description yourself.

For agentic architects

Give an agent a graph tool whose mistakes are loud, and grant it reach one step at a time.

A query tool an agent cannot misuse

The situation. An agent needs to compose graph queries, and nobody is watching each one.

Register the MCP server. Its three tools list capabilities, check a request, and render it. It opens no connection and holds no credential, so nothing an agent sends through it can change data.

Use: graphlift-mcp

Limit. It speaks stdio, the transport most MCP clients use. There is no HTTP MCP endpoint.

Refusals the agent can act on

The situation. Agents recover from errors they can read, and repeat mistakes they cannot.

A refusal names the capability, the operation and the reason, and the CLI separates rendered (0), refused (2) and malformed (1). An agent fixes its request or picks another backend. It never gets query text that silently means something else.

Use: graphlift query and graphlift-mcp

Limit. Nothing here measures whether a model composes the right request in the first place (graphlift#442).

Grant reach in steps

The situation. You want an agent to read production data, and write only with explicit permission.

Render only, then read through the execution binary, then writes with a flag, then writes reaching every instance of a type with a second flag. Each step is a flag you grant, and the binary takes credentials from the environment, never from an argument the agent writes.

Use: graphlift-exec and its write flags

Limit. Its exit codes separate a refusal before connecting (2) from a server refusal (3) and an unmappable answer (4). Stable per-error codes with retry hints are recorded and not scheduled (graphlift#903).

An audit trail per run

The situation. You need to reconstruct what an agent asked a database, and when.

Each run ends with one JSON audit line on standard error: backend, database, operation, outcome, exit code, duration, row count and whether the answer was cut, plus a fingerprint of the query.

Use: graphlift-exec's audit line

Limit. The fingerprint is for correlation, not redaction. A low-entropy literal can be recovered by hashing candidates.

Ready to try one? The practical guide walks through each step with the commands.