@berthojoris/mcp-mysql-server 1.14.1 → 1.16.0

package/dist/mcp-server.js

@@ -659,6 +659,23 @@ const TOOLS = [
             properties: {},
         },
     },
+    {
+        name: "read_changelog",
+        description: "Reads the changelog to see what features are new or changed.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                version: {
+                    type: "string",
+                    description: "Optional: specific version to read (e.g., '1.0.0')",
+                },
+                limit: {
+                    type: "number",
+                    description: "Optional: limit character count (default: 5000)",
+                },
+            },
+        },
+    },
     {
         name: "test_connection",
         description: "Tests the database connection and returns latency information.",
@@ -2806,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({
@@ -2874,6 +3134,9 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
             case "test_connection":
                 result = await mysqlMCP.testConnection();
                 break;
+            case "read_changelog":
+                result = await mysqlMCP.readChangelog((args || {}));
+                break;
             case "get_table_relationships":
                 result = await mysqlMCP.getTableRelationships((args || {}));
                 break;
@@ -3204,6 +3467,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/documentationGeneratorTools.d.ts

@@ -0,0 +1,145 @@
+import { SecurityLayer } from "../security/securityLayer";
+/**
+ * AI-Powered Documentation Generator
+ * Automatic database documentation generation with business glossary
+ */
+export declare class DocumentationGeneratorTools {
+    private db;
+    private security;
+    constructor(security: SecurityLayer);
+    /**
+     * Validate database access - ensures only the connected database can be accessed
+     */
+    private validateDatabaseAccess;
+    /**
+     * Generate comprehensive database documentation
+     */
+    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;
+    }>;
+    /**
+     * Generate data dictionary for a specific table
+     */
+    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;
+    }>;
+    /**
+     * Generate a business glossary from the schema
+     */
+    generateBusinessGlossaryReport(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;
+    }>;
+    /**
+     * Generate business glossary from columns
+     */
+    private generateBusinessGlossary;
+    /**
+     * Get table statistics
+     */
+    private getTableStatistics;
+    /**
+     * Generate Markdown documentation
+     */
+    private generateMarkdown;
+    /**
+     * Generate HTML documentation
+     */
+    private generateHTML;
+    /**
+     * Generate JSON documentation
+     */
+    private generateJSON;
+    /**
+     * Group indexes by name
+     */
+    private groupIndexes;
+    /**
+     * Infer business term from column name
+     */
+    private inferBusinessTerm;
+    /**
+     * Infer column description from name and type
+     */
+    private inferColumnDescription;
+    /**
+     * Infer table description from name
+     */
+    private inferTableDescription;
+    /**
+     * Infer category from column name and type
+     */
+    private inferCategory;
+    /**
+     * Normalize column name for comparison
+     */
+    private normalizeColumnName;
+}