@andezdev/tokenlite-mysql-mcp 1.0.0 → 2.0.0

package/README.md

@@ -10,9 +10,11 @@ Designed specifically to solve the shortcomings of current generic MCP servers t
 ## 🌟 Core Pillars
 
 1. **Safe-Query Optimizer (AST & EXPLAIN)**: Protects production databases by pre-analyzing queries. Blocks unindexed Full Table Scans that exceed configurable thresholds and injects strict `LIMIT` clauses automatically at the AST level.
-2. **Business Intelligence Injection**: Bridges the gap between raw data and company logic. Automatically attaches semantic dictionaries (`metadata.json`) to database schema exploration, and exposes a Semantic Template Search tool (`templates.json`) so the LLM uses pre-approved analytical queries instead of hallucinating them.
-3. **Graph-Based Semantic Schema**: Avoids sending giant schemas to the LLM that saturate the context window. When a table is searched, the engine uses heuristics to deduce implicit relationships and packages the exact "Auto-Join Context".
-4. **CSV Token Compression**: Database results are efficiently transformed into tabular CSV markdown, saving up to 60% of Output Tokens compared to verbose JSON.
+2. **Granular AST-Based Write Permissions**: By default, TokenLite is 100% Read-Only. You can surgically enable specific write operations (INSERT, UPDATE, DELETE, DDL) via environment variables. The firewall uses strict AST parsing to prevent SQL injection and comment-bypass attacks, and strictly prohibits privilege escalation commands (like `GRANT` or `CALL`).
+3. **Session-Level Defense in Depth**: If the server is configured in strict Read-Only mode (all write variables disabled), TokenLite injects `SET SESSION TRANSACTION READ ONLY` directly into the connection pool sockets. This guarantees that even if a theoretical bypass exists in the AST parser, the MySQL engine itself will physically reject any data modification.
+4. **Business Intelligence Injection**: Bridges the gap between raw data and company logic. Automatically attaches semantic dictionaries (`metadata.json`) to database schema exploration, and exposes Semantic Templates via the official **MCP Prompts API** (`templates.json`) so the LLM uses pre-approved analytical queries instead of hallucinating them.
+5. **Graph-Based Semantic Schema**: Avoids sending giant schemas to the LLM that saturate the context window. When a table is searched, the engine uses heuristics to deduce implicit relationships and packages the exact "Auto-Join Context".
+6. **CSV Token Compression**: Database results are efficiently transformed into tabular CSV markdown, saving up to 60% of Output Tokens compared to verbose JSON.
 
 ---
 
@@ -98,6 +100,14 @@ To use within Cursor IDE:
 | `MCP_SAFE_QUERY_ENABLE_BLOCKING`| Enable or disable the EXPLAIN guardrail. | `true` | No |
 | `MCP_METADATA_PATH` | Absolute path to your custom `metadata.json` dictionary. | (Disabled) | No |
 | `MCP_TEMPLATES_PATH` | Absolute path to your custom `templates.json` queries. | (Disabled) | No |
+| `TOOL_PREFIX` | Prefix for tool names (useful when running multiple instances). | Random (e.g., `db_a1b2_`) | No |
+| `MYSQL_QUERY_TIMEOUT` | Max execution time for a query (in ms). Aborts heavy queries to protect against DoS. | `15000` | No |
+| `MYSQL_CONNECTION_LIMIT` | Max concurrent pool connections. | `10` | No |
+| `MYSQL_CONNECT_TIMEOUT` | Max time to wait for a socket to establish (in ms). | `10000` | No |
+| `ALLOW_INSERT_OPERATION` | Enable `INSERT` and `REPLACE` queries. | `false` | No |
+| `ALLOW_UPDATE_OPERATION` | Enable `UPDATE` queries. | `false` | No |
+| `ALLOW_DELETE_OPERATION` | Enable `DELETE` and `TRUNCATE` queries. | `false` | No |
+| `ALLOW_DDL_OPERATION` | Enable Data Definition Language (`CREATE`, `ALTER`, `DROP`, `RENAME`). | `false` | No |
 
 ---
 
@@ -158,6 +168,26 @@ TokenLite converts raw database rows to a dense, structured CSV layout. This avo
 
 ---
 
+## 🌐 Advanced Networking & Remote Connections
+
+By design, `tokenlite-mysql-mcp` adheres to the Unix philosophy: it does one thing (AI-driven MySQL interactions) and does it securely via the standard `stdio` transport. It deliberately avoids bloating the codebase with HTTP servers or built-in SSH clients. 
+
+If you need to connect to remote databases or expose this server over the network, here are the recommended, enterprise-grade alternatives:
+
+### 1. Connecting to Remote Databases (SSH Tunnels)
+Instead of embedding SSH libraries, we recommend using native OS tunnels. This is much more secure, respects your `~/.ssh/config`, and supports advanced authentication (2FA, hardware keys).
+
+Simply open a terminal and run:
+
+```bash
+ssh -N -L 3306:127.0.0.1:3306 user@your-remote-server.com
+```
+Then, point `tokenlite-mysql-mcp` to `localhost` and port `3306`.
+
+### 2. Exposing the MCP Server over HTTP/Network
+If you need to host this MCP Server in the cloud (AWS, GCP) and have multiple Claude desktop clients connect to it remotely via HTTP/SSE, do not modify this codebase to add Express/HTTP logic. 
+Instead, wrap the process using standard open-source MCP proxies like [mcp-proxy](https://github.com/sparfenyuk/mcp-proxy). This cleanly separates the transport layer security from the AI logic.
+
 ## 🐛 Troubleshooting
 
 **Error: `OptimizerError: Full table scan detected...`**
@@ -169,3 +199,5 @@ This means the MCP JSON-RPC protocol crashed. Ensure you are passing the correct
 
 ---
 *Built for the AI Engineering era.*
+
+---

package/dist/db/index.js

@@ -10,24 +10,65 @@ export const pool = mysql.createPool({
     password: process.env.DB_PASSWORD || '',
     database: process.env.DB_NAME || 'test',
     waitForConnections: true,
-    connectionLimit: 10,
+    connectionLimit: parseInt(process.env.MYSQL_CONNECTION_LIMIT || '10', 10),
     queueLimit: 0,
-    connectTimeout: 10000 // 10 seconds
+    connectTimeout: parseInt(process.env.MYSQL_CONNECT_TIMEOUT || '10000', 10)
 });
+// Session-Level Defense in Depth
+const allowInsert = process.env.ALLOW_INSERT_OPERATION === 'true';
+const allowUpdate = process.env.ALLOW_UPDATE_OPERATION === 'true';
+const allowDelete = process.env.ALLOW_DELETE_OPERATION === 'true';
+const allowDdl = process.env.ALLOW_DDL_OPERATION === 'true';
+const isStrictReadOnlyMode = !(allowInsert || allowUpdate || allowDelete || allowDdl);
+if (isStrictReadOnlyMode) {
+    pool.on('connection', (connection) => {
+        // At runtime this is a callback connection, despite what TS types say
+        connection.query('SET SESSION TRANSACTION READ ONLY', (err) => {
+            if (err) {
+                console.error('[tokenlite-mysql-mcp] Warning: Failed to set connection to READ ONLY:', err.message);
+            }
+        });
+    });
+}
 export function getDbName() {
     return process.env.DB_NAME || 'test';
 }
 /**
- * Executes a safe query with a Timeout.
+ * Executes a safe query with a Timeout and Granular Permissions.
  */
 export async function executeSafeQuery(sql) {
     // AST Validation and Limit Injection
-    const astOptimizedSql = injectLimitAst(sql);
-    // Pre-flight Analysis
-    await analyzeQueryPlan(astOptimizedSql, pool);
+    const { sql: astOptimizedSql, astType } = injectLimitAst(sql);
+    // Permission Enforcement
+    if (astType !== 'select' && astType !== 'show') {
+        const blockedTypes = ['call', 'grant', 'revoke', 'set', 'use'];
+        if (blockedTypes.includes(astType)) {
+            throw new Error(`Security Error: Dangerous operation '${astType}' is strictly prohibited.`);
+        }
+        const allowInsert = process.env.ALLOW_INSERT_OPERATION === 'true';
+        const allowUpdate = process.env.ALLOW_UPDATE_OPERATION === 'true';
+        const allowDelete = process.env.ALLOW_DELETE_OPERATION === 'true';
+        const allowDdl = process.env.ALLOW_DDL_OPERATION === 'true';
+        let isAllowed = false;
+        if ((astType === 'insert' || astType === 'replace') && allowInsert)
+            isAllowed = true;
+        else if (astType === 'update' && allowUpdate)
+            isAllowed = true;
+        else if ((astType === 'delete' || astType === 'truncate') && allowDelete)
+            isAllowed = true;
+        else if (['create', 'alter', 'drop', 'rename'].includes(astType) && allowDdl)
+            isAllowed = true;
+        if (!isAllowed) {
+            throw new Error(`Security Error: Operation '${astType}' is disabled in the server configuration.`);
+        }
+    }
+    // Pre-flight Analysis (Only blocks full table scans on SELECT)
+    if (astType === 'select') {
+        await analyzeQueryPlan(astOptimizedSql, pool);
+    }
     const [rows] = await pool.query({
         sql: astOptimizedSql,
-        timeout: 15000
+        timeout: parseInt(process.env.MYSQL_QUERY_TIMEOUT || '15000', 10)
     });
     return rows;
 }
@@ -40,3 +81,15 @@ export async function pingDb() {
         return false;
     }
 }
+/**
+ * Gracefully shuts down the MySQL connection pool.
+ */
+export async function closePool() {
+    try {
+        await pool.end();
+        console.error('[tokenlite-mysql-mcp] Database connection pool closed gracefully.');
+    }
+    catch (error) {
+        console.error('[tokenlite-mysql-mcp] Error closing database connection pool:', error.message);
+    }
+}

package/dist/db/optimizer.js

@@ -16,11 +16,11 @@ function isBlockingEnabled() {
     return process.env.MCP_SAFE_QUERY_ENABLE_BLOCKING !== 'false';
 }
 /**
- * Parses the SQL query to AST, injects a LIMIT if missing, and returns the modified SQL.
+ * Parses the SQL query to AST, injects a LIMIT if missing for SELECTs, and returns the modified SQL and AST type.
  */
 export function injectLimitAst(sql, maxLimit = 500) {
     if (sql.trim().toUpperCase().startsWith('SHOW')) {
-        return sql;
+        return { sql, astType: 'show' };
     }
     try {
         const astOpt = { database: 'MySQL' };
@@ -32,27 +32,29 @@ export function injectLimitAst(sql, maxLimit = 500) {
             }
             ast = ast[0];
         }
-        if (ast.type !== 'select') {
-            throw new OptimizerError("Security Error: Only SELECT or SHOW statements are allowed.");
-        }
-        if (!ast.limit) {
-            ast.limit = {
-                seperator: "",
-                value: [
-                    { type: 'number', value: maxLimit }
-                ]
-            };
-        }
-        else {
-            // Check if existing limit exceeds maxLimit
-            // @ts-ignore
-            const limitValue = ast.limit.value[0]?.value;
-            if (typeof limitValue === 'number' && limitValue > maxLimit) {
-                // @ts-ignore
-                ast.limit.value[0].value = maxLimit;
+        // @ts-ignore
+        const type = ast.type?.toLowerCase();
+        // Only inject LIMIT and sqlify if it's a SELECT query.
+        // For DML/DDL, we just return the original SQL to avoid parser mangling.
+        if (type === 'select') {
+            const selectAst = ast;
+            if (!selectAst.limit) {
+                selectAst.limit = {
+                    seperator: "",
+                    value: [
+                        { type: 'number', value: maxLimit }
+                    ]
+                };
+            }
+            else {
+                const limitValue = selectAst.limit.value[0]?.value;
+                if (typeof limitValue === 'number' && limitValue > maxLimit) {
+                    selectAst.limit.value[0].value = maxLimit;
+                }
             }
+            return { sql: parser.sqlify(selectAst, astOpt), astType: type };
         }
-        return parser.sqlify(ast, astOpt);
+        return { sql, astType: type };
     }
     catch (e) {
         if (e instanceof OptimizerError) {

package/dist/db/schema.js

@@ -1,5 +1,20 @@
 import { pool, getDbName } from './index.js';
 export let schemaGraph = new Map();
+/**
+ * Retrieves the raw DDL (CREATE TABLE) statement for a given table.
+ */
+export async function getTableDDL(tableName) {
+    try {
+        const [rows] = await pool.query(`SHOW CREATE TABLE \`${tableName}\``);
+        if (rows && rows.length > 0) {
+            return rows[0]['Create Table'] || rows[0]['Create View'];
+        }
+        return null;
+    }
+    catch (e) {
+        return null;
+    }
+}
 /**
  * Connects to the database and builds the relational graph in-memory.
  * Optimized for low RAM usage by only extracting node names and edges (no DDL/Columns cached).

package/dist/index.js

@@ -4,9 +4,11 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { registerExecuteQueryTool } from "./tools/executeQuery.js";
 import { registerSearchSchemaTool } from "./tools/searchSchema.js";
 import { registerRefreshSchemaTool } from "./tools/refreshSchema.js";
-import { registerGetTemplatesTool } from "./tools/getTemplates.js";
+import { registerTemplatesPrompt } from "./prompts/templates.js";
+import { registerTableResources } from "./resources/tables.js";
 import { buildSchemaGraph } from "./db/schema.js";
 import { initMetadata } from "./db/metadata.js";
+import { closePool } from "./db/index.js";
 import dotenv from "dotenv";
 dotenv.config({ quiet: true });
 async function main() {
@@ -18,12 +20,27 @@ async function main() {
     await buildSchemaGraph();
     // Load Metadata and Templates
     initMetadata();
-    // Register MCP Tools
-    registerSearchSchemaTool(server);
-    registerExecuteQueryTool(server);
-    registerRefreshSchemaTool(server);
-    registerGetTemplatesTool(server);
+    // Generate or use provided tool prefix (dev_, prod_ ...)
+    let prefix = process.env.TOOL_PREFIX;
+    if (!prefix) {
+        const randomStr = Math.random().toString(36).substring(2, 6);
+        prefix = `db_${randomStr}_`;
+    }
+    // Register MCP tools & prompts & resources
+    registerSearchSchemaTool(server, prefix);
+    registerExecuteQueryTool(server, prefix);
+    registerRefreshSchemaTool(server, prefix);
+    registerTemplatesPrompt(server, prefix);
+    registerTableResources(server);
     const transport = new StdioServerTransport();
     await server.connect(transport);
+    const cleanup = async () => {
+        console.error('\n[tokenlite-mysql-mcp] Shutting down server...');
+        await server.close();
+        await closePool();
+        process.exit(0);
+    };
+    process.on('SIGINT', cleanup);
+    process.on('SIGTERM', cleanup);
 }
 main().catch(console.error);

package/dist/prompts/templates.js

@@ -0,0 +1,39 @@
+import { z } from "zod";
+import { searchTemplates } from "../db/metadata.js";
+export function registerTemplatesPrompt(server, prefix = "") {
+    server.prompt(`${prefix}query_templates`, "Official company SQL templates for business metrics. Use this as a starting point to avoid writing SQL from scratch.", {
+        query: z.string().optional().describe("Keyword to search for in templates (e.g., 'revenue', 'ltv').")
+    }, ({ query }) => {
+        const results = searchTemplates(query || "");
+        if (results.length === 0) {
+            return {
+                messages: [
+                    {
+                        role: "user",
+                        content: {
+                            type: "text",
+                            text: "No SQL templates found matching your query."
+                        }
+                    }
+                ]
+            };
+        }
+        let output = "--- PRE-APPROVED SQL TEMPLATES ---\n\n";
+        for (const t of results) {
+            output += `### ${t.name}\n`;
+            output += `Description: ${t.description}\n`;
+            output += `SQL:\n\`\`\`sql\n${t.sql}\n\`\`\`\n\n`;
+        }
+        return {
+            messages: [
+                {
+                    role: "user",
+                    content: {
+                        type: "text",
+                        text: output
+                    }
+                }
+            ]
+        };
+    });
+}

package/dist/resources/tables.js

@@ -0,0 +1,50 @@
+import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { schemaGraph, getTableDDL } from "../db/schema.js";
+import { getTableSemantics } from "../db/metadata.js";
+export function registerTableResources(server) {
+    // List all available tables
+    server.resource("schema", "mysql://schema", { description: "Lists all available tables in the database schema" }, async (uri) => {
+        const tables = Array.from(schemaGraph.keys());
+        if (tables.length === 0) {
+            return {
+                contents: [{
+                        uri: uri.href,
+                        text: "Schema Graph is empty. Make sure the database is connected."
+                    }]
+            };
+        }
+        return {
+            contents: [{
+                    uri: uri.href,
+                    text: `Available tables in the database:\n\n${tables.map(t => `- ${t}`).join('\n')}`
+                }]
+        };
+    });
+    // DDL for a specific table
+    server.resource("table", new ResourceTemplate("mysql://tables/{name}", { list: undefined }), { description: "Exposes the SQL DDL and semantic dictionary of a specific table" }, async (uri, { name }) => {
+        const tableName = typeof name === 'string' ? name : String(name);
+        const ddl = await getTableDDL(tableName);
+        if (!ddl) {
+            return {
+                contents: [{
+                        uri: uri.href,
+                        text: `Table '${tableName}' not found or could not fetch DDL.`
+                    }]
+            };
+        }
+        let output = `-- === TABLE: ${tableName} ===\n${ddl};\n`;
+        // Append Semantics if available
+        const semantics = getTableSemantics(tableName);
+        if (Object.keys(semantics).length > 0) {
+            output += `\n/* SEMANTIC DICTIONARY:\n`;
+            output += JSON.stringify(semantics, null, 2);
+            output += `\n*/\n`;
+        }
+        return {
+            contents: [{
+                    uri: uri.href,
+                    text: output
+                }]
+        };
+    });
+}

package/dist/tools/executeQuery.js

@@ -2,32 +2,48 @@ import { z } from "zod";
 import { executeSafeQuery } from "../db/index.js";
 import { jsonToCsv } from "../utils/csvFormatter.js";
 export async function handleExecuteQuery({ sql }) {
-    if (!sql.trim().toUpperCase().startsWith("SELECT") && !sql.trim().toUpperCase().startsWith("SHOW")) {
-        return {
-            content: [{ type: "text", text: "Security Error: Only SELECT or SHOW statements are allowed." }],
-            isError: true
-        };
-    }
     try {
-        const rows = await executeSafeQuery(sql);
-        const csvData = jsonToCsv(rows);
-        return {
-            content: [{ type: "text", text: csvData }]
-        };
+        const result = await executeSafeQuery(sql);
+        // If it's a SELECT, result are rows
+        if (Array.isArray(result)) {
+            const csvData = jsonToCsv(result);
+            return {
+                content: [{ type: "text", text: csvData }]
+            };
+        }
+        // If it's a DML/DDL operation, result is a ResultSetHeader object
+        else {
+            const header = result;
+            const message = `Operation executed successfully.\nAffected rows: ${header.affectedRows || 0}` +
+                (header.insertId ? `\nInsert ID: ${header.insertId}` : '') +
+                (header.changedRows ? `\nChanged rows: ${header.changedRows}` : '');
+            return {
+                content: [{ type: "text", text: message }]
+            };
+        }
     }
     catch (error) {
         let errorMessage = error.name === 'OptimizerError' ? error.message : `Database Error: ${error.message}`;
         if (error.code === 'ER_BAD_FIELD_ERROR' || error.message?.includes('Unknown column')) {
             errorMessage += `\n\nHint: If you believe this column exists, the DBA might have just added it. Please call the 'refresh_schema' tool and try again.`;
         }
+        else if (error.code === 'PROTOCOL_SEQUENCE_TIMEOUT' || error.message?.includes('timeout')) {
+            errorMessage += `\n\nHint: The query took too long and was aborted to protect the database (DoS protection). Please optimize your query by using better filters, utilizing indexes, or ask the user to increase the MYSQL_QUERY_TIMEOUT.`;
+        }
         return {
             content: [{ type: "text", text: errorMessage }],
             isError: true
         };
     }
 }
-export function registerExecuteQueryTool(server) {
-    server.tool("execute_safe_query", "Executes a safe SELECT query on the database. Large results are automatically truncated. CRITICAL: NEVER use this tool (e.g., SHOW TABLES or querying information_schema) to understand the database structure. You MUST ALWAYS use the 'search_schema' tool first to understand the relationships and tables before writing any JOIN queries.", {
+export function registerExecuteQueryTool(server, prefix = "") {
+    const allowInsert = process.env.ALLOW_INSERT_OPERATION === 'true';
+    const allowUpdate = process.env.ALLOW_UPDATE_OPERATION === 'true';
+    const allowDelete = process.env.ALLOW_DELETE_OPERATION === 'true';
+    const allowDdl = process.env.ALLOW_DDL_OPERATION === 'true';
+    // If any write operation is enabled, this tool is no longer read-only
+    const isReadOnly = !(allowInsert || allowUpdate || allowDelete || allowDdl);
+    server.tool(`${prefix}execute_safe_query`, "Executes a safe SELECT query on the database. Large results are automatically truncated. CRITICAL: NEVER use this tool (e.g., SHOW TABLES or querying information_schema) to understand the database structure. You MUST ALWAYS use the 'search_schema' tool first to understand the relationships and tables before writing any JOIN queries.", {
         sql: z.string().describe("SQL SELECT statement to execute."),
-    }, handleExecuteQuery);
+    }, { readOnlyHint: isReadOnly }, handleExecuteQuery);
 }

package/dist/tools/refreshSchema.js

@@ -1,6 +1,6 @@
 import { buildSchemaGraph } from "../db/schema.js";
-export function registerRefreshSchemaTool(server) {
-    server.tool("refresh_schema", "Forces the MCP server to rebuild the internal Schema Graph. Use this if you suspect a DBA recently added a table, column, or foreign key and the search_schema or execute queries are failing.", {}, async () => {
+export function registerRefreshSchemaTool(server, prefix = "") {
+    server.tool(`${prefix}refresh_schema`, "Forces the MCP server to rebuild the internal Schema Graph. Use this if you suspect a DBA recently added a table, column, or foreign key and the search_schema or execute queries are failing.", {}, { idempotentHint: true }, async () => {
         try {
             await buildSchemaGraph();
             return {

package/dist/tools/searchSchema.js

@@ -1,20 +1,7 @@
 import { z } from "zod";
 import Fuse from "fuse.js";
-import { pool } from "../db/index.js";
-import { schemaGraph } from "../db/schema.js";
+import { schemaGraph, getTableDDL } from "../db/schema.js";
 import { getTableSemantics } from "../db/metadata.js";
-async function getTableDDL(tableName) {
-    try {
-        const [rows] = await pool.query(`SHOW CREATE TABLE \`${tableName}\``);
-        if (rows && rows.length > 0) {
-            return rows[0]['Create Table'] || rows[0]['Create View'];
-        }
-        return null;
-    }
-    catch (e) {
-        return null;
-    }
-}
 export async function handleSearchSchema({ query }) {
     if (schemaGraph.size === 0) {
         return {
@@ -81,13 +68,13 @@ export async function handleSearchSchema({ query }) {
     if (inferredHints.length > 0) {
         output += "\n-- === HEURISTIC GRAPH HINTS ===\n" + inferredHints.join("\n");
     }
-    output += "\n\n/* ⚠️ CRITICAL REMINDER: If you are asked to calculate business metrics (LTV, revenue, etc.), DO NOT write the SQL manually. You MUST use the `get_query_templates` tool first to fetch the official template. */";
+    output += "\n\n/* ⚠️ CRITICAL REMINDER: If you are asked to calculate business metrics (LTV, revenue, etc.), DO NOT write the SQL manually. You MUST use the `query_templates` prompt first to fetch the official template. */";
     return {
         content: [{ type: "text", text: output }]
     };
 }
-export function registerSearchSchemaTool(server) {
-    server.tool("search_schema", "CRITICAL TOOL FOR SCHEMA EXPLORATION: Use this tool FIRST to understand the database structure. Searches for a table and returns its exact SQL DDL, along with the DDL of its direct parent and child tables (Auto-Join Context). Do NOT use execute_safe_query for schema exploration.", {
+export function registerSearchSchemaTool(server, prefix = "") {
+    server.tool(`${prefix}search_schema`, "CRITICAL TOOL FOR SCHEMA EXPLORATION: Use this tool FIRST to understand the database structure. Searches for a table and returns its exact SQL DDL, along with the DDL of its direct parent and child tables (Auto-Join Context). Do NOT use execute_safe_query for schema exploration.", {
         query: z.string().describe("The name of the table or entity to search for (e.g. 'users', 'invoices')."),
-    }, handleSearchSchema);
+    }, { readOnlyHint: true }, handleSearchSchema);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@andezdev/tokenlite-mysql-mcp",
-  "version": "1.0.0",
+  "version": "2.0.0",
   "description": "A secure, efficient, and intelligent MySQL server for the Model Context Protocol",
   "main": "dist/index.js",
   "type": "module",