Skip to main content
Glama

Server Details

Query Postgres, MySQL, SQL Server, Oracle, BigQuery, ClickHouse and Redshift from your AI client.

Ownership verified
Status
Healthy
Uptime
100.0% over the last 24 hours
Last Tested
Transport
Streamable HTTP · MCP 2025-11-25
URL
ChatGPT
–
Claude
–

TDQS

A4.2/5.0

Scored across 32 tools

Disambiguation4/5

Most tools are sharply differentiated, and the descriptions actively disambiguate siblings (execute_query vs run_saved_query vs export_query_results; get_schema vs get_context vs export_ossie; get_guard vs list_access_rules). The main risks are the near-identical set_description vs set_descriptions pair and the many 'save_*' Guard mutators that all share one approval preamble, but the text resolves both.

Naming Consistency4/5

Everything follows snake_case verb_noun, which is consistent at the structural level. The verb vocabulary is looser: the same create-or-update semantics are expressed as save_query, save_group, save_policy, save_access_rules, upsert_definition and set_description, and query execution splits across execute_* and run_*, so an agent must read descriptions rather than infer intent from the verb.

Tool Count3/5

32 tools is heavy, but the server spans four genuinely large sub-domains: ad hoc querying, the saved-query library, scheduled delivery, and a full Guard governance layer. Almost every tool earns its place within its sub-domain, though the surface is broad enough that an agent must navigate a large mental map before acting.

Completeness3/5

Querying, context/semantic-model authoring and Guard all have create/read/update/delete coverage, but two lifecycles have dead ends: saved queries can be created and overwritten yet never deleted, and schedules can be created, listed and force-run but not updated, paused, disabled or deleted despite list_schedules exposing an 'enabled' flag and lastError. Connections are also read-only with no create/delete.

Publisher details

Operator
Panda Capital Oy Ab · Publisher source
Vendor relationship
First-party
Privacy policy
Not provided
Restrictions
Requires a SaturnSQL Starter plan or higher, or an active trial, and access to a configured database connection. Supports OAuth or API key authentication. · Publisher source

Available Tools

32 tools
create_scheduleCreate scheduleA
Destructive
Inspect

Schedule a saved query to run on a cron cadence and deliver its result to exactly one destination: a Google Sheets tab or a Slack channel. Use it when the user wants a report refreshed or posted regularly; for a one-off file use export_query_results. Save the SQL first with save_query if it is not in the library, and check list_schedules, since each saved query can have only one schedule. Every run replaces what the previous run wrote to the sheet range, or posts a new Slack message. Set spreadsheetId, or createNew with spreadsheetName, or slackChannelId, never more than one destination. Requires a plan that includes scheduling, the write and execute scopes, and a member role that can edit. The query must be one you could run yourself: shared with the team on an approved_queries connection, and a read unless the connection's aiAccess is same_as_people. Test it right away with run_schedule_now.

Inputs: savedQueryId (required), cronExpression (required), timezone, createNew, +8 more. Returns: schedule

delete_access_rulesDelete access rulesA
Destructive
Inspect

Delete one rule set by its id from list_access_rules. The group then falls back to the next rules that apply. Guard decides what AI tools, including you, may do on the team's databases, so change it only when the user asked for this exact change, and say what will change first. Needs an admin, the write scope, and an admin's approval in SaturnSQL for this AI tool: without it the call fails with code GUARD_APPROVAL_REQUIRED. Then call request_guard_edit, show the user the approvalUrl, and repeat the call after they approve. An approval lasts 12 hours; call end_guard_edit when the user's changes are done. Every change is recorded in SaturnSQL with the user's name.

Inputs: id (required).

delete_definitionDelete definitionA
Destructive
Inspect

Delete one business definition from a connection, by its name as get_context lists it (any case). Only when the user asked for it. Changes what every AI tool and person on this connection reads, and is recorded in SaturnSQL with your name. Only make it when the user asked for it or confirmed it. Needs the write scope, the connection's owner or an admin, and a plan that includes Context.

Inputs: name (required), connectionId (required). Returns: deleted

delete_groupDelete groupA
Destructive
Inspect

Delete a group by its id from get_guard, with its access rules. Guard decides what AI tools, including you, may do on the team's databases, so change it only when the user asked for this exact change, and say what will change first. Needs an admin, the write scope, and an admin's approval in SaturnSQL for this AI tool: without it the call fails with code GUARD_APPROVAL_REQUIRED. Then call request_guard_edit, show the user the approvalUrl, and repeat the call after they approve. An approval lasts 12 hours; call end_guard_edit when the user's changes are done. Every change is recorded in SaturnSQL with the user's name.

Inputs: id (required).

delete_policyDelete policyA
Destructive
Inspect

Delete a policy by its id from get_guard. Guard decides what AI tools, including you, may do on the team's databases, so change it only when the user asked for this exact change, and say what will change first. Needs an admin, the write scope, and an admin's approval in SaturnSQL for this AI tool: without it the call fails with code GUARD_APPROVAL_REQUIRED. Then call request_guard_edit, show the user the approvalUrl, and repeat the call after they approve. An approval lasts 12 hours; call end_guard_edit when the user's changes are done. Every change is recorded in SaturnSQL with the user's name.

Inputs: id (required).

end_guard_editStop changing GuardA
Idempotent
Inspect

Give back your approval to change Guard settings as soon as the changes the user asked for are done, instead of keeping it for the full 12 hours. Also withdraws a request still waiting. Guard is then closed to you again until an admin approves a new request.

Inputs: no named parameters. Returns: ended, message

execute_queryRun SQLA
Read-only
Inspect

Run ad hoc SQL on one connection and return the rows as JSON objects keyed by column name, plus column names, rowCount, duration in ms and a truncated flag. Use it to answer a one-off question. If a saved query already answers it, use run_saved_query instead; to hand the data on as a file, use export_query_results. Read-only: only a single SELECT, WITH or EXPLAIN statement is accepted, and anything else is rejected without running. Refused on an approved_queries connection; use run_saved_query there. A repeated identical query may return a result cached for up to 5 minutes. Each call counts against the company's monthly query quota and a limit of 30 queries per minute (the team can set a lower one per connection). Needs the execute scope and a member role that can edit; viewers get an error. A database error is returned as an error with the database's message. The team can require a person to approve some requests: the call then fails with code APPROVAL_REQUIRED and an approvalUrl. Show the user that link, wait until they say it is approved, then repeat the exact same call with approvalId. An approval works once, for that SQL, within 30 minutes.

Inputs: sql (required), connectionId (required), limit, approvalId. Returns: result, success

execute_write_queryRun SQL that changes dataA
Destructive
Inspect

Run one SQL statement that changes data or structure (INSERT, UPDATE, DELETE, CREATE and so on) on a connection whose aiAccess is same_as_people, and return its result in the same shape as execute_query. Only use it when the user has asked for the change; for reading, use execute_query. Refused on every other connection, and on a connection the team made read-only for people too. DROP DATABASE, DROP SCHEMA and TRUNCATE are always refused. Counts against the company's monthly query quota and a limit of 30 queries per minute (the team can set a lower one per connection). Needs the execute scope and a member role that can edit. The team can require a person to approve some requests: the call then fails with code APPROVAL_REQUIRED and an approvalUrl. Show the user that link, wait until they say it is approved, then repeat the exact same call with approvalId. An approval works once, for that SQL, within 30 minutes.

Inputs: sql (required), connectionId (required), approvalId. Returns: result, success

export_ossieExport context as Apache OssieA
Read-only
Inspect

Get a connection's context as an Apache Ossie semantic model in YAML: tables and columns with descriptions and synonyms, notes for AI, and definitions as metrics. Use it when the user wants the model as a file, for another tool, or to edit and bring back with import_ossie. For answering questions, use get_context instead. Read-only. Refused on an approved_queries connection.

Inputs: connectionId (required). Returns: yaml, filename

export_query_resultsExport query resultsA
Read-only
Inspect

Run SQL on one connection and return the whole result as a file body in CSV, JSON or XLSX. Use it when the user wants a file to download, attach or load into another tool, or needs more rows than execute_query returns (10000 at most). To read or analyse rows yourself, use execute_query instead: it is smaller and returns structured rows. For a recurring export to Google Sheets or Slack, use create_schedule. On PostgreSQL and MySQL, omitting limit exports every row the query returns, bounded only by the query timeout; other engines stop at 100000 rows. Always reads the database, never the result cache. Read-only: only a single SELECT, WITH or EXPLAIN statement is accepted. Refused on an approved_queries connection. Counts against the company's monthly query quota and a limit of 30 queries per minute (the team can set a lower one per connection). Needs the execute scope and a member role that can edit. CSV and JSON come back as text; XLSX comes back base64-encoded. The team can require a person to approve some requests: the call then fails with code APPROVAL_REQUIRED and an approvalUrl. Show the user that link, wait until they say it is approved, then repeat the exact same call with approvalId. An approval works once, for that SQL, within 30 minutes.

Inputs: sql (required), format (required), connectionId (required), limit, +1 more. Returns: format, content, truncated

get_contextGet contextA
Read-only
Inspect

Get what the team wants AI tools to know about one connection: notes for AI (for example which table to prefer or what unit amounts are in), business definitions such as "active customer" with their SQL, and the description and synonyms of each described table and column. Call it once at the start of a conversation about a connection, after list_connections and before writing SQL, and follow the notes. Pass intent to get only the tables and definitions relevant to the question, which keeps the answer short on large databases. Descriptions written in SaturnSQL take the place of the database's own comments. Read-only. Refused on an approved_queries connection.

Inputs: connectionId (required), intent. Returns: engine, tables, definitions, description, +4 more

get_guardGet Guard settingsA
Read-only
Inspect

Read Guard for the whole workspace: every connection with its AI tool access, approval mode and AI limits, the workspace's members, the groups used by access rules, and the policies. Call it before changing Guard so you change the right thing. Needs an active Guard approval; see request_guard_edit.

Inputs: no named parameters.

get_queryGet saved queryA
Read-only
Inspect

Get one saved query by id: its name, SQL, connectionId, folder and declared {{variables}} with each variable's type, default, required flag and dropdown options. Call it before run_saved_query to learn which values to pass and in what format. Read-only.

Inputs: id (required). Returns: id, sql, name, isShared, +4 more

get_schemaGet schemaA
Read-only
Inspect

Get every table of one connection with its columns (name, type, nullable, primary key), and the description and synonyms of each table and column where the team or the database has one. Call it before writing SQL for execute_query, export_query_results or save_query, so table and column names match the real database instead of being guessed; read the descriptions to pick the right table and units. Call get_context too for the team's notes for AI and business definitions. Read-only. On a large database the response is long; fetch it once per conversation and reuse it. Refused on an approved_queries connection.

Inputs: connectionId (required). Returns: tables

import_ossieImport Apache Ossie modelA
DestructiveIdempotent
Inspect

Bring an Apache Ossie semantic model (YAML, core spec 0.3.0.dev0 or the older semantic_model list) into a connection's context: model description and ai_context become the description and notes for AI, dataset and field descriptions become table and column descriptions, synonyms and labels are added, and metrics become definitions. Nothing the file leaves out is changed or removed, and relationships are not stored. First call it without apply to get a preview of what would change and which datasets and fields match nothing, show that to the user, and call again with apply: true only after they confirm. Changes what every AI tool and person on this connection reads, and is recorded in SaturnSQL with your name. Only make it when the user asked for it or confirmed it. Needs the write scope, the connection's owner or an admin, and a plan that includes Context.

Inputs: yaml (required), connectionId (required), apply. Returns: model, notes, applied, summary, +1 more

list_access_rulesList access rulesA
Read-only
Inspect

List the access rules on one connection: for each group, and for everyone else, which tables are allowed or hidden, hidden and masked columns, row filters and AI limits, in the order they apply. Needs an active Guard approval; see request_guard_edit.

Inputs: connectionId (required).

list_connectionsList connectionsA
Read-only
Inspect

List the database connections you can use in this SaturnSQL company, with each one's id, name, engine, database and aiAccess, which says what you may do on it. Call this first: get_schema, execute_query and export_query_results need a connectionId from this list. On an approved_queries connection use list_queries and run_saved_query instead. Connections the team closed to AI are not listed. Read-only, takes no parameters.

Inputs: no named parameters. Returns: connections

list_queriesList saved queriesA
Read-only
Inspect

List the saved queries you can see: your own plus the ones shared with the company, each with its id, name, SQL, connectionId, folder and declared {{variables}}. Check here before writing new SQL, since the team may already have a query that answers the question; pass its id to run_saved_query, get_query or create_schedule. Read-only, takes no parameters.

Inputs: no named parameters. Returns: queries

list_schedulesList schedulesA
Read-only
Inspect

List the company's scheduled exports: the saved query each runs, its cron cadence and timezone, its destination (Google Sheets tab or Slack channel), whether it is enabled, its last and next run, and the last error. Check here before create_schedule, since a saved query can have only one schedule, and to find the id for run_schedule_now. Read-only, takes no parameters.

Inputs: no named parameters. Returns: schedules

request_guard_editAsk to change GuardAInspect

Ask an admin to let you read and change Guard settings (AI tool access, approvals, limits, access rules, groups and policies) for 12 hours. Call it when a Guard tool failed with GUARD_APPROVAL_REQUIRED and the user wants the change. Say in reason what you want to change. Show the user the approvalUrl from the result and wait until they say it is approved; calling again then returns the approval with state active. Asking again while a request waits returns the same request.

Inputs: reason (required). Returns: message, request

run_saved_queryRun saved queryA
Read-only
Inspect

Run a saved query from the team library by id and return its rows, in the same shape as execute_query. Prefer it over execute_query whenever list_queries has a query that answers the question: the saved SQL runs unchanged on the query's own connection, and you pass only the values for its {{variables}}, never SQL. On an approved_queries connection it is the only way to get data, and only queries shared with the team (isShared true) may run. Call get_query first to see which variables it declares, their types and which are required. Values are type-checked and escaped server side; if any value is missing or invalid, nothing runs and the error names each variable and what is wrong with it. Read-only: the filled-in SQL must be a single SELECT, WITH or EXPLAIN. A repeated identical run may return a result cached for up to 5 minutes unless refresh is true. Counts against the company's monthly query quota and a limit of 30 queries per minute (the team can set a lower one per connection). Needs the execute scope; works for viewers too. Fails if the saved query has no connection or its connection is paused. The team can require a person to approve some requests: the call then fails with code APPROVAL_REQUIRED and an approvalUrl. Show the user that link, wait until they say it is approved, then repeat the exact same call with approvalId. An approval works once, for that SQL, within 30 minutes.

Inputs: id (required), limit, values, refresh, +2 more. Returns: result, success

run_schedule_nowRun schedule nowA
Destructive
Inspect

Run an existing schedule once, now, and deliver the result to its configured destination exactly as the next scheduled run would: it overwrites the schedule's Google Sheets range or posts to its Slack channel. Use it to test a schedule right after create_schedule, or when someone needs fresh data before the next run. A successful run also clears a failing schedule's retry backoff, so use it to confirm a fix when list_schedules shows a lastError. Does not change the cadence. Returns the spreadsheet URL and written range, or whether the Slack message was delivered. Needs the execute scope and a member role that can edit.

Inputs: id (required). Returns: success, writtenRange, slackDelivered, spreadsheetUrl

save_access_rulesSave access rulesA
Destructive
Inspect

Create a group's access rules on a connection (pass connectionId and groupId, or groupId null for everyone else), or replace an existing rule set's rules (pass id from list_access_rules). Send the complete rules: this replaces them rather than merging. Also needs the execute scope. Guard decides what AI tools, including you, may do on the team's databases, so change it only when the user asked for this exact change, and say what will change first. Needs an admin, the write scope, and an admin's approval in SaturnSQL for this AI tool: without it the call fails with code GUARD_APPROVAL_REQUIRED. Then call request_guard_edit, show the user the approvalUrl, and repeat the call after they approve. An approval lasts 12 hours; call end_guard_edit when the user's changes are done. Every change is recorded in SaturnSQL with the user's name.

Inputs: tables (required), rowFilters (required), tableAccess (required), hiddenColumns (required), +4 more.

save_groupSave groupA
Destructive
Inspect

Create a group of people for access rules, or rename one (pass id from get_guard). Guard decides what AI tools, including you, may do on the team's databases, so change it only when the user asked for this exact change, and say what will change first. Needs an admin, the write scope, and an admin's approval in SaturnSQL for this AI tool: without it the call fails with code GUARD_APPROVAL_REQUIRED. Then call request_guard_edit, show the user the approvalUrl, and repeat the call after they approve. An approval lasts 12 hours; call end_guard_edit when the user's changes are done. Every change is recorded in SaturnSQL with the user's name.

Inputs: name (required), id.

save_policySave policyA
Destructive
Inspect

Create a plain-language policy for AI queries, such as "salaries only in aggregate", or replace one (pass id from get_guard). connectionId null applies it to every connection; action is block or ask_admin. Guard decides what AI tools, including you, may do on the team's databases, so change it only when the user asked for this exact change, and say what will change first. Needs an admin, the write scope, and an admin's approval in SaturnSQL for this AI tool: without it the call fails with code GUARD_APPROVAL_REQUIRED. Then call request_guard_edit, show the user the approvalUrl, and repeat the call after they approve. An approval lasts 12 hours; call end_guard_edit when the user's changes are done. Every change is recorded in SaturnSQL with the user's name.

Inputs: text (required), id, action, enabled, +1 more.

save_querySave queryA
Destructive
Inspect

Save SQL to the query library, or overwrite one of your own saved queries by passing its id. Use it when the user wants to keep, reuse or schedule a query; pass the returned id to run_saved_query or create_schedule. Does not run the SQL, so test it with execute_query first. A new query is private to you until shared in the app; on an approved_queries connection it is a draft that cannot run until a person shares it, and the SQL of a shared query there cannot be changed. Passing an id replaces that query's name, SQL, connection and folder; you can only update queries you created. Needs the write scope, plus execute to change the SQL of a scheduled query.

Inputs: sql (required), name (required), id, folderPath, +1 more. Returns: id, sql, name, isShared, +4 more

set_ai_accessSet AI tool accessA
DestructiveIdempotent
Inspect

Change what AI tools and API keys may do on one connection, which of their requests wait for a person's approval, and their limits. aiAccess: off, approved_queries (only the team's shared saved queries), read_only, or same_as_people. approvalMode: none, writes, writes_and_exports or all; approvalBy: user or admin. Omitted fields keep their value; a limit set to null goes back to the default. Also needs the execute scope. Guard decides what AI tools, including you, may do on the team's databases, so change it only when the user asked for this exact change, and say what will change first. Needs an admin, the write scope, and an admin's approval in SaturnSQL for this AI tool: without it the call fails with code GUARD_APPROVAL_REQUIRED. Then call request_guard_edit, show the user the approvalUrl, and repeat the call after they approve. An approval lasts 12 hours; call end_guard_edit when the user's changes are done. Every change is recorded in SaturnSQL with the user's name.

Inputs: connectionId (required), aiAccess, aiMaxRows, approvalBy, +4 more.

set_descriptionSet table or column descriptionA
DestructiveIdempotent
Inspect

Write the team's description and synonyms for one table, or one column when column is set, on a connection. AI tools then read it in get_schema and get_context in place of the database's own comment. Use it when the user explains what a table or column means, or asks you to document it. An empty description falls back to the database's comment; omitted fields keep their current value. The table and column must exist in get_schema. Changes what every AI tool and person on this connection reads, and is recorded in SaturnSQL with your name. Only make it when the user asked for it or confirmed it. Needs the write scope, the connection's owner or an admin, and a plan that includes Context.

Inputs: table (required), connectionId (required), column, synonyms, +1 more. Returns: table, column, synonyms, description

set_descriptionsSet many descriptionsA
DestructiveIdempotent
Inspect

Write the team's descriptions and synonyms for up to 200 tables and columns in one call, for example when the user asks you to document a whole table or schema. Each item works like set_description. All items are saved together, or none if a table or column does not exist in get_schema, and the error lists which. Show the user what you plan to write before calling it. Changes what every AI tool and person on this connection reads, and is recorded in SaturnSQL with your name. Only make it when the user asked for it or confirmed it. Needs the write scope, the connection's owner or an admin, and a plan that includes Context.

Inputs: items (required), connectionId (required). Returns: items

set_group_memberAdd or remove a group memberA
DestructiveIdempotent
Inspect

Add a person to a group, or remove them with member: false. Ids come from get_guard. Guard decides what AI tools, including you, may do on the team's databases, so change it only when the user asked for this exact change, and say what will change first. Needs an admin, the write scope, and an admin's approval in SaturnSQL for this AI tool: without it the call fails with code GUARD_APPROVAL_REQUIRED. Then call request_guard_edit, show the user the approvalUrl, and repeat the call after they approve. An approval lasts 12 hours; call end_guard_edit when the user's changes are done. Every change is recorded in SaturnSQL with the user's name.

Inputs: member (required), userId (required), groupId (required).

set_instructionsSet notes for AIA
DestructiveIdempotent
Inspect

Replace the connection's notes for AI: the guidance every AI tool receives from get_context, such as "Amounts are in cents" or "Use orders_v2, not orders". Call get_context first and send the full new text, since this replaces the notes rather than appending. An empty string clears them. Changes what every AI tool and person on this connection reads, and is recorded in SaturnSQL with your name. Only make it when the user asked for it or confirmed it. Needs the write scope, the connection's owner or an admin, and a plan that includes Context.

Inputs: connectionId (required), instructions (required). Returns: updatedAt, instructions

upsert_definitionSave definitionA
DestructiveIdempotent
Inspect

Create a business definition on a connection, such as "active customer", or replace the one with the same name (names match in any case). Give a plain-language description and, when there is one, the SQL that computes it in the connection's dialect. AI tools read definitions from get_context. Changes what every AI tool and person on this connection reads, and is recorded in SaturnSQL with your name. Only make it when the user asked for it or confirmed it. Needs the write scope, the connection's owner or an admin, and a plan that includes Context.

Inputs: name (required), connectionId (required), sql, description. Returns: id, sql, name, updatedAt, +1 more

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      C
      maintenance
      Enables AI assistants to query business databases directly via natural language, with enforced read-only access and secure query limits. Supports SQLite and PostgreSQL, and works with any OpenAI-compatible model.
      0
      ISC
    • A
      license
      Not graded
      quality
      D
      maintenance
      Enables natural language querying of SQL databases using AI, supporting multiple database types and automatic schema discovery.
      1
      MIT
    • F
      license
      Not graded
      quality
      B
      maintenance
      Enables AI clients to interact with PostgreSQL databases through natural language, translating requests into structured queries and returning results via a secure self-hosted server.
      -
    • F
      license
      Not graded
      quality
      A
      maintenance
      Enables LLM agents and AI applications to connect to and retrieve data from multiple database types such as PostgreSQL, MySQL, SQLite, BigQuery, Oracle, MS SQL, and Redshift through a unified API with schema normalization and query transformation.
      -
    Try in Browser

    Glama MCP Gateway

    Add one secure layer between your agents and this server.

    Resources