BlitzGraph
Supabase for graphs, designed for LLM agents
Last verified:
What is BlitzGraph?
BlitzGraph is an AI-native backend that models data as polymorphic graph entities and exposes a typed JSON query language (BQL) so applications and LLM agents can read and write graph-shaped data without SQL, joins, or ORMs. It provides multi-kind entities (units that can hold multiple kinds simultaneously), bidirectional relationships with O(1) reverse lookups, built-in full-text search, and first-class content types and validations so schema and business logic live in the database. The platform includes a visual studio (BlitzStudio) with a spreadsheet-style browser, a live BQL console, and visual schema editing, plus agent sandboxes and integration points for LLM agents to use the backend as a remote MCP server. BlitzGraph targets product teams building agent-driven apps, knowledge/agent memory systems, and developers who want a graph+document+relational engine that enforces referential integrity, smart transactions, and business rules at the data layer.
BlitzGraph pricing
Pricing model: Freemium
Public beta with a free tier—developers can build a backend and create one namespace with multiple subspaces for free; the site advertises a free developer playground and the ability to 'start building' without an account for live data. Paid plans are offered via the control plane (workspace/namespace management, additional namespaces, higher limits, and enterprise features like private keys and admin APIs); the website encourages booking a demo for enterprise pricing and shows token families (bzt_* for scoped grants and bzi_* for internal control-plane keys) as part of the access model. Exact plan names, limits, and prices are available through the BlitzGraph control plane or sales channel rather than exposed as fixed tier tables on the public homepage.
BlitzGraph pros
- Typed JSON query language (BQL) designed for agents and code
- Multi-kind entities let units evolve without migrations
- Bidirectional arcs with O(1) reverse lookups
- Native BM25 full-text search with typeahead and prefix modes
- Rich built-in content types (EMAIL, URL, DATE, FILE, JSON, FLEX)
- Referential integrity with cardinality and onDelete policies
- Smart transactions validated against final state (topological ordering)
- Business logic in schema: validations, computed fields, hooks, effects
- Agent sandboxes for isolated agent experiments and live data
- BlitzStudio visual tools: Schema Editor, QueryStudio, BlitzSheet
- Multipart file uploads treated as native FILE values with signed URLs
- $expand and nested graph reads avoid N+1 queries
- Polymorphic roleFields and linkFields for flexible relations
- Atomic batch and nested mutation support with $var cross-references
- Control-flow helpers ($for, $if) in mutations for programmatic writes
BlitzGraph cons
- Realtime/live-query capabilities are not the platform’s primary strength
- You must learn BQL (a new structured JSON query language)
- Some hook features (cross-unit cascades, link transform hooks) are limited
- Not as mature or broadly battle-tested as decades-old SQL ecosystems
- Ecosystem, community, and third-party integrations smaller than Postgres/Supabase
- Migration from table-first systems requires conceptual model changes
- Certain advanced native expressions require $js or native @ calls
- Large-scale realtime streaming or very long-established tooling may be better served elsewhere
Frequently asked questions about BlitzGraph
What is BQL and why use it instead of SQL or GraphQL?
BQL is BlitzGraph’s structured, typed JSON query language that agents and applications compose as JSON objects rather than string-based queries; it supports nested expands, filters, projections, and full-text search in a single request and is validated against the schema, reducing generation errors and eliminating ORM/SQL string construction issues.
How do entities (units) and kinds work in BlitzGraph?
A unit is a single identity that can hold multiple kinds simultaneously; kinds define fields, linkFields, and roleFields, and units evolve by gaining or losing kinds without migrations, enabling polymorphism and composition such as [User, Admin, Moderator] on one unit.
Does BlitzGraph support file uploads and how are files stored?
Yes—FILE is a native value type; the TS client auto-detects File/Blob values and switches to multipart where the JSON mutation contains a '#file' marker; reads return FileValue objects with filename, mime, size, url, and thumbnail_url (signed URLs are emitted by the server).
How are relationships represented and queried?
Relationships are first-class: roleFields and linkFields define relation topology; BlitzGraph stores bidirectional arcs so reverse lookups are O(1); use $expand to inline related units, $expandArc to include arc metadata like timestamps, and arc operations ($op: link/unlink/replace) to manage connections atomically.
How does authentication and tokens work?
The data server accepts only Bearer tokens; there are two token families—bzt_* scoped customer grant tokens for data-plane calls (query/mutate/admin) and bzi_* internal control-plane keys for internal system routes; human/agent sessions authenticate via app routes that mint scoped bzt_* tokens so the dataserver never sees raw human credentials.
Can I run business logic inside the database?
Yes—BlitzGraph supports computed fields, validations, transform/validate/effect hooks defined on kinds so business rules, defaults, and side effects can run inside the mutation pipeline and be enforced at commit time rather than scattering rules across application middleware.
How do transactions and batch mutations behave?
Mutations can be batched atomically (all succeed or roll back); the engine topologically sorts operations and resolves $var references so complex multi-entity creates/updates/deletes work in one atomic batch, and smart transactions validate the final state rather than line-by-line.
What search capabilities are built in?
BlitzGraph includes a native BM25 full-text engine with typeahead, prefix, exact modes and $search support; fields marked with fts: true are searchable and queries can return $score for relevance, all integrated into graph traversals without an external search service.
How does schema management work at runtime?
The platform exposes endpoints to import, export, query, and mutate definitions; schema changes are additive via definition/import, and definition/mutate supports incremental edits to kinds, dataFields, roleFields, and linkFields—all manageable from BlitzStudio or the admin APIs.
What isolation and workspace structures exist?
BlitzGraph uses namespaces and subspaces: a namespace is a top-level isolation boundary with its own schema, data, and indexes; free-tier users get one namespace and multiple subspaces (e.g., main, archive, drafts) to separate environments while keeping schema consistent across subspaces.