Three languages, one schema
GraphQL, Cypher, and SQL all query the same federated schema and retarget to any source dialect. Governance applies identically across all three — not three integrations, but one.
In preview — general availability coming soon
Query all your data
Query all your data
in 3 languages and 9 protocols.
In 5 minutes.
Connect your databases once. Then query them in GraphQL, SQL, or Cypher — from psql, Tableau, Neo4j Browser, or an AI agent. Governance is compiled into the query plan, so there's no way in that goes around it.
# psql speaks to Provisa as if it were Postgres — on port 5439
psql -h localhost -p 5439 -U analyst
# One SQL query, joined across Postgres, Mongo, and Elasticsearch
SELECT c.name, o.total, t.trace_id
FROM customers c
JOIN orders o ON o.customer_id = c.id
JOIN queries t ON t.actor = c.email
WHERE o.total > 1000;
# RLS, masking, and approval already applied. Nothing to remember.- 52source types, one schema
- 6governance layers, every path
You describe your data once — sources, tables, relationships, who may see what. Everything else is generated from that one description: the APIs, the legal join paths, the governance, and the audit trail. There is no second place to keep in sync.
We call this an Active Semantic Layer.
Every other semantic layer is a description — a model something else has to honor. This one runs the query, enforces the policy, and writes the audit trail itself, at query time, on every protocol.
Active vs. passive — what the word has to meanRead and write
Analytical and transactional flows through the same governed API: cross-source reads fan out through federation; writes and single-source reads route direct to the driver, sub-100ms.
Smart routing
Single-source queries bypass federation entirely. Materialized views record the transform that built them, so queries rewrite transparently onto a fresh MV.
Query interfaces & wire protocols
Write in three languages. Connect over nine protocols.
From columnar Arrow batches streamed over gRPC to plain HTTP JSON — pick the transport your workload actually wants. The query language and the wire protocol are independent choices, and the same governance reaches every entry point.
GraphQL
Per-role schemas with field-level visibility, constrained to registered relationships — valid by construction.
SQL
Full SQL over federated data. Single-source queries bypass federation entirely for sub-100ms latency.
Cypher
Graph traversals over the same federated schema, under identical governance.
pgwire
Any Postgres client connects on port 5439. pg_catalog is answered in-memory, so schema browsers just work.
Bolt (Neo4j)
Neo4j Browser, Bloom, and the official drivers run Cypher against the federated graph.
Arrow Flight
Arrow record batches streamed over gRPC — columnar all the way out, no row-by-row serialization. Accepts GraphQL or SQL.
gRPC model API
A .proto generated from your schema — typed query and insert RPCs per table.
JDBC & REST
Tableau, Power BI, and DBeaver over JDBC; JSON:API 1.1 for applications.
Airport (DuckDB)
Any DuckDB client attaches Provisa as a database and pushes filters down.
WebSocket & SSE
Subscriptions stream change events — Postgres native, MongoDB native, CDC, or polling.
MCP server
AI agents query your governed data as tools. The OAuth token maps to a role, so agents get no bypass.
Natural language
NL→SQL, Cypher, or GraphQL powered by Claude, with a validation loop before anything runs.
Active, query-time governance
Six layers. Every language. Every transport.
Governance is applied uniformly — there is no query path that bypasses it. Add a source, column, or relationship and every layer applies automatically.
- 0
Introspection filtering
Schema browsers only ever see what the role is allowed to see.
- 1
Public access
Anonymous surface is explicit, never accidental.
- 2
Domain access
Roles reach only the domains registered to them.
- 3
Row-level security
Per-table, per-role
WHEREinjection — inherited recursively. - 4
Column visibility & masking
Regex, constant, or truncate masking with role-based bypass.
- 5
Predicate guard & approval
Pre-execution ABAC hook over webhook, gRPC, or unix socket.
Relationships are governed too. A JOIN or a graph traversal is legal only if it matches a registered, approved relationship — so people and agents can roam the model freely while every path stays inside what policy sanctioned. It's a per-role flag: trusted roles can turn it off.
How each layer worksData sources
52 source types through one API.
Graph and RDF sources are first-class, not adapters. Register REST, GraphQL, gRPC, WebSocket, or RSS endpoints as governed tables — federated joins across API and relational sources work transparently.
- PostgreSQL
- MySQL
- MongoDB
- Cassandra
- Elasticsearch
- Neo4j
- SPARQL
- Kafka
- Snowflake
- Databricks
- BigQuery
- Fabric
- ClickHouse
- DuckDB
- Google Sheets
- CSV / Parquet
- Excel · DOCX · PPTX
- SharePoint
- Splunk
- S3 · FTP · SFTP
- REST APIs
- GraphQL APIs
- gRPC APIs
- RSS · WebSocket
An instant data lake — governed on arrival
You don't register files, you register a location: point Provisa at a folder, a bucket, or a SharePoint site and it crawls the tree, discovers every file, and registers each as a governed table. A data lake that's governed the moment it exists, not months later.
What it crawls, and what else registers
Derived data & your existing stack
Declare the analytics layer. Publish it.
Declared datasets, not pipelines
A pipeline is a program that ran; to audit one you read code. Declare the dataset instead and the definition is the record — column-level lineage, the data version consumed, the rules that produced it. No orchestration DAG.
Feeds the catalog you bought
One registration publishes to OpenMetadata, DataHub, Collibra, Atlan, Apache Atlas, and OpenLineage — with lineage stitched on business identity, so re-platforming doesn't reset it.
Every value has an address
Governed values resolve over REST or MCP at a semantic address, optionally as of a point in time. Physical URIs are refused, so a citation can't leak a location.
Enterprise-ready
Airgap-ready. Installs from your own Artifactory.
The embedded profile ships the entire runnable system — precompiled UI and all — as a single Python wheel. Regulated and airgapped orgs already trust Artifactory-as-PyPI, so there's no new supply chain to approve: no Docker registry to mirror, no JVM, no root.
- SQLite control plane + embedded DuckDB engine — no Docker, no daemon
- Bring your own engine: Trino, Databricks, Snowflake, Postgres, ClickHouse, Oracle — one env var
- Reproducible and hash-pinned; passes the same CVE gate as every wheel
# One wheel. Everything inside.
pip install "provisa[embedded]"
provisa run
# Federate against your own engine when you want scale-out
export TRINO_HOST=trino.internal
export TRINO_PORT=8080
provisa runLocked-in ecosystems become replaceable execution engines
Your model, semantics, and governance live above the infrastructure, not inside it. Swap the engine — embedded to Trino to your warehouse; new CTO, switch it to Databricks — and the queries and policies don't change. Re-point a table from Oracle to Postgres and consumers never see it move.
We don't lock you in either: your model is portable declarative config, and the SQL it compiles is yours to read, export, and keep.
The full argument — including domains as products, config promotion, and the compute billGet Provisa
Download and run in a minute.
Signed desktop installers for every OS, or pip install the
embedded runtime. The native tier boots immediately — no Docker, no JVM.
Preview builds; join the list for the general-availability release.
Or install from PyPI
The whole runnable system — precompiled UI included — as a single wheel. Airgap-ready over an Artifactory PyPI mirror: no Docker, no JVM, no root.
# One wheel. Everything inside. (Python 3.12 or 3.13)
python3 -m venv .venv && source .venv/bin/activate
pip install "provisa[embedded]"
provisa run # your data
provisa run --demo # a guided tour on a sample stackDeploy anywhere
From a laptop to a cluster — same platform.
Desktop installers
Signed macOS, Windows, and Linux installers — each with a one-click demo build that boots a sample stack.
Python wheel
pip install "provisa[embedded]" — the whole system, precompiled UI included. Airgap-ready.
Kubernetes · Helm
A production chart deploys the control plane, workers, and engine — scale the federation tier horizontally.
Cloud & VM · Terraform
Modules for AWS, Azure, and GCP stand up a VM or cluster deployment end to end.
Questions
Frequently asked
Is Provisa a database, or does it replace my warehouse?
Neither. Provisa is a semantic and governance layer that runs on an engine you choose — Trino, DuckDB, ClickHouse, Postgres, Snowflake, Databricks, BigQuery, or the embedded Trino-compatible engine in the box. Your warehouse becomes a replaceable execution engine rather than the place your semantics live.
Why that mattersHow is this different from Starburst or Denodo?
Starburst is a query engine; Provisa sits above one and can use Starburst as
its engine. Denodo is the closest comparison — same category, different
center of gravity: Provisa adds GraphQL and Cypher as peers to SQL, nine wire
protocols including pgwire and Bolt, engine choice, and a deployment that
starts at one pip install.
I'm on Hasura v2. Can I migrate?
Yes. Point the converter at your Hasura v2 metadata directory and it emits a Provisa config: sources, tables, per-role permissions as row-level security, relationships, remote schemas, actions, event triggers, and cron triggers. Anything it can't map cleanly is reported as a warning rather than dropped.
The migration pathCan AI agents query my data safely?
An MCP server — stdio and remote Streamable HTTP — exposes governed tables as tools. The OAuth token maps to a role, so every agent call passes the same six governance layers as a human query, and traversals are limited to registered relationships. Agents get no bypass and there's no second policy to keep in sync.
How governance appliesDoes it work in an airgap?
The embedded profile ships the entire runnable system, precompiled UI included, as a single Python wheel. Regulated orgs already trust Artifactory-as-PyPI, so there's no Docker registry to mirror, no JVM, and no root required. Builds are reproducible and hash-pinned.
What happens to my model if I stop using Provisa?
You keep it. Provisa is a handful of primitives — domains, tables, relationships, masking, views — compiled deterministically. The model is portable declarative config held in git, and the SQL it compiles is yours to read and export. The semantics you write don't die with the tool.
Our position on lock-inDescribe your data and govern it in the same act.
One governed path for analytical, application, and human data movement.