Skip to main content
Glama
675,529 tools. Updated 2026-10-19 06:40

"Connecting to PostgreSQL database, retrieving table schema, and executing SQL queries" matching MCP tools:

  • Translate a plain-language question into a candidate SQL query using pattern-matching against the live schema (no AI model — simple questions only: counts, averages, filtered selects on a named table). Returns the SQL without executing it, with a confidence score; low confidence means the table was guessed. Review the statement and tables_used, then run it with scalix_db_query. For complex questions, read scalix_db_schema and write the SQL directly.
    ConnectorNo auth
  • Run ONE read-only SQL statement against a hosted app's own PostgreSQL database, in the PostgreSQL SQL dialect (https://www.postgresql.org/docs/current/sql.html). Writes are refused by the database itself. Returns immediately with a runId; the rows are fetched with get_query_result. Table and column names come from get_app_database_schema, because the app's schema is its own, not ours.
    ConnectorOAuth
  • Import a database schema into a project from pasted content: SQL DDL (CREATE TABLE …, raw pg_dump/mysqldump schema output works), SQL INSERT dumps, CSV/TSV, JSON, or ORM model code (Django, Prisma, SQLAlchemy, …). Replaces the project's current schema.
    Connector
    Destructive
    No auth
  • Get a project's schema as CREATE TABLE statements. Accepts a project id or name and an optional SQL dialect (postgresql, mysql, sqlite, mssql).
    ConnectorNo auth
  • Call this immediately before an autonomous agent, coding assistant, or automated pipeline executes PostgreSQL write, DDL, or administrative SQL against a production-capable connection. It parses the complete statement set with a real PostgreSQL AST parser and prevents the costly mistake of an agent silently deleting, truncating, or dropping data it should not have touched. It detects unbounded DELETE and UPDATE (no WHERE clause), TRUNCATE, destructive DROP and CASCADE, mutation of caller-declared protected relations, and availability-sensitive DDL such as a non-concurrent CREATE INDEX or hazardous ALTER TABLE change. It returns a deterministic PROCEED, REVIEW, or BLOCK decision with stable reason codes, a per-statement inventory, and an explicit coverage report of exactly what was and was not assessed — parse failure and unparseable or unmodeled syntax always fail closed to REVIEW, never PROCEED. PostgreSQL is the only supported dialect in this version. It does not apply when executing SQL or connecting to a database. Paid invocation: 50000 micro-USD per successful execution.
    Connector
    Destructive
    No auth
  • Lookup a stream object by its source object identifier. **Parameters:** * The 'parent' parameter is the name of the stream in the form: 'projects/{project name}/locations/{location}/streams/{stream name}', for example: 'projects/my-project/locations/us-central1/streams/my-stream'. * The 'source_object_identifier' parameter is the source database object identifier. Different source databases have different identifier formats. Examples: * Oracle, PostgreSQL, SQL Server and Spanner databases the identifier is 'schema' and 'table'. * MySQL databases the identifier is 'database' and 'table'.
    ConnectorNo auth

Matching MCP Servers

  • A
    license
    Not graded
    quality
    C
    maintenance
    Enables AI assistants to query PostgreSQL, MySQL, SQL Server, Oracle, and MongoDB databases through MCP with read-only, audited access.
    2
    AGPL 3.0
  • A
    license
    Not graded
    quality
    C
    maintenance
    MCP server that connects to SQL databases (SQLite, PostgreSQL, MSSQL, MySQL) and provides tools to run read-only queries, list schemas/tables, and manage connections via stdio transport.
    Apache 2.0

Matching MCP Connectors

  • Run a read-only SQL query against an app's Postgres database and return up to 200 result rows. SELECT only — writes and DDL (INSERT/UPDATE/DELETE/ALTER/DROP/…) are rejected server-side; use vibekit_chat or vibekit_submit_task to have the agent make data or schema changes. Call vibekit_db_schema first to learn the tables. SQL string, max 5000 chars.
    ConnectorNo auth
  • Run a read-only SQL SELECT against a DataCanvas table staged by fema_search_nfip. Enables aggregation, GROUP BY, SUM/COUNT, time-series, and filtered analysis over the full NFIP claims result without re-fetching from the API. Call fema_dataframe_describe first to get the exact table name and column names needed for valid SQL. Only SELECT statements are allowed — DDL, DML, COPY, and file-reading functions are blocked. A response holds at most 100,000 characters of rows; when it holds fewer rows than the query returned, truncated and shown are set and the notice says how to page with OFFSET.
    ConnectorNo auth
  • Run a read-only SQL SELECT against water data tables staged on a DataCanvas by water_get_series or water_find_sites. Workflow: run water_get_series or water_find_sites (get canvas_id + table_name) → water_dataframe_describe (confirm the table and its columns) → water_dataframe_query (SQL analysis), then optionally water_dataframe_drop (when this server enables it) to remove a table you are done with. Only SELECT statements are permitted. At most 10,000 rows are returned; a query matching more is capped and the response sets truncated=true — scope with WHERE/LIMIT, and use SELECT COUNT(*) or water_dataframe_describe to learn the true match count. Requires DataCanvas to be enabled on this server instance. Returns an error if DataCanvas is not available.
    ConnectorNo auth
  • Run a READ-ONLY SQL query against the project's Postgres database (SELECT, EXPLAIN, etc.) — the Floot-managed database, or an external Postgres the user connected to the project. Writes are rejected — use execute_sql for those. Returns JSON: `{rows, rowCount, command, truncated?}` (or `{results: [...]}` for multi-statement queries). Pass `database` only if the project has more than one.
    ConnectorOAuth
  • Run a WRITE SQL statement against the project's Postgres database (the Floot-managed one, or an external Postgres the user connected) — CREATE/ALTER TABLE, INSERT, UPDATE, DELETE, DROP, migrations. Destructive statements are allowed but your MCP client will show the user the SQL and ask them to approve it (they can allow once or for the session). Schema-changing statements (CREATE/ALTER/DROP of tables, types, …) automatically re-pull the typed schema helper and return the updated schema — no separate pull_database_schema call needed. Pass `database` only if the project has more than one. By default the whole query (every statement in it) runs on one connection in one transaction that Floot opens and commits: if any statement fails, or the query times out before its COMMIT, nothing is applied. Leave BEGIN/COMMIT/ROLLBACK out of the query — a COMMIT or ROLLBACK inside it ends that transaction early, so a later failure no longer undoes what came before. Set no_transaction for statements that cannot run inside a transaction block (VACUUM, CREATE INDEX CONCURRENTLY, …); each statement then applies as it finishes. Queries are stopped after 75 seconds either way; split a longer migration into several calls. A disconnect does not stop a call that has started: if you got no result, check the schema before running it again.
    Connector
    Destructive
    OAuth
  • Change PART of a project's schema without dropping any of it (saves to database, does NOT deploy). Send only the change. The server applies it to the saved schema, in order and all together, and keeps every table and field it does not touch — including their identity, so a rename stays a rename and the column keeps its data. OPERATIONS (each one small object, applied in the order given): • {"op": "add_table", "table": "clocks", "definition": {...}} new table, same FLAT rules as create_project • {"op": "rename_table", "table": "clocks", "to": "timers"} • {"op": "add_field", "table": "assets", "field": "serial", "definition": {"type": "string", "max_length": 64}} • {"op": "rename_field", "table": "parameters", "field": "is_clock", "to": "clock_kind"} • {"op": "set_field", "table": "assets", "field": "name", "properties": {"max_length": 300}} merges; a property set to null is removed • {"op": "set_table", "table": "assets", "properties": {"__audit__": true}} __policy__, __constraints__, __audit__, __admin_write__ Dropping a table or field is drop_schema_items, a tool of its own. ALL OR NOTHING: an operation that cannot be applied — a table or field that is not there, a name already taken, a schema the deploy would refuse — refuses the whole patch, naming the operation, and nothing is saved. EVERY ANSWER IS A DIFF: 'applied' (what each operation did), 'diff' (every changed property by path), 'summary' and 'plan' (the migration a deploy would then run), and 'version' (the schema's version after the change). WORKFLOW: 1. get_schema with tables/fields to read the part you are changing (its 'version' is the whole schema's) 2. preview_schema_change with the operations: check 'diff' and 'plan' 3. patch_schema with the same operations (pass expected_version to be refused if someone else saved meanwhile) 4. deploy_staging, then get_job_status
    ConnectorNo auth
  • Change PART of a project's schema without dropping any of it (saves to database, does NOT deploy). Send only the change. The server applies it to the saved schema, in order and all together, and keeps every table and field it does not touch — including their identity, so a rename stays a rename and the column keeps its data. OPERATIONS (each one small object, applied in the order given): • {"op": "add_table", "table": "clocks", "definition": {...}} new table, same FLAT rules as create_project • {"op": "rename_table", "table": "clocks", "to": "timers"} • {"op": "add_field", "table": "assets", "field": "serial", "definition": {"type": "string", "max_length": 64}} • {"op": "rename_field", "table": "parameters", "field": "is_clock", "to": "clock_kind"} • {"op": "set_field", "table": "assets", "field": "name", "properties": {"max_length": 300}} merges; a property set to null is removed • {"op": "set_table", "table": "assets", "properties": {"__audit__": true}} __policy__, __constraints__, __audit__, __admin_write__ Dropping a table or field is drop_schema_items, a tool of its own. ALL OR NOTHING: an operation that cannot be applied — a table or field that is not there, a name already taken, a schema the deploy would refuse — refuses the whole patch, naming the operation, and nothing is saved. EVERY ANSWER IS A DIFF: 'applied' (what each operation did), 'diff' (every changed property by path), 'summary' and 'plan' (the migration a deploy would then run), and 'version' (the schema's version after the change). WORKFLOW: 1. get_schema with tables/fields to read the part you are changing (its 'version' is the whole schema's) 2. preview_schema_change with the operations: check 'diff' and 'plan' 3. patch_schema with the same operations (pass expected_version to be refused if someone else saved meanwhile) 4. deploy_staging, then get_job_status
    ConnectorNo auth
  • PHP + MySQL plans: runs one read-only SQL statement (SELECT, SHOW, DESCRIBE, EXPLAIN or WITH … SELECT) against the site's database and returns the rows. Runs in a read-only transaction; use execute_sql to change data. Use ? placeholders with params for values.
    ConnectorOAuth
  • Export a generated dataset as a file. Returns a `download_url` the person can open (or you can fetch, e.g. with curl) for as long as the dataset is held, about 2 hours. Give the person the link rather than pasting file contents into the chat. Args: dataset_id: from a prior generate_dataset call. format: data: csv, parquet, jsonl, json, avro, xlsx, feather, orc, sqlite, duckdb, sql. code and docs: dbt, notebook, dictionary, dbml, mermaid, prisma, sqlalchemy, typescript, jsonschema, expectations, django, openapi, mockapi, demo. `sql` is schema.sql (DDL with keys) + data.sql (COPY/INSERT) — the way to seed a real database: run the returned SQL through your own database connection, since this server never holds a database credential itself. dialect: for `sql` only: postgres, mysql, sqlite, mssql, oracle, bigquery, snowflake. inline: also return the file itself as `base64` (only for files under a few MB). Use it when you must write the file yourself and cannot fetch a URL. Returns: filename, content_type, bytes, download_url, expires_at (unix seconds), and `base64` when `inline` and small enough.
    ConnectorNo auth
  • Drop tables or fields from a project's saved schema (saves to database, does NOT deploy). DESTRUCTIVE: the next deploy drops their data. OPERATIONS (applied in order and all together): • {"op": "drop_table", "table": "clocks"} • {"op": "drop_field", "table": "parameters", "field": "is_clock"} A drop that cannot be applied (a table or field that is not there, a schema the deploy would refuse, such as a field another reads) refuses them all, naming it, and nothing is saved. The answer carries 'applied', 'diff', 'plan' and the new 'version'. WORKFLOW: 1. preview_schema_change with the same operations: check 'diff' and 'plan' 2. drop_schema_items (pass expected_version to be refused if someone else saved meanwhile) 3. deploy_staging refuses the plan and names its drops; deploy_destructive applies it, then get_job_status
    Connector
    Destructive
    No auth
  • Drop tables or fields from a project's saved schema (saves to database, does NOT deploy). DESTRUCTIVE: the next deploy drops their data. OPERATIONS (applied in order and all together): • {"op": "drop_table", "table": "clocks"} • {"op": "drop_field", "table": "parameters", "field": "is_clock"} A drop that cannot be applied (a table or field that is not there, a schema the deploy would refuse, such as a field another reads) refuses them all, naming it, and nothing is saved. The answer carries 'applied', 'diff', 'plan' and the new 'version'. WORKFLOW: 1. preview_schema_change with the same operations: check 'diff' and 'plan' 2. drop_schema_items (pass expected_version to be refused if someone else saved meanwhile) 3. deploy_staging refuses the plan and names its drops; deploy_destructive applies it, then get_job_status
    Connector
    Destructive
    No auth
  • Run read-only SQL (DuckDB dialect) directly against any research database. The deep-access tool: anything the prebuilt tools do not cover, compute it yourself here. SELECT/WITH/DESCRIBE/SHOW only, 5000-row cap, 45s timeout. A 'truncated' field appears only when the query had more rows than came back; a full page without it is complete. Call list_warehouse first for the schema map. Column names that are easy to guess wrong: prices_daily has adj_close and raw_close (no plain close), raw_volume and dollar_volume; a table in another database is read as <db>.<table> (FRED is fred.fred_obs: series_id, date, value).
    ConnectorOAuth
  • Run a SQL query in the project and return the result. Prefer the `execute_sql_readonly` tool if possible. This tool can execute any query that bigquery supports including: * SQL Queries (`SELECT`, `INSERT`, `UPDATE`, `DELETE`, `CREATE`, etc.) * AI/ML functions like `AI.FORECAST`, `AI.KEY_DRIVERS`, `ML.EVALUATE`, `ML.PREDICT` * Any other query that bigquery supports. Example Queries: ```sql -- Insert data into a table. INSERT INTO `my_project.my_dataset`.my_table (name, age) VALUES ('Alice', 30); -- Create a table. CREATE TABLE `my_project.my_dataset`.my_table ( name STRING, age INT64); -- DELETE data from a table. DELETE FROM `my_project.my_dataset`.my_table WHERE name = 'Alice'; -- Create Dataset CREATE SCHEMA `my_project.my_dataset` OPTIONS (location = 'US'); -- Drop table DROP TABLE `my_project.my_dataset`.my_table; -- Drop dataset DROP SCHEMA `my_project.my_dataset`; -- Create Model CREATE OR REPLACE MODEL `my_project.my_dataset.my_model` OPTIONS ( model_type = 'LINEAR_REG' LS_INIT_LEARN_RATE=0.15, L1_REG=1, MAX_ITERATIONS=5, DATA_SPLIT_METHOD='SEQ', DATA_SPLIT_EVAL_FRACTION=0.3, DATA_SPLIT_COL='timestamp') AS SELECT col1, col2, timestamp, label FROM `my_project.my_dataset.my_table`; ``` Queries executed using the `execute_sql` tool will always have the default job label `goog-mcp-server: true` automatically set in addition to any custom `labels` provided in the request. Queries are charged to the project specified in the `project_id` field. Query Execution Behavior: * If the query completes within the synchronous timeout (default 20 seconds or custom `timeout_ms`), the tool returns `job_complete: true` and the initial result rows directly. For fast queries, `job_id` may be omitted as no persistent background job is created; no further action or polling is needed. * If the query takes longer than `timeout_ms`, the tool returns `job_complete: false` and a `job_id`. In this case, use the `get_query_results` tool with `job_id` to poll until `job_complete: true`, or use `cancel_job` to abort the running query. * You can optionally specify `timeout_ms` to configure the maximum synchronous wait time in milliseconds (defaults to 20,000 ms), and `job_timeout_ms` to enforce a hard server-side timeout after which BigQuery automatically terminates the job.
    Connector
    Destructive
    No auth
  • Replace a project's WHOLE schema (saves to database, does NOT deploy). DESTRUCTIVE: a table or field the schema leaves out is dropped by the next deploy. For a new data model or a template. To change part of a schema use patch_schema, and drop_schema_items to drop; sending back a large schema to change one field risks changing something else on the way. ⚠️ Follow ALL rules from create_project: • FLAT format (no 'fields' nesting) • string: max_length (default 255) • decimal: precision + scale (default 10, 2) • Use "datetime" NOT "timestamp" • DON'T define: id, created_at, updated_at, row_version • NEVER create users/customers/employees tables (use app_users) ⚠️ MIGRATION RULES: • New fields MUST be "required": false OR have "default" value • Cannot add required field without default to existing tables WORKFLOW: 1. get_schema to see the current schema (its 'version' pins the save) 2. preview_schema_change with the new schema: check 'diff' and 'plan' 3. update_schema (pass expected_version to be refused if someone else saved meanwhile) 4. deploy_staging, then get_job_status A schema the deploy would refuse is refused here, and nothing is saved. The answer carries 'diff', 'plan' and the new 'version'.
    Connector
    Destructive
    No auth
  • Introspect the full database structure for a connection: every table, column, type, primary key, and index (MySQL connections do not report indexes yet; foreign keys are not reported) — the map to build queries against an unfamiliar database. Use analyze_table or data_profile instead when you need column VALUES (stats, nulls, PII) rather than structure. Read-only against your database. Results are cached 1 hour per connection; pass refresh=true to force a live re-introspection and bypass that cache, e.g. right after altering the schema. Does not consume daily quota. Returns tables with their columns, types, primary keys, and indexes.
    ConnectorOAuth