The map

Everything in Dippr hangs off one tenant. People and machines belong to it and hold roles; sources are connected to it as integrations; and its compute runs in one or more data planes. Short, plain-language definitions of terms like these are also in the glossary.
Dippr at a glance: people and agents on top, Dippr in the middle, your data plane below it, and your sources left where they are

Who you are

Tenant is the account your work happens in: everyone you work with, every source you’ve connected, and every engine, app and database you’ve registered belongs to exactly one. You reach yours at its own subdomain, like acme.app.us.dippr.ai. See Users and members. Member and roles: A member is a person who belongs to your tenant. What they can see and do is decided by the roles they hold: built-in roles like viewer, analyst, data_engineer, data_admin and account_admin each inherit everything the role below it can do. See Roles and permissions and the full roles matrix. Service user and API key: A service user is a machine identity for a script, a scheduled job, or an agent that isn’t a person signing in. It authenticates with a long-lived API key (alt_…) instead of a browser session, and it’s assigned roles the same way a member is. See Service users and API keys.

Where your data lives

Dippr is split into a control plane, which holds who you are and what you may do, and a data plane, which holds your compute and your data. The control plane never reaches into a data plane; the plane connects outbound to it.
The control plane run by Dippr, and your data plane where rows, results and files stay
Data plane: The execution boundary where your compute and your data actually run: your query engines, data apps and workspace databases all run inside one. Dippr runs your data plane on its own compute by default; you can also register one inside your own cloud account. See Data planes. Integration and capability: An integration is a connection Dippr holds to an external system: a database, a warehouse or a file store, including its credentials. What it’s allowed to do once connected is its capabilities: driver lets a query engine read it directly, federation lets other catalogs be queried alongside it, and mcp exposes it to MCP tools. See Integrations. Query engine and catalog: A query engine is a managed Trino cluster that runs SQL against your connected sources. A catalog is the named collection of schemas and tables one integration exposes to an engine, usually one catalog per connected integration. See Query engines. Catalogs pending and apply: Connecting a new source, a workspace database’s first time serving, or a platform update changes what an engine’s catalogs would be, but an engine only reads catalogs at startup. So a change sits as “pending” until someone clicks Apply, which restarts the engine and interrupts whatever it’s running at that moment. See Catalogs and apply. Engine power states: An engine is Starting while it provisions, Ready once it’s serving queries, Suspended after it scales to zero from being idle (the next query wakes it automatically), or Parked after someone deliberately stops it (only a person can wake it back up). Draining and Stopping are the brief transitions in between. See Power and scale-to-zero.

Working with data

Explore: The console’s page for browsing catalogs and running SQL against your query engines, in one surface: you read a table in order to query it, and you query it to understand what you read. See Catalog browser and SQL workbench. Query history and lineage: Query history is the record of every query your tenant’s engines have run, visible to everyone who can read it. Lineage is the graph of what produced a given table or column and what depends on it, reachable from that table’s own page. See Query history and Lineage. Metadata search and the crawl: A crawl is a scan of your engines’ catalogs that indexes tables, columns and queries so you can search across all of them from one box. It’s a paid capability, and it costs engine time to build. See Search and Search indexing.

Meaning, not just tables

Tables are what your sources expose. The semantic layer and the ontology add layers of meaning on top, each governed and certified separately.
Three layers of meaning: your tables, governed metrics on top of them, and business concepts on top of those
Semantic model, metric, question: A semantic model is a governed definition over your tables; a metric is a named, certified calculation inside one, like “active users.” A question is a natural-language question your tenant has agreed how to answer, paired with the verified SQL that answers it. See Models and metrics and Questions and review. Concept, relationship, binding: A concept is a piece of business vocabulary your tenant defines once, like “Customer,” independent of which table implements it. A relationship declares how two concepts connect (a Customer has Orders). A binding is the link between a concept and the model that actually realizes it. See Ontology and concepts and Relationships and bindings. Marketplace and listing: The Marketplace is a curated catalog of ready-made semantic models and ontologies. A listing is one of those definitions at a named version; installing it copies the definition into your semantic layer as drafts you own, which you then certify like any other. See Marketplace.

Connecting agents

An agent connects to your tenant’s MCP endpoint, asks for scopes, and you consent once. Every tool call after that runs as you, so what it can see is what your roles already allow.
Connect an agent, consent once, and it works as you
MCP endpoint and tools: Every data plane runs a Model Context Protocol server at its own endpoint. An agent connected to it gets a fixed set of tools: running SQL, listing engines and catalogs, and, where enabled, searching metadata and query history. See MCP overview and Tools. Scope and consent: A scope is a named capability a connecting client asks for, like “run SQL on your data.” Consent is your explicit approval of the scopes a client requested, shown as a list before you approve. Holding a scope never lets a client do more than your own roles already allow. See Scopes and consent.

Building on Dippr

Data app and installation: A data app is a packaged application that runs inside your data plane and queries it on your users’ behalf, declared by a manifest and built with the dip CLI. Installing one creates one running instance, with its own consent and its own wake/park state. See Data apps overview and Install and consent. Workspace database: A DuckDB database you own inside your data plane. You write to it directly from your own machine, and every engine on its data plane reads it live as a read-only catalog. See Workspace databases.

What never leaves your data plane

Your query results, the content your data apps generate, the rows an MCP tool call returns, and the rows in your workspace databases: none of it crosses into Dippr’s control plane. The console reads result data straight from your data plane. The control plane does receive metadata about your data and the text of your queries; see What leaves your data plane.