@cemalturkcann/mariadb-mcp-server 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Cemal Turkcan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,108 @@
+# mariadb-mcp-server
+
+MCP (Model Context Protocol) server for MariaDB/MySQL databases. Provides AI assistants with safe, controlled database access through per-connection read/write permissions.
+
+## Features
+
+- **Multi-connection** — manage multiple MariaDB/MySQL databases from a single server
+- **Per-connection access control** — `read` and `write` flags per connection
+- **Optional limits** — `statement_timeout_ms`, `default_row_limit`, `max_row_limit` (all optional, unlimited by default)
+- **SQL guard** — validates queries to prevent accidental writes through read tools
+- **Transaction support** — atomic multi-query execution on writable connections
+
+## Installation
+
+```bash
+npm install -g mariadb-mcp-server
+```
+
+Or use directly with npx:
+
+```bash
+npx mariadb-mcp-server
+```
+
+## Configuration
+
+Create a `config.json` next to the package (or set `DB_MCP_CONFIG_PATH` env var):
+
+```json
+{
+  "connections": {
+    "local": {
+      "host": "localhost",
+      "port": 3306,
+      "user": "root",
+      "password": "",
+      "description": "Local MariaDB",
+      "read": true,
+      "write": true
+    },
+    "production": {
+      "host": "db.example.com",
+      "port": 3306,
+      "user": "readonly_user",
+      "password": "secret",
+      "database": "mydb",
+      "description": "Production (read-only)",
+      "read": true,
+      "write": false,
+      "statement_timeout_ms": 5000,
+      "default_row_limit": 50,
+      "max_row_limit": 500
+    }
+  }
+}
+```
+
+### Connection options
+
+| Field | Type | Default | Description |
+|-------|------|---------|-------------|
+| `host` | string | `localhost` | Database host |
+| `port` | number | `3306` | Database port |
+| `user` | string | `root` | Database user |
+| `password` | string | `""` | Database password |
+| `database` | string | `""` | Default database |
+| `description` | string | `""` | Human-readable label |
+| `read` | boolean | `true` | Allow read queries |
+| `write` | boolean | `false` | Allow write queries |
+| `ssl` | boolean/object | `false` | SSL configuration |
+| `statement_timeout_ms` | number | *none* | Connection timeout (0 or omit = unlimited) |
+| `default_row_limit` | number | *none* | Default LIMIT for SELECT (0 or omit = unlimited) |
+| `max_row_limit` | number | *none* | Max allowed LIMIT (0 or omit = unlimited) |
+
+## MCP Tools
+
+| Tool | Description | Requires |
+|------|-------------|----------|
+| `list_connections` | List all configured connections | — |
+| `list_databases` | Show databases on a connection | `read` |
+| `list_tables` | Show tables (optionally in a specific database) | `read` |
+| `describe_table` | Show column definitions | `read` |
+| `execute_select` | Run SELECT/SHOW/DESCRIBE/EXPLAIN queries | `read` |
+| `execute_write` | Run INSERT/UPDATE/DELETE/DDL queries | `write` |
+| `execute_transaction` | Run multiple write queries atomically | `write` |
+| `suggest_query` | Suggest a query for manual review | — |
+
+## Claude Desktop / MCP Client Setup
+
+Add to your MCP client config:
+
+```json
+{
+  "mcpServers": {
+    "mariadb": {
+      "command": "npx",
+      "args": ["-y", "mariadb-mcp-server"],
+      "env": {
+        "DB_MCP_CONFIG_PATH": "/path/to/your/config.json"
+      }
+    }
+  }
+}
+```
+
+## License
+
+MIT

package/config.example.json

@@ -0,0 +1,27 @@
+{
+  "connections": {
+    "local": {
+      "host": "localhost",
+      "port": 3306,
+      "user": "root",
+      "password": "",
+      "database": "",
+      "description": "Local MariaDB",
+      "read": true,
+      "write": true
+    },
+    "production": {
+      "host": "db.example.com",
+      "port": 3306,
+      "user": "readonly_user",
+      "password": "secret",
+      "database": "mydb",
+      "description": "Production (read-only)",
+      "read": true,
+      "write": false,
+      "statement_timeout_ms": 5000,
+      "default_row_limit": 50,
+      "max_row_limit": 500
+    }
+  }
+}

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@cemalturkcann/mariadb-mcp-server",
+  "version": "1.0.0",
+  "description": "MCP server for MariaDB/MySQL with per-connection read/write access control",
+  "type": "module",
+  "main": "src/index.js",
+  "bin": {
+    "mariadb-mcp-server": "./src/index.js"
+  },
+  "files": [
+    "src",
+    "config.example.json",
+    "README.md"
+  ],
+  "scripts": {
+    "start": "node src/index.js",
+    "check": "node --check src/index.js && node --check src/config.js && node --check src/db.js && node --check src/sqlGuard.js && node --check src/tools.js"
+  },
+  "keywords": [
+    "mcp",
+    "mariadb",
+    "mysql",
+    "model-context-protocol",
+    "database",
+    "ai",
+    "llm",
+    "claude"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cemalturkcan/mariadb-mcp-server.git"
+  },
+  "homepage": "https://github.com/cemalturkcan/mariadb-mcp-server#readme",
+  "bugs": {
+    "url": "https://github.com/cemalturkcan/mariadb-mcp-server/issues"
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "mariadb": "^3.3.0"
+  },
+  "devDependencies": {
+    "semantic-release": "^24.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "release": {
+    "branches": [
+      "main"
+    ],
+    "plugins": [
+      "@semantic-release/commit-analyzer",
+      "@semantic-release/release-notes-generator",
+      "@semantic-release/npm",
+      "@semantic-release/github"
+    ]
+  }
+}

package/src/config.js

@@ -0,0 +1,92 @@
+import { existsSync, readFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+function toPositiveInt(value, fallback) {
+  const n = Number(value);
+  if (!Number.isFinite(n) || n <= 0) return fallback;
+  return Math.floor(n);
+}
+
+function toNonNegativeInt(value) {
+  if (value == null) return 0;
+  const n = Number(value);
+  if (!Number.isFinite(n) || n < 0) return 0;
+  return Math.floor(n);
+}
+
+function normalizeConnection(connection) {
+  return {
+    host: connection.host || "localhost",
+    port: toPositiveInt(connection.port, 3306),
+    user: connection.user || "root",
+    password: connection.password || "",
+    database: connection.database || "",
+    description: connection.description || "",
+    read: connection.read !== false,
+    write: connection.write === true,
+    statement_timeout_ms: toNonNegativeInt(connection.statement_timeout_ms),
+    default_row_limit: toNonNegativeInt(connection.default_row_limit),
+    max_row_limit: toNonNegativeInt(connection.max_row_limit),
+    ssl: connection.ssl || false,
+  };
+}
+
+export function loadConfig() {
+  const candidates = [
+    process.env.DB_MCP_CONFIG_PATH,
+    join(__dirname, "../config.json"),
+    join(process.cwd(), "config.json"),
+  ].filter(Boolean);
+
+  let rawConfig;
+  for (const configPath of candidates) {
+    if (existsSync(configPath)) {
+      rawConfig = JSON.parse(readFileSync(configPath, "utf8"));
+      break;
+    }
+  }
+
+  if (!rawConfig) {
+    throw new Error(
+      "config.json bulunamadi. DB_MCP_CONFIG_PATH ayarlayin veya proje kokune config.json koyun."
+    );
+  }
+
+  const raw = rawConfig.connections || rawConfig.databases;
+  if (!raw || typeof raw !== "object") {
+    throw new Error(
+      "config.json icinde 'connections' (veya eski format 'databases') nesnesi olmalidir."
+    );
+  }
+
+  const entries = Object.entries(raw);
+  if (entries.length === 0) {
+    throw new Error("En az bir baglanti tanimlamalisiniz.");
+  }
+
+  const connections = {};
+  for (const [name, connection] of entries) {
+    if (!connection || typeof connection !== "object") {
+      throw new Error(`'${name}' baglantisi gecersiz.`);
+    }
+
+    const normalized = normalizeConnection(connection);
+
+    if (
+      normalized.default_row_limit > 0 &&
+      normalized.max_row_limit > 0 &&
+      normalized.default_row_limit > normalized.max_row_limit
+    ) {
+      throw new Error(
+        `'${name}' icin default_row_limit, max_row_limit degerinden buyuk olamaz.`
+      );
+    }
+
+    connections[name] = normalized;
+  }
+
+  return { connections };
+}

package/src/db.js

@@ -0,0 +1,151 @@
+import mariadb from "mariadb";
+
+export class DbManager {
+  constructor(config) {
+    this.config = config;
+    this.pools = new Map();
+  }
+
+  getConnectionNames() {
+    return Object.keys(this.config.connections);
+  }
+
+  getReadableConnections() {
+    return this.getConnectionNames().filter(
+      (name) => this.config.connections[name].read
+    );
+  }
+
+  getWritableConnections() {
+    return this.getConnectionNames().filter(
+      (name) => this.config.connections[name].write
+    );
+  }
+
+  getConnectionConfig(name) {
+    const cfg = this.config.connections[name];
+    if (!cfg) {
+      const available = this.getConnectionNames().join(", ");
+      throw new Error(
+        `Baglanti bulunamadi: '${name}'. Mevcut baglantilar: ${available}`
+      );
+    }
+    return cfg;
+  }
+
+  getPool(name, databaseOverride = null) {
+    const c = this.getConnectionConfig(name);
+    const database = databaseOverride || c.database;
+    const poolKey = `${name}::${database}`;
+
+    if (!this.pools.has(poolKey)) {
+      const poolOptions = {
+        host: c.host,
+        port: c.port,
+        user: c.user,
+        password: c.password,
+        database: database || undefined,
+        connectionLimit: 5,
+        insertIdAsNumber: true,
+        bigIntAsNumber: true,
+      };
+
+      if (c.statement_timeout_ms > 0) {
+        poolOptions.connectTimeout = c.statement_timeout_ms;
+      }
+
+      if (c.ssl) {
+        poolOptions.ssl =
+          typeof c.ssl === "object" ? c.ssl : { rejectUnauthorized: false };
+      }
+
+      this.pools.set(poolKey, mariadb.createPool(poolOptions));
+    }
+
+    return this.pools.get(poolKey);
+  }
+
+  assertReadable(connectionName) {
+    const cfg = this.getConnectionConfig(connectionName);
+    if (!cfg.read) {
+      throw new Error(
+        `'${connectionName}' baglantisi read (okuma) izni vermiyor.`
+      );
+    }
+  }
+
+  assertWritable(connectionName) {
+    const cfg = this.getConnectionConfig(connectionName);
+    if (!cfg.write) {
+      throw new Error(
+        `'${connectionName}' baglantisi write (yazma) izni vermiyor.`
+      );
+    }
+  }
+
+  async runReadOnly(connectionName, sql, options = {}) {
+    this.assertReadable(connectionName);
+    const database = options.database || null;
+    const conn = await this.getPool(connectionName, database).getConnection();
+    try {
+      return await conn.query(sql);
+    } finally {
+      conn.release();
+    }
+  }
+
+  async runWrite(connectionName, sql, options = {}) {
+    this.assertWritable(connectionName);
+    const database = options.database || null;
+    const conn = await this.getPool(connectionName, database).getConnection();
+    try {
+      const result = await conn.query(sql);
+      return {
+        affectedRows: result.affectedRows,
+        insertId: result.insertId,
+        warningStatus: result.warningStatus,
+      };
+    } finally {
+      conn.release();
+    }
+  }
+
+  async runTransaction(connectionName, queries, options = {}) {
+    this.assertWritable(connectionName);
+    const database = options.database || null;
+    const conn = await this.getPool(connectionName, database).getConnection();
+    try {
+      await conn.beginTransaction();
+      const results = [];
+      for (const q of queries) {
+        const r = await conn.query(q);
+        results.push({
+          query: q.substring(0, 100),
+          affectedRows: r.affectedRows,
+          insertId: r.insertId,
+        });
+      }
+      await conn.commit();
+      return { committed: true, results };
+    } catch (error) {
+      try {
+        await conn.rollback();
+      } catch {
+        /* asil hatayi koruyoruz */
+      }
+      throw new Error(
+        `Transaction basarisiz, rollback yapildi: ${error.message}`
+      );
+    } finally {
+      conn.release();
+    }
+  }
+
+  async closeAll() {
+    const tasks = [];
+    for (const pool of this.pools.values()) {
+      tasks.push(pool.end());
+    }
+    await Promise.all(tasks);
+  }
+}

package/src/index.js

@@ -0,0 +1,191 @@
+#!/usr/bin/env node
+
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from "@modelcontextprotocol/sdk/types.js";
+import { loadConfig } from "./config.js";
+import { DbManager } from "./db.js";
+import {
+  validateReadQuery,
+  validateWriteQuery,
+  resolveRowLimit,
+  buildLimitedQuery,
+} from "./sqlGuard.js";
+import { buildToolDefinitions, fail, ok } from "./tools.js";
+
+const config = loadConfig();
+const db = new DbManager(config);
+
+const allConnections = db.getConnectionNames();
+const readableConnections = db.getReadableConnections();
+const writableConnections = db.getWritableConnections();
+
+const server = new Server(
+  { name: "mariadb-mcp", version: "2.0.0" },
+  { capabilities: { tools: {} } },
+);
+
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: buildToolDefinitions(
+    readableConnections,
+    writableConnections,
+    allConnections,
+  ),
+}));
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+
+  try {
+    switch (name) {
+      case "list_connections": {
+        const list = allConnections.map((connectionName) => {
+          const c = db.getConnectionConfig(connectionName);
+          return {
+            name: connectionName,
+            description: c.description,
+            host: c.host,
+            port: c.port,
+            database: c.database,
+            read: c.read,
+            write: c.write,
+            ...(c.statement_timeout_ms > 0 && {
+              statement_timeout_ms: c.statement_timeout_ms,
+            }),
+            ...(c.default_row_limit > 0 && {
+              default_row_limit: c.default_row_limit,
+            }),
+            ...(c.max_row_limit > 0 && { max_row_limit: c.max_row_limit }),
+          };
+        });
+        return ok(list);
+      }
+
+      case "list_databases": {
+        const connection = args?.connection;
+        if (!connection) return fail("'connection' alani zorunludur.");
+        const rows = await db.runReadOnly(connection, "SHOW DATABASES");
+        return ok(rows);
+      }
+
+      case "list_tables": {
+        const { connection, database } = args || {};
+        if (!connection) return fail("'connection' alani zorunludur.");
+        const sql = database
+          ? `SHOW TABLES FROM \`${database}\``
+          : "SHOW TABLES";
+        const rows = await db.runReadOnly(connection, sql);
+        return ok(rows);
+      }
+
+      case "describe_table": {
+        const { connection, table, database } = args || {};
+        if (!connection) return fail("'connection' alani zorunludur.");
+        if (!table) return fail("'table' alani zorunludur.");
+        const path = database ? `\`${database}\`.\`${table}\`` : `\`${table}\``;
+        const rows = await db.runReadOnly(connection, `DESCRIBE ${path}`);
+        return ok(rows);
+      }
+
+      case "execute_select": {
+        const connection = args?.connection;
+        const query = args?.query;
+        const database = args?.database;
+        const requestedRowLimit = args?.row_limit;
+
+        if (!connection) return fail("'connection' alani zorunludur.");
+        if (!query) return fail("'query' alani zorunludur.");
+
+        const connectionConfig = db.getConnectionConfig(connection);
+        const validatedQuery = validateReadQuery(query);
+
+        const upper = validatedQuery.trim().toUpperCase();
+        let finalQuery = validatedQuery;
+        let appliedRowLimit = null;
+
+        if (upper.startsWith("SELECT") || upper.startsWith("WITH")) {
+          appliedRowLimit = resolveRowLimit(
+            requestedRowLimit,
+            connectionConfig,
+          );
+          if (appliedRowLimit !== null) {
+            finalQuery = buildLimitedQuery(validatedQuery, appliedRowLimit);
+          }
+        }
+
+        const rows = await db.runReadOnly(connection, finalQuery, { database });
+
+        const result = {
+          row_count: Array.isArray(rows) ? rows.length : 0,
+          rows,
+        };
+        if (appliedRowLimit !== null) {
+          result.row_limit = appliedRowLimit;
+        }
+        return ok(result);
+      }
+
+      case "execute_write": {
+        const { connection, query } = args || {};
+        if (!connection) return fail("'connection' alani zorunludur.");
+        if (!query) return fail("'query' alani zorunludur.");
+
+        const validatedQuery = validateWriteQuery(query);
+        const meta = await db.runWrite(connection, validatedQuery);
+        return ok({ success: true, meta });
+      }
+
+      case "execute_transaction": {
+        const { connection, queries } = args || {};
+        if (!connection) return fail("'connection' alani zorunludur.");
+        if (!Array.isArray(queries) || queries.length === 0) {
+          return fail("'queries' en az bir sorgu iceren bir dizi olmalidir.");
+        }
+
+        for (const q of queries) {
+          validateWriteQuery(q);
+        }
+
+        const result = await db.runTransaction(connection, queries);
+        return ok(result);
+      }
+
+      case "suggest_query": {
+        const { connection, query, reason } = args || {};
+        return ok({
+          message: "MANUEL CALISTIRMA GEREKLI",
+          connection,
+          reason: reason || "Yazma islemi",
+          query,
+        });
+      }
+
+      default:
+        return fail(`Bilinmeyen arac: ${name}`);
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return fail(`Hata: ${message}`);
+  }
+});
+
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
+main().catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  console.error(`Sunucu baslatilamadi: ${message}`);
+  process.exit(1);
+});
+
+for (const signal of ["SIGINT", "SIGTERM"]) {
+  process.on(signal, async () => {
+    await db.closeAll();
+    process.exit(0);
+  });
+}

package/src/sqlGuard.js

@@ -0,0 +1,103 @@
+const READ_PREFIXES = ["SELECT", "SHOW", "DESCRIBE", "DESC", "EXPLAIN", "WITH"];
+
+const WRITE_PREFIXES = [
+  "INSERT",
+  "UPDATE",
+  "DELETE",
+  "REPLACE",
+  "CREATE",
+  "ALTER",
+  "DROP",
+  "TRUNCATE",
+  "RENAME",
+  "SET",
+  "START TRANSACTION",
+  "COMMIT",
+  "ROLLBACK",
+];
+
+export function isReadQuery(sql) {
+  const t = sql.trim().toUpperCase();
+  return READ_PREFIXES.some((p) => t.startsWith(p));
+}
+
+export function isWriteQuery(sql) {
+  const t = sql.trim().toUpperCase();
+  return WRITE_PREFIXES.some((p) => t.startsWith(p));
+}
+
+export function validateReadQuery(rawQuery) {
+  if (typeof rawQuery !== "string") {
+    throw new Error("Sorgu metin (string) olmalidir.");
+  }
+
+  const query = rawQuery.trim();
+  if (!query) {
+    throw new Error("Sorgu bos olamaz.");
+  }
+
+  if (!isReadQuery(query)) {
+    throw new Error(
+      "Yalnizca SELECT/SHOW/DESCRIBE/EXPLAIN sorgularina izin verilir."
+    );
+  }
+
+  return query;
+}
+
+export function validateWriteQuery(rawQuery) {
+  if (typeof rawQuery !== "string") {
+    throw new Error("Sorgu metin (string) olmalidir.");
+  }
+
+  const query = rawQuery.trim();
+  if (!query) {
+    throw new Error("Sorgu bos olamaz.");
+  }
+
+  if (isReadQuery(query)) {
+    throw new Error(
+      "Read-only sorgular (SELECT/SHOW/DESCRIBE/EXPLAIN) execute_write'da kullanilamaz. execute_select kullanin."
+    );
+  }
+
+  if (!isWriteQuery(query)) {
+    throw new Error(
+      `Sorgu gecerli bir yazma islemi olarak taninamadi. Izin verilen: ${WRITE_PREFIXES.join(", ")}`
+    );
+  }
+
+  return query;
+}
+
+/**
+ * Resolves the effective row limit for a query.
+ * Returns null when no limit should be applied.
+ *
+ * - Config'de default_row_limit / max_row_limit yoksa (0) → sinirsiz
+ * - Kullanici row_limit verdiyse ve max_row_limit varsa → min(request, max) uygulanir
+ * - Kullanici row_limit vermediyse ama default_row_limit varsa → default uygulanir
+ */
+export function resolveRowLimit(requestedRowLimit, connectionConfig) {
+  const defaultLimit = connectionConfig.default_row_limit || 0;
+  const maxLimit = connectionConfig.max_row_limit || 0;
+
+  if (requestedRowLimit != null) {
+    const n = Number(requestedRowLimit);
+    if (!Number.isFinite(n) || n <= 0) {
+      throw new Error("row_limit pozitif bir sayi olmalidir.");
+    }
+    const chosen = Math.floor(n);
+    return maxLimit > 0 ? Math.min(chosen, maxLimit) : chosen;
+  }
+
+  if (defaultLimit > 0) {
+    return maxLimit > 0 ? Math.min(defaultLimit, maxLimit) : defaultLimit;
+  }
+
+  return null;
+}
+
+export function buildLimitedQuery(query, rowLimit) {
+  return `SELECT * FROM (${query}) AS mcp_query LIMIT ${rowLimit}`;
+}

package/src/tools.js

@@ -0,0 +1,135 @@
+export function buildToolDefinitions(
+  readableConnections,
+  writableConnections,
+  allConnections
+) {
+  const tools = [
+    {
+      name: "list_connections",
+      description: "Tanimli MariaDB baglantilarini listeler.",
+      inputSchema: { type: "object", properties: {} },
+    },
+    {
+      name: "list_databases",
+      description: "Secilen baglantidaki veritabanlarini listeler.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          connection: { type: "string", enum: readableConnections },
+        },
+        required: ["connection"],
+      },
+    },
+    {
+      name: "list_tables",
+      description: "Secilen baglantida tablolari listeler.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          connection: { type: "string", enum: readableConnections },
+          database: { type: "string" },
+        },
+        required: ["connection"],
+      },
+    },
+    {
+      name: "describe_table",
+      description: "Bir tablonun kolon bilgilerini dondurur.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          connection: { type: "string", enum: readableConnections },
+          table: { type: "string" },
+          database: { type: "string" },
+        },
+        required: ["connection", "table"],
+      },
+    },
+    {
+      name: "execute_select",
+      description:
+        "Salt-okunur SELECT/SHOW/DESCRIBE/EXPLAIN sorgusu calistirir. Satir limiti uygulanir.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          connection: { type: "string", enum: readableConnections },
+          query: { type: "string" },
+          database: { type: "string" },
+          row_limit: { type: "number" },
+        },
+        required: ["connection", "query"],
+      },
+    },
+  ];
+
+  if (writableConnections.length > 0) {
+    tools.push(
+      {
+        name: "execute_write",
+        description: `INSERT/UPDATE/DELETE/CREATE/ALTER/DROP vb. yazma sorgusu calistirir. Baglantilar: ${writableConnections.join(", ")}`,
+        inputSchema: {
+          type: "object",
+          properties: {
+            connection: { type: "string", enum: writableConnections },
+            query: { type: "string" },
+          },
+          required: ["connection", "query"],
+        },
+      },
+      {
+        name: "execute_transaction",
+        description: `Birden fazla yazma sorgusunu transaction icinde calistirir. Baglantilar: ${writableConnections.join(", ")}`,
+        inputSchema: {
+          type: "object",
+          properties: {
+            connection: { type: "string", enum: writableConnections },
+            queries: {
+              type: "array",
+              items: { type: "string" },
+              minItems: 1,
+            },
+          },
+          required: ["connection", "queries"],
+        },
+      }
+    );
+  }
+
+  tools.push({
+    name: "suggest_query",
+    description: "Manuel calistirilmasi gereken bir sorgu onerir.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        connection: { type: "string" },
+        query: { type: "string" },
+        reason: { type: "string" },
+      },
+      required: ["connection", "query"],
+    },
+  });
+
+  return tools;
+}
+
+export function ok(payload) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(
+          payload,
+          (key, value) => (typeof value === "bigint" ? Number(value) : value),
+          2
+        ),
+      },
+    ],
+  };
+}
+
+export function fail(message) {
+  return {
+    content: [{ type: "text", text: message }],
+    isError: true,
+  };
+}