@berthojoris/mcp-mysql-server 1.15.0 → 1.16.1

package/dist/index.d.ts

@@ -25,6 +25,9 @@ export declare class MySQLMCP {
     private analysisTools;
     private aiTools;
     private macroTools;
+    private intelligentQueryTools;
+    private smartDiscoveryTools;
+    private documentationGeneratorTools;
     private security;
     private featureConfig;
     constructor(permissionsConfig?: string, categoriesConfig?: string, presetName?: string);
@@ -1175,5 +1178,227 @@ export declare class MySQLMCP {
         message?: string;
         error?: string;
     }>;
+    buildQueryFromIntent(params: {
+        natural_language: string;
+        context?: "analytics" | "reporting" | "data_entry" | "schema_exploration";
+        max_complexity?: "simple" | "medium" | "complex";
+        safety_level?: "strict" | "moderate" | "permissive";
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: {
+            generated_sql: string;
+            explanation: string;
+            tables_involved: string[];
+            columns_involved: string[];
+            estimated_complexity: string;
+            safety_notes: string[];
+            optimization_hints: string[];
+            alternatives?: string[];
+        };
+        error?: string;
+    }>;
+    suggestQueryImprovements(params: {
+        query: string;
+        optimization_goal?: "speed" | "memory" | "readability";
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: {
+            original_query: string;
+            suggestions: Array<{
+                type: string;
+                description: string;
+                improved_query?: string;
+            }>;
+            estimated_improvement: string;
+        };
+        error?: string;
+    }>;
+    smartSearch(params: {
+        search_term: string;
+        search_type?: "column" | "table" | "data_pattern" | "relationship" | "all";
+        similarity_threshold?: number;
+        include_sample_data?: boolean;
+        max_results?: number;
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: {
+            search_term: string;
+            search_type: string;
+            results: {
+                tables: Array<{
+                    name: string;
+                    relevance_score: number;
+                    match_reason: string;
+                    column_count: number;
+                    row_estimate: number;
+                    matching_columns?: string[];
+                }>;
+                columns: Array<{
+                    table_name: string;
+                    column_name: string;
+                    data_type: string;
+                    relevance_score: number;
+                    match_reason: string;
+                    sample_values?: any[];
+                }>;
+                data_patterns: Array<{
+                    table_name: string;
+                    column_name: string;
+                    pattern_type: string;
+                    description: string;
+                    sample_matches?: any[];
+                }>;
+                relationships: Array<{
+                    from_table: string;
+                    from_column: string;
+                    to_table: string;
+                    to_column: string;
+                    relationship_type: string;
+                    confidence: number;
+                }>;
+            };
+            total_matches: number;
+            search_time_ms: number;
+        };
+        error?: string;
+    }>;
+    findSimilarColumns(params: {
+        column_name?: string;
+        table_name?: string;
+        include_data_comparison?: boolean;
+        max_results?: number;
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: {
+            reference_column?: {
+                table: string;
+                column: string;
+                data_type: string;
+            };
+            similar_columns: Array<{
+                table_name: string;
+                column_name: string;
+                data_type: string;
+                similarity_score: number;
+                similarity_type: string;
+                data_overlap_percentage?: number;
+            }>;
+            potential_joins: Array<{
+                table1: string;
+                column1: string;
+                table2: string;
+                column2: string;
+                confidence: number;
+                reason: string;
+            }>;
+        };
+        error?: string;
+    }>;
+    discoverDataPatterns(params: {
+        table_name: string;
+        pattern_types?: Array<"unique" | "null" | "duplicate" | "format" | "range">;
+        max_columns?: number;
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: {
+            table_name: string;
+            patterns: Array<{
+                column_name: string;
+                pattern_type: string;
+                description: string;
+                metrics?: Record<string, any>;
+                recommendations?: string[];
+            }>;
+            summary: {
+                columns_analyzed: number;
+                patterns_found: number;
+                data_quality_score: number;
+            };
+        };
+        error?: string;
+    }>;
+    generateDocumentation(params: {
+        scope?: "database" | "table" | "column" | "relationship";
+        table_name?: string;
+        include_business_glossary?: boolean;
+        format?: "markdown" | "html" | "json";
+        include_examples?: boolean;
+        include_statistics?: boolean;
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: {
+            format: string;
+            scope: string;
+            content: string;
+            metadata: {
+                generated_at: string;
+                database: string;
+                tables_documented: number;
+                columns_documented: number;
+            };
+        };
+        error?: string;
+    }>;
+    generateDataDictionary(params: {
+        table_name: string;
+        include_sample_values?: boolean;
+        include_constraints?: boolean;
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: {
+            table_name: string;
+            description: string;
+            columns: Array<{
+                name: string;
+                data_type: string;
+                description: string;
+                constraints: string[];
+                is_nullable: boolean;
+                default_value: string | null;
+                sample_values?: any[];
+                business_term?: string;
+            }>;
+            primary_key: string[];
+            foreign_keys: Array<{
+                column: string;
+                references_table: string;
+                references_column: string;
+            }>;
+            indexes: Array<{
+                name: string;
+                columns: string[];
+                is_unique: boolean;
+            }>;
+        };
+        error?: string;
+    }>;
+    generateBusinessGlossary(params: {
+        include_descriptions?: boolean;
+        group_by?: "table" | "category" | "alphabetical";
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: {
+            glossary: Array<{
+                term: string;
+                technical_name: string;
+                source_table: string;
+                data_type: string;
+                description: string;
+                category: string;
+                related_terms?: string[];
+            }>;
+            categories: string[];
+            total_terms: number;
+        };
+        error?: string;
+    }>;
 }
 export default MySQLMCP;

package/dist/index.js

@@ -26,6 +26,9 @@ const performanceTools_1 = require("./tools/performanceTools");
 const analysisTools_1 = require("./tools/analysisTools");
 const aiTools_1 = require("./tools/aiTools");
 const macroTools_1 = require("./tools/macroTools");
+const intelligentQueryTools_1 = require("./tools/intelligentQueryTools");
+const smartDiscoveryTools_1 = require("./tools/smartDiscoveryTools");
+const documentationGeneratorTools_1 = require("./tools/documentationGeneratorTools");
 const securityLayer_1 = __importDefault(require("./security/securityLayer"));
 const connection_1 = __importDefault(require("./db/connection"));
 const featureConfig_1 = require("./config/featureConfig");
@@ -60,6 +63,9 @@ class MySQLMCP {
         this.analysisTools = new analysisTools_1.AnalysisTools(this.security);
         this.aiTools = new aiTools_1.AiTools(this.security);
         this.macroTools = new macroTools_1.MacroTools(this.security);
+        this.intelligentQueryTools = new intelligentQueryTools_1.IntelligentQueryTools(this.security);
+        this.smartDiscoveryTools = new smartDiscoveryTools_1.SmartDiscoveryTools(this.security);
+        this.documentationGeneratorTools = new documentationGeneratorTools_1.DocumentationGeneratorTools(this.security);
     }
     // Helper method to check if tool is enabled
     checkToolEnabled(toolName) {
@@ -1068,6 +1074,60 @@ class MySQLMCP {
             return { status: "error", error: check.error };
         return await this.performanceTools.resetPerformanceStats();
     }
+    // ==========================================
+    // PHASE 1: AI Enhancement Tools
+    // ==========================================
+    // Intelligent Query Assistant
+    async buildQueryFromIntent(params) {
+        const check = this.checkToolEnabled("buildQueryFromIntent");
+        if (!check.enabled)
+            return { status: "error", error: check.error };
+        return await this.intelligentQueryTools.buildQueryFromIntent(params);
+    }
+    async suggestQueryImprovements(params) {
+        const check = this.checkToolEnabled("suggestQueryImprovements");
+        if (!check.enabled)
+            return { status: "error", error: check.error };
+        return await this.intelligentQueryTools.suggestQueryImprovements(params);
+    }
+    // Smart Data Discovery
+    async smartSearch(params) {
+        const check = this.checkToolEnabled("smartSearch");
+        if (!check.enabled)
+            return { status: "error", error: check.error };
+        return await this.smartDiscoveryTools.smartSearch(params);
+    }
+    async findSimilarColumns(params) {
+        const check = this.checkToolEnabled("findSimilarColumns");
+        if (!check.enabled)
+            return { status: "error", error: check.error };
+        return await this.smartDiscoveryTools.findSimilarColumns(params);
+    }
+    async discoverDataPatterns(params) {
+        const check = this.checkToolEnabled("discoverDataPatterns");
+        if (!check.enabled)
+            return { status: "error", error: check.error };
+        return await this.smartDiscoveryTools.discoverDataPatterns(params);
+    }
+    // Documentation Generator
+    async generateDocumentation(params) {
+        const check = this.checkToolEnabled("generateDocumentation");
+        if (!check.enabled)
+            return { status: "error", error: check.error };
+        return await this.documentationGeneratorTools.generateDocumentation(params);
+    }
+    async generateDataDictionary(params) {
+        const check = this.checkToolEnabled("generateDataDictionary");
+        if (!check.enabled)
+            return { status: "error", error: check.error };
+        return await this.documentationGeneratorTools.generateDataDictionary(params);
+    }
+    async generateBusinessGlossary(params) {
+        const check = this.checkToolEnabled("generateBusinessGlossary");
+        if (!check.enabled)
+            return { status: "error", error: check.error };
+        return await this.documentationGeneratorTools.generateBusinessGlossaryReport(params);
+    }
 }
 exports.MySQLMCP = MySQLMCP;
 exports.default = MySQLMCP;

package/dist/mcp-server.js

@@ -392,7 +392,7 @@ const TOOLS = [
     },
     {
         name: "run_query",
-        description: "Runs a read-only SQL SELECT query with optional parameters, optimizer hints, and caching support. Only SELECT statements are allowed.",
+        description: "⚡ USE THIS FOR SELECT QUERIES. Runs a read-only SQL SELECT query with optional parameters, optimizer hints, and caching support. ONLY SELECT statements are allowed - use execute_sql for INSERT/UPDATE/DELETE, use execute_ddl for CREATE/ALTER/DROP.",
         inputSchema: {
             type: "object",
             properties: {
@@ -459,7 +459,7 @@ const TOOLS = [
     },
     {
         name: "execute_sql",
-        description: 'Executes a write SQL operation (INSERT, UPDATE, DELETE) with optional parameters. DDL operations require "ddl" permission.',
+        description: '⚡ USE THIS FOR INSERT/UPDATE/DELETE. Executes a write SQL operation (INSERT, UPDATE, DELETE) with optional parameters. NOT for SELECT (use run_query), NOT for DDL (use execute_ddl for CREATE/ALTER/DROP/TRUNCATE/RENAME).',
         inputSchema: {
             type: "object",
             properties: {
@@ -639,13 +639,13 @@ const TOOLS = [
     },
     {
         name: "execute_ddl",
-        description: 'Executes raw DDL SQL (CREATE, ALTER, DROP, TRUNCATE, RENAME). Requires "ddl" permission.',
+        description: '⚡ USE THIS FOR DDL ONLY (CREATE, ALTER, DROP, TRUNCATE, RENAME). NOT for SELECT (use run_query), NOT for INSERT/UPDATE/DELETE (use execute_sql). Requires "ddl" permission.',
         inputSchema: {
             type: "object",
             properties: {
                 query: {
                     type: "string",
-                    description: "DDL SQL query to execute",
+                    description: "DDL SQL query to execute (must start with CREATE, ALTER, DROP, TRUNCATE, or RENAME - NO SELECT queries!)",
                 },
             },
             required: ["query"],
@@ -2823,6 +2823,249 @@ const TOOLS = [
             properties: {},
         },
     },
+    // ==========================================
+    // PHASE 1: AI Enhancement Tools
+    // ==========================================
+    // Intelligent Query Assistant
+    {
+        name: "build_query_from_intent",
+        description: "Converts natural language to optimized SQL with context-aware query generation. Analyzes your intent and generates safe, optimized SQL queries with explanations.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                natural_language: {
+                    type: "string",
+                    description: "Natural language description of what you want to query, e.g., 'show me all users who registered last month'",
+                },
+                context: {
+                    type: "string",
+                    enum: ["analytics", "reporting", "data_entry", "schema_exploration"],
+                    description: "Context for query generation (default: analytics)",
+                },
+                max_complexity: {
+                    type: "string",
+                    enum: ["simple", "medium", "complex"],
+                    description: "Maximum allowed query complexity (default: medium)",
+                },
+                safety_level: {
+                    type: "string",
+                    enum: ["strict", "moderate", "permissive"],
+                    description: "Safety level for query generation (default: moderate)",
+                },
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+            },
+            required: ["natural_language"],
+        },
+    },
+    {
+        name: "suggest_query_improvements",
+        description: "Analyzes a SQL query and suggests improvements for speed, memory, or readability. Identifies inefficient patterns and provides optimized alternatives.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                query: {
+                    type: "string",
+                    description: "SQL query to analyze and improve",
+                },
+                optimization_goal: {
+                    type: "string",
+                    enum: ["speed", "memory", "readability"],
+                    description: "Primary optimization goal (default: speed)",
+                },
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+            },
+            required: ["query"],
+        },
+    },
+    // Smart Data Discovery
+    {
+        name: "smart_search",
+        description: "Finds relevant tables, columns, data patterns, and relationships using semantic search. Essential for exploring large databases with hundreds of tables.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                search_term: {
+                    type: "string",
+                    description: "Search term to find related database objects (e.g., 'customer', 'order date', 'email')",
+                },
+                search_type: {
+                    type: "string",
+                    enum: ["column", "table", "data_pattern", "relationship", "all"],
+                    description: "Type of search (default: all)",
+                },
+                similarity_threshold: {
+                    type: "number",
+                    description: "Minimum similarity score 0-1 (default: 0.3)",
+                },
+                include_sample_data: {
+                    type: "boolean",
+                    description: "Include sample values from matched columns (default: false)",
+                },
+                max_results: {
+                    type: "number",
+                    description: "Maximum results per category (default: 20)",
+                },
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+            },
+            required: ["search_term"],
+        },
+    },
+    {
+        name: "find_similar_columns",
+        description: "Finds columns with similar names or data across tables. Discovers potential join candidates and implicit relationships between tables.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                column_name: {
+                    type: "string",
+                    description: "Optional: reference column name to find similar columns",
+                },
+                table_name: {
+                    type: "string",
+                    description: "Optional: table containing the reference column",
+                },
+                include_data_comparison: {
+                    type: "boolean",
+                    description: "Compare actual data overlap between columns (slower but more accurate, default: false)",
+                },
+                max_results: {
+                    type: "number",
+                    description: "Maximum results (default: 20)",
+                },
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+            },
+        },
+    },
+    {
+        name: "discover_data_patterns",
+        description: "Discovers data patterns in a table including uniqueness, null rates, duplicates, formats, and value ranges. Provides data quality score and recommendations.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                table_name: {
+                    type: "string",
+                    description: "Name of the table to analyze",
+                },
+                pattern_types: {
+                    type: "array",
+                    items: {
+                        type: "string",
+                        enum: ["unique", "null", "duplicate", "format", "range"],
+                    },
+                    description: "Types of patterns to discover (default: all)",
+                },
+                max_columns: {
+                    type: "number",
+                    description: "Maximum columns to analyze (default: 20)",
+                },
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+            },
+            required: ["table_name"],
+        },
+    },
+    // Documentation Generator
+    {
+        name: "generate_documentation",
+        description: "Generates comprehensive database documentation with business glossary in Markdown, HTML, or JSON format. Includes schema, relationships, and example queries.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                scope: {
+                    type: "string",
+                    enum: ["database", "table", "column", "relationship"],
+                    description: "Documentation scope (default: database)",
+                },
+                table_name: {
+                    type: "string",
+                    description: "Optional: specific table to document (for table scope)",
+                },
+                include_business_glossary: {
+                    type: "boolean",
+                    description: "Include business term glossary (default: true)",
+                },
+                format: {
+                    type: "string",
+                    enum: ["markdown", "html", "json"],
+                    description: "Output format (default: markdown)",
+                },
+                include_examples: {
+                    type: "boolean",
+                    description: "Include example SQL queries (default: true)",
+                },
+                include_statistics: {
+                    type: "boolean",
+                    description: "Include row counts and statistics (default: true)",
+                },
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+            },
+        },
+    },
+    {
+        name: "generate_data_dictionary",
+        description: "Generates a detailed data dictionary for a specific table with column descriptions, constraints, sample values, and business terms.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                table_name: {
+                    type: "string",
+                    description: "Name of the table to document",
+                },
+                include_sample_values: {
+                    type: "boolean",
+                    description: "Include sample values for each column (default: true)",
+                },
+                include_constraints: {
+                    type: "boolean",
+                    description: "Include constraint information (default: true)",
+                },
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+            },
+            required: ["table_name"],
+        },
+    },
+    {
+        name: "generate_business_glossary",
+        description: "Generates a business glossary from database column names with inferred descriptions and categorization. Helps with onboarding and data governance.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                include_descriptions: {
+                    type: "boolean",
+                    description: "Include auto-generated descriptions (default: true)",
+                },
+                group_by: {
+                    type: "string",
+                    enum: ["table", "category", "alphabetical"],
+                    description: "How to group glossary terms (default: category)",
+                },
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+            },
+        },
+    },
 ];
 // Create the MCP server
 const server = new index_js_1.Server({
@@ -2876,6 +3119,40 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
             case "read_table_schema":
                 result = await mysqlMCP.readTableSchema((args || {}));
                 break;
+            // CRUD Tools
+            case "create_record":
+                result = await mysqlMCP.createRecord((args || {}));
+                break;
+            case "read_records":
+                result = await mysqlMCP.readRecords((args || {}));
+                break;
+            case "update_record":
+                result = await mysqlMCP.updateRecord((args || {}));
+                break;
+            case "delete_record":
+                result = await mysqlMCP.deleteRecord((args || {}));
+                break;
+            // Bulk Operations
+            case "bulk_insert":
+                result = await mysqlMCP.bulkInsert((args || {}));
+                break;
+            case "bulk_update":
+                result = await mysqlMCP.bulkUpdate((args || {}));
+                break;
+            case "bulk_delete":
+                result = await mysqlMCP.bulkDelete((args || {}));
+                break;
+            // Query Tools
+            case "run_query":
+                result = await mysqlMCP.runQuery((args || {}));
+                break;
+            case "execute_sql":
+                result = await mysqlMCP.executeSql((args || {}));
+                break;
+            // DDL Tools
+            case "create_table":
+                result = await mysqlMCP.createTable(args || {});
+                break;
             case "alter_table":
                 result = await mysqlMCP.alterTable(args || {});
                 break;
@@ -3224,6 +3501,36 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
             case "repair_query":
                 result = await mysqlMCP.repairQuery((args || {}));
                 break;
+            // ==========================================
+            // PHASE 1: AI Enhancement Tools
+            // ==========================================
+            // Intelligent Query Assistant
+            case "build_query_from_intent":
+                result = await mysqlMCP.buildQueryFromIntent((args || {}));
+                break;
+            case "suggest_query_improvements":
+                result = await mysqlMCP.suggestQueryImprovements((args || {}));
+                break;
+            // Smart Data Discovery
+            case "smart_search":
+                result = await mysqlMCP.smartSearch((args || {}));
+                break;
+            case "find_similar_columns":
+                result = await mysqlMCP.findSimilarColumns((args || {}));
+                break;
+            case "discover_data_patterns":
+                result = await mysqlMCP.discoverDataPatterns((args || {}));
+                break;
+            // Documentation Generator
+            case "generate_documentation":
+                result = await mysqlMCP.generateDocumentation((args || {}));
+                break;
+            case "generate_data_dictionary":
+                result = await mysqlMCP.generateDataDictionary((args || {}));
+                break;
+            case "generate_business_glossary":
+                result = await mysqlMCP.generateBusinessGlossary((args || {}));
+                break;
             default:
                 throw new Error(`Unknown tool: ${name}`);
         }

package/dist/tools/ddlTools.js

@@ -201,7 +201,7 @@ class DdlTools {
             if (!isDdl) {
                 return {
                     status: "error",
-                    error: "Only DDL operations (CREATE, ALTER, DROP, TRUNCATE, RENAME) are allowed with executeDdl",
+                    error: "Only DDL operations (CREATE, ALTER, DROP, TRUNCATE, RENAME) are allowed with execute_ddl. For SELECT queries, use the 'run_query' tool instead. For INSERT/UPDATE/DELETE, use the 'execute_sql' tool.",
                 };
             }
             const result = await this.db.query(query);