@berthojoris/mcp-mysql-server 1.4.7 → 1.4.12

package/CHANGELOG.md

@@ -5,6 +5,111 @@ All notable changes to the MySQL MCP Server will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.4.12] - 2025-11-21
+
+### Added
+- **Explicit LLM instruction field** - Added `⚠️ IMPORTANT_INSTRUCTION_TO_ASSISTANT` field that explicitly instructs the LLM to always display SQL query information to users
+- **Mandatory display directive** - Clear instruction stating "ALWAYS display the SQL query execution details below to the user in your response"
+
+### Technical Changes
+- Response now includes three fields in order:
+  1. `⚠️ IMPORTANT_INSTRUCTION_TO_ASSISTANT` - Direct instruction to the LLM
+  2. `⚠️ SQL_QUERY_EXECUTED` - The SQL query details
+  3. `📊 RESULTS` - The query results
+- This approach ensures LLMs understand that SQL query information is not optional context
+
+## [1.4.11] - 2025-11-21
+
+### Changed
+- **SQL query as data field (BREAKING)** - Restructured response to embed SQL query directly in the data JSON as `⚠️ SQL_QUERY_EXECUTED` field
+- **Results wrapped** - Actual query results now under `📊 RESULTS` field
+- **LLM-proof approach** - By making SQL query part of the data structure itself, LLMs cannot filter it out when describing results
+
+### Technical Changes
+- Response format changed from `{data: [...]}` to `{"⚠️ SQL_QUERY_EXECUTED": "...", "📊 RESULTS": [...]}`
+- SQL query information is now a required part of the response structure, not optional metadata
+- This forces AI assistants to acknowledge and communicate SQL query details to users
+
+## [1.4.10] - 2025-11-21
+
+### Improved  
+- **SQL query embedded in data structure** - SQL query is now embedded as a field in the response JSON, forcing LLMs to include it when describing results
+- **Visual field names** - Using emoji-prefixed field names (`⚠️ SQL_QUERY_EXECUTED` and `📊 RESULTS`) to make SQL query information stand out
+- **Guaranteed visibility** - By making SQL query part of the actual data structure instead of metadata, LLMs must process and describe it
+
+### Technical Changes
+- Changed response structure to wrap data in object with SQL query as a top-level field
+- SQL query appears as `"⚠️ SQL_QUERY_EXECUTED"` field containing formatted query details
+- Results appear as `"📊 RESULTS"` field containing the actual query results
+- This approach treats SQL execution details as primary data, not optional metadata
+- Forces LLMs to acknowledge and describe the SQL query when processing tool responses
+
+## [1.4.9] - 2025-11-21
+
+### Improved
+- **Multi-block content response** - SQL query and results are now returned as separate MCP content blocks for better visibility in client UIs
+- **Enhanced MCP client compatibility** - Completely redesigned query log output format for better rendering in Kilocode and other MCP clients
+- **Visual query log hierarchy** - Added clear visual separators using box-drawing characters (━) for better readability
+- **Prominent SQL display** - SQL queries are now displayed at the TOP of responses with clear emoji indicators (✅/❌)
+- **Better information architecture** - Query execution details (time, timestamp, status) now prominently displayed before SQL
+- **Improved emoji usage** - Added contextual emojis (📝 for SQL, 📋 for parameters, ⏱️ for time, 🕐 for timestamp) for quick visual scanning
+- **Response structure optimization** - Query logs appear as FIRST content block, results as second block
+- **Enhanced error visibility** - Error messages now include ❌ emoji for immediate identification
+- **Explicit LLM instructions** - Added explicit notes instructing LLMs to display SQL query information to users
+
+### Technical Changes
+- **Breaking improvement**: Changed response structure from single text content to multiple content blocks (MCP spec compliant)
+- First content block contains SQL query execution details
+- Second content block contains query results
+- Updated `QueryLogger.formatLogs()` with new visual hierarchy using Unicode box-drawing characters
+- Modified `mcp-server.ts` response builder to use separate content blocks
+- Added explicit user-facing notes to SQL query blocks
+- Improved line spacing and formatting for better readability across different client UIs
+
+### Fixed
+- Query logs now render properly in Kilocode without markdown parsing issues
+- SQL query information is structurally separated from results for better LLM and UI handling
+- Visual hierarchy prevents information from being buried in JSON output
+
+## [1.4.8] - 2025-11-21
+
+### Added
+- **Enhanced human-readable SQL query formatting** - All SQL queries in logs are now automatically formatted with proper line breaks, indentation, and structure for better readability
+- **Markdown-friendly query logs** - Query logs use markdown syntax (###, ```, **bold**, ---) for optimal rendering in AI agent UIs
+- **SQL syntax highlighting** - SQL queries wrapped in ```sql code blocks for syntax highlighting support
+- **Formatted parameter display** - Query parameters now displayed with JSON pretty-printing for better readability
+- **Universal query logging** - Extended query log output to ALL 30 tools (previously only available in query and CRUD operations)
+- **Structured log separators** - Added markdown horizontal rules (---) to clearly delineate query sections
+
+### Enhanced Tools with Query Logging
+- ✅ Database Discovery: `list_databases`, `list_tables`, `read_table_schema`, `get_table_relationships`
+- ✅ DDL Operations: `create_table`, `alter_table`, `drop_table`, `execute_ddl`
+- ✅ Transaction Management: `execute_in_transaction`
+- ✅ Stored Procedures: `list_stored_procedures`, `get_stored_procedure_info`, `execute_stored_procedure`, `create_stored_procedure`, `drop_stored_procedure`, `show_create_procedure`
+- ✅ Data Export: `export_table_to_csv`, `export_query_to_csv`
+- ✅ Utilities: `get_table_relationships`
+
+### Technical Changes
+- Enhanced `QueryLogger.formatSQL()` method for intelligent SQL formatting with keyword detection and line breaking
+- Added `formatLogs()` method with visual enhancements replacing previous compact format
+- Retained `formatLogsCompact()` for backward compatibility
+- Updated return type signatures for all 30 tools to include `queryLog?: string`
+- Improved query log output consistency across all tool categories
+- **Fixed MCP server handler** - Query logs are now properly included in LLM responses (previously only data was forwarded)
+- Added visual separator header "📝 SQL QUERY LOG" in MCP responses for better readability
+
+### Fixed
+- **Critical: Query logs now visible to AI agents** - Fixed MCP server handler to properly forward `queryLog` field to LLM responses
+- Query logs now appear in both success and error responses
+
+### Improved
+- **SQL readability** - Complex queries with multiple columns, JOINs, and conditions are now formatted for easy reading
+- **UI rendering** - Switched from Unicode box characters to markdown for better compatibility with AI agent interfaces (Kilocode, Claude Desktop, etc.)
+- **Developer experience** - Logs are now optimized for human consumption with markdown formatting that renders beautifully in chat interfaces
+- **Debugging efficiency** - Clean markdown structure makes it faster to identify query patterns and issues
+- **Documentation** - Comprehensive README updates with markdown-friendly examples of the new query log format
+- **Error transparency** - Failed queries now also show the SQL that was attempted with proper formatting
+
 ## [1.4.7] - 2025-11-21
 
 ### Added

package/README.md

@@ -89,6 +89,46 @@ npm run build
 }
 ```
 
+**Configuration (using local path - for development):**
+
+```json
+{
+  "mcpServers": {
+    "mysql": {
+      "command": "node",
+      "args": [
+        "C:\\DEKSTOP\\MCP\\mcp_mysql\\bin\\mcp-mysql.js",
+        "mysql://user:password@localhost:3306/database",
+        "list,read,utility"
+      ]
+    }
+  }
+}
+```
+
+**Configuration (using environment variables - alternative local approach):**
+
+```json
+{
+  "mcpServers": {
+    "mysql": {
+      "command": "node",
+      "args": [
+        "C:\\DEKSTOP\\MCP\\mcp_mysql\\dist\\mcp-server.js"
+      ],
+      "env": {
+        "DB_HOST": "localhost",
+        "DB_PORT": "3306",
+        "DB_USER": "root",
+        "DB_PASSWORD": "",
+        "DB_NAME": "your_database",
+        "MCP_PERMISSIONS": "list,read,utility"
+      }
+    }
+  }
+}
+```
+
 #### Cline (VS Code Extension)
 
 Add to Cline MCP settings (same JSON format as Claude Desktop).
@@ -111,6 +151,82 @@ Try asking your AI:
 
 ---
 
+## Local vs NPX Configuration
+
+### When to Use Local Path Configuration
+
+Use the local path approach when you:
+- **Want full control** over the version and source code
+- **Need offline access** without internet dependency
+- **Want to modify the source** for custom functionality
+- **Need faster startup** without package download
+- **Are developing/debugging** the MCP server
+- **Have network restrictions** or security policies
+
+### Local Configuration Benefits
+
+| Feature | Local Path | NPX |
+|---------|------------|-----|
+| **Control** | Full control over code | Depends on npm registry |
+| **Offline** | Works completely offline | Requires internet download |
+| **Speed** | Instant startup | Download time |
+| **Customization** | Can modify source code | Limited to published version |
+| **Debugging** | Full source access available | Limited debugging |
+| **Updates** | Manual updates | Automatic updates |
+| **Setup** | Requires building project | Zero setup |
+
+### Local Setup Requirements
+
+1. **Build the project:**
+   ```bash
+   cd "C:\DEKSTOP\MCP\mcp_mysql"
+   npm run build
+   ```
+
+2. **Ensure paths are absolute** - Use full paths to avoid ambiguity
+3. **Use correct binaries:**
+   - `bin/mcp-mysql.js` - CLI wrapper with argument parsing
+   - `dist/mcp-server.js` - Direct server executable
+
+### Common Local Configuration Patterns
+
+**Direct binary with arguments:**
+```json
+{
+  "command": "node",
+  "args": [
+    "C:\\DEKSTOP\\MCP\\mcp_mysql\\bin\\mcp-mysql.js",
+    "mysql://user:pass@localhost:3306/database",
+    "permissions"
+  ]
+}
+```
+
+**Direct server with environment variables:**
+```json
+{
+  "command": "node",
+  "args": ["C:\\DEKSTOP\\MCP\\mcp_mysql\\dist\\mcp-server.js"],
+  "env": {
+    "DB_HOST": "localhost",
+    "DB_PORT": "3306",
+    "DB_USER": "root",
+    "DB_PASSWORD": "",
+    "DB_NAME": "database",
+    "MCP_PERMISSIONS": "permissions"
+  }
+}
+```
+
+### Path Tips
+
+- **Windows paths:** Use double backslashes `\\` in JSON
+- **Cross-platform:** Use forward slashes `/` if supported by your AI agent
+- **Environment variables:** Can use `%USERPROFILE%` or `$HOME` in some systems
+- **Relative paths:** Not recommended - use absolute paths for reliability
+
+---
+
 ##  Permission System
 
 ### Permission Categories
@@ -179,6 +295,7 @@ list,ddl,utility
 
 You can have different databases with different permissions in the same AI agent:
 
+**Using NPX:**
 ```json
 {
   "mcpServers": {
@@ -204,6 +321,30 @@ You can have different databases with different permissions in the same AI agent
 }
 ```
 
+**Using Local Paths:**
+```json
+{
+  "mcpServers": {
+    "mysql-prod": {
+      "command": "node",
+      "args": [
+        "C:\\DEKSTOP\\MCP\\mcp_mysql\\bin\\mcp-mysql.js",
+        "mysql://reader:pass@prod-server:3306/prod_db",
+        "list,read,utility"
+      ]
+    },
+    "mysql-dev": {
+      "command": "node",
+      "args": [
+        "C:\\DEKSTOP\\MCP\\mcp_mysql\\bin\\mcp-mysql.js",
+        "mysql://root:pass@localhost:3306/dev_db",
+        "list,read,create,update,delete,execute,ddl,utility"
+      ]
+    }
+  }
+}
+```
+
 ---
 
 ## 🚫 Permission Error Handling
@@ -1059,53 +1200,185 @@ END IF;
 
 ---
 
-## 📝 Query Logging
+## 📝 Query Logging & Automatic SQL Display
+
+All queries executed through the MySQL MCP Server are automatically logged with detailed execution information in a **human-readable format**. Query logs are **automatically displayed to users** in the LLM response output of **ALL tool operations** that interact with the database.
+
+### ✨ Automatic SQL Query Display (v1.4.12+)
+
+**The SQL queries are now automatically shown to users without needing to explicitly ask for them!**
+
+When you ask questions like:
+- *"Show me all tables in my database"*
+- *"Get the first 10 users"*
+- *"Update user email where id = 5"*
+
+The LLM will automatically include the SQL query execution details in its response, such as:
+
+> "The SQL query 'SHOW TABLES' was executed successfully in 107ms and returned 73 tables including users, products, orders..."
 
-All queries executed through the MySQL MCP Server are automatically logged with detailed execution information. Query logs are included in the response output of all query and data manipulation operations.
+This happens because the SQL query information is embedded as part of the response data structure with an explicit instruction to the LLM to always display it to users.
+
+### How It Works
+
+The MCP server returns responses in this structured format:
+
+```json
+{
+  "⚠️ IMPORTANT_INSTRUCTION_TO_ASSISTANT": "ALWAYS display the SQL query execution details below to the user in your response. This is critical information that users need to see.",
+  "⚠️ SQL_QUERY_EXECUTED": "✅ SQL Query #1 - SUCCESS\n⏱️ 107ms\n📝 SHOW TABLES",
+  "📊 RESULTS": [
+    { "table_name": "users" },
+    { "table_name": "products" }
+  ]
+}
+```
+
+The LLM processes this structure and naturally includes the SQL query information when describing results to you.
 
 ### Query Log Information
 
 Each logged query includes:
-- **Timestamp** - ISO 8601 formatted execution time
-- **SQL Query** - The exact SQL statement executed
-- **Parameters** - Values passed to the query (if any)
-- **Execution Duration** - Time taken to execute in milliseconds
-- **Status** - Success or error indication
+- **Query Number** - Sequential identifier for the query
+- **Status** - Success (✓) or error (✗) with visual indicator
+- **Execution Duration** - Time taken to execute in milliseconds with ⏱️ icon
+- **Timestamp** - ISO 8601 formatted execution time with 🕐 icon
+- **Formatted SQL Query** - Properly formatted SQL with line breaks for readability
+- **Parameters** - Values passed to the query (if any), formatted with JSON indentation
 - **Error Details** - Error message if the query failed (optional)
 
 ### Example Query Log Output
 
+**Markdown-Friendly Format (optimized for AI agent UIs):**
+
+```markdown
+### Query #1 - SUCCESS (12ms)
+**Timestamp:** 2025-11-21T10:30:45.123Z
+
+**SQL:**
+```sql
+SELECT * 
+FROM users 
+WHERE id = ?
 ```
-[1] 2025-11-21T10:30:45.123Z | SELECT * FROM users WHERE id = ? | Params: [5] | Duration: 12ms | Status: success
+Parameters:
+[5]
 ```
 
+**Complex Query with Multiple Parameters:**
+
+```markdown
+### Query #1 - SUCCESS (45ms)
+**Timestamp:** 2025-11-21T10:32:15.456Z
+
+**SQL:**
+```sql
+INSERT INTO users (name,
+  email,
+  age,
+  created_at) 
+VALUES (?,
+  ?,
+  ?,
+  ?)
+```
+Parameters:
+[
+  "John Doe",
+  "john@example.com",
+  30,
+  "2025-11-21T10:32:15.000Z"
+]
+```
+
+### Benefits of Automatic SQL Display
+
+1. **🎓 Learning** - Users can see and learn from the SQL queries being executed
+2. **🔍 Transparency** - Clear visibility into what database operations are performed
+3. **🐛 Debugging** - Easy to identify and troubleshoot query issues
+4. **📊 Performance Monitoring** - See execution times for queries
+5. **✅ Verification** - Confirm the AI is executing the correct queries
+
 ### Viewing Query Logs in Responses
 
-Query logs are automatically included in tool responses via the `queryLog` field:
+Query logs are automatically included in **ALL** tool responses and displayed to users via the structured response format with explicit LLM instructions:
+
+**Example: Viewing Response with Query Log:**
+
+When you call `list_tables`, the AI agent receives:
 
-**Query execution:**
 ```json
-{
-  "status": "success",
-  "data": [
-    {"id": 1, "name": "John Doe", "email": "john@example.com"}
-  ],
-  "queryLog": "[1] 2025-11-21T10:30:45.123Z | SELECT * FROM users | Duration: 8ms | Status: success"
-}
+[
+  {"table_name": "users"},
+  {"table_name": "orders"}
+]
+```
+
+---
+
+## SQL Query Execution Log
+
+### Query #1 - SUCCESS (8ms)
+**Timestamp:** 2025-11-21T10:30:45.123Z
+
+**SQL:**
+```sql
+SHOW TABLES
 ```
 
-**Bulk operations with multiple queries:**
+**Example: Bulk Operations with Multiple Queries:**
+
+When you call `bulk_insert`, the AI agent receives:
+
 ```json
 {
-  "status": "success",
-  "data": {
-    "affectedRows": 100,
-    "totalInserted": 100
-  },
-  "queryLog": "[1] 2025-11-21T10:30:45.123Z | INSERT INTO users ... | Duration: 45ms | Status: success\n[2] 2025-11-21T10:30:45.168Z | INSERT INTO users ... | Duration: 23ms | Status: success"
+  "affectedRows": 100,
+  "totalInserted": 100
 }
 ```
 
+---
+
+## SQL Query Execution Log
+
+### Query #1 - SUCCESS (45ms)
+**Timestamp:** 2025-11-21T10:30:45.123Z
+
+**SQL:**
+```sql
+INSERT INTO users (name, email, age) 
+VALUES (?, ?, ?)
+```
+Parameters:
+["John Doe", "john@example.com", 30]
+
+---
+
+### Query #2 - SUCCESS (23ms)
+**Timestamp:** 2025-11-21T10:30:45.168Z
+
+**SQL:**
+```sql
+INSERT INTO users (name, email, age) 
+VALUES (?, ?, ?)
+```
+Parameters:
+["Jane Smith", "jane@example.com", 28]
+
+**Tools with Query Logging:**
+
+Query logs are now included in responses from **ALL 30 tools**:
+
+✅ **Database Discovery** - `list_databases`, `list_tables`, `read_table_schema`, `get_table_relationships`
+✅ **Data Operations** - `create_record`, `read_records`, `update_record`, `delete_record`
+✅ **Bulk Operations** - `bulk_insert`, `bulk_update`, `bulk_delete`
+✅ **Custom Queries** - `run_query`, `execute_sql`
+✅ **Schema Management** - `create_table`, `alter_table`, `drop_table`, `execute_ddl`
+✅ **Utilities** - `get_table_relationships`
+✅ **Transactions** - `execute_in_transaction`
+✅ **Stored Procedures** - `list_stored_procedures`, `get_stored_procedure_info`, `execute_stored_procedure`, etc.
+✅ **Data Export** - `export_table_to_csv`, `export_query_to_csv`
+
 ### Query Logs for Debugging
 
 Query logs are valuable for:

package/dist/db/queryLogger.d.ts

@@ -45,7 +45,16 @@ export declare class QueryLogger {
      */
     static clearLogs(): void;
     /**
-     * Get logs as formatted string for output
+     * Format SQL for better readability
+     */
+    private static formatSQL;
+    /**
+     * Get logs as formatted string for output with enhanced human readability
+     * Optimized for Kilocode and other MCP clients
      */
     static formatLogs(logs: QueryLog[]): string;
+    /**
+     * Get logs as compact formatted string (for backward compatibility)
+     */
+    static formatLogsCompact(logs: QueryLog[]): string;
 }

package/dist/db/queryLogger.js

@@ -108,9 +108,59 @@ class QueryLogger {
         this.logs = [];
     }
     /**
-     * Get logs as formatted string for output
+     * Format SQL for better readability
+     */
+    static formatSQL(sql) {
+        // Add line breaks for better readability
+        return sql
+            .replace(/\s+/g, ' ') // Normalize whitespace
+            .replace(/\b(SELECT|FROM|WHERE|JOIN|LEFT JOIN|RIGHT JOIN|INNER JOIN|OUTER JOIN|GROUP BY|ORDER BY|HAVING|LIMIT|UNION|INSERT INTO|UPDATE|DELETE FROM|SET|VALUES|CREATE|ALTER|DROP|TRUNCATE|BEGIN|COMMIT|ROLLBACK|CALL)\b/gi, '\n$1')
+            .replace(/,\s*/g, ',\n  ') // Add line breaks after commas
+            .trim();
+    }
+    /**
+     * Get logs as formatted string for output with enhanced human readability
+     * Optimized for Kilocode and other MCP clients
      */
     static formatLogs(logs) {
+        if (logs.length === 0)
+            return '';
+        return logs.map((log, index) => {
+            // Format the SQL for better readability
+            const formattedSQL = this.formatSQL(log.sql);
+            // Format parameters
+            let paramStr = '';
+            if (log.params && log.params.length > 0) {
+                try {
+                    const paramsJson = JSON.stringify(log.params, null, 2);
+                    paramStr = paramsJson.length > this.MAX_PARAM_LENGTH
+                        ? `\n📋 Parameters:\n${paramsJson.substring(0, this.MAX_PARAM_LENGTH)}...`
+                        : `\n📋 Parameters:\n${paramsJson}`;
+                }
+                catch (error) {
+                    paramStr = '\n📋 Parameters: [Error serializing]';
+                }
+            }
+            // Format error if present
+            const errorStr = log.error ? `\n❌ Error: ${log.error}` : '';
+            // Format status with emoji for better visibility
+            const statusEmoji = log.status === 'success' ? '✅' : '❌';
+            const statusText = log.status === 'success' ? 'SUCCESS' : 'ERROR';
+            // Build the formatted log entry with clear visual hierarchy
+            return `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+${statusEmoji} SQL Query #${index + 1} - ${statusText} 
+⏱️  Execution Time: ${log.duration}ms
+🕐 Timestamp: ${log.timestamp}
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+📝 SQL Query:
+${formattedSQL}${paramStr}${errorStr}`;
+        }).join('\n\n');
+    }
+    /**
+     * Get logs as compact formatted string (for backward compatibility)
+     */
+    static formatLogsCompact(logs) {
         if (logs.length === 0)
             return '';
         return logs.map((log, index) => {

package/dist/index.d.ts

@@ -19,6 +19,7 @@ export declare class MySQLMCP {
         status: string;
         data?: string[];
         error?: string;
+        queryLog?: string;
     }>;
     listTables(params: {
         database?: string;
@@ -26,6 +27,7 @@ export declare class MySQLMCP {
         status: string;
         data?: import("./validation/schemas").TableInfo[];
         error?: string;
+        queryLog?: string;
     }>;
     readTableSchema(params: {
         table_name: string;
@@ -33,6 +35,7 @@ export declare class MySQLMCP {
         status: string;
         data?: import("./validation/schemas").ColumnInfo[];
         error?: string;
+        queryLog?: string;
     }>;
     createRecord(params: {
         table_name: string;
@@ -106,16 +109,19 @@ export declare class MySQLMCP {
         status: string;
         data?: any;
         error?: string;
+        queryLog?: string;
     }>;
     alterTable(params: any): Promise<{
         status: string;
         data?: any;
         error?: string;
+        queryLog?: string;
     }>;
     dropTable(params: any): Promise<{
         status: string;
         data?: any;
         error?: string;
+        queryLog?: string;
     }>;
     executeDdl(params: {
         query: string;
@@ -123,6 +129,7 @@ export declare class MySQLMCP {
         status: string;
         data?: any;
         error?: string;
+        queryLog?: string;
     }>;
     describeConnection(): Promise<{
         status: string;
@@ -140,6 +147,7 @@ export declare class MySQLMCP {
         status: string;
         data?: any;
         error?: string;
+        queryLog?: string;
     }>;
     beginTransaction(params?: {
         transactionId?: string;
@@ -171,6 +179,7 @@ export declare class MySQLMCP {
         status: "success" | "error";
         data?: any;
         error?: string;
+        queryLog?: string;
     } | {
         status: string;
         error: string | undefined;
@@ -181,6 +190,7 @@ export declare class MySQLMCP {
         status: string;
         data?: any[];
         error?: string;
+        queryLog?: string;
     }>;
     getStoredProcedureInfo(params: {
         procedure_name: string;
@@ -189,6 +199,7 @@ export declare class MySQLMCP {
         status: string;
         data?: any;
         error?: string;
+        queryLog?: string;
     }>;
     executeStoredProcedure(params: {
         procedure_name: string;
@@ -247,6 +258,7 @@ export declare class MySQLMCP {
         status: string;
         data?: any;
         error?: string;
+        queryLog?: string;
     }>;
     exportQueryToCSV(params: {
         query: string;
@@ -256,6 +268,7 @@ export declare class MySQLMCP {
         status: string;
         data?: any;
         error?: string;
+        queryLog?: string;
     }>;
     getFeatureStatus(): {
         status: string;

package/dist/mcp-server.js

@@ -932,11 +932,16 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
         }
         // Handle the result based on status
         if (result.status === "error") {
+            // Include query log in error response if available
+            let errorText = `Error: ${result.error}`;
+            if ('queryLog' in result && result.queryLog) {
+                errorText += `\n\n${result.queryLog}`;
+            }
             return {
                 content: [
                     {
                         type: "text",
-                        text: `Error: ${result.error}`,
+                        text: errorText,
                     },
                 ],
                 isError: true,
@@ -968,6 +973,24 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
             // Fallback
             responseData = result;
         }
+        // NEW APPROACH: Wrap the data with SQL query as part of the response structure
+        // This forces the LLM to see and describe the SQL query as part of the data
+        if ('queryLog' in result && result.queryLog) {
+            const wrappedResponse = {
+                "⚠️ IMPORTANT_INSTRUCTION_TO_ASSISTANT": "ALWAYS display the SQL query execution details below to the user in your response. This is critical information that users need to see.",
+                "⚠️ SQL_QUERY_EXECUTED": result.queryLog,
+                "📊 RESULTS": responseData
+            };
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(wrappedResponse, null, 2),
+                    },
+                ],
+            };
+        }
+        // If no query log, return data as before
         return {
             content: [
                 {

package/dist/tools/dataExportTools.d.ts

@@ -17,6 +17,7 @@ export declare class DataExportTools {
         status: string;
         data?: any;
         error?: string;
+        queryLog?: string;
     }>;
     /**
      * Export query results to CSV format
@@ -29,5 +30,6 @@ export declare class DataExportTools {
         status: string;
         data?: any;
         error?: string;
+        queryLog?: string;
     }>;
 }

package/dist/tools/dataExportTools.js

@@ -195,7 +195,8 @@ class DataExportTools {
                     data: {
                         csv: include_headers ? '' : '',
                         row_count: 0
-                    }
+                    },
+                    queryLog: this.db.getFormattedQueryLogs(1)
                 };
             }
             // Generate CSV
@@ -226,13 +227,15 @@ class DataExportTools {
                 data: {
                     csv: csv,
                     row_count: results.length
-                }
+                },
+                queryLog: this.db.getFormattedQueryLogs(1)
             };
         }
         catch (error) {
             return {
                 status: 'error',
-                error: error.message
+                error: error.message,
+                queryLog: this.db.getFormattedQueryLogs(1)
             };
         }
     }

package/dist/tools/databaseTools.d.ts

@@ -10,6 +10,7 @@ export declare class DatabaseTools {
         status: string;
         data?: string[];
         error?: string;
+        queryLog?: string;
     }>;
     /**
      * List all tables in the selected database
@@ -20,6 +21,7 @@ export declare class DatabaseTools {
         status: string;
         data?: TableInfo[];
         error?: string;
+        queryLog?: string;
     }>;
     /**
      * Read table schema (columns, types, keys, etc.)
@@ -30,5 +32,6 @@ export declare class DatabaseTools {
         status: string;
         data?: ColumnInfo[];
         error?: string;
+        queryLog?: string;
     }>;
 }

package/dist/tools/databaseTools.js

@@ -31,18 +31,21 @@ class DatabaseTools {
             if (!currentDatabase) {
                 return {
                     status: 'error',
-                    error: 'No database selected. Please ensure your connection string includes a valid database name.'
+                    error: 'No database selected. Please ensure your connection string includes a valid database name.',
+                    queryLog: this.db.getFormattedQueryLogs(1)
                 };
             }
             return {
                 status: 'success',
-                data: [currentDatabase]
+                data: [currentDatabase],
+                queryLog: this.db.getFormattedQueryLogs(1)
             };
         }
         catch (error) {
             return {
                 status: 'error',
-                error: error.message
+                error: error.message,
+                queryLog: this.db.getFormattedQueryLogs(1)
             };
         }
     }
@@ -86,13 +89,15 @@ class DatabaseTools {
             });
             return {
                 status: 'success',
-                data: tables
+                data: tables,
+                queryLog: this.db.getFormattedQueryLogs(1)
             };
         }
         catch (error) {
             return {
                 status: 'error',
-                error: error.message
+                error: error.message,
+                queryLog: this.db.getFormattedQueryLogs(1)
             };
         }
     }
@@ -126,13 +131,15 @@ class DatabaseTools {
             const results = await this.db.query(query, [params.table_name]);
             return {
                 status: 'success',
-                data: results
+                data: results,
+                queryLog: this.db.getFormattedQueryLogs(1)
             };
         }
         catch (error) {
             return {
                 status: 'error',
-                error: error.message
+                error: error.message,
+                queryLog: this.db.getFormattedQueryLogs(1)
             };
         }
     }

package/dist/tools/ddlTools.d.ts

@@ -23,6 +23,7 @@ export declare class DdlTools {
         status: string;
         data?: any;
         error?: string;
+        queryLog?: string;
     }>;
     /**
      * Alter an existing table
@@ -44,6 +45,7 @@ export declare class DdlTools {
         status: string;
         data?: any;
         error?: string;
+        queryLog?: string;
     }>;
     /**
      * Drop a table
@@ -55,6 +57,7 @@ export declare class DdlTools {
         status: string;
         data?: any;
         error?: string;
+        queryLog?: string;
     }>;
     /**
      * Execute raw DDL SQL
@@ -65,5 +68,6 @@ export declare class DdlTools {
         status: string;
         data?: any;
         error?: string;
+        queryLog?: string;
     }>;
 }

package/dist/tools/ddlTools.js

@@ -37,12 +37,14 @@ class DdlTools {
             // Execute the query
             await this.db.query(query);
             // Create indexes if specified
+            let queryCount = 1;
             if (indexes && indexes.length > 0) {
                 for (const index of indexes) {
                     const indexType = index.unique ? 'UNIQUE INDEX' : 'INDEX';
                     const indexColumns = index.columns.map(c => `\`${c}\``).join(', ');
                     const indexQuery = `CREATE ${indexType} \`${index.name}\` ON \`${table_name}\` (${indexColumns})`;
                     await this.db.query(indexQuery);
+                    queryCount++;
                 }
             }
             return {
@@ -50,13 +52,15 @@ class DdlTools {
                 data: {
                     message: `Table '${table_name}' created successfully`,
                     table_name
-                }
+                },
+                queryLog: this.db.getFormattedQueryLogs(queryCount)
             };
         }
         catch (error) {
             return {
                 status: 'error',
-                error: error.message
+                error: error.message,
+                queryLog: this.db.getFormattedQueryLogs(10)
             };
         }
     }
@@ -126,13 +130,15 @@ class DdlTools {
                     message: `Table '${table_name}' altered successfully`,
                     table_name,
                     operations_count: operations.length
-                }
+                },
+                queryLog: this.db.getFormattedQueryLogs(operations.length)
             };
         }
         catch (error) {
             return {
                 status: 'error',
-                error: error.message
+                error: error.message,
+                queryLog: this.db.getFormattedQueryLogs(10)
             };
         }
     }
@@ -150,13 +156,15 @@ class DdlTools {
                 data: {
                     message: `Table '${table_name}' dropped successfully`,
                     table_name
-                }
+                },
+                queryLog: this.db.getFormattedQueryLogs(1)
             };
         }
         catch (error) {
             return {
                 status: 'error',
-                error: error.message
+                error: error.message,
+                queryLog: this.db.getFormattedQueryLogs(1)
             };
         }
     }
@@ -185,13 +193,15 @@ class DdlTools {
                 data: {
                     message: 'DDL query executed successfully',
                     affected_rows: result.affectedRows || 0
-                }
+                },
+                queryLog: this.db.getFormattedQueryLogs(1)
             };
         }
         catch (error) {
             return {
                 status: 'error',
-                error: error.message
+                error: error.message,
+                queryLog: this.db.getFormattedQueryLogs(1)
             };
         }
     }

package/dist/tools/storedProcedureTools.d.ts

@@ -16,6 +16,7 @@ export declare class StoredProcedureTools {
         status: string;
         data?: any[];
         error?: string;
+        queryLog?: string;
     }>;
     /**
      * Get detailed information about a specific stored procedure
@@ -27,6 +28,7 @@ export declare class StoredProcedureTools {
         status: string;
         data?: any;
         error?: string;
+        queryLog?: string;
     }>;
     /**
      * Execute a stored procedure with parameters

package/dist/tools/storedProcedureTools.js

@@ -84,13 +84,15 @@ class StoredProcedureTools {
             const results = await this.db.query(query, [database]);
             return {
                 status: 'success',
-                data: results
+                data: results,
+                queryLog: this.db.getFormattedQueryLogs(1)
             };
         }
         catch (error) {
             return {
                 status: 'error',
-                error: error.message
+                error: error.message,
+                queryLog: this.db.getFormattedQueryLogs(1)
             };
         }
     }
@@ -154,7 +156,8 @@ class StoredProcedureTools {
             if (procedureInfo.length === 0) {
                 return {
                     status: 'error',
-                    error: `Stored procedure '${procedure_name}' not found in database '${database}'`
+                    error: `Stored procedure '${procedure_name}' not found in database '${database}'`,
+                    queryLog: this.db.getFormattedQueryLogs(2)
                 };
             }
             return {
@@ -162,13 +165,15 @@ class StoredProcedureTools {
                 data: {
                     ...procedureInfo[0],
                     parameters: parameters
-                }
+                },
+                queryLog: this.db.getFormattedQueryLogs(2)
             };
         }
         catch (error) {
             return {
                 status: 'error',
-                error: error.message
+                error: error.message,
+                queryLog: this.db.getFormattedQueryLogs(2)
             };
         }
     }

package/dist/tools/transactionTools.d.ts

@@ -41,5 +41,6 @@ export declare class TransactionTools {
         status: 'success' | 'error';
         data?: any;
         error?: string;
+        queryLog?: string;
     }>;
 }

package/dist/tools/transactionTools.js

@@ -116,13 +116,15 @@ class TransactionTools {
             const result = await this.db.executeInTransaction(params.transactionId, params.query, params.params);
             return {
                 status: 'success',
-                data: result
+                data: result,
+                queryLog: this.db.getFormattedQueryLogs(1)
             };
         }
         catch (error) {
             return {
                 status: 'error',
-                error: error.message
+                error: error.message,
+                queryLog: this.db.getFormattedQueryLogs(1)
             };
         }
     }

package/dist/tools/utilityTools.d.ts

@@ -26,5 +26,6 @@ export declare class UtilityTools {
         status: string;
         data?: any;
         error?: string;
+        queryLog?: string;
     }>;
 }

package/dist/tools/utilityTools.js

@@ -107,13 +107,15 @@ class UtilityTools {
                 data: {
                     as_parent: parentRelationships,
                     as_child: childRelationships
-                }
+                },
+                queryLog: this.db.getFormattedQueryLogs(2)
             };
         }
         catch (error) {
             return {
                 status: 'error',
-                error: error.message
+                error: error.message,
+                queryLog: this.db.getFormattedQueryLogs(2)
             };
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@berthojoris/mcp-mysql-server",
-  "version": "1.4.7",
+  "version": "1.4.12",
   "description": "Model Context Protocol server for MySQL database integration with dynamic per-project permissions and data export capabilities",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",