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.
Nothing to connect yet? Download and take the demo tour — a sample federation is bundled, so there is nothing to connect first.
# 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;# The per-role schema, over plain HTTP
POST https://provisa.internal/graphql
# The same question — relationships are fields, not joins
query BigOrders {
orders(where: { total: { gt: 1000 } }) {
total
customers { name email }
queries { trace_id }
}
}# Neo4j Browser and the official drivers, over Bolt
bolt://localhost:7687 # database: provisa_analyst
# The same question — sources are labels, relationships are edges
MATCH (c:Customer)-[:PLACED]->(o:Order)
MATCH (c)-[:RAN]->(t:Query)
WHERE o.total > 1000
RETURN c.name, o.total, t.trace_id# No new language. The endpoints are generated from the model.
curl -G https://provisa.internal/data/jsonapi/orders \
-H "Authorization: Bearer $TOKEN" \
-d 'filter[total][gt]=1000' -d 'include=customers'
# The same question — JSON back, related rows sideloaded
{ "data": [ { "type": "orders", "attributes": { "total": 1420 } } ],
"included": [ { "type": "customers", "attributes": { "name": "Acme" } } ] }
# The spec is generated too — point a client generator at it
curl https://provisa.internal/data/jsonapi/openapi.jsonOne model, three languages — and if you want none of them, generated REST. RLS, masking, and approval are already applied on whichever tab you pick — nothing to remember, and nothing to re-implement per protocol.
Most people start with one of these.
Give an agent your data
Point Claude or any MCP client at Provisa instead of the database. The OAuth token maps to a role, so the agent gets the same six governance layers a person does — and no bypass to forget about.
MCP, and the eight other protocols →A backend for your frontend
The app needs Postgres, a document store, and two internal REST services in the same response. Declare the relationships once and the API spans all of them — per-role, filtered, paginated — in whichever shape your client wants: GraphQL/OpenAPI, JSON:API, or gRPC. No BFF service to maintain.
The interfaces, and the Hasura path in →BI without a warehouse
Postgres, Mongo, Elasticsearch, a Google Sheet, an S3 prefix of extracts. Connect the BI tool over JDBC or pgwire and join across all of them — no pipeline, no copy, no warehouse in the middle.
All 53 source types →Data science, connected
Register the sources once and the whole team queries them from pandas, Polars, or DuckDB. Arrow Flight streams record batches columnar all the way out — no row-by-row serialization, nothing materialized server-side while you read — and single-source queries route straight to the driver.
Flight, Airport, and pgwire →Provision data to other teams
The consuming team writes SQL and gets it back fast: Arrow streams over Flight, typed gRPC, and — past a row threshold — a presigned S3 URL for multi-GB deliveries instead of a timed-out HTTP response. Kafka carries the change notifications, so they pull the delta rather than the snapshot.
How the governance follows the data →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 meanGraphQL, Cypher, and SQL all query the same federated model and retarget to any source dialect. Domains carve it into namespaces — a domain is the schema a SQL client sees — and governance applies identically across all three languages: not three integrations, but one.
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.
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
From columnar Arrow batches streamed over gRPC to plain HTTP JSON — pick the transport your workload actually wants. Each of these exists for a reason: a BI extract is not a dashboard poll is not a service-to-service call, and the right wire for one is the wrong wire for the next. The query language and the wire protocol are independent choices, and the same governance reaches every entry point.
Per-role schemas with field-level visibility, constrained to registered relationships — valid by construction.
Full SQL over federated data. Single-source queries bypass federation entirely for sub-100ms latency.
Graph traversals over the same federated model, under identical governance.
Tableau, Power BI, DBeaver, psql, and local analytical engines.
pg_catalog is answered in-memory, so schema browsers just work.Neo4j Browser and Bloom, plus application-side traversals.
Columnar streaming, microservices, zero-serialization ML.
.proto generated from your schema; typed query and insert RPCs per table.Agentic tool calls and LLM-driven query generation.
Active, query-time governance
You do not configure any of this to get started — one source and a role is enough. It matters later, when the project you started alone has to survive an auditor: governance is applied uniformly, there is no query path that bypasses it, and adding a source, column, or relationship applies every layer automatically.
Schema browsers only ever see what the role is allowed to see.
Anonymous surface is explicit, never accidental.
Roles reach only the domains registered to them.
Per-table, per-role WHERE injection — inherited recursively.
Regex, constant, or truncate masking with role-based bypass.
Pre-execution ABAC hook over webhook, gRPC, or unix socket.
All six are applied while the query is compiled, not checked against a policy list afterwards. What executes is already the governed query — so there is no version of it that could have run ungoverned.
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
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.
Auto-indexing file crawler
One of the 53 behaves unlike the other fifty-two: you register a location, not a table. It walks the tree recursively, introspects every data file it finds, and catalogs each one as an available table — the shared drive nobody has mapped, the S3 prefix of extracts, the SharePoint site a department has been running on for years.
A local or network folder, an S3 bucket, a SharePoint site, an HDFS path, or an HTTP, FTP, or SFTP host — one location, not one table.
It walks the tree to whatever depth you allow, converts documents that hold tables into data, and reads the schema out of each one.
You pick which of the discovered tables to register — and they land under the same six governance layers as everything else.
Derived data & your existing stack
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.
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.
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
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.
# 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 runYour 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
Signed desktop installers for every OS, or pip install the
embedded runtime. The whole working system runs on your desktop in about five
minutes — no Docker, no JVM, no cluster. Launch it and pick the guided demo:
a sample federation is already bundled, so you can run SQL, GraphQL, and
Cypher over it before you connect anything of your own.
Preview builds; join the list for the general-availability release.
A hosted SaaS tier is coming — the same runtime, run for you.
Business Source License 1.1. Non-production use is free for everyone, with no time limit — evaluate it for as long as you like. Production use is also free for organizations under 100 people and under $1M revenue in the prior tax year; larger organizations need a commercial license to run it in production — get in touch. Each release converts to GPL v2-or-later four years after it ships.
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
Signed macOS, Windows, and Linux installers — each with a one-click demo build that boots a sample stack.
pip install "provisa[embedded]" — the whole system, precompiled UI included. Airgap-ready.
A production chart deploys the control plane, workers, and engine — scale the federation tier horizontally.
Modules for AWS, Azure, and GCP stand up a VM or cluster deployment end to end.
Questions
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 matters
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.
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 pathAn 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 appliesThe 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.
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-inOne governed path for analytical, application, and human data movement.