Connect Postgres, Snowflake and Salesforce.
Query with SQL, GraphQL or your AI agent.
In 5 minutes.

Provisa is a compiler and runtime for building your data control plane. Declare your sources, relationships and access rules once, and every tool, from psql and Tableau to GraphQL and your AI agent, gets the same data under the same rules.

No hand-coded APIs
No data pipeline scripts
Access rules in one place
Agents grounded in your policies
Works with your build systems
Tag issues and work them together

Live Demo Download

No login needed. Use your own data instead

# psql talks 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, with relationships as fields
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, with sources as labels and relationships as edges
MATCH (c:Customer)-[:PLACED]->(o:Order)
MATCH (c)-[:RAN]->(t:Query)
WHERE o.total > 1000
RETURN c.name, o.total, t.trace_id

# The endpoints are generated from the model, so there's no new language
curl -G https://provisa.internal/data/jsonapi/orders \
  -H "Authorization: Bearer $TOKEN" \
  -d 'filter[total][gt]=1000' -d 'include=customers'

# The same question, returning JSON with related rows sideloaded
{ "data": [ { "type": "orders", "attributes": { "total": 1420 } } ],
  "included": [ { "type": "customers", "attributes": { "name": "Acme" } } ] }

# The spec is generated too, so you can point a client generator at it
curl https://provisa.internal/data/jsonapi/openapi.json

# A .proto generated from your schema, with typed RPCs per table
grpcurl -d '{"total_gt": 1000}' provisa.internal:443 \
  provisa.orders.OrdersService/Query

# The same question, with a typed response, so the schema can't drift
message Order {
  string id = 1;
  double total = 2;
  Customer customer = 3;
  repeated Query queries = 4;
}

Every tab queries the same model. RLS, masking and approval are already applied, whichever one you pick.

Start with the job in front of you.

AI access

Now leadership wants an AI agent on it, and nobody wants to hand it the database.

Five-minute start →

App backends

Now the app team needs an API over it, and the data lives in sources that don't match.

Five-minute start →

BI across sources

Now the business wants it in Tableau, and the warehouse project is a year away.

Five-minute start →

Data science access

Now the data scientists want all of it, and each dataset is a separate request.

Five-minute start →

Data products & provisioning

Now three other teams need it, and each one wants its own pipeline.

Five-minute start →

New or changing sources

Now there's a new source to bring in, or one you depend on just changed, and everything built on it has to be redone.

Five-minute start →

Why it holds up

Keep your tools. Add the part that connects them.

One model, nothing to keep in sync, and every choice stays yours to change. Each tool usually keeps its own copy of what your data means: the catalog's glossary, dbt's models, BI's metric definitions, every API's access checks, the agent's context. When one changes, the rest are wrong until someone catches it. Here there is one description, and every surface is compiled from it.

-- role: finance
SELECT c.name, c.email, o.total
FROM customers c JOIN orders o ON o.customer_id = c.id;

 name    | email          | total
 Acme    | [email protected]    | 1420
 Globex  | [email protected]  | 2310
 Initech | [email protected] | 1180

-- role: support_emea
SELECT c.name, c.email, o.total
FROM customers c JOIN orders o ON o.customer_id = c.id;

 name    | email          | total
 Acme    | ***@acme.com   | 1420

The same query for two roles. The row rule and the mask are compiled into each plan.

How it works What the model covers

Any database, API or file store, including

PostgreSQL
Snowflake
Salesforce
MongoDB
Elasticsearch
Databricks
Google Sheets

See all 79 connectors

Run it

An evaluation shouldn't take three months to stand up.

The whole system runs on your desktop in about five minutes, with no Docker, no JVM and no cluster. Launch it and pick the guided demo, or connect your own sources. Prefer not to install anything? Open the live demo, or connect your own sources at sandbox.provisa.dev.

Free to evaluate, for any size of organization. License terms →

Or install from PyPI

You get the whole runnable system, precompiled UI included, as a single wheel. It installs in an airgap over an Artifactory PyPI mirror, with no Docker, no JVM and no root.

# The whole system in one wheel (Python 3.12)
python3.12 -m venv .venv && source .venv/bin/activate
pip install "provisa[embedded]"

provisa run          # your data
provisa run --demo   # a guided tour on a sample stack

Kubernetes, Helm and Terraform

Questions

Before you install

Is Provisa a database, or does it replace my warehouse?

Neither. Provisa is a compiler and runtime that builds your data control plane and runs it on an engine you choose: Trino, DuckDB, ClickHouse, Postgres, Snowflake, Databricks, BigQuery, or the embedded DuckDB engine in the box. Your warehouse keeps running your queries, and your semantics live in the model, so you can change that choice later.

How it works in depth

Does it work with Starburst or Denodo?

Yes. Provisa sits above an engine and can use Starburst as its engine, and it registers Denodo's views as governed tables. Either way you keep what you run and add GraphQL and Cypher as peers to SQL, nine wire protocols including pgwire and Bolt, and one set of rules on all of them.

Provisa and Starburst

Can AI agents query my data safely?

An MCP server, over stdio or remote Streamable HTTP, exposes governed tables as tools. The OAuth token maps to a role, so every agent call passes the same six access-control 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.

Governed data for AI

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 path

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-in

Architecture FAQ

Start with the job in front of you.

Now leadership wants an AI agent on it, and nobody wants to hand it the database.

Now the app team needs an API over it, and the data lives in sources that don't match.

Now the business wants it in Tableau, and the warehouse project is a year away.

Now the data scientists want all of it, and each dataset is a separate request.

Now three other teams need it, and each one wants its own pipeline.

Now there's a new source to bring in, or one you depend on just changed, and everything built on it has to be redone.

macOS

Windows

Linux & NixOS

Or install from PyPI