Skip to main content
Glama
singlestore-mcp-server

singlestore-mcp-server

by jonasliesas

Server Configuration

Describes the environment variables required to run the server.

NameRequiredDescriptionDefault
SINGLESTORE_URLNoAlternative to SINGLESTORE_HOST: user:password@host:port/database
SINGLESTORE_HOSTNoThe SingleStore host. Either this or SINGLESTORE_URL must be set.
SINGLESTORE_PORTNoThe SingleStore port. Defaults to 3306.3306
SINGLESTORE_USERNoThe SingleStore user. Defaults to root.root
SINGLESTORE_DATABASENoDefault database for queries.
SINGLESTORE_PASSWORDNoThe SingleStore password.
SINGLESTORE_SSL_DISABLEDNoSet to 'true' for a self-managed cluster without TLS configured.false

Instructions

Guidance the server publishes about itself, which clients place ahead of the tool catalog so the model reads it before choosing anything.

This server publishes no instructions, or was last inspected before Glama recorded them.

Capabilities

Features and capabilities supported by this server

Protocol revision2025-11-25

CapabilityDetails
tools
{
  "listChanged": false
}
prompts
{
  "listChanged": false
}
resources
{
  "subscribe": false,
  "listChanged": false
}
experimental
{}

Tools

Functions exposed to the LLM to take actions

NameDescription
pipeline_monitorA

Open an interactive monitor of SingleStore pipelines.

Shows every pipeline's state, source, latest batch and recent errors, with
buttons to start, stop and test pipelines and an auto-refresh. Use this
when the user wants to see or manage pipelines visually.

The result includes ``browser_url``, which opens this view full-window in
the user's browser: post it as a clickable link right under the app.

Args:
    database: Limit to one database. Omit to show pipelines in all databases.
pipeline_monitor_dataC

Refresh data for the Pipeline Monitor app.

pipeline_errorsC

Most recent errors for one pipeline, for the Pipeline Monitor app.

query_gridA

Run a read-only SQL query and show the results in an interactive grid.

Use this when the user wants to see, browse, sort, filter or export
(CSV) query results, or when a result is too large to read as text. The
user can also edit and re-run the query from the grid. You receive only
a summary with the first 20 rows; the user sees all fetched rows.

Only read-only statements are accepted: SELECT, WITH, SHOW, DESCRIBE,
DESC, EXPLAIN (one statement, no SELECT ... INTO). For writes, DDL or when
you just need a value for your own reasoning, use run_sql instead.

The result includes ``browser_url``, which opens this view full-window in
the user's browser: post it as a clickable link right under the app.

Args:
    sql: A single read-only statement.
    database: Database to run it against (defaults to the connection's
        configured database).
    max_rows: Maximum rows to fetch, 1-10000 (default 1000). The result
        is flagged as truncated when more rows exist.
query_grid_rowsB

Full rows of an earlier query_grid result, for the Query Results Grid app.

schema_explorerA

Open an interactive Schema Explorer for the SingleStore cluster.

Shows every database and its tables/views with storage type
(columnstore/rowstore/reference), row counts and sizes; for a selected
table it shows columns, shard key and sort key, the full CREATE TABLE DDL
and a 50-row data preview. The user can browse freely and ask follow-up
questions from the UI. Use this when the user wants to explore, browse or
understand the schema visually. For a plain list of tables or columns
inside your own reasoning, list_tables / describe_table are cheaper.

The result includes ``browser_url``, which opens this view full-window in
the user's browser: post it as a clickable link right under the app.

Args:
    database: Pre-select this database (case-sensitive). Omit to start at the database list.
    table: Pre-select this table or view in `database` (case-sensitive). Requires `database`.
schema_explorer_databasesA

List databases with table/view counts, for the Schema Explorer app.

schema_explorer_tablesB

Tables and views of one database with storage type, rows and size, for the Schema Explorer app.

schema_explorer_tableB

Columns, keys, DDL and stats of one table, for the Schema Explorer app.

schema_explorer_previewB

First rows of a table or view, for the Schema Explorer app.

schema_explorer_reshardA

Reshard simulation for the Distribution tab: how a table's rows would spread over the partitions with another shard key (columns), next to the current skew - nothing is changed. Uses the docs' query (GROUP BY the candidate key, then GROUP BY PARTITION_ID() on the leaves), which scans the whole table: the app runs it only on an explicit click. sample_rows: estimate from about that many rows (a random sample, scaled up).

schema_explorer_reshard_scriptA

"Change shard key…": a SQL script for a DBA (nothing runs). CREATE TABLE __reshard from the real SHOW CREATE TABLE with only the SHARD KEY replaced, INSERT … SELECT, a row-count and skew check, the rename swap and a commented-out DROP of the old table, with warnings filled in for this table (size, pipelines, views, grants, duration). Read-only (logic and docs in ..reshard).

Args:
    database: Database (case-sensitive).
    table: Table (case-sensitive).
    columns: The new shard key's columns, as the table spells them.
    simulation: The simulation result's numbers (rsd_pct, current_rsd_pct, elapsed_ms, fraction,
        partition_count) for the header and the duration estimate; optional.
schema_explorer_skewA

Data skew, for the Schema Explorer's Distribution tab / database "Check skew": rows and data per partition and per leaf, skew % (relative standard deviation and (max - avg) / avg), the largest partitions, the shard key and a plain explanation. Read-only (TABLE_STATISTICS, COLUMNAR_SEGMENTS).

Args:
    database: Database (case-sensitive).
    table: One table (case-sensitive); omit for every table of the database.
cleanup_work_tablesA

Open the Schema Explorer's Clean-up panel for leftover SAS work tables.

SAS jobs leave work tables behind in SingleStore (SAS Data Management
``_dm…`` tables, SAS flow ``_flw…`` tables, ``SASTMP…`` / ``_tmp…``). The
panel scans every non-system database by name pattern (editable, and
optionally every table older than N days) and shows per table its rows,
size, creator, age, last use in the query history and dependent views.
The user selects tables, confirms, and they are dropped one by one (with a
dry-run mode and a log). Nothing is dropped by this call; only the user
can drop from the panel. Use this when the user wants to find or clean up
leftover, temporary or SAS work tables.

The result includes ``browser_url``, which opens this view full-window in
the user's browser: post it as a clickable link right under the app.
schema_explorer_cleanup_scanA

Find leftover work tables by name pattern (and age), for the Schema Explorer's Clean-up panel.

Args:
    patterns: [{"pattern": "_dm*", "kind": "SAS DM"}, ...]; shell-style, case-insensitive. Omit for the saved ones.
    older_than_days: Also offer every table not created/altered for this many days.
    recent_days: Tables used or created this recently are flagged as risky.
    save: Store these settings in ~/.singlestore-mcp/cleanup.json.
schema_explorer_cleanup_settingsC

Read (or change the dry-run default of) the Clean-up settings, plus recent log entries.

schema_explorer_cleanup_dropA

Drop the selected work tables one statement at a time (DROP TABLE IF EXISTS), for the Clean-up panel.

Re-checks each table on the server; system databases are refused and a table
with a dependent view is skipped unless that view is listed in ``views``
(it is then dropped first). With ``dry_run`` only the statements are returned.

Args:
    tables: [{"database": "SASDP", "name": "_dmallchars"}, ...]
    views: Dependent views to drop as well, same shape.
    dry_run: Only show the statements; drop nothing.
schema_explorer_analyze_planA

Read-only plan for ANALYZE TABLE: per base table its statistics (age, outdated / missing columns, row-count drift), whether they look stale and why, and the exact statements. Runs nothing.

Args:
    database: Database (case-sensitive).
    tables: Tables to include (case-sensitive). Omit for every base table in the database.
schema_explorer_analyzeA

Run ANALYZE TABLE on the given tables, one statement per table, and report each result.

Refuses unless ``confirm`` is true: call it only after the user saw the plan
(schema_explorer_analyze_plan) and explicitly confirmed. At most 10 tables per call.

Args:
    database: Database (case-sensitive).
    tables: Base tables to analyze (case-sensitive), at most 10.
    confirm: Must be true: the user's explicit confirmation.
cluster_monitorA

Open a live monitor of the SingleStore cluster.

Shows every node (aggregators and leaves) with CPU, memory and disk
usage, and the queries running right now, with auto-refresh. Use this
when the user wants to see cluster load, resource usage or what is
running.

The result includes ``browser_url``, which opens this view full-window in
the user's browser: post it as a clickable link right under the app.
cluster_monitor_dataC

Refresh data (including CPU history) for the Cluster Monitor app.

cluster_monitor_diskA

Disk use per node by type (columnstore, logs, snapshots, plan cache, ...), per mount, and the largest databases / tables.

Args:
    force: Measure the SingleStore directories again now (otherwise a measurement up to a minute old is reused).
cluster_monitor_bottomlessA

Traffic to and from remote (object) storage per node and database, for the Cluster Monitor's Bottomless tab.

cluster_monitor_ioB

Blob cache IO over the session and the statements that waited most on the blob cache, for the IO tab.

cluster_monitor_remote_statsA

Bytes each bottomless database keeps in remote storage (MV_BOTTOMLESS_REMOTE_STATS queries object storage: on demand only).

cluster_monitor_healthA

Cluster health for the Cluster Monitor's Health tab: node and availability-group state, partition health per database (masters / replicas, offline, unrecoverable, orphans), replication lag, recent cluster events (MV_EVENTS), license and version, with the problems listed worst first and a plain explanation each.

cluster_monitor_backupsA

Backup overview for the Cluster Monitor's Backups tab: per database the last successful backup and its age, failed backups, sizes and durations (MV_BACKUP_HISTORY) and backups running now (MV_BACKUP_STATUS). Read-only.

Args:
    warn_days: Flag databases whose last successful backup is older than this many days.
cluster_monitor_historyA

Stored per-node metrics (CPU, memory, disk, queued and running queries, connections) for the History tab.

Args:
    range: "1h", "24h" or "7d".
    sample_now: Take one sample now first (otherwise only the local store is read; no cluster query).
app_pageA

HTML of one of this server's app pages (the workspace loads its views with this).

Tool results aren't cached by hosts, unlike resources/read, so views pick
up changes right after restart_server.

``head``: the caller's shared-head hash (its ``s2-head`` meta); when it matches,
the page comes without the shared head (``head_omitted``; the caller puts its own
copy in at SHARED_HEAD_MARKER). ``build``: the build the caller already has; when
it matches, only ``unchanged`` comes back. ``vendors``: vendor blocks the caller
already has (name -> data-s2-hash, e.g. CodeMirror from the SQL Editor's page);
matching ones are left out (``vendors_omitted``; the caller puts its copy in at
each VENDOR_HAVE_MARKER).
sql_editorA

Open the SingleStore workspace: an interactive SQL editor plus views.

A slim rail on the left switches between the SQL Editor (schema tree,
editor with autocomplete for keywords, SingleStore functions, databases,
tables and columns, and a results pane), the Schema Explorer, the Pipeline
Monitor and the Cluster Monitor. Use this when the user wants to write,
edit or run SQL themselves, or wants the combined workspace. To run a
query for your own reasoning use run_sql; to show results use query_grid.
The editor has a chat panel: questions from it arrive in the conversation
tagged "[SQL Editor <id>]"; answer those with sql_editor_reply.

The editor has tabs; `sql` goes into the active tab, below the user's
text (or into a new tab with new_tab=true).

The result includes ``browser_url``, which opens this view full-window in
the user's browser: post it as a clickable link right under the app.

Args:
    database: Database to start in (case-sensitive).
    sql: SQL to put in the editor (not run automatically).
    view: View to show first: "sql" (default), "notebook", "schema", "pipelines", "cluster", "history" (Query History), "alerts", "workload" or "connections".
    table: For view="schema": table to pre-select in `database`.
    new_tab: With `sql`: open it in a new editor tab instead of the active one.
sql_editor_queryA

Run a read-only statement from the SQL Editor app, streaming its result.

Returns as soon as the first ``max_rows`` rows (the first page) are in, or the result is complete; the
rest keeps loading on the server (up to SINGLESTORE_MCP_EDITOR_MAX_ROWS, default 100,000 rows) and the
app pages through it with sql_editor_rows (``done`` / ``loaded`` give the progress and the total).
``stream_id`` is chosen by the app, so its Stop (sql_editor_stop) works before this call returns;
``replaces``: the tab's previous result, dropped. Statements that change data or schema are answered
with ``needs_confirmation`` instead of running; the app then asks the user and uses
sql_editor_execute. Every run lands in the editor's history (when it has finished), with the tab
(``tab_id``, its label ``tab``) and open ``file`` it ran from.
sql_editor_rowsA

More rows of a streamed SQL Editor result (from sql_editor_query), from offset, plus its progress.

At most ``limit`` rows and about 2 MB per call. ``wait_ms``: wait up to this long for rows past
``offset`` (or the end) while the result is still loading, instead of polling.
sql_editor_stopA

Stop a SQL Editor query that is still running or loading rows (KILL QUERY on its own connection, after checking it still runs this statement). The rows read so far stay.

sql_editor_classifyA

Which of these statements need the user's confirmation (change data or schema), for "Run all".

Same check as sql_editor_query, without running anything.
sql_editor_executeA

Run any single statement the user confirmed in the SQL Editor app (writes and DDL included).

Streamed like sql_editor_query: returns the first ``max_rows`` rows of a statement that returns rows (or
the affected-rows count) and the rest pages through sql_editor_rows; ``stream_id`` / Stop as there. The
statement is sent once (never retried after a dropped connection).
files_browseA

List a folder for the file browser: subfolders and .sql / .sas (kind="sql") or .ipynb (kind="notebook") files.

``path`` defaults to the SQL folder. Only folders inside the allowed roots
(the user's home folder, the SQL folder, SINGLESTORE_MCP_FILE_ROOTS) can be browsed.
sql_editor_filesB

The .sql files in the SQL Editor's folder, newest first.

sql_editor_open_fileA

Read one .sql file from the SQL Editor's folder, or a file on SAS Viya.

``name``: a local file (relative to the SQL folder, or absolute), or a SAS Viya file ref
(``sas-content://<connection>/<path>`` or ``sas-server://<connection>/<path>``, see viya_files_browse);
a Viya file's result has its ``version`` (ETag), which sql_editor_save_file checks before overwriting.
``remember`` puts it on the Recent list (false when the editor only
re-reads its open file to compare it with the restored draft).
sql_editor_save_fileB

Save the editor's SQL as a .sql file in the SQL Editor's folder, or to a file on SAS Viya.

An existing file is only replaced with ``overwrite``; otherwise the result
says ``exists`` so the app can ask first.

SAS Viya files (``name`` a ``sas-content://`` / ``sas-server://`` ref): ``expected_version`` is the version
(ETag) the editor opened; when the file on Viya is newer the result says ``conflict`` (nothing written) and
the app asks before saving with ``overwrite``. A ref of another SAS Viya connection than the active one
answers ``connection_mismatch``; ``use_active`` saves it to the same path on the active connection.
viya_files_browseA

List a folder on SAS Viya for the SQL Editor's Open / Save as: subfolders and .sql / .sas files (kind="notebook": .ipynb, for the Notebook; show_all: every file) with size and modified time.

``location``: "content" (SAS Content; starts in My Folder, shortcuts Public and all folders) or "server" (the
SAS Compute server's file system, in the Workspace's SAS session; starts in the first lockdown path, else the
session's home). Each file has ``ref``, the name sql_editor_open_file / _save_file take.
viya_files_mkdirC

Create a folder name in parent on SAS Viya ("content" or "server"), for Save as.

viya_files_connectionB

The active SAS Viya connection (files on Viya belong to one), without signing in or starting a session.

sql_editor_stateB

One SQL Editor tab's saved draft (the active tab's by default), recent files and history size, for restoring it.

sql_editor_save_draftA

Autosave one SQL Editor tab's text, database and cursor (never writes the open .sql file itself).

``file_version``: for a file on SAS Viya, the version (ETag) the editor opened or last saved, so Save after
a restart still notices a newer version on the server.

``saved_hash`` is the editor's hash of the open file's last saved text, so a
restored draft knows whether it has unsaved changes; ``dirty`` says so for
the tab bar. ``origin``: the workload statement the tab was opened from
(``{"workload", "statement_id", "statement_name"}``), for "Update in workload".
``language``: what the tab runs as (singlestore, procsql, fedsql, cas); ``sas``: its SAS library / caslib
and PROC SQL options (outobs, noexec, feedback, pushdown).
``closed`` in the result: the tab was closed (elsewhere) and the text wasn't kept.
sql_editor_tabsB

The SQL Editor's tabs in order, each with its open file and unsaved-changes flag, and the active tab.

sql_editor_tab_newA

Open a new, empty SQL Editor tab right after the tab after (else at the end) and make it active.

sql_editor_tab_closeA

Close a SQL Editor tab and drop its draft (the open .sql file is untouched); the last tab is replaced by an empty one.

sql_editor_tab_activateB

Remember which SQL Editor tab is active (it's the one that opens next time).

sql_editor_tab_renameA

Give a SQL Editor tab its own title; an empty title goes back to the file name or "untitled N".

sql_editor_tab_reorderC

Put the SQL Editor tabs in this order (tab ids).

sql_editor_historyA

The SQL Editor's run history, newest first (SQL cut to a preview; full text with sql_editor_history_entry).

sql_editor_history_entryC

One statement from the SQL Editor's run history, with its full SQL.

sql_editor_history_clearB

Empty the SQL Editor's run history.

sql_editor_inboxB

Replies sent to one SQL Editor's chat panel, newer than after.

sql_editor_assistantC

Whether the SQL Editor can answer questions in the app (Claude Code installed).

sql_editor_askB

Answer a SQL Editor chat question in the app; the reply arrives in the editor's inbox.

``profile`` picks speed vs depth: "fast", "balanced" (default) or "thorough". ``language``: what the tab runs
as (singlestore, procsql, fedsql, cas). For a SAS tab, ``sas`` is its context: ``library`` (library or caslib),
``library_info`` ({name, engine/type, database, singlestore, singlestore_kind}), ``tables`` (names, or
{name, loaded}), ``columns`` ({"LIB.TABLE": [{name, type, length, format}]}) and ``options``; the question then
carries the SAS guide of that language (once per Claude session and language).
sql_editor_sas_functionsA

The SAS function matrix for the editor's pre-run check: per function (as called in SQL) whether PROC SQL, FedSQL and FedSQL in CAS support it and push it down to SingleStore, its SingleStore equivalent and what to use instead (data/sas_functions.json).

sql_editor_assistant_warmA

Start the editor's assistant process ahead of the first question (no model call).

sql_editor_ask_cancelB

Stop the in-app answer that is running for one SQL Editor.

sql_editor_schemaB

Tables, columns and routines of one database, for the SQL Editor's tree and autocomplete.

presenter_labelsB

Presenter mode: the neutral stand-in of every identifying value known so far (connection names, hosts, user names, SAS Viya addresses), after adding values ([{value, kind}], kind connection / host / viya / user). The same value always gets the same label while this server runs.

connection_healthA

Whether SingleStore and SAS Viya were reachable on the last calls (in memory: no round trip on the caller's thread). probe: "down" checks the services that are down again in the background (at most every few seconds), "all" (the page came back online) every service used so far, "none" nothing. notices: one-time messages with an id above after_notice (e.g. a SAS session restarted after a connection loss).

notebookA

Open a SingleStore notebook: SQL and Python cells on a Jupyter kernel.

SQL cell results become pandas DataFrames for the Python cells; Python has
pandas, matplotlib and `conn` (a SingleStore connection). Notebooks are
.ipynb files in the user's SQL folder. It's also the Notebook view of the
SingleStore Workspace (sql_editor with view="notebook").

The result includes ``browser_url``: post it as a clickable link under the app.

Args:
    name: Notebook file to open (e.g. "sales.ipynb", or a SAS Viya ref "sas-content://<connection>/<path>");
        omit for a new notebook.
    database: Database for SQL cells (case-sensitive).
notebook_environmentB

Status of the notebook Python environment (and install progress).

notebook_environment_installA

Create the notebook Python environment (ipykernel, pandas, matplotlib, singlestoredb) with uv.

notebook_packagesB

Packages installed in the notebook Python environment (name, version, summary, core).

notebook_packages_installB

Install packages (space-separated names with optional version pins) into the notebook environment.

notebook_kernel_startA

Start the notebook's Python kernel ahead of the first cell (no code runs).

notebook_kernel_stateB

The notebook kernel's state: stopped, starting, idle, busy, error or dead.

notebook_kernel_controlB

Interrupt, restart or shut down the notebook's kernel (action: interrupt | restart | shutdown).

notebook_runA

Run one notebook cell in its kernel; returns a run id to poll with notebook_poll.

cell_type "sql": a SingleStore statement whose result becomes a DataFrame
(``df``, and ``name`` if given). Statements that change data or schema
come back with ``needs_confirmation`` unless ``confirmed``.
cell_type "python": Python code, run as-is.
cell_type "sas": SAS code through saspy in the kernel's own SAS session (kept for older callers; the app runs
SAS cells with notebook_sas_cell in the Workspace's SAS session).
notebook_pollB

New output of a running (or finished) cell since output index after.

notebook_sas_pythonA

Run a "Python in SAS" cell: the code as PROC PYTHON in the Workspace's SAS Compute session of the SAS Viya connection (default: the active one) - the SQL Editor's session, queue, pre-warm and Stop (sas_stop), so Python variables persist between cells and WORK tables are the session's; Restart SAS session (sas_session_reset) clears both. Doesn't need a local kernel. Code containing "endsubmit" is refused.

``run_id`` (chosen by the app, so Stop works at once) names the run; ``wait_ms``: how long to wait for the
result (default: until done); a run still going answers ``running`` (``python_started`` false: Python
still has to start in the session, ~8 s) and the app asks again with notebook_sas_python_status. Done:
``outputs`` (nbformat: stdout, the SAS log / ODS output, a Python exception) and ``status`` ok / error /
aborted.
notebook_sas_cellA

Run a SAS cell (DATA steps, PROCs, macro code) in the Workspace's SAS Compute session of the SAS Viya connection (default: the active one) - the session, queue, pre-warm and Stop (sas_stop) of the SQL Editor's SAS runs and the Python in SAS cells, so WORK tables and macro variables are shared with them; Restart SAS session (sas_session_reset) clears them. Doesn't need a local kernel. The automatic SingleStore library (S2) is the session's (the active SingleStore connection's database); database: the notebook's, only named in the note.

``run_id`` / ``wait_ms`` / ``running`` as notebook_sas_python (ask again with notebook_sas_python_status). Done:
``outputs`` (the notebook's SAS output: error / warning counts, ODS output, the log) and ``status`` ok / error /
aborted.
notebook_sas_python_statusB

A running Python in SAS cell (notebook_sas_python) or SAS cell (notebook_sas_cell): its outputs once done (waits up to wait_ms, at most 25 s), else its status.

notebook_filesB

The .ipynb notebooks in the SQL folder, newest first.

notebook_openA

Read one .ipynb notebook from the SQL folder, or from SAS Viya by its ref (sas-content://<connection>/… or sas-server://…, see viya_files_browse with kind="notebook"); a Viya notebook's version (ETag) is what notebook_save checks before overwriting.

notebook_saveA

Save a notebook (nbformat 4 JSON) as a .ipynb file in the SQL folder, or on SAS Viya by its ref.

SAS Viya (``name`` a ``sas-content://`` / ``sas-server://`` ref; SAS Content stores it as
``application/x-ipynb+json``): ``expected_version`` is the version the notebook opened; a newer one on Viya
answers ``conflict`` (nothing written), an existing file on Save as ``exists``, a ref of another connection
``connection_mismatch`` (``use_active`` saves it to the same path on the active connection) - as the SQL
Editor's Save does.
notebook_askA

Ask the in-app assistant about the notebook; the reply arrives in the notebook's inbox (sql_editor_inbox).

notebook_assistant_warmA

Start the notebook's assistant process ahead of the first question (no model call).

connections_windowA

Open the Connections window: add, edit, test and switch between saved SingleStore connections.

It's also the Connections view of the SingleStore Workspace. The result
includes ``browser_url``: post it as a clickable link under the app.
connections_stateB

Saved connections, the active one and where passwords are stored.

connection_saveB

Create or update a saved connection. password None keeps the stored one; "" removes it.

connection_deleteA

Delete a saved connection and its stored password.

connection_testC

Try a connection: a saved one by name, or the settings from the form.

connection_activateA

Make a saved connection the active one, and test it (token connections may need a sign-in first).

connection_sso_sign_inA

Browser sign-in for SSO connections (Helios or Microsoft Entra ID): open the sign-in page in the user's browser and wait for the token (up to 2 min).

sas_connections_stateB

Saved SAS Viya connections, the active one and each one's sign-in (from the stored token; no network).

sas_connection_saveB

Create or update a saved SAS Viya connection (name, Viya address, compute context, client ID, certificate check, SingleStore libref, CAS server, startup code). activate also makes it the active one.

sas_connection_deleteB

Delete a saved SAS Viya connection and its sign-in.

sas_connection_activateA

Make a saved SAS Viya connection the active one: the Workspace's SAS views and new notebook kernels use it. Each connection has its own SAS sessions, so nothing is restarted (SQL Editor tabs pinned to the other connection keep theirs).

sas_viya_stateB

Settings and sign-in status of a SAS Viya connection (default: the active one).

sas_viya_saveB

Update the active SAS Viya connection with the settings given (others stay; an empty address never blanks the saved one). Without any connection, an address creates one.

sas_viya_sign_inA

Sign in to a saved SAS Viya connection (default: the active one). Without code: open SAS Logon in the browser. With code: finish signing in with the code SAS Logon shows. Saves no settings.

sas_viya_sign_outC

Forget the sign-in of a SAS Viya connection (default: the active one).

sas_viya_testA

Check a SAS Viya connection's sign-in and compute context (lists the compute contexts; starts no SAS session). Reuses the SAS Viya MCP server's or CLI's sign-in to the same Viya if there's no own one.

connection_helios_caA

Download SingleStore's CA bundle (needed for Helios / TLS) to ~/.singlestore-mcp once; returns its path.

browser_reset_linksA

Give the browser view a new secret token: every open browser tab and every browser link made before stops working (the tab shows "Session ended"). Restarts keep the token; this is the way to change it.

query_historyA

Open the Query History: every finished query on the cluster with its runtime, user, database and result, filtered by minimum runtime (1 s and up). Select a query in the app for tuning recommendations.

Uses SingleStore's query history (event tracing, information_schema.MV_TRACE_EVENTS). Use this when the
user asks about slow / long-running queries or jobs over time (the Cluster Monitor shows only what's
running now).

Args:
    min_seconds: Only queries that ran at least this long (minimum 1).
    hours: Only the last N hours (default: everything in the history).
    tab: "queries" (default), "trends" (daily / hourly load, failures and p95 from a local copy of the history
        kept across the cluster's ring buffer, plus queries that got slower), "usage" (most used tables and
        most active users) or "advisor" (table-design advice from the whole history).

The result includes ``browser_url``: post it as a clickable link right under the app.
query_history_dataC

Refresh the Query History list.

query_history_eventB

One query from the history with its full SQL and details.

query_history_tuningB

Tuning recommendations for one query from the history (EXPLAIN, plan cache statistics, table design).

query_history_plan_tuningB

Tuning recommendations for a statement known only from the plan cache (its totals and cached plan).

query_history_profileA

PROFILE one read-only query (SELECT / WITH) from the history: runs it once more and returns the operator tree with actual rows, time, memory, spilling and segments skipped (SHOW PROFILE JSON).

query_history_usageB

Most used tables and most active users over the last days (0: everything stored), from the local copy of the query history (traced runs) and of the plan cache (every execution, no user).

query_history_advisorB

Table-design advice from the whole query history: sort keys, shard keys, reference tables, indexes, statistics, plus workload findings. EXPLAINs every distinct query (without running it).

query_advisor_reportB

Recommend table design changes from the whole query history: SORT KEY and SHARD KEY per table, REFERENCE table candidates, indexes and missing statistics, plus workload issues (huge results, SELECT *, failures).

Every distinct query in the history is EXPLAINed (compiled, not run) to see which columns it filters,
joins and groups on, weighted by how long those queries ran. Opens the Query History app on its Advisor tab.

The result includes ``browser_url``: post it as a clickable link right under the app.
query_history_assistantC

Whether Claude can answer in the app (Claude Code installed).

query_history_askB

Ask Claude, in the app, how to tune one query from the history; poll query_history_answer for the reply.

query_history_answerC

Claude's in-app answer for one query (or its progress while it works).

query_history_ask_cancelC

Stop Claude's in-app answer for one query.

query_history_assistant_warmA

Start the screen's Claude process ahead of the first question (no model call).

alertsA

Open the Alerts view: alerts the server raised while watching the SingleStore cluster in the background (queries running too long, slow or failed queries, failed pipeline batches / pipeline errors, node memory and disk thresholds, nodes not online, disk / memory projected full from the History trend), with the rules to edit and acknowledge / clear buttons.

The result includes ``browser_url``: post it as a clickable link right under the app.
alerts_dataB

Alerts, rules and checker status for the Alerts view (no cluster queries).

alerts_badgeA

Unacknowledged alert count for the workspace rail (in-memory state only; cheap to poll).

alerts_updateB

Change alert rules ({name: {enabled, seconds, percent, days}}) and settings ({interval_s, notify}).

alerts_ackB

Acknowledge alerts by id, or all of them.

alerts_clearB

Remove alerts from the list (all, or only the acknowledged ones).

alerts_check_nowA

Run every enabled check now (read-only queries) and return the new state.

query_history_trendsB

Daily / hourly query counts, runtime, failures and p95 from the local copy of the history, plus query shapes that got slower than the week before.

query_history_trend_runsB

The queries behind one Trends bar (a day "YYYY-MM-DD" or an hour "YYYY-MM-DD HH"), slowest first.

query_history_compare_candidatesB

The heaviest read-only queries in the history that read table (database.table), with the table name replaced by new_table (nothing is run).

query_history_compare_startB

Run the selected candidate queries against the original and the new table (wrapped in COUNT(*)), alternating, runs times each. Poll query_history_compare_status.

query_history_compare_statusC

Progress and results of a before/after comparison.

query_history_compare_cancelC

Stop a running comparison (the statement running now is cancelled too).

workloadB

Open the Workload view: define test workloads (SQL statements, each with how often it runs per minute), run them against the cluster with N connections for a set time, watch throughput and latency live, and compare two runs statement by statement (e.g. before and after a new sort key or index).

Args:
    name: Workload to select (optional).

The result includes ``browser_url``: post it as a clickable link right under the app.
workload_runA

Start a run of a saved workload (one run at a time). Returns the run id; follow it with workload_status and compare runs with workload_compare. Give runs a label such as "baseline" or "after sort key".

Args:
    name: The workload.
    label: A short label for this run.
    duration_s: Override the workload's duration for this run.
    concurrency: Override the number of connections for this run.
workload_compareA

Compare two runs of a workload statement by statement: p50 / p95 before and after, change in percent, throughput, errors, and whether the SQL or the row counts changed. Use it to check a tuning change: run a baseline, change the table (sort key, shard key, index ...), run again, compare.

workload_overviewB

Workloads, recent runs and the running one, for the Workload view.

workload_saveC

Save a workload from the Workload view (create, replace or rename).

workload_deleteB

Delete a saved workload (and optionally its saved runs).

workload_delete_runC

Delete one saved run.

workload_from_historyB

The heaviest read-only queries of the last hours from the query history, as workload statements (runs per minute = how often they ran). Nothing is saved or run.

workload_test_statementA

Run one statement once (placeholders filled in) to check it: time, rows or the error. Read-only statements only; others are only checked for placeholders.

workload_parse_statementsC

Workload statements from SQL texts (the SQL Editor's "→ Workload", the chat's "Add to workload"): leading -- name: / -- per_minute: hint lines name a statement and set its rate (else per_minute).

workload_handoff_putC

Keep statements for a Workload page about to open in the browser (target workload or a new one's name); returns the id to put in its link as handoff.

workload_handoff_takeC

The statements kept by workload_handoff_put (once: they are then removed).

workload_update_statementB

Write SQL edited in the SQL Editor back into one statement of a saved workload, and save the workload.

workload_chat_contextC

The context the Workload chat sends with a question (workload, last run, table definitions), as text of at most limit characters; for asking in the Claude chat instead of the in-app assistant.

workload_askB

Ask the in-app assistant about a workload (it may query the database read-only); the answer arrives in the chat's inbox (sql_editor_inbox with editor_id = chat_id).

workload_assistant_warmA

Start the Workload chat's assistant process ahead of the first question (no model call).

workload_tuneC

Tuning recommendations for one workload statement (EXPLAIN, table design), as for a query in the history.

securityA

Open the Security view of the SingleStore cluster (read-only).

Tabs: "users" (every user with type, lock status, password age and expiry, default resource pool, groups,
connections and risk flags such as ALL/SUPER on *.*, host '%', password never expires, locked, unused),
"roles" (user -> group -> role -> privileges, and "who can access" a database or table) and "pools"
(resource pool limits and live status, the workload manager queue with the limit each queued query waits
for, and which users use which pool). Nothing is changed: where a change would help, the view shows SQL
the user can copy.

The result includes ``browser_url``, which opens this view full-window in the user's browser: post it
as a clickable link right under the app.
who_can_accessA

Every user who has privileges on a database (or one table in it), and how they got them.

"How" is "direct" (granted to the user), "via role R ← group G" (user -> group -> role), on the database /
table itself or globally on *.*. Administrative global privileges that don't open data (CREATE USER,
PROCESS, ...) and USAGE are left out. Read-only. Opens the Security view on this lookup.

Args:
    database: Database name (exact).
    table: Optional table in that database.
user_privilegesA

Effective privileges of one SingleStore user with the reason for each (direct, or via role ← group), its groups and roles, resource pool grants, and SHOW GRANTS (password hash hidden). Read-only.

Args:
    user: User name.
    host: Host part ('%' etc.). Needed only when the name exists for several hosts.
resource_pool_statusA

Resource pools now: limits per pool, running / queued queries summed over nodes, the workload manager queue with the resource each queued query is waiting for (threads, connections or leaf memory), and the users whose default pool it is. Read-only. Opens the Security view on the Resource pools tab.

security_usersC

Users tab data for the Security view.

security_user_detailC

Effective privileges of one user, for the Users tab.

security_rolesB

Roles & groups tab data for the Security view.

security_whoC

Reverse lookup ("who can access") for the Roles & groups tab.

security_tablesC

Tables of one database, for the "who can access" picker.

security_poolsC

Resource pools tab data (with the per-pool history kept while the view refreshes).

security_admin_capabilitiesB

What the connected user may change in the Security view (and why not), plus the privilege and pool-setting lists for the pickers. Read-only.

security_change_planA

Read-only preview of one change: the exact statements (any password masked), warnings, blockers (lock-out, last admin, missing objects) and whether the user must type the object's name to confirm. Runs nothing. Works without the change privileges (allowed says whether the connected user may run it).

Args:
    action: {"action": one of create_user, drop_user, grant, revoke, revoke_all, create_role, drop_role,
        create_group, drop_group, grant_role, revoke_role, grant_group, revoke_group, create_pool, alter_pool,
        drop_pool, set_default_pool, grant_pool, revoke_pool, change_password, lock_user, unlock_user,
        set_login_policy, set_require, grant_view, plus its fields: user, host, role, group,
        grantee_type ("user"/"role"), privileges, database, table, with_grant_option, grant_option, pool,
        settings, default_pool, failed_login_attempts, password_lock_time (seconds; both 0 = off),
        require ("SSL"/"NONE"), columns and view (grant_view: a view with these columns of database.table,
        SELECT granted on it – 9.0 has no column-level grants)}. Never a password.
    pending: The changes already in the script basket (same shape), for a change that needs objects they
        create (the plan then says ``needs_script``).
security_change_scriptA

Read-only: one or more changes as a SQL script for review (e.g. by a DBA), instead of running them. The statements are what Run would execute, rebuilt from the cluster state now (each change checked as if the earlier ones had run), in a safe order (creates, grants, revokes, drops) unless keep_order, with a header (connection, connected user, time, one line per change) and each change's warnings as -- WARNING: comments. Runs nothing and needs none of the change privileges. Never takes or writes a password: CREATE USER and a password change get '<set password>' to fill in.

Args:
    actions: The changes, each the same object as for security_change_plan.
    keep_order: Keep the given order instead of the safe order.
security_change_applyA

Run one previewed change (users, roles, groups, grants, resource pools) on the cluster.

Refuses unless ``confirm`` is true: call it only after the user saw the plan (security_change_plan) and
explicitly confirmed. Where the plan asks for it (DROP, revoke all, the connected user or an admin user),
``typed_confirmation`` must be the name the user typed. The plan is rebuilt from fresh cluster state first,
and blockers (lock-out, last admin) refuse the change. ``password`` (create_user, change_password) is sent as a
bound parameter and never returned, logged or stored.

Args:
    action: The same action object as for security_change_plan.
    confirm: Must be true: the user's explicit confirmation.
    typed_confirmation: The object name the user typed, when the plan requires it.
    password: The new user's password (create_user) or the new password (change_password).
    update_connection: Changing your own password: after it succeeded, also save the new password for the
        active saved connection in the OS credential store.
security_columnsC

Columns of one table, for the column picker of "Grant columns (through a view)". Read-only.

security_viewsC

Views of a database (those that read table when given) with their creator, columns and the grants on them, for the "Grant columns (view)" form's list of column views and their "Drop view…". Read-only.

security_auditB

Audit tab data: audit log settings and how to turn audit logging on. Read-only.

cluster_configA

List SingleStore engine variables (configuration parameters) with their values per node, read-only.

Marks variables whose value differs from the documented default (defaults come from the docs page for the
cluster's version, downloaded once and kept locally) and variables whose value differs between nodes.
Opens the Config view; nothing is changed.

Args:
    search: Only variables whose name, description or category contains this text.
    changed_only: Only variables changed from the default or differing between nodes.

The result includes ``browser_url``, which opens this view full-window in the user's browser: post it
as a clickable link right under the app.
config_dataC

All engine variables for the Config view. fetch_docs downloads the docs reference when it isn't kept locally yet.

sas_sourcesB

Whether SAS Viya is set up and signed in (for the SAS libraries / caslibs sources); starts no session. connection: a saved SAS Viya connection (default: the active one).

sas_prewarmA

The Workspace's SAS session for a SAS Viya connection (default: the active one): with start, starts it in the background (Compute session with the automatic SingleStore library and the startup code, then CAS) so the first run doesn't wait, or checks a running one now and then (keep-alive); answers at once. Never asks to sign in: state is starting / ready / idle / off / not_signed_in / unreachable / error. Turned off per connection (Connections → SAS Viya → Edit) or with SINGLESTORE_MCP_SAS_PREWARM=0.

sas_librariesA

SAS libraries in the Workspace's SAS Compute session (compute context + startup code): engine, path and, for SAS/ACCESS to SingleStore (engine S2 / SSTORE), the SingleStore database. connection: a saved SAS Viya connection (default: the active one).

sas9_librariesA

SAS 9 libraries through SAS/CONNECT: signs on to the SAS 9 server from the Workspace's SAS session (the active Viya connection's "SAS 9 sign-on code", its log never shown) once, assigns the remote libraries (libname X server=… slibref=X) and lists them (engine REMOTE). refresh: sign on again.

sas_library_codeB

The LIBNAME statement for one SAS library, reconstructed from the session's dictionary.libnames (engine, path, database, user); passwords as placeholders (password="<set password>"), never real values.

cas_caslib_codeB

The CASLIB statement and the table.addCaslib action (PROC CAS) for one caslib, reconstructed from caslibInfo (verbose); passwords / tokens / authentication domains as placeholders. Nothing is run.

sas_tablesC

Tables (data sets and views) in one SAS library, with rows and columns where SAS knows them.

sas_columnsC

Columns of one SAS table: name, type, length, format, label.

cas_caslibsB

Caslibs on the CAS server: type, description, path and, for SingleStore caslibs, the database.

cas_tablesB

Tables in one caslib: the ones loaded in memory (rows, columns) and the source tables / files not loaded. database: for a SingleStore caslib, its database (only its tables are listed).

cas_load_infoA

Before "Load into this session": the caslib's kind (SpeedyStore: stays live in SingleStore; others: copied into CAS memory), the source table's size from table.fileInfo where CAS can tell, whether the load needs a second confirmation (a copy above SINGLESTORE_MCP_CAS_LOAD_CONFIRM_MB, default 100 MB, or of unknown size) and whether this session already has it. Nothing is loaded.

cas_load_tableA

"Load into this session": table.loadTable of a caslib's source table into the Workspace's CAS session of the SAS Viya connection - session scope only (never promoted, the caslib unchanged), so FedSQL in CAS can query it. where / columns (optional) narrow a copy (SpeedyStore caslibs ignore where). A big or unknown-size copy answers needs_confirmation unless confirmed. Answers where the table is now: live (SpeedyStore: queries run in SingleStore) or copied into CAS memory (memory bytes).

cas_unload_tableB

Unload a table this CAS session loaded (table.dropTable of the session table; the source is unchanged). A global (promoted) table is refused, never dropped.

cas_session_loadsB

Tables "Load into this session" loaded: loaded (in the current CAS session) and lost (loaded before the CAS session restarted - offer cas_reload_tables). Nothing is sent to CAS.

cas_reload_tablesB

Load the tables again that were loaded into the CAS session before it restarted (same where / columns; they were confirmed then). forget: don't reload, just stop offering it.

cas_columnsC

Columns of a CAS table, loaded or not (for a database caslib CAS asks the database).

sas_lookup_columnsA

Columns of up to 8 SAS tables ([{library, table}]) for the SQL Editor's autocomplete, in one call: SAS libraries for procsql / fedsql, caslibs for cas. A table that doesn't exist comes back with missing: true (not an error), so the editor can remember it briefly and not ask again.

sas_session_resetA

End the Workspace's SAS Compute and CAS sessions of a SAS Viya connection (default: the active one); the next run starts new ones (startup code runs again). Runs on it (also one a Stop couldn't end) are stopped.

sas_fedsql_checkB

Before a FedSQL run (nothing runs): does the SELECT have a subquery FedSQL would push down with the CREATE TABLE (fails on SingleStore libraries), and can the editor run it as a derived table instead? warn: it can't (an ORDER BY on expressions) - message says why and how to rewrite it.

sas_queryA

Run one statement from the SQL Editor as PROC SQL / FedSQL (SAS libraries) or FedSQL in CAS (caslibs).

``language``: procsql, fedsql or cas. The SQL is wrapped (proc sql; … quit; etc.); text starting with
proc / data / % runs as plain SAS code. Statements that write anywhere but WORK / CASUSER are answered with
``needs_confirmation`` (the app asks, then calls sas_execute). ``pushdown`` adds sastrace / the FedSQL plan
and returns what was sent to SingleStore with a verdict. ``history`` false: not recorded in the editor's
run history (the Schema Explorer's previews).

The run goes to the background: ``run_id`` (chosen by the app, so Stop works at once) names it,
``wait_ms`` is how long to wait for the result (default: until it's done); a run still going is answered
with ``running`` and its status (``waiting_for``: the run in another tab it waits for), and the app asks
again with sas_run_status. ``connection``: the SAS Viya connection (default: the active one).
``max_rows``: rows in the answer; ``table_rows``: rows PROC SQL keeps in the result table for paging
(sas_rows; default ``max_rows``).
sas_executeA

Run one SAS statement the user confirmed in the SQL Editor (writes outside WORK / CASUSER included). Same background run, Stop and paging as sas_query.

sas_run_statusA

A background SAS run (sas_query / sas_execute): its result once it's done (waits up to wait_ms, at most 25 s), else running with its state, how long it has run and, while it waits for the session, waiting_for (the run in another tab). After Stop: stopping, and cancel_failed when Viya didn't end it (offer Restart SAS session).

sas_stopB

Stop a SAS run from the SQL Editor: a waiting run doesn't start; a running one is cancelled on Viya (Compute: the job's state set to canceled; CAS: the session's running action cancelled). The SAS session keeps running. The run then ends "stopped" with the log so far (sas_run_status).

sas_rowsA

More rows of a SAS run's result (its result table in the SAS / CAS session), from offset. Works until the same tab runs something else (its result table is then replaced). Waits up to 15 s for a busy session.

sas_classifyC

For "Run all" in a SAS language: which statements need confirmation (write outside WORK / CASUSER).

sas_singlestore_logA

The SingleStore side of a SAS run: the statements the cluster's aggregators ran between started_at and ended_at (the run's epoch seconds), from MV_PLANCACHE - what SAS (PROC SQL, FedSQL, DATA step, CAS) really sent, whatever library it used. The plan cache keeps totals per plan, so rows and ms are per run on average; literals show as ^; another session's identical statement in the same seconds would show too.

sas_history_lookupC

Is this SQL (sent to SingleStore by SAS) in the cluster's plan cache or the local query history?

``plan``: the plan cache entry as a Query History plan-cache row (``key`` "plan:…", totals, parameterized
text), so the editor can open Query History on it when the statement isn't in its list (runs under the
trace threshold of 1 s only show in the plan cache).
files_renameA

Rename a file or folder on this computer in its folder (the file browser's Rename).

``path``: the item's full path (inside the folders the browser may use; never a root or shortcut folder);
``new_name``: a plain name (a file without an extension keeps its own); ``kind``: "sql" (.sql / .sas) or
"notebook" (.ipynb), the only files touched; ``expected_modified``: the modified time the browser listed
(``conflict`` if it changed). ``exists`` when the new name is taken. Open SQL Editor tabs follow the rename.
files_deleteB

Delete one file, or one empty folder, on this computer (the file browser's Delete; the app confirms first).

Same limits as files_rename; a folder that isn't empty answers ``not_empty`` and nothing is deleted. SQL Editor
tabs that had the file open keep its text as unsaved.
viya_files_renameA

Rename a file or folder on SAS Viya ("content" or "server", the active connection) in its folder.

Sends the item's version (ETag) as If-Match: a change meanwhile answers ``conflict``, as does a file whose
modified time differs from ``expected_modified``. Top-level folders, My Folder, the SAS server's home and
lockdown folders (and the folders above them) are refused. Open SQL Editor tabs follow the rename.
viya_files_deleteA

Delete one file, or one empty folder, on SAS Viya ("content" or "server"); the app confirms first.

Same checks as viya_files_rename (version / If-Match, protected folders); a folder that isn't empty answers
``not_empty``. SQL Editor tabs that had the file open keep its text as unsaved.
load_file_infoB

Whether "Load file into table" works here (not in server mode: the PC's disk isn't reachable), the size above which the server route (a pipeline) is recommended, and the file types listed.

load_file_browseB

List a folder on this computer for the Load file dialog: subfolders and data files (.csv .tsv .txt .tab .psv .dat). Same folders as the SQL Editor's file browser (user folder, SQL folder, SINGLESTORE_MCP_FILE_ROOTS).

load_file_previewA

Read the start of a data file on this computer for the Load file wizard (nothing is written).

Detects (or takes) the encoding, delimiter, quote ("" = none), header, null markers and decimal comma; returns the
first rows, the columns with suggested SingleStore types and date / time formats (``formats``: {column: format
name} overrides), the estimated row count, whether the file is over the size limit, and for ``database`` a CREATE
TABLE for ``table`` (default: from the file name) plus ``target`` (does the table exist; its column mapping).
load_file_targetA

Does database.table exist, and how do the file's columns ([{name, index, kind, format, source}], from load_file_preview) map onto it by name (mapping {table column: file column or null} overrides).

load_file_pipelineB

CREATE PIPELINE templates (S3 and Azure blob, credential placeholders) that load the file on the cluster's side instead of through this computer – for files above the size limit. Nothing is run.

load_file_startA

Load a file from this computer into a table – only after the user confirmed in the wizard (confirmed; above the size limit also confirmed_large, the second confirmation).

``mode`` "new" runs ``create_sql`` (one CREATE TABLE for ``database.table``) first, "append" adds to the existing
table. ``columns`` / ``width`` / ``options`` come from load_file_preview; ``expected_size`` is the file size the user
saw (a file that changed since is refused). Every row is checked first; bad rows stop the load before anything is
written unless ``skip_bad``. ``method``: "auto" (LOAD DATA LOCAL INFILE, else INSERTs), "local_infile" or "insert".
Runs in the background: follow it with load_file_status, stop it with load_file_cancel.
load_file_statusA

Progress of a file load (phase, rows, bytes, %, bad rows, result). wait_ms: wait up to this long (max 5 s) for it to finish before answering.

load_file_cancelC

Stop a file load: while checking nothing has been written; while loading the statement is aborted (LOAD DATA) or rolled back (INSERTs); a table the load created is removed again when it stayed empty.

run_sqlA

Run one arbitrary SQL statement against SingleStore and return the results.

Use this for SELECT/DML/DDL that isn't pipeline-specific. For creating,
altering, starting, stopping, dropping or inspecting Pipelines, prefer
the dedicated pipeline tools -- they validate the statement type and are
easier to call correctly.

Args:
    sql: The statement to execute.
    database: Database to run it against (defaults to the connection's
        configured database).
    max_rows: Truncate returned rows to this many (does not affect how
        many rows the statement itself processes).
list_databasesA

List all databases visible to the connected user.

list_tablesA

List tables (and views) in a database.

Args:
    database: Database to list tables from (defaults to the connection's
        configured database).
describe_tableA

Show column definitions for a table.

Args:
    table: Table name.
    database: Database the table lives in (defaults to the connection's
        configured database).
list_pipelinesA

List all pipelines in a database and their current state (Running/Stopped/Error).

Args:
    database: Database to list pipelines from (defaults to the
        connection's configured database).
pipeline_statusA

Get the current state of one pipeline by name.

Equivalent to SHOW PIPELINES filtered down to a single pipeline. Returns
an empty row list if no pipeline with that name exists.

Args:
    pipeline_name: Name of the pipeline to look up.
    database: Database the pipeline lives in (defaults to the
        connection's configured database).
get_pipeline_ddlA

Get the full CREATE PIPELINE statement that reproduces an existing pipeline.

Args:
    pipeline_name: Name of the pipeline.
    database: Database the pipeline lives in (defaults to the
        connection's configured database).
create_pipelineA

Create a new pipeline from a full CREATE PIPELINE statement.

Pipeline definitions vary a lot by source (S3, Kafka, Azure Blob, GCS,
filesystem, ...), format (CSV/JSON/Avro/Parquet) and optional transforms,
so this tool takes the complete statement text rather than trying to
model every variant as separate parameters. It only checks that the
statement actually starts with CREATE [OR REPLACE] PIPELINE before
running it. Creating a pipeline does not start it -- call start_pipeline
afterwards, or include FOREGROUND handling via start_pipeline.

Example create_pipeline_sql:
    CREATE PIPELINE my_pipeline AS
    LOAD DATA S3 's3://my-bucket/path/'
    CONFIG '{"region": "us-east-1"}'
    CREDENTIALS '{"aws_access_key_id": "...", "aws_secret_access_key": "..."}'
    INTO TABLE my_table
    FIELDS TERMINATED BY ',';

Args:
    create_pipeline_sql: The full CREATE PIPELINE ... statement.
    database: Database to create the pipeline in (defaults to the
        connection's configured database).
alter_pipelineA

Alter an existing pipeline from a full ALTER PIPELINE statement.

Commonly used to change the connection string/credentials or reset
offsets. Takes the full statement for the same reason as create_pipeline:
the set of alterable clauses is source-specific.

Args:
    alter_pipeline_sql: The full ALTER PIPELINE ... statement.
    database: Database the pipeline lives in (defaults to the
        connection's configured database).
start_pipelineA

Start a pipeline so it begins (or resumes) loading data.

Args:
    pipeline_name: Name of the pipeline to start.
    database: Database the pipeline lives in (defaults to the
        connection's configured database).
    foreground: If true, run synchronously and report rows loaded /
        errors in the result instead of returning immediately. Useful
        for a one-off load or for testing a pipeline end to end.
    limit_batches: Only valid with foreground=True: stop after this many
        batches instead of running indefinitely.
    if_not_running: Add IF NOT RUNNING so starting an already-running
        pipeline is a no-op instead of an error.
stop_pipelineA

Stop a running pipeline.

Args:
    pipeline_name: Name of the pipeline to stop.
    database: Database the pipeline lives in (defaults to the
        connection's configured database).
drop_pipelineA

Delete a pipeline. Running pipelines are stopped automatically before being dropped.

Args:
    pipeline_name: Name of the pipeline to drop.
    database: Database the pipeline lives in (defaults to the
        connection's configured database).
    if_exists: Add IF EXISTS so dropping a nonexistent pipeline is a
        no-op instead of an error.
test_pipelineA

Test an existing pipeline: extract and transform data without loading it into the table.

The pipeline must already exist and must be stopped first (SingleStore
errors if you test a running pipeline) -- call stop_pipeline before this
if needed. Nothing is written to the destination table; this is purely
for validating that the source/format/transform config works.

Args:
    pipeline_name: Name of the pipeline to test.
    database: Database the pipeline lives in (defaults to the
        connection's configured database).
    limit: Only pull this many rows/messages instead of testing the
        whole batch.
browser_linkA

Get a link that opens one of the interactive apps full-window in the user's web browser.

Use this when the user wants an app bigger than the chat allows or in
their browser. Give the user the returned URL as a clickable link. It
works on this machine only; it keeps working across restart_server (an
open tab reconnects by itself).

Args:
    tool: The app tool: pipeline_monitor, query_grid, schema_explorer, cluster_monitor or sql_editor.
    arguments: That tool's arguments, e.g. {"sql": "...", "database": "SASDP"}
        for query_grid or {"database": "SASDP", "table": "CARS"} for
        schema_explorer.
sql_editor_replyA

Send an answer to the chat panel of an open SQL Editor app.

Use this to answer a message that arrived from the SQL Editor (it starts
with "[SQL Editor <editor_id>]") or the Workload view's chat ("[Workload
<id>]": each ```sql block gets Add to workload / Replace / Test buttons there,
optionally preceded by "-- name: …" and "-- per_minute: N" lines), or when the user asks you to put SQL into
their open editor (the editor reports its id in the model context). The
message is plain text; put SQL in ```sql fenced blocks - each block gets
Replace / Insert / Copy buttons in the editor. Keep explanations short.
After calling this, reply briefly in the chat as well.

Args:
    editor_id: The editor's id, e.g. "e-4f9a2c".
    message: The answer, with SQL in ```sql fenced blocks.
list_connectionsA

List the saved SingleStore connections (no passwords) and which one is active.

All tools and apps use the active connection. The user manages them in the
Connections window (connections_window tool, or the workspace's Connect view).
use_connectionA

Switch the active SingleStore connection; all tools, apps and new notebook kernels then use it.

Args:
    name: Name of a saved connection (see list_connections).
restart_serverA

Restart the SingleStore MCP server so code and app changes load, without reconnecting.

Open apps keep working after a reload of the app; open browser tabs and browser links reconnect to the new server by themselves.

workload_defineA

Create or replace a saved test workload (it can then be run with workload_run, again and again).

Args:
    name: Workload name (letters, digits, spaces, . - _).
    statements: [{"sql": "...", "per_minute": 30, "name": "Top makes", "database": null, "id": "s1",
        "enabled": true}]. per_minute is how often the statement runs (with pacing "max": its relative
        weight). SQL may use placeholders filled per execution: {{int:1:1000}}, {{float:0:1}},
        {{pick:a|b|c}}, {{date:2024-01-01:2024-12-31}} (quote strings yourself: '{{pick:US|EU}}').
    database: Default database for the statements.
    pacing: "rate" (each statement per_minute times a minute) or "max" (as fast as the connections can).
    concurrency: Connections (parallel workers), 1-64.
    duration_s: How long a run lasts, 5 s - 4 h.
    timeout_s: Per-statement timeout; the statement is cancelled (KILL QUERY) after it.
    arrivals: "even" (fixed spacing) or "random" (Poisson arrivals at the same average rate).
    think_ms: Pause between statements per worker (pacing "max").
    fetch_rows: Read every result row (off measures just the execute time, not the time to read rows back).
    allow_writes: Allow statements other than SELECT / WITH (they run repeatedly: use a test table).
    trace_all: Turn on full query tracing on the cluster for the run, so every statement (not just those
        over the trace threshold) shows up in Query History afterwards. Affects the whole cluster.
    original_name: The workload's current name when renaming it.
workload_listA

Saved workloads (with their statements and settings), the run going on now, and recent runs.

workload_statusB

Progress and results of a run (live while it runs): per-statement count, throughput, p50 / p95 / p99 / max latency, errors and queue wait, plus a per-second timeline from second since.

workload_stopB

Stop a running workload (the statements running now are cancelled).

Prompts

Interactive templates invoked by user choice

NameDescription
workspaceOpen the SingleStore Workspace (SQL editor, schema, pipelines, cluster).
explain_queryExplain a SingleStore query and suggest how to make it faster.
create_pipelineCreate a SingleStore pipeline from an S3 path, Kafka topic or other source.
pipeline_healthCheck all pipelines for errors, stalls and lag.
table_reportSummarize a table: size, storage, keys and data profile.
restartRestart the SingleStore MCP server to load code and app changes.

Resources

Contextual data attached and managed by the client

NameDescription
Pipeline MonitorLive status of SingleStore pipelines with start/stop/test controls
Query Results GridSortable, filterable, exportable grid of a read-only SQL query's results
Schema ExplorerBrowse SingleStore databases, tables, columns, shard/sort keys, DDL and sample rows
Cluster MonitorCPU, memory and disk usage per SingleStore node, and the queries running right now
SQL EditorSQL editor with SingleStore autocomplete, schema tree and results
SingleStore WorkspaceSQL editor with notebook, schema explorer, pipeline monitor and cluster monitor views
NotebookSQL and Python notebook on a Jupyter kernel
ConnectionsSaved SingleStore connections and the active one
Query HistoryEvery finished query on the cluster, filtered by runtime, with tuning recommendations
AlertsAlerts on long-running and failed queries, pipeline failures, memory, disk and nodes
WorkloadTest workloads: SQL statements with how often each runs, replayed against the cluster; compare runs
SecurityUsers, groups, roles and effective privileges, who can access what, resource pools / workload queue and audit log settings; previewed, confirmed changes for users with the right privileges
ConfigEvery SingleStore engine variable with its value per node, its default and whether it was changed

TDQS

C2.8/5.0

Scored across 222 tools

Disambiguation2/5

While individual descriptions are detailed, the set contains many near-duplicate tools: query_history_advisor vs query_advisor_report (both table-design advice from the whole history), query_history_tuning vs query_history_plan_tuning vs workload_tune, who_can_access vs security_who vs security_user_detail vs user_privileges, and workload_define vs workload_save vs workload_list vs workload_overview. The distinction between run_sql, query_grid, sql_editor_query and sql_editor_execute is explained but still easy to misselect, and dozens of *_data/_status/*_state app-backend tools blur the lines further.

Naming Consistency3/5

Names are consistently snake_case, but they follow several competing conventions: plain verb_noun (list_databases, describe_table, run_sql), domain-prefixed app helpers (schema_explorer_tables, cluster_monitor_data, query_history_trends), and noun-first state getters (pipeline_status, workload_status, config_data, alerts_badge). Prefix families are readable but the mix of action-first vs domain-first naming makes the pattern unpredictable.

Tool Count1/5

222 tools for a single MCP server is an extreme mismatch relative to the roughly 10-15 tools an agent can reliably navigate. The surface includes dozens of UI-backend, helper, and status-polling tools that exist only to support the in-app views (schema_explorer_*, query_history_*, workload_*, alerts_*, notebook_*), massively ballooning the count beyond what is practical for tool selection.

Completeness4/5

Coverage of the apparent domain (SingleStore cluster ops, SQL execution, pipelines, schema exploration, security/privileges, backups, workloads, notebooks, SAS Viya integration, file loading) is remarkably thorough, with lifecycle coverage for pipelines, pipelines, users/roles, notebooks and workloads. Minor gaps exist (e.g. no explicit pipeline schedule/validate-only tools, limited dedicated alter-table tooling outside run_sql), but agents can work around them via run_sql.

Maintenance

ActivityActive
ResponsivenessOutdated data