The MCP Server Evaluation Checklist for Teams Running AI Agents Against Supabase
A pass/fail checklist for keeping AI agents away from live data.

Governed data access for AI agents on Supabase via MCP should give agents pre-modeled datasets through a separate access layer and keep production tables out of their direct reach. The MCP Server Evaluation Checklist for Teams Running AI Agents Against Supabase puts data safety, query governance, and the need to protect production ahead of how much a server can do. Server evaluation establishes the minimum controls, while the data architecture determines how much risk remains.
Why the MCP registry's growth creates a real evaluation problem for Supabase teams
The MCP registry has scaled to roughly 10,000 servers, with rapid growth in under a year making manual evaluation difficult. Most are not production-ready. Tool availability says little about whether a server constrains access, handles credentials safely, or protects a live database.
For Supabase teams, more is at stake than the time spent on integration. A connected agent can read or mutate user data, while Supabase's own MCP server exposes SQL execution, schema inspection, RLS policy changes, and migrations. These capabilities are useful precisely because they reach consequential parts of the system. What can this server do that the team has not authorized?
What a Supabase MCP server actually exposes to an agent
Supabase's MCP server exposes SQL execution, table listing, row reads, schema inspection, migration execution, Edge Function deployment, and RLS policy inspection through get_advisors. Its broader capability surface includes infrastructure provisioning and operations that can delete data. Authentication lets an agent use tools as well as read information. Evaluators need to map those tools to the database and administrative permissions available to the session.
The credential regime changes that exposure substantially. A service role key bypasses all Row Level Security and provides unrestricted database access, making it appropriate for schema migrations but never for agent sessions that touch user data. An anon key operates within RLS policies and is the right default for most agent sessions. That distinction must survive the integration. Tests should check whether every tool call appears in the Supabase audit log with its own agent identifier and whether exploratory work can stay in a separate development database or staging branch.
How to scope a Supabase MCP server to the minimum it needs
Supabase's guidance establishes four concrete scoping controls. A server should support project_ref to restrict access to one project, read_only=true for unattended routines and real-data connections, and features to limit available tool groups. It should also permit exploratory workflows to use a staging branch or development database, keeping those workflows off production data. These controls form a pass/fail gate. A workflow that needs one project and a small set of tools has no need for organization-wide access.
For evaluators, the question is whether all four controls are available without granting permissions beyond the task. Read-heavy access is the starting point, with writes added only when the human approval path is explicit. A server that asks for service role credentials for read-only tasks fails that test before the team even checks how well authentication works. It should not reach production. Restricting what the agent is told to do cannot substitute for restricting what its credentials and tools permit.
Authentication and credential handling: what to check before connecting
Scoping limits authorized activity, but authentication determines who can invoke it. A server without authentication lets any process that can reach it call its tools, which is unacceptable for database access. Static API keys introduce a different weakness because leaked access persists until manual rotation. OAuth is the production bar to clear. Its scoped, revocable, auditable access is the standard against which a candidate should be assessed.
The evaluation should cover the credential's full lifecycle. Does authentication precede every tool call, are credentials stored securely, and can they rotate without downtime? Expiry must also produce a graceful, visible failure. A server below the OAuth bar should be treated as untrusted by default, even when its tool catalog fits the workflow. Sessions that touch user data must also use an anon key or a custom role scoped to only the tables they need, with no use of the service role key.
Human-in-the-loop controls and the risk of autonomous write operations
Responsibility now shifts from team configuration to server behavior. An authenticated, narrowly scoped agent can still execute a destructive operation within its permissions. Read-only schema inspection does not need a confirmation gate. SQL that deletes, truncates, or drops data does, as do RLS policy changes, paid project or branch creation, production migrations, and Edge Function deployment.
Supabase's server asks for confirmation before creating a paid project or branch or running SQL that could delete data when the client supports form-based elicitations, such as over HTTP. Older or stdio-based clients fall back to softer, model-mediated confirmation or none at all. The actual client-server combination must enforce it. Confirmation can leave some autonomous actions free to run, but a server without human-in-the-loop controls should be used only in trusted, controlled environments and kept out of production sessions that involve real user data.
Prompt injection and what returned database rows can do to an agent
Instructions hidden in returned data can get past permissions and confirmation gates. When an agent reads a row, its text enters the model's context window. A support ticket, form submission, comment, or note can contain an instruction such as “ignore previous instructions and…”. The model may act on that instruction. User-generated content is therefore part of the attack surface, even when the database read itself is authorized.
Prompt wrapping can help by framing returned content as data, but it is not a complete boundary. Determined injection attempts can escape naive wrappers. Evaluators should ask whether the server sanitizes or flags potentially instructional text, whether its documentation acknowledges the risk, and whether its tool schema distinguishes data fields from metadata fields. These are separate checks on handling, documentation, and representation. A server that treats every returned row as trusted input assumes a level of trust the data pipeline does not provide.
DLP in the tool-call path: what happens to PII before it reaches the model
Injection concerns what returned text persuades an agent to do, while data loss prevention concerns what the model receives at all. In a default MCP setup, there is no inspection step between the database response and the context window. Results may therefore include PII, financial records, or credentials visible to the authorizing credential. A founder who stores a payment processor's customer data in Supabase runs this risk even without a large compliance department.
An MCP-layer DLP gateway intercepts tool calls between the agent and Supabase so sensitive content can be redacted, tokenized, or vaulted before reaching the model. Evaluation should establish whether the server provides field-level redaction or tokenization, supports a DLP proxy without breaking tool discovery, and exposes metadata for identifying sensitive columns. These checks concern the actual return path. For healthcare, fintech, and legal workloads, absent DLP controls represent a compliance risk that disqualifies the server from production use.
How to test an MCP server against Supabase before it touches production
Testing should start in a separate Supabase project or branch with non-production data like the data it will use and the credential type planned for deployment. The environment must reproduce the intended permission boundary. Otherwise, passing tests say little about how the server will behave in production. Each part of the earlier evaluation needs a pass/fail result from tests in that environment, backed by more than documentation.
Functional testing comes next. Tool discovery should list exactly the tools in the documentation, and returned reads should match direct database queries run at the same time. Tests should also establish that read-only credentials block writes and every tool call appears in the audit log with a distinct agent identifier. Failure handling needs explicit coverage. Credential expiry during a session, connection pool exhaustion, and a missing table should each have an observed result.
Security testing then probes the boundaries. An instructional row tests injection handling, while an anon-key call to a service-role-only tool tests rejection of credential escalation. Rate-limit tests should reveal graceful failure or retries without backoff, and interrupted writes or migrations should be examined for database consistency. Performance capture follows those checks, recording task-completion rate, latency per tool call, token usage per workflow, and required human interventions. The selection rule is the smallest stack that completes the workflow reliably, securely, and within acceptable latency, excluding servers that add surface area without useful capability.
Why pointing agents at production Postgres directly undermines the safety work above
Even a server that passes these checks poses risks because it queries production Postgres. Agent aggregations compete with transactional application traffic and contribute to the Supabase bill. Application RLS policies also make it harder to read data for analysis. Schema changes introduce another source of error. An agent's cached understanding can become stale, while unrestricted aggregation can produce numbers that disagree with the business's metric definitions.
The architectural alternative is a governed, pre-modeled data layer. Metrics are defined ahead of time and exposed through a separate access layer that agents query without touching production tables. This uses the same MCP pattern at a different boundary. The semantic layer owns the definition, and the agent consumes pre-calculated results instead of constructing its own SQL against production. That separation prevents agent metric queries from overloading the production pool or redefining the metric calculation per request, while access remains subject to controls in the data layer.
What a governed data layer for Supabase agents looks like in practice
In this pattern, metrics are calculated ahead of time and stored in governed Parquet files. Agents query those files through DuckDB, keeping production Postgres and its OLTP connection pool outside that query path. A single MCP server exposes the dataset catalog, allowing agents to discover available metrics through tool discovery, bypassing raw schema exploration. Dashboards, AI agents, and automated reports all use the same definitions.
This changes the object of least privilege from raw tables to governed datasets. It also places access control in the data layer rather than relying on application-level Postgres policies for analytical workflows. Those controls still require evaluation. A separate dataset is not permission to expose every record, and architectural isolation does not replace authentication, injection mitigation, or DLP.
The complete MCP server evaluation checklist for Supabase teams
Gate 1 covers scope and least privilege. Does the server support single-project scoping through project_ref? Does it support read_only=true? Can tool groups be restricted through features? Can exploratory sessions use an isolated development database or staging branch? Can the workflow run without credentials broader than it needs? Each answer should be recorded as yes or no.
Gate 2 covers authentication and credential handling. Does authentication precede every tool call? Does the server support OAuth? Are credentials stored securely? Can they rotate without downtime? Does expiry fail gracefully? Do user-data sessions avoid the service role key?
Gate 3 checks how human approval works in the client-server combination in use. Does it require confirmation for destructive SQL? Does it gate RLS changes and production migrations? Does it gate paid project and branch creation? Does it gate Edge Function deployment? Model-mediated assurances do not establish an enforced confirmation boundary.
Gate 4 covers prompt injection mitigation. Does the server sanitize or flag instructional content in returned rows? Does its documentation acknowledge injection risk? Does its tool schema distinguish data fields from metadata fields? Gate 5 covers disclosure before model access. Does the return path provide field-level redaction or tokenization? Can the server operate behind a DLP proxy without breaking discovery? Does it expose metadata for sensitive-column identification?
Gate 6 covers pre-production verification. Did all functional tests pass? Did all security tests pass? Were task completion, latency, token usage, and human interventions captured? Is the selected stack the smallest one that completes the target workflow reliably and securely? These answers describe a tested deployment.
Gate 7 covers architectural fit beyond the server. Do agents bypass production tables to query a governed data layer? Is analytical agent load isolated from OLTP traffic? Does a semantic layer define what the metrics mean? Are dataset access controls enforced in that layer?
Gates 1–3 are hard requirements, and failure at any of them blocks production use. Gates 4–5 are weighted by data sensitivity, with missing DLP disqualifying regulated-data deployments. Gate 6 is a required evaluation process. Gate 7 is the architectural recommendation that extends protection beyond what any individual MCP server can provide.


