Provisa / Interfaces
Each language and protocol you add is another headache.
Each language-transport stack needs its own governance integration and its own programmers. Data leaks and exfiltration paths appear at every new surface; the attack surface grows with each protocol you add. A change to the access model now touches every interface point, which becomes its own lock-in. Business logic fragments across stacks, and every system is trusted less because nobody can prove what goes in and out where.
Every language and wire protocol here compiles to one IR. Governance is applied once at that IR and pushed down to the engine, so you make a change once and no path in skips it. One model does not mean one namespace. You divide sources into
domains, so sales.orders and
finance.orders stay distinct while resolving through the same
governed model.
Query languages
Your analyst opens psql, your app sends GraphQL and your data scientist runs Arrow Flight. All of them compile to the same governed plan, so none of them needs a separate governance integration.
GraphQL
Per-role schemas with field-level visibility, cursor pagination, and aggregates. The schema is constrained to registered relationships, so a query that traverses an unapproved path cannot be expressed at all, so it never gets as far as being rejected. Apollo Automatic Persisted Queries are included.
SQL
Full SQL across all sources, correlated subqueries and all. Cross-source joins fan out through the engine you choose; single-source queries bypass the engine routing entirely and route direct to the driver, transactional and sub-100ms.
Cypher
Graph queries over the same model. Traverse relationships as edges, union sources into a single node label, and walk variable-length paths, under the same governance as SQL and GraphQL.
Wire protocols
Adding a wire protocol normally means adding a new access path to govern. Here each protocol is another surface for the same compiled plan, so there is no new integration to secure.
pgwire on port 5439
Any Postgres client connects: psql, DBeaver, DataGrip, pandas
read_sql, or anything else speaking the frontend/backend protocol.
pg_catalog is answered in-memory, so schema browsers, foreign-key
arrows, and autocomplete work without a real Postgres behind them.
Bolt (Neo4j)
Neo4j Browser, Bloom, and the official drivers run Cypher over Bolt against the
registered schema. Each role surfaces as a provisa_<role>
database, so the client's database picker is the governance boundary.
Arrow Flight
Arrow record batches streamed over gRPC, columnar all the way out, with no row-by-row serialization between the engine and the client. Accepts GraphQL or SQL. Result sets are unbounded: nothing is materialized server-side while the client reads.
gRPC model API
A .proto is generated from the registered schema: typed query and
insert RPCs per table, with streamed responses. It regenerates when the model changes, with no separate build step.
JDBC, REST, and JSON:API
BI tools such as Tableau, Power BI and DBeaver connect over JDBC. Applications get two
HTTP shapes over the same model: plain REST at
/data/rest/{table}, with filter, ordering, pagination, and field
selection as query parameters, and JSON:API 1.1 at
/data/jsonapi/{table} with sparse fieldsets and filter
expressions. Both are described by a generated OpenAPI 3.1 document, so a
client generator produces a typed SDK without anyone hand-writing a spec.
Airport (DuckDB)
Any DuckDB client attaches Provisa as a database with ATTACH 'grpc://host' AS p (TYPE AIRPORT) and queries the governed registered model from local DuckDB. Filters and projections push down; writes
update by primary key.
WebSocket and SSE
Subscriptions stream near-real-time change events. The backend is your choice: Postgres native notification, MongoDB change streams, CDC or polling, and events can fan out over Kafka.
For AI agents
MCP server
A Model Context Protocol server, over stdio or remote Streamable HTTP, exposes your governed data to agents as tools. The OAuth token maps to a role, so every agent call is governed by the same six layers as a human query. Agents get no bypass, and no separate policy to keep in sync.
Natural language
Natural language to SQL, Cypher or GraphQL, on the language model you configure, with an interactive validation loop so a generated query is reviewed before anything executes.