Skip to main content
Glama
675,138 tools. Updated 2026-10-19 04:15

"Running MySQL Queries Through a MySQL Socket" matching MCP tools:

  • WRITE: restart MySQL (database) on one server. All sites on the server lose database access for a short time; running queries are interrupted. Asynchronous: returns an event_id. POST /servers/{id}/services/mysql/restart.
    Connector
    Destructive
    No auth
  • Turn raw EXPLAIN output into a plain-language diagnosis — no query needed. Paste PostgreSQL EXPLAIN / EXPLAIN ANALYZE (text or JSON) or MySQL EXPLAIN (tabular, \G, FORMAT=JSON, FORMAT=TREE) and get: what the planner is doing step by step, where the cost concentrates, named risk findings (full scans, spilling sorts, nested-loop blowups, row misestimates) with index suggestions, and what to look at next. Use when the user pastes EXPLAIN output or asks 'can you read this plan'. Input is analyzed in memory and never stored.
    ConnectorOAuth
  • Decode a database error and get the fix and the next step — no connection needed. Paste a MySQL error number (1213, 1062, 1452, 1205…) or a PostgreSQL SQLSTATE (40P01, 23505, 53300…), optionally with the failing statement, and get the proximate cause, the concrete fix, and — when it helps — the SIXTA tool and artifact to go deeper (e.g. a deadlock → paste SHOW ENGINE INNODB STATUS for sixta_explain_deadlock). Use when the user pastes a DB error code or message. Input is analyzed in memory and never stored.
    ConnectorOAuth
  • Connectivity check only — does NOT return any analytics data. Pings every connected Tracklution server and reports reachable / unreachable. USE WHEN: - The user reports the integration "isn't working" and you need to isolate network vs. data issues. - You want to confirm a freshly-added server is online before running real queries. For any data question (counts, events, sessions), skip this and go straight to get_summary or get_report.
    ConnectorOAuth
  • PHP + MySQL plans: runs one read-only SQL statement (SELECT, SHOW, DESCRIBE, EXPLAIN or WITH … SELECT) against the site's database and returns the rows. Runs in a read-only transaction; use execute_sql to change data. Use ? placeholders with params for values.
    ConnectorOAuth
  • Export a generated dataset as a file. Returns a `download_url` the person can open (or you can fetch, e.g. with curl) for as long as the dataset is held, about 2 hours. Give the person the link rather than pasting file contents into the chat. Args: dataset_id: from a prior generate_dataset call. format: data: csv, parquet, jsonl, json, avro, xlsx, feather, orc, sqlite, duckdb, sql. code and docs: dbt, notebook, dictionary, dbml, mermaid, prisma, sqlalchemy, typescript, jsonschema, expectations, django, openapi, mockapi, demo. `sql` is schema.sql (DDL with keys) + data.sql (COPY/INSERT) — the way to seed a real database: run the returned SQL through your own database connection, since this server never holds a database credential itself. dialect: for `sql` only: postgres, mysql, sqlite, mssql, oracle, bigquery, snowflake. inline: also return the file itself as `base64` (only for files under a few MB). Use it when you must write the file yourself and cannot fetch a URL. Returns: filename, content_type, bytes, download_url, expires_at (unix seconds), and `base64` when `inline` and small enough.
    ConnectorNo auth

Matching MCP Servers

  • A
    license
    A
    quality
    C
    maintenance
    Read-only MySQL MCP server that lets AI agents list tables, describe schemas, and run SELECT/SHOW/EXPLAIN queries with a row cap, bound to a single database for safety.
    3
    MIT
  • A
    license
    A
    quality
    D
    maintenance
    A Model Context Protocol (MCP) server for interacting with MySQL databases. Provides tools for querying, inspecting, and modifying databases directly from Claude.
    7
    10 npm
    MIT

Matching MCP Connectors

  • Find your worst queries by TOTAL time — no connection needed. Paste a MySQL slow query log or a PostgreSQL pg_stat_statements export and get a ranked top-N: each query shape with calls, total/mean time, and (slow log) the rows-examined-to-sent ratio, fingerprinted so thousands of log lines collapse into a few classes. Flags the dominant query, N+1 patterns, and full-scan ratios, reports how concentrated the load is (what share of total time the top shapes own), and hands the worst offenders to sixta_analyze_query. Call this whenever the user shares a slow query log or pg_stat_statements export — even a long one — or asks which queries are slowest: summing time across thousands of log lines is arithmetic a model cannot do reliably by eye. Input is analyzed in memory and never stored.
    ConnectorOAuth
  • Triage of diagnostics the user runs themselves. Paste any of: pg_stat_user_tables (vacuum/bloat triage, graded A–F with ready-to-run fixes), pg_settings / SHOW GLOBAL VARIABLES / conf files (configuration review against DBRE sizing rules — pass ram_gb, cpu_cores, workload), SHOW ENGINE INNODB STATUS (deadlock analysis, purge lag, buffer-pool misses, long-running transactions), or a pg_stat_statements excerpt (workload triage: dominant queries, N+1 signatures, slow-per-call outliers). Use when the user asks 'is my database healthy', mentions bloat/autovacuum/wraparound/deadlocks, or wants their config or workload reviewed. Called with nothing parseable, it returns the exact queries to run. Input is analyzed in memory and never stored.
    ConnectorOAuth
  • Provisions a managed MySQL (or MariaDB) database on a dedicated VM on your private network - the relational-database resource (use this instead of create_database when the app needs MySQL/MariaDB, e.g. WordPress, NextCloud, Matomo, many PHP/LAMP apps). Requires a recent plan_managed_datastore. For app deployments, prefer deploy_app database:'managed' with db_engine mysql/mariadb so plan_deploy includes and wires the DB automatically. It is PRIVATE - reachable only from another instance on the same private network, via the DB's internal/private IP (port 3306), not a public address. Get the ids from plan_managed_datastore/list_flavors/list_private_networks/list_keypairs. Provisioning takes ~5 min; poll list_relational_databases until status='ready', then the connection details (private_ip, port 3306, db_name, db_user) are populated. MySQL is created with mysql_native_password auth so older clients/apps connect cleanly. (ClickHouse is a separate resource - use create_clickhouse / list_clickhouse_databases.)
    ConnectorNo auth
  • Deploys an app to a VM and exposes it at a public https://<name>-<id>.redu.cloud URL. The container is built ON the VM. PREREQS - run check_deploy_prerequisites first for network_id + keypair_name, then plan_deploy for cost approval. Source can be git repo or prepare_upload source_token. PORT must be the real app listen port. DATASTORES ARE MANAGED BY DEFAULT: each one you reported in send_signals runs as a managed store started at your signal and is wired with no settings (DATABASE_URL and PG*/MYSQL_*, REDIS_URL, QDRANT_URL with QDRANT_API_KEY); without a signal, pass database:'managed' (db_engine 'postgres', or 'mysql'/'mariadb' for WordPress/Matomo/LAMP), redis:'managed' or qdrant:'managed'. For WordPress/WooCommerce cluster intent, do not use generic stateless deploy: pass app_profile, cluster_target:true, database:'managed', db_engine:'mariadb' or 'mysql', cluster_media_mode:'media_space', and either media_space_id or create_media_space:true. Redu mounts the media space into wp-content/uploads and refuses unsafe local uploads. Build+provision takes minutes; poll list_deployments/get_deployment. ROUTE: when plan_deploy returned recommended_route:'compose', do NOT use this tool for that folder: deploy its recommended_compose_file with deploy_compose (compose_file, recommended_service as service, recommended_port as port), for the reason in route_reason. The exceptions are route_next's: this tool builds the folder's Dockerfile instead only if the user asked for a build from source, the user changed the code the Dockerfile builds (check git status and unpushed commits in the folder), or the image cannot be pulled.
    ConnectorNo auth
  • Introspect the full database structure for a connection: every table, column, type, primary key, and index (MySQL connections do not report indexes yet; foreign keys are not reported) — the map to build queries against an unfamiliar database. Use analyze_table or data_profile instead when you need column VALUES (stats, nulls, PII) rather than structure. Read-only against your database. Results are cached 1 hour per connection; pass refresh=true to force a live re-introspection and bypass that cache, e.g. right after altering the schema. Does not consume daily quota. Returns tables with their columns, types, primary keys, and indexes.
    ConnectorOAuth
  • ⚠️ SQL MUST BE VALID IN EVERY DIALECT YOU TARGET — stick to ANSI-ish SELECT syntax when mixing pg/mysql/mssql. `SELECT TOP 10` (mssql) or `LIMIT` (others) will fail on the wrong side. Run the same query across 2-4 connections in parallel; returns per-connection rows + errors for diffing. Canonical use cases: regional compare (`['mssql-reporting-us', 'mssql-reporting-eu']`), cross-dialect sync check (`['prod-postgres-fleet', 'prod-mysql-app']`), 3-env drift, 4-region compare. Resolve every connection name via `list_connections` first; tool fails per-connection on unknown names. Cap: 4 connections per call on every plan; to compare more, split into sequential calls of ≤4 and combine. [ARCHITECT tier]
    ConnectorOAuth
  • Get the organization's subscription: which plan is in force, its status, how many seats are paid for versus actually used, and whether a plan change is already scheduled for the period end. effectiveTier is the field feature limits are gated on — it accounts for a running trial and the grace period and can differ from the subscribed planTier. Use this for the plan in force; while a trial is running use get_trial. Requires organization context. Read-only: plan, seat and top-up changes are not available through MCP by design — a human does those in the web app.
    ConnectorAPI key
  • LÖSCHT eine MySQL-Datenbank samt Inhalt — der Weg zurück zu create_database und die folgenschwerste Aktion dieses Servers. DAS IST IRREVERSIBLER DATENVERLUST: Alles, was darin gespeichert ist, ist danach endgültig weg. Es gibt keinen Papierkorb, keine Rückgängig-Funktion und keinen Weg zurück — auch nicht über den turbopress-Support; create_database bringt nur eine LEERE Datenbank zurück. Bevor du das aufrufst: Sieh mit get_databases nach, wie groß die Datenbank ist und ob eine WordPress-Installation sie benutzt (dann liegen Beiträge, Seiten, Bestellungen und Benutzerkonten darin und die Website zeigt danach einen Datenbankfehler), nenne dem Kunden beides, und frage ausdrücklich nach einer eigenen Sicherung. Der Name wird serverseitig gegen die Datenbanken genau dieses Abonnements geprüft und dann über die Kennung aus dieser Liste gelöscht — eine geratene oder fremde Angabe erreicht das Hosting-System nicht. Die Antwort sagt ausdrücklich, ob die Datenbank danach wirklich aus der Liste verschwunden ist; war die Liste danach nicht abrufbar, meldet sie das als ungeprüft statt als Erfolg. War die Liste schon vorher nicht abrufbar, wird nichts gelöscht — das heißt dann NICHT, dass es die Datenbank nicht gibt.
    Connector
    Destructive
    OAuth
  • Use this when the user asks which Bing searches bring them traffic. Top Bing Webmaster Tools queries for a property, aggregated across the window (clicks, impressions, CTR as a 0-100 percentage, and impression-weighted average position). Not for Google queries: use query_top_queries; for one page use get_bing_page_queries. Bing reports only its top queries, dated by week: a window selects whole weeks, and the rows do not sum to get_bing_traffic_stats totals. Rows are sorted by clicks, then impressions, highest first. `rowCount` counts the rows returned (at most `limit`), `totalRows` the distinct queries Bing reported before that cut. Returns notConfigured: true when no Bing Webmaster API key is set up for the property.
    ConnectorOAuth
  • Use this when the user asks which searches bring their site visitors from Yandex: Yandex Webmaster queries for a property, with impressions, clicks, average impression position and average clicked position. IMPORTANT COVERAGE LIMIT: Yandex exposes only its top queries for the period (at most 3,000), so totals from these rows are a floor, not a complete figure, and any share is of the listed queries, not of the site; say so when reporting them. Yandex serves 500 rows per request and this tool pages through as many as `limit` allows, defaulting to the first 500 by `orderBy`, sorted by that metric, highest first; `totalAvailable` and `truncated` say how much of the pool was left. CTR is a percentage (0-100, like every other CTR this server returns), calculated from impressions and clicks because Yandex publishes no CTR metric; null when there were no impressions. Yandex has no query-by-page report, so these queries cannot be attributed to URLs. Not for Google or Bing queries: use query_top_queries or get_bing_query_stats. The dates select a real window, so a longer range returns more queries and larger totals; omitting them gives the last week only. Yandex finishes a day about four days late, so `range` echoes the window it actually served. The full set of caveats is in `limitations` on every response. Returns notConfigured: true (with a `reason`) when no Yandex account is connected, the connection has to be granted again, the property is not in it, or the caller holds a share of the property rather than owning it: Yandex data is owner-only.
    ConnectorOAuth
  • Tells whether a language, runtime, framework, database or operating-system version is still supported and when it reaches end of life. Covers about 480 products (Python, Node.js, PHP, Java, Ruby, Go, Rust, Django, Laravel, Rails, React, Angular, PostgreSQL, MySQL, Ubuntu, Debian, Kubernetes and more). With product and version it returns that version's status (supported / security_only / end_of_life / upcoming), its release, active-support and end-of-life dates, days remaining or elapsed, and the cycles that are still supported; with only product it returns every release cycle; with neither it lists the product identifiers. Read-only and requires no authentication. Status is computed on every call from today's date; the dates come from endoflife.date and are refreshed every 12 hours. Use it before choosing a runtime or base image, when writing a Dockerfile or CI matrix, or when auditing an old version. It concerns the language, runtime or platform itself; for a library's own versions use package_status.
    ConnectorNo auth
  • Call this whenever the user proposes a migration / DDL change or asks 'is this safe to run' — before answering from memory. Whether a migration locks the table is version-specific (exactly which MySQL 8.0.x or PostgreSQL version makes an ALTER lock-free, INSTANT vs INPLACE vs COPY eligibility), and model recall of those version boundaries is unreliable — this is where answering from memory most often ships an outage. Returns an explicit safety verdict per statement (Critical/High/Medium/Info), the exact lock taken and what it blocks, the MySQL algorithm verdict with version-specific eligibility, PostgreSQL rewrite triggers, replication and MDL-starvation warnings, and the safe execution strategy (CREATE INDEX CONCURRENTLY, NOT VALID + VALIDATE, gh-ost / pt-osc) as ready-to-run SQL. Optional table size/FK/trigger hints sharpen duration estimates; for entitled Connect Pro orgs these are filled from live production context automatically (an explicit argument still wins). Findings are deterministic, treat them as ground truth. Input is analyzed in memory and never stored.
    ConnectorOAuth
  • Create a database user for a Cloud SQL instance. * This tool returns a long-running operation. Use the `get_operation` tool to poll its status until the operation completes. * When you use the `create_user` tool, specify the type of user: `CLOUD_IAM_USER`, `CLOUD_IAM_SERVICE_ACCOUNT`, or `BUILT_IN`. * By default the newly created user is assigned the `cloudsqlsuperuser` role, unless you specify other database roles explicitly in the request. * You can use a newly created user with the `execute_sql` tool if the user is a currently logged in IAM user. The `execute_sql` tool executes the SQL statements using the privileges of the database user logged in using IAM database authentication. The `create_user` tool has the following limitations: * To create a built-in user with password, use the `password_secret_version` field to provide password using the Google Cloud Secret Manager. The value of `password_secret_version` should be the resource name of the secret version, like `projects/12345/locations/us-central1/secrets/my-password-secret/versions/1` or `projects/12345/locations/us-central1/secrets/my-password-secret/versions/latest`. The caller needs to have `secretmanager.secretVersions.access` permission on the secret version. * The `create_user` tool doesn't support creating a user for SQL Server. To create an IAM user in PostgreSQL: * The database username must be the IAM user's email address and all lowercase. For example, to create user for PostgreSQL IAM user `example-user@example.com`, you can use the following request: ``` { "name": "example-user@example.com", "type": "CLOUD_IAM_USER", "instance":"test-instance", "project": "test-project" } ``` The created database username for the IAM user is `example-user@example.com`. To create an IAM service account in PostgreSQL: * The database username must be created without the `.gserviceaccount.com` suffix even though the full email address for the account is`service-account-name@project-id.iam.gserviceaccount.com`. For example, to create an IAM service account for PostgreSQL you can use the following request format: ``` { "name": "test@test-project.iam", "type": "CLOUD_IAM_SERVICE_ACCOUNT", "instance": "test-instance", "project": "test-project" } ``` The created database username for the IAM service account is `test@test-project.iam`. To create an IAM user or IAM service account in MySQL: * When Cloud SQL for MySQL stores a username, it truncates the @ and the domain name from the user or service account's email address. For example, `example-user@example.com` becomes `example-user`. * For this reason, you can't add two IAM users or service accounts with the same username but different domain names to the same Cloud SQL instance. * For example, to create user for the MySQL IAM user `example-user@example.com`, use the following request: ``` { "name": "example-user@example.com", "type": "CLOUD_IAM_USER", "instance": "test-instance", "project": "test-project" } ``` The created database username for the IAM user is `example-user`. * For example, to create the MySQL IAM service account `service-account-name@project-id.iam.gserviceaccount.com`, use the following request: ``` { "name": "service-account-name@project-id.iam.gserviceaccount.com", "type": "CLOUD_IAM_SERVICE_ACCOUNT", "instance": "test-instance", "project": "test-project" } ``` The created database username for the IAM service account is `service-account-name`.
    ConnectorNo auth
  • Core dossier check: Discover subdomains visible in Certificate Transparency logs. Use for attack-surface mapping; prefer dossier_full when running a complete audit. Queries crt.sh first, falls back to certspotter; capped at 100 unique subdomains; 10s timeout. Returns a CheckResult with { subdomains[], wildcards[], certCount, source }.
    ConnectorNo auth
  • Convert a SQL statement from one dialect to another — mysql, postgres, sqlite, tsql, oracle, snowflake, bigquery, redshift, spark, hive, presto, trino, duckdb, clickhouse, databricks, doris, starrocks and more. Deterministic parser (sqlglot), not an LLM: the same input always produces the same output, and syntax errors come back with the exact line and column. Use it when migrating queries between databases or debugging dialect-specific syntax.
    ConnectorNo auth