Provides tools for interacting with a MariaDB database, including listing tables, describing table structure, running SELECT queries, explaining query execution plans, and optionally executing write operations when explicitly enabled.
Provides tools for interacting with a MySQL database, including listing tables, describing table structure, running SELECT queries, explaining query execution plans, and optionally executing write operations when explicitly enabled.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@mcp-mysql-client What tables exist in the database and how are they structured?"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
MySQL MCP connects an AI application to a single MySQL or MariaDB database: view the schema, ask questions about the data in natural language, find out why a query is slow, and — if you have explicitly allowed it — change the data.
The server is bound to one database: the database is set through the configuration, and no tool can escape into any other. By default, only read access is available.
6 tools. Connection and permissions, list tables, table structure, read query, query plan, modifying query.
The server determines the request type. SQL is parsed before connecting: DELETE in the read tool is rejected even if write permissions are enabled.
Reads cannot write. Read queries run inside START TRANSACTION READ ONLY — MySQL itself rejects the write even if the SQL parser is tricked.
The response will not overflow the context. Rows are read as a stream and are cut off at the limit instead of being loaded entirely; the response carries an honest truncated marker.
Permissions are only granted from outside. INSERT, UPDATE, and DELETE are switched on by environment variables and require a restart — they cannot be granted from a chat. DDL is always unavailable.
Start with a query that only reads data:
Show me the database schema and count how many records were added in the last week.
Claude Code:
claude mcp add mysql-myapp \
-e MYSQL_HOST=db.example.com \
-e MYSQL_USER=myapp_ro \
-e MYSQL_PASS='пароль' \
-e MYSQL_DB=myapp \
-e MYSQL_SSL=true \
-- npx -y mcp-mysql-clientOr in .mcp.json / claude_desktop_config.json:
{
"mcpServers": {
"mysql-myapp": {
"command": "npx",
"args": ["-y", "mcp-mysql-client"],
"env": {
"MYSQL_HOST": "db.example.com",
"MYSQL_PORT": "3306",
"MYSQL_USER": "myapp_ro",
"MYSQL_PASS": "пароль",
"MYSQL_DB": "myapp",
"MYSQL_SSL": "true"
}
}
}
}One server — one database. Need several databases? Add several entries with their own credentials: this keeps permissions isolated, and a server connected to the test database physically cannot see the production one.
Related MCP server: MySQL MCP Server
Request | What the server does |
"What is there at all in this database?" |
|
"How is the orders table structured?" |
|
"How many orders were placed in July, and for how much?" |
|
"Why is this query slow?" |
|
"Who am I connected as and what am I allowed to do?" |
|
"Set the status of the canceled orders." |
|
By default, nothing: the server starts in read-only mode. Writing is enabled per operation:
"ALLOW_INSERT_OPERATION": "true",
"ALLOW_UPDATE_OPERATION": "true",
"ALLOW_DELETE_OPERATION": "false"What remains impossible:
What | Why |
DDL |
|
Switching databases, | Changes the meaning of the next query or executes untrusted text. |
| Writing a file on the database server. |
| Requires explicit |
Multiple statements in one call | Executes exactly one. |
MySQL privileges are a separate restriction on top of the above. The ALLOW_UPDATE_OPERATION permission does not give anything to a user without a GRANT UPDATE. Best practice: a dedicated user with minimal privileges, not root.
Variable | Default | Purpose |
|
| Database server host |
|
| Port |
| — | Unix socket instead of host/port |
| — | User (required) |
| — | Password (alias of |
| — | Read the password from a file instead of a variable |
| — | Database (required, alias of |
|
| Require TLS |
| — | Path to the root certificate; it alone enables TLS |
|
| Verify the server certificate |
|
| Allow INSERT |
|
| Allow UPDATE |
|
| Allow DELETE |
|
| Maximum rows in one response |
|
| Query timeout |
|
| Connection timeout |
|
| Connections in the pool |
|
| Retries on connection loss or deadlocks |
|
| Run reads in a read-only transaction |
| — |
|
The password is present in the MCP client config in plain text. MYSQL_PASS_FILE lets you keep it in a file with the required permissions.
@benborla29/mcp-server-mysqlThe variable names are the same, so just replace the package in the launch command:
- "args": ["-y", "@benborla29/mcp-server-mysql"]
+ "args": ["-y", "mcp-mysql-client"]What will change in behavior:
Behavior | Change |
| The server is always bound to one database. |
Responses are limited by | Answers are marked as |
DDL is unavailable | Even if write permissions are enabled. |
| They require explicit confirmation in the call. |
The toolset is different |
|
First, call server_info: it shows where the server has connected, what permissions the MySQL user has, and which limits are enabled.
Symptom | Cause |
| Invalid |
| The user exists, but has no access to the database. |
| Missing |
| The server requires TLS: set |
| Host, port, firewall, or a VPN that isn’t up. |
| TLS is required for |
Server doesn’t connect | The configuration error is visible directly in the dialog: the server starts without credentials and explains what is missing. |
Tools — parameters and responses
Development — building, tests, live verification
Publishing — releases in npm and the MCP registry
CLAUDE.md — repository layout for AI agents
Показывает структуру таблицы: столбцы с типами, обнуляемостью, значениями по умолчанию и комментариями, индексы с их составом, внешние ключи наружу и, главное, ссылки на эту таблицу из других (referenced_by) — именно они определяют, безопасно ли удалять строки. Разделы, кроме столбцов, можно отключить, если нужен только их список.
| Name | Required | Description | Default |
|---|---|---|---|
| table | Yes | Имя таблицы в подключённой базе данных. | |
| include_indexes | No | Включить индексы (по умолчанию да). | |
| include_foreign_keys | No | Включить внешние ключи в обе стороны (по умолчанию да). |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare the tool read-only, idempotent, and non-destructive, so the description's main job is to add behavioral detail beyond that. It does this by revealing the inclusion of 'referenced_by' and its significance, and by noting that sections other than columns can be disabled. This adds meaningful context about output content and configurability without contradicting the annotations. A slight miss is not mentioning the return format (e.g., structured object vs. text), but given the tool's simplicity, this is minor.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, well-structured sentence that leads with the primary action ('Shows the structure of a table'), then enumerates details and ends with a practical use case. Every clause contributes information, and there is no fluff. The sentence is long but flows logically, front-loading the core purpose. A slight improvement could be splitting into two sentences for readability, but it remains efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a read-only introspection tool with no output schema, the description adequately explains the output contents (columns, indexes, foreign keys, referenced_by) and their relevance. It also informs about optional sections, which is necessary for parameter usage. Missing details like the exact structure/format of the result and any limits (e.g., max rows shown) are not critical for this tool's use case. Overall, it provides enough for an agent to call and interpret the result correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so all three parameters (table, include_indexes, include_foreign_keys) are already documented with types, defaults, and brief explanations. The description's mention that 'sections besides columns can be disabled' only paraphrases the boolean parameters, adding no new semantic meaning. Since the schema carries the full burden, a baseline of 3 is appropriate; the description adds negligible extra value.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: 'Shows the structure of a table' and enumerates the exact elements returned (columns, indexes, foreign keys, referenced_by). It distinctly separates this from sibling tools like query/execute, which handle data manipulation, and server_info/list_tables, which cover server- or catalog-level metadata. The specific mention of 'referenced_by' as the key to deletion safety ties the purpose to a concrete decision, making it unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for when to use this tool, especially the scenario of determining whether it's safe to delete rows ('they determine whether it's safe to delete rows'). It also notes that sections can be toggled for lightweight use. However, it does not explicitly name sibling tools to avoid using, though the contrast with query/execute is implicitly established. The guidance is sufficient but not exhaustive.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Выполняет один изменяющий запрос — INSERT, UPDATE, DELETE или REPLACE — и возвращает число затронутых строк. Сейчас сервер разрешает: только чтение. Права выдаются переменными ALLOW_INSERT_OPERATION, ALLOW_UPDATE_OPERATION и ALLOW_DELETE_OPERATION в конфигурации MCP-клиента и требуют перезапуска сервера — из диалога их получить нельзя. DDL (CREATE, ALTER, DROP, TRUNCATE) не поддерживается ни при каких настройках. Запрос выполняется сразу и без транзакции: откатить его отсюда нельзя. UPDATE и DELETE без WHERE и LIMIT требуют явного allow_full_table=true.
| Name | Required | Description | Default |
|---|---|---|---|
| sql | Yes | Один SQL-запрос. Несколько инструкций через ; не выполняются. | |
| params | No | Значения для подстановки вместо ? в порядке появления. | |
| allow_full_table | No | Подтверждение для UPDATE или DELETE без WHERE и LIMIT — такой запрос затрагивает всю таблицу. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already mark the tool as destructive and non-read-only, so the description's job is to add behavioral context. It does abundantly: immediate execution without a transaction, no rollback possible, permission gating via environment variables requiring restart, DDL unsupported regardless of config, and full-table protection requiring explicit confirmation. This exceeds what the annotations convey.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is compact and information-dense, with the core function front-loaded first, followed by permission constraints, DDL exclusion, transactional behavior, and full-table guardrails. Every sentence earns its place and no content is redundant filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a mutating SQL tool with no output schema, the description is complete: it covers supported statement types, permission requirements, environmental configuration, unsupported DDL, rollback impossibility, full-table confirmation, and the return value (affected-row count). An agent has what it needs to decide whether and how to invoke it safely.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, and the schema already explains sql, params substitution, and allow_full_table confirmation semantics. The description reinforces these points but does not add new parameter-level meaning; its extra value is mostly about execution behavior rather than parameter semantics.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb and resource: it executes one mutating SQL query (INSERT, UPDATE, DELETE, or REPLACE) and returns the affected-row count. This clearly separates it from read-oriented siblings like query and explain, even without naming them.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives strong when-to-use and when-not-to-use guidance: mutations require configuration flags and a server restart, DDL is never supported, and full-table UPDATE/DELETE need allow_full_table=true. It does not explicitly point to a sibling read tool for SELECT queries, but the 'server allows only reading' caveat makes the intended usage largely inferable.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Возвращает план выполнения читающего запроса: какие индексы будут использованы и сколько строк сервер рассчитывает просмотреть. Обычный режим ничего не выполняет; analyze=true запускает запрос по-настоящему и показывает фактическое время — на больших таблицах это дорого. Полезно перед тяжёлой выборкой и при диагностике медленных запросов.
| Name | Required | Description | Default |
|---|---|---|---|
| sql | Yes | Один SQL-запрос. Несколько инструкций через ; не выполняются. | |
| format | No | Формат плана: traditional — таблица, json — подробное дерево, tree — читаемое дерево. | |
| params | No | Значения для подстановки вместо ? в порядке появления. | |
| analyze | No | Выполнить запрос и показать фактические строки и время (EXPLAIN ANALYZE). |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint and idempotentHint, so the description adds valuable extra context: normal mode does nothing, while analyze=true actually executes and can be expensive on large tables. This goes beyond the annotations without contradicting them.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three sentences with no redundancy: purpose, key behavioral caveat, and usage context are all front-loaded. Every sentence earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a 4-parameter tool with no output schema, the description is sufficient: it covers purpose, behavior, cost, and when to use. Minor gaps (e.g., exact return format) are covered by the schema, so nothing critical is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so baseline is 3. The description adds meaningful semantics for the analyze parameter (explains it runs the query and is costly), enriching understanding beyond the schema's simple boolean description.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool returns an execution plan for read queries, specifying what it shows (indexes and row estimates). It distinguishes from siblings implicitly by focusing on planning rather than execution, but does not explicitly name alternatives.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides concrete guidance on when to use: before heavy selections and when diagnosing slow queries. No exclusions or alternative tool mentions, but the context is clear enough for an agent to decide between explain and query/execute.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Перечисляет таблицы и представления подключённой базы: движок, кодировку, комментарий, размер данных и индексов в байтах и оценку числа строк. Оценка берётся из статистики InnoDB и может заметно расходиться с реальностью — точное число даёт COUNT(*) через query. С этого инструмента стоит начинать знакомство с незнакомой базой.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
While annotations already declare the operation read-only, idempotent, and non-destructive, the description adds crucial behavioral context: the row count is an estimate from InnoDB statistics and may differ significantly from reality. This is an important caveat beyond what annotations express and helps set expectations for the returned data.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two concise sentences, front-loading the core functionality and then providing the key caveat about row count estimation. It ends with a clear usage recommendation, all without redundancy or unnecessary detail. Every sentence earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has zero parameters and no output schema, the description fully explains what the tool does, what data it returns, and the reliability of that data. It also provides usage guidance, making it complete for an agent to understand when and how to use it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so the schema describes an empty object. The description compensates by detailing exactly what data is returned (engine, encoding, comment, sizes, row count estimate), providing the semantic richness that a parameterized tool would normally get from parameter descriptions. This goes beyond the baseline for no-parameter tools.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states a specific action (list tables and views) and identifies the returned attributes (engine, encoding, comment, sizes, row count estimate). It distinctively frames itself as the starting point for exploring an unfamiliar database, which sets it apart from sibling tools like describe_table or query.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly advises using this tool first when encountering an unfamiliar database, and it recommends COUNT(*) via the query tool for exact row counts, thereby guiding the agent on when to use this vs an alternative. This is direct and actionable.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Выполняет один читающий запрос (SELECT, SHOW, DESCRIBE, WITH ... SELECT) и возвращает строки. Изменяющие запросы отклоняются даже при включённых правах на запись — для них есть execute. Запрос идёт внутри read-only транзакции, число строк ограничено MYSQL_MAX_ROWS: если ответ обрезан, поле truncated равно true и это префикс, а не весь результат. Значения подставляйте через ? и params — драйвер экранирует их сам.
| Name | Required | Description | Default |
|---|---|---|---|
| sql | Yes | Один SQL-запрос. Несколько инструкций через ; не выполняются. | |
| limit | No | Максимум строк в ответе. Потолок задан MYSQL_MAX_ROWS и не повышается этим полем. | |
| params | No | Значения для подстановки вместо ? в порядке появления. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, destructiveHint=false, but the description goes beyond by explaining that modifying queries are rejected even with write permissions, queries run in a read-only transaction, rows are limited by MYSQL_MAX_ROWS, and truncated responses are marked with 'truncated: true' as a prefix not the full result. This adds behavioral details not available in annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise (3 sentences) and front-loaded with the primary purpose. Every sentence adds critical information: allowed query types, rejection of write queries, parameter handling, and truncation behavior. No fluff or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple query-execution tool with full schema coverage, no output schema, and rich annotations, the description covers all essential aspects: what queries are allowed, how to pass parameters, limits, and truncation semantics. An agent has everything needed to call it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, but the description adds valuable meaning beyond the schema: it explains how to use '?' placeholders with 'params', notes the limit is capped by MYSQL_MAX_ROWS, and clarifies that multiple statements separated by ';' are not executed. This is meaningful semantic guidance beyond the raw property descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool executes a read-only SQL query (SELECT, SHOW, DESCRIBE, WITH) and returns rows. It explicitly distinguishes from modifying queries and mentions the sibling 'execute' for those, so an agent can differentiate easily.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states when to use this tool (only for read-only queries) and when not to (modifying queries should use 'execute'). It also provides important usage guidance about parameter substitution and truncation behavior, which helps the agent choose the right tool and call it correctly.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Показывает, к какой базе и под каким пользователем подключён сервер, версию MySQL, размер базы, выданные пользователю права (GRANT) и действующие ограничения самого MCP-сервера: разрешённые операции записи, потолок строк в ответе и таймаут запроса. Стоит вызвать первым, если непонятно, почему запрос отклонён: права MySQL и разрешения сервера — это два независимых ограничения.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and non-destructive behavior. The description adds meaningful behavioral context beyond that: the concrete diagnostic fields returned and the key mental model that two independent constraint layers affect query success.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two focused sentences: the first enumerates exactly what the tool reveals, and the second gives actionable guidance on when to call it. No filler or redundant restatement of the tool name or title.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite no output schema, the description fully enumerates the returned information categories (connection identity, MySQL version, database size, grants, server limits) and the intended diagnostic use case. This is complete enough for an agent to select and invoke the tool correctly in context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters and schema description coverage is 100%, so the baseline is 4. The description adds no param-specific detail, which is appropriate because no input parameters exist.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly identifies the tool as an introspection/diagnostic operation: it shows the connected database, user, MySQL version, database size, grants, and MCP-server restrictions. This distinguishes it from the sibling data-access tools (list_tables, query, execute) by role and scope.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives explicit situational guidance: 'worth calling first if it is unclear why a query was rejected' and explains that MySQL permissions and server-side restrictions are independent. It lacks named alternatives or explicit when-not-to-use conditions, so it does not fully reach the top criterion.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
v1.0.0describe_tableexecuteexplainlist_tablesqueryserver_infoScored across 6 tools
Each tool has a clearly distinct purpose: server_info covers connection state, list_tables and describe_table cover schema discovery, query executes read-only SQL, explain returns execution plans, and execute handles mutations. The only mild overlap is between query and explain, but their outputs and use cases are sufficiently different that an agent should not select the wrong one.
The tool names are all lowercase and readable, but they do not follow one consistent pattern: list_tables and describe_table use verb_noun, explain and execute are bare verbs, while server_info and query are noun-style names. This is a mixed convention rather than a chaotic one, but it still falls short of a uniform naming scheme.
Six tools is a well-scoped set for a MySQL client server. Each tool covers a distinct part of the interaction surface: server diagnostics, table enumeration, schema inspection, read queries, query planning, and write execution, so none feel redundant or missing.
The tool set covers the full expected workflow for a MySQL client: understand the environment, discover tables, inspect schema, run read queries, analyze plans, and perform DML writes. DDL and transactions are explicitly excluded by design, so their absence is not an unexpected gap within the server's declared scope.
Safe, read-only Postgres and MySQL access for AI agents. Audit log + column-level controls.
Draxlr's remote MCP server connects AI assistants to your SQL databases and dashboards. Explore schemas, run read-only queries, manage saved queries and dashboards, and export results, all with row-level security so each user sees only their own data.
AI agents propose database changes as reviewable requests — no direct write access.
Let AI agents query data and act across all your business apps via MCP.
