sql.try-mcp.dev

{
  "name": "list-connections",
  "kind": "answer",
  "impl": "imperative",
  "description": "List the database connections the user has opened up to agents, and which one is active. Never returns credentials.",
  "inputSchema": {
    "type": "object",
    "properties": {}
  }
}

{
  "name": "get-active-connection",
  "kind": "answer",
  "impl": "imperative",
  "description": "Details of the database connection the notebook is currently pointed at, with a count of schemas and tables.",
  "inputSchema": {
    "type": "object",
    "properties": {}
  }
}

{
  "name": "list-tables",
  "kind": "answer",
  "impl": "imperative",
  "description": "List tables in the active database with their estimated row counts. Use search-schema instead when looking for something by name.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "schema": {
        "type": "string",
        "description": "Restrict to one schema, e.g. 'public'."
      },
      "limit": {
        "type": "number",
        "description": "Maximum tables to return (default 100)."
      }
    }
  }
}

{
  "name": "search-schema",
  "kind": "answer",
  "impl": "imperative",
  "description": "Fuzzy-search tables and columns by name in the active database. The fastest way to find the right tables in a large schema.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "query": {
        "type": "string",
        "description": "Substring to look for in table and column names."
      },
      "limit": {
        "type": "number",
        "description": "Maximum tables to return (default 20, max 50)."
      }
    },
    "required": [
      "query"
    ]
  }
}

{
  "name": "describe-tables",
  "kind": "answer",
  "impl": "imperative",
  "description": "Full column detail (types, nullability, primary keys) for named tables, plus the foreign keys connecting them. Accepts 'schema.table' or a bare table name.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "tables": {
        "type": "array",
        "items": {
          "type": "string"
        },
        "description": "Table names, e.g. ['public.orders', 'order_items']."
      }
    },
    "required": [
      "tables"
    ]
  }
}

{
  "name": "get-canvas-focus",
  "kind": "answer",
  "impl": "imperative",
  "description": "What the user currently has in focus on the schema canvas: the open table, the search filter, and the highlighted tables. This is the user's own curation of context — prefer these tables when answering an ambiguous question.",
  "inputSchema": {
    "type": "object",
    "properties": {}
  }
}

{
  "name": "list-cells",
  "kind": "answer",
  "impl": "imperative",
  "description": "List the cells in the open notebook with their SQL and last run status. Row data is not included — use get-cell-result for that.",
  "inputSchema": {
    "type": "object",
    "properties": {}
  }
}

{
  "name": "get-cell",
  "kind": "answer",
  "impl": "imperative",
  "description": "One notebook cell: its SQL, name and last run status.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "cellId": {
        "type": "string",
        "description": "Cell id from list-cells."
      }
    },
    "required": [
      "cellId"
    ]
  }
}

{
  "name": "add-cell",
  "kind": "act",
  "impl": "imperative",
  "description": "Append a SQL cell to the notebook, optionally running it. The cell is visible to the user and can be edited, saved and re-run by hand.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "sql": {
        "type": "string",
        "description": "The SQL statement for the cell."
      },
      "name": {
        "type": "string",
        "description": "Cell title shown in the notebook, e.g. 'Revenue by month'."
      },
      "variableName": {
        "type": "string",
        "description": "Publish this cell's rows as a variable that later cells can reference as :name."
      },
      "run": {
        "type": "boolean",
        "description": "Run the cell immediately and return a preview (default false)."
      },
      "previewRows": {
        "type": "number",
        "description": "Rows to return when run is true (default 20, max 100)."
      }
    },
    "required": [
      "sql"
    ]
  }
}

{
  "name": "run-sql",
  "kind": "act",
  "impl": "imperative",
  "description": "Add a cell for this SQL, run it, and return a small preview of the rows. The one-shot version of add-cell + run-cell. Read-only statements only (SELECT, EXPLAIN, WITH ... SELECT).",
  "inputSchema": {
    "type": "object",
    "properties": {
      "sql": {
        "type": "string",
        "description": "A single read-only SQL statement."
      },
      "name": {
        "type": "string",
        "description": "Cell title shown in the notebook."
      },
      "variableName": {
        "type": "string",
        "description": "Publish the rows as :name for later cells."
      },
      "previewRows": {
        "type": "number",
        "description": "Rows to return (default 20, max 100)."
      }
    },
    "required": [
      "sql"
    ]
  }
}

{
  "name": "run-cell",
  "kind": "act",
  "impl": "imperative",
  "description": "Run an existing notebook cell and return a preview of its rows. Waits for the query to finish.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "cellId": {
        "type": "string",
        "description": "Cell id from list-cells."
      },
      "previewRows": {
        "type": "number",
        "description": "Rows to return (default 20, max 100)."
      }
    },
    "required": [
      "cellId"
    ]
  }
}

{
  "name": "update-cell",
  "kind": "act",
  "impl": "imperative",
  "description": "Edit an existing cell's SQL, title, or variable name — the way to iterate after a query fails, instead of piling up new cells.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "cellId": {
        "type": "string",
        "description": "Cell id from list-cells."
      },
      "sql": {
        "type": "string",
        "description": "Replacement SQL."
      },
      "name": {
        "type": "string",
        "description": "Replacement cell title."
      },
      "variableName": {
        "type": "string",
        "description": "Replacement variable name; empty string clears it."
      }
    },
    "required": [
      "cellId"
    ]
  }
}

{
  "name": "delete-cell",
  "kind": "transact",
  "impl": "imperative",
  "description": "Delete a notebook cell. The notebook always keeps at least one cell.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "cellId": {
        "type": "string",
        "description": "Cell id from list-cells."
      }
    },
    "required": [
      "cellId"
    ]
  }
}

{
  "name": "get-cell-result",
  "kind": "answer",
  "impl": "imperative",
  "description": "Page through the rows a cell returned. Prefer aggregating in SQL over paging: the user can already see the full grid.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "cellId": {
        "type": "string",
        "description": "Cell id from list-cells."
      },
      "offset": {
        "type": "number",
        "description": "First row to return (default 0)."
      },
      "limit": {
        "type": "number",
        "description": "Rows to return (default 20, max 100)."
      }
    },
    "required": [
      "cellId"
    ]
  }
}

{
  "name": "list-variables",
  "kind": "answer",
  "impl": "imperative",
  "description": "List the notebook variables published by cells. Reference them in SQL as :name (or :name.column).",
  "inputSchema": {
    "type": "object",
    "properties": {}
  }
}

{
  "name": "set-variable",
  "kind": "act",
  "impl": "imperative",
  "description": "Set a notebook variable directly, for parameterising later cells. Accepts a scalar, an array of scalars, or an array of row objects.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "name": {
        "type": "string",
        "description": "Variable name, referenced in SQL as :name."
      },
      "value": {
        "type": [
          "string",
          "number",
          "boolean",
          "array",
          "object",
          "null"
        ],
        "description": "Scalar, array of scalars, or array of row objects."
      }
    },
    "required": [
      "name",
      "value"
    ]
  }
}

{
  "name": "delete-variable",
  "kind": "transact",
  "impl": "imperative",
  "description": "Remove a notebook variable.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "name": {
        "type": "string",
        "description": "Variable name."
      }
    },
    "required": [
      "name"
    ]
  }
}

{
  "name": "list-saved-queries",
  "kind": "answer",
  "impl": "imperative",
  "description": "List queries saved in the query library, optionally filtered by a search term matching the name or SQL.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "search": {
        "type": "string",
        "description": "Substring of the name or SQL."
      },
      "limit": {
        "type": "number",
        "description": "Maximum results (default 25)."
      }
    }
  }
}

{
  "name": "load-saved-query",
  "kind": "act",
  "impl": "imperative",
  "description": "Load a saved query into the notebook as a new cell, optionally running it.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "queryId": {
        "type": "string",
        "description": "Id from list-saved-queries."
      },
      "run": {
        "type": "boolean",
        "description": "Run it after loading (default false)."
      }
    },
    "required": [
      "queryId"
    ]
  }
}

{
  "name": "save-query",
  "kind": "act",
  "impl": "imperative",
  "description": "Save SQL to the query library so it survives the session. Lands in the user's first workspace and folder.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "name": {
        "type": "string",
        "description": "Name for the saved query."
      },
      "sql": {
        "type": "string",
        "description": "The SQL to save."
      },
      "tags": {
        "type": "array",
        "items": {
          "type": "string"
        },
        "description": "Optional tags."
      }
    },
    "required": [
      "name",
      "sql"
    ]
  }
}

{
  "name": "focus-tables",
  "kind": "act",
  "impl": "imperative",
  "description": "Highlight tables on the user's schema canvas and centre the view on them, dimming everything else. Use this to show which tables you are working with before running queries against them.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "tables": {
        "type": "array",
        "items": {
          "type": "string"
        },
        "description": "Table names to highlight, e.g. ['public.orders', 'order_items']."
      },
      "open": {
        "type": "boolean",
        "description": "Also open the column panel for the first table (default false)."
      }
    },
    "required": [
      "tables"
    ]
  }
}

{
  "name": "clear-canvas-focus",
  "kind": "act",
  "impl": "imperative",
  "description": "Undim the schema canvas, restoring the full schema view after focus-tables.",
  "inputSchema": {
    "type": "object",
    "properties": {}
  }
}