singlestore-mcp-server
Server Configuration
Describes the environment variables required to run the server.
| Name | Required | Description | Default |
|---|---|---|---|
| SINGLESTORE_URL | No | Alternative to SINGLESTORE_HOST: user:password@host:port/database | |
| SINGLESTORE_HOST | No | The SingleStore host. Either this or SINGLESTORE_URL must be set. | |
| SINGLESTORE_PORT | No | The SingleStore port. Defaults to 3306. | 3306 |
| SINGLESTORE_USER | No | The SingleStore user. Defaults to root. | root |
| SINGLESTORE_DATABASE | No | Default database for queries. | |
| SINGLESTORE_PASSWORD | No | The SingleStore password. | |
| SINGLESTORE_SSL_DISABLED | No | Set 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
| Capability | Details |
|---|---|
| tools | {
"listChanged": false
} |
| prompts | {
"listChanged": false
} |
| resources | {
"subscribe": false,
"listChanged": false
} |
| experimental | {} |
Tools
Functions exposed to the LLM to take actions
| Name | Description |
|---|---|
| pipeline_monitorA | Open an interactive monitor of SingleStore pipelines. |
| 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. |
| 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. |
| 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 ( |
| 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 |
| 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). |
| cleanup_work_tablesA | Open the Schema Explorer's Clean-up panel for leftover SAS work tables. |
| schema_explorer_cleanup_scanA | Find leftover work tables by name pattern (and age), for the Schema Explorer's Clean-up panel. |
| 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. |
| 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. |
| schema_explorer_analyzeA | Run ANALYZE TABLE on the given tables, one statement per table, and report each result. |
| cluster_monitorA | Open a live monitor of the SingleStore cluster. |
| 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. |
| 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. |
| cluster_monitor_historyA | Stored per-node metrics (CPU, memory, disk, queued and running queries, connections) for the History tab. |
| app_pageA | HTML of one of this server's app pages (the workspace loads its views with this). |
| sql_editorA | Open the SingleStore workspace: an interactive SQL editor plus views. |
| sql_editor_queryA | Run a read-only statement from the SQL Editor app, streaming its result. |
| sql_editor_rowsA | More rows of a streamed SQL Editor result (from sql_editor_query), from |
| 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". |
| sql_editor_executeA | Run any single statement the user confirmed in the SQL Editor app (writes and DDL included). |
| files_browseA | List a folder for the file browser: subfolders and .sql / .sas (kind="sql") or .ipynb (kind="notebook") files. |
| 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. |
| 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. |
| viya_files_browseA | List a folder on SAS Viya for the SQL Editor's Open / Save as: subfolders and .sql / .sas files
( |
| viya_files_mkdirC | Create a folder |
| 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). |
| 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 |
| 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 |
| 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. |
| 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 |
| connection_healthA | Whether SingleStore and SAS Viya were reachable on the last calls (in memory: no round trip on the caller's
thread). |
| notebookA | Open a SingleStore notebook: SQL and Python cells on a Jupyter kernel. |
| 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. |
| notebook_pollB | New output of a running (or finished) cell since output index |
| 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. |
| 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); |
| 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 |
| 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 ( |
| notebook_saveA | Save a notebook (nbformat 4 JSON) as a .ipynb file in the SQL folder, or on SAS Viya by its ref. |
| 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. |
| connections_stateB | Saved connections, the active one and where passwords are stored. |
| connection_saveB | Create or update a saved connection. |
| connection_deleteA | Delete a saved connection and its stored password. |
| connection_testC | Try a connection: a saved one by |
| 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). |
| 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 |
| 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. |
| 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 |
| 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). |
| 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. |
| 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 |
| query_history_compare_startB | Run the selected candidate queries against the original and the new table (wrapped in COUNT(*)),
alternating, |
| 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). |
| 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". |
| 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 |
| 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
|
| 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 |
| 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 |
| 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 |
| 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). |
| who_can_accessA | Every user who has privileges on a database (or one table in it), and how they got them. |
| 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. |
| 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 ( |
| 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 |
| security_change_applyA | Run one previewed change (users, roles, groups, grants, resource pools) on the cluster. |
| 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 |
| 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. |
| config_dataC | All engine variables for the Config view. |
| sas_sourcesB | Whether SAS Viya is set up and signed in (for the SAS libraries / caslibs sources); starts no session.
|
| sas_prewarmA | The Workspace's SAS session for a SAS Viya connection (default: the active one): with |
| 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. |
| 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
( |
| sas_library_codeB | The LIBNAME statement for one SAS library, reconstructed from the session's dictionary.libnames (engine,
path, database, user); passwords as placeholders ( |
| cas_caslib_codeB | The CASLIB statement and the |
| 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.
|
| 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. |
| 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: |
| cas_reload_tablesB | Load the tables again that were loaded into the CAS session before it restarted (same where / columns;
they were confirmed then). |
| 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 ( |
| 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? |
| sas_queryA | Run one statement from the SQL Editor as PROC SQL / FedSQL (SAS libraries) or FedSQL in CAS (caslibs). |
| 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 |
| 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 |
| 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 |
| sas_history_lookupC | Is this SQL (sent to SingleStore by SAS) in the cluster's plan cache or the local query history? |
| files_renameA | Rename a file or folder on this computer in its folder (the file browser's Rename). |
| files_deleteB | Delete one file, or one empty folder, on this computer (the file browser's Delete; the app confirms first). |
| viya_files_renameA | Rename a file or folder on SAS Viya ("content" or "server", the active connection) in its folder. |
| viya_files_deleteA | Delete one file, or one empty folder, on SAS Viya ("content" or "server"); the app confirms first. |
| 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). |
| load_file_targetA | Does |
| 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 ( |
| load_file_statusA | Progress of a file load (phase, rows, bytes, %, bad rows, result). |
| 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. |
| list_databasesA | List all databases visible to the connected user. |
| list_tablesA | List tables (and views) in a database. |
| describe_tableA | Show column definitions for a table. |
| list_pipelinesA | List all pipelines in a database and their current state (Running/Stopped/Error). |
| pipeline_statusA | Get the current state of one pipeline by name. |
| get_pipeline_ddlA | Get the full CREATE PIPELINE statement that reproduces an existing pipeline. |
| create_pipelineA | Create a new pipeline from a full CREATE PIPELINE statement. |
| alter_pipelineA | Alter an existing pipeline from a full ALTER PIPELINE statement. |
| start_pipelineA | Start a pipeline so it begins (or resumes) loading data. |
| stop_pipelineA | Stop a running pipeline. |
| drop_pipelineA | Delete a pipeline. Running pipelines are stopped automatically before being dropped. |
| test_pipelineA | Test an existing pipeline: extract and transform data without loading it into the table. |
| browser_linkA | Get a link that opens one of the interactive apps full-window in the user's web browser. |
| sql_editor_replyA | Send an answer to the chat panel of an open SQL Editor app. |
| list_connectionsA | List the saved SingleStore connections (no passwords) and which one is active. |
| use_connectionA | Switch the active SingleStore connection; all tools, apps and new notebook kernels then use it. |
| 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). |
| 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 |
| workload_stopB | Stop a running workload (the statements running now are cancelled). |
Prompts
Interactive templates invoked by user choice
| Name | Description |
|---|---|
| workspace | Open the SingleStore Workspace (SQL editor, schema, pipelines, cluster). |
| explain_query | Explain a SingleStore query and suggest how to make it faster. |
| create_pipeline | Create a SingleStore pipeline from an S3 path, Kafka topic or other source. |
| pipeline_health | Check all pipelines for errors, stalls and lag. |
| table_report | Summarize a table: size, storage, keys and data profile. |
| restart | Restart the SingleStore MCP server to load code and app changes. |
Resources
Contextual data attached and managed by the client
| Name | Description |
|---|---|
| Pipeline Monitor | Live status of SingleStore pipelines with start/stop/test controls |
| Query Results Grid | Sortable, filterable, exportable grid of a read-only SQL query's results |
| Schema Explorer | Browse SingleStore databases, tables, columns, shard/sort keys, DDL and sample rows |
| Cluster Monitor | CPU, memory and disk usage per SingleStore node, and the queries running right now |
| SQL Editor | SQL editor with SingleStore autocomplete, schema tree and results |
| SingleStore Workspace | SQL editor with notebook, schema explorer, pipeline monitor and cluster monitor views |
| Notebook | SQL and Python notebook on a Jupyter kernel |
| Connections | Saved SingleStore connections and the active one |
| Query History | Every finished query on the cluster, filtered by runtime, with tuning recommendations |
| Alerts | Alerts on long-running and failed queries, pipeline failures, memory, disk and nodes |
| Workload | Test workloads: SQL statements with how often each runs, replayed against the cluster; compare runs |
| Security | Users, 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 |
| Config | Every SingleStore engine variable with its value per node, its default and whether it was changed |
TDQS
Scored across 222 tools
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.
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.
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.
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.