Loading ToolBench
A FastMCP server that provides tools for interacting with a Supabase database. Uses the Model Context Protocol (MCP) with Stdio transport.
Supabase MCP provides 4 well-named CRUD tools with detailed descriptions and Pydantic-validated schemas. Tool names follow verb_noun convention (read_records, create_records, update_records, delete_records). Descriptions are comprehensive (150-250 chars each) with use cases and caveats. However, output schemas are not documented, responses are inferred from handler code (returns Dict[str, Any]). Parameter descriptions are present but lack constraints (e.g., no enum for sort direction, no min/max for limit/offset). Error handling returns generic error strings without recovery guidance. No tool annotations (readOnlyHint, destructiveHint, idempotentHint) despite clear risk levels. Missing per-parameter type clarity in some fields (filters and order_by are 'object' without nested schema detail).
Creates one or more records in a Supabase database table. Use this tool to insert new data into your database. Common use cases: - Add a single new record to a table - Bulk insert multiple records at once - Create related records You can provide either a single record object or an array of record objects. The tool returns the created records with their assigned IDs and timestamps (if applicable). Make sure the data structure matches the table schema to avoid validation errors.
Deletes records from a Supabase database table based on filter conditions. Use this tool to remove data that matches specific criteria. Common use cases: - Delete a specific record by ID - Remove multiple records matching a condition - Clean up old or unnecessary data ⚠️ IMPORTANT: Deletions are permanent and cannot be undone. Always confirm the filter conditions carefully before deleting records. For safety, always use specific filter conditions to avoid accidentally deleting too many records. The tool returns the deleted records as they were before deletion.
Reads records from a Supabase database table with flexible querying options. Use this tool to fetch data from your database with options for filtering, sorting, and pagination. Common use cases: - Retrieve all records from a table - Fetch specific records based on conditions - Get paginated results for large datasets - Retrieve only specific columns from records The returned data is always an array of record objects, even if only one record is found. If no records match the criteria, an empty array is returned.
Output schemas not documented. Handlers return Dict[str, Any] with no declared structure. LLMs cannot plan downstream calls or extract fields reliably.
Parameter constraints missing. 'limit' and 'offset' lack min/max bounds; 'order_by' direction has no enum (asc|desc); 'filters' and 'order_by' are untyped 'object' without nested schema.
No tool annotations. delete_records and update_records lack destructiveHint/idempotentHint; read_records lacks readOnlyHint. Agents cannot infer safety/retry semantics.
Error handling returns generic error strings ('error': str(e)) without recovery guidance. No categorization (retryable vs fatal) or actionable next steps.
| Scored | Grade | Overall | Spec posture | Rubric |
|---|---|---|---|---|
| 2026-09-23 | B | 71 | 2026-07-28+ | v2 |
Updates existing records in a Supabase database table based on filter conditions. Use this tool to modify existing data that matches specific criteria. Common use cases: - Update a specific record by ID - Batch update multiple records matching a condition - Modify specific fields while keeping others unchanged The 'updates' parameter specifies which fields to update and their new values. The 'filters' parameter determines which records will be updated. Be careful with filter conditions - if they match many records, all of them will be updated. The tool returns the updated records after modification.
No pagination metadata. read_records accepts limit/offset but response does not include total_count or next_cursor. Large result sets risk context window exhaustion.