metabase-ai-assistant 3.4.3 → 3.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "metabase-ai-assistant",
-  "version": "3.4.3",
+  "version": "3.6.0",
   "mcpName": "io.github.enessari/metabase-ai-assistant",
   "description": "The most powerful MCP Server for Metabase - 111+ tools for AI-powered SQL generation, dashboard automation, user management & enterprise BI. Works with Claude, Cursor, and any MCP-compatible AI.",
   "main": "src/index.js",
@@ -96,4 +96,4 @@
     "eslint": "^8.56.0",
     "jest": "^29.7.0"
   }
-}
+}

package/src/mcp/handlers/dashboard_direct.js

@@ -0,0 +1,316 @@
+import { McpError, ErrorCode } from '@modelcontextprotocol/sdk/types.js';
+import { logger } from '../../utils/logger.js';
+import { config } from '../../utils/config.js';
+
+/**
+ * Handler for Direct SQL Dashboard Operations
+ * Bypasses API limitations by directly interacting with Internal DB
+ */
+export class DashboardDirectHandler {
+    constructor(metabaseClient, metadataHandler) {
+        this.metabaseClient = metabaseClient;
+        this.metadataHandler = metadataHandler;
+    }
+
+    /**
+     * Add Cards to Dashboard via SQL (Batch/Loop Insert)
+     * Resolves positioning issues and timeouts found in API
+     */
+    async handleAddCardSql(args) {
+        const { dashboard_id, cards } = args;
+
+        // 1. Get Internal DB ID
+        // Use MetadataHandler's helper or fallback to 6
+        let internalDbId;
+        try {
+            internalDbId = await this.metadataHandler.getInternalDbId();
+        } catch (e) {
+            internalDbId = 6; // Fallback from user guide
+            logger.warn(`Could not determine Internal DB ID, using default: ${internalDbId}`);
+        }
+
+        const results = [];
+        const errors = [];
+
+        logger.info(`Adding ${cards.length} cards to dashboard ${dashboard_id} via Direct SQL (DB: ${internalDbId})`);
+
+        // 2. Loop through cards (Single Row Insert Constraint)
+        // "Metabase/Driver limitations often cause batch inserts to fail silently or partially"
+        for (const card of cards) {
+            try {
+                // Validation / Defaults
+                const row = card.row !== undefined ? card.row : 0;
+                const col = card.col !== undefined ? card.col : 0;
+                const sizeX = card.size_x || 4;
+                const sizeY = card.size_y || 4;
+                const vizSettings = card.visualization_settings ? JSON.stringify(card.visualization_settings) : '{}';
+                const paramMappings = card.parameter_mappings ? JSON.stringify(card.parameter_mappings) : '[]';
+
+                // 3. Construct SQL
+                const sql = `
+            INSERT INTO report_dashboardcard 
+            (card_id, dashboard_id, row, col, size_x, size_y, visualization_settings, parameter_mappings, created_at, updated_at)
+            VALUES 
+            (
+                ${card.card_id}, 
+                ${dashboard_id}, 
+                ${row}, 
+                ${col}, 
+                ${sizeX}, 
+                ${sizeY}, 
+                '${vizSettings}', 
+                '${paramMappings}', 
+                NOW(), 
+                NOW()
+            )
+        `;
+
+                // 4. Execute
+                await this.metabaseClient.executeNativeQuery(internalDbId, sql, { enforcePrefix: false });
+
+                results.push(`✅ Card ${card.card_id} -> (${row}, ${col}) [${sizeX}x${sizeY}]`);
+
+            } catch (error) {
+                const msg = `❌ Failed Card ${card.card_id}: ${error.message}`;
+                logger.error(msg);
+                errors.push(msg);
+            }
+        }
+
+        // 5. Construct Response
+        let output = `🏗️ **Direct SQL Card Addition Results**\n\n`;
+        output += `Target Dashboard: ${dashboard_id}\n`;
+        output += `Success: ${results.length} / ${cards.length}\n\n`;
+
+        if (results.length > 0) {
+            output += `**Successfully Added:**\n${results.join('\n')}\n\n`;
+        }
+
+        if (errors.length > 0) {
+            output += `**Errors:**\n${errors.join('\n')}\n`;
+        }
+
+        output += `\n💡 *Note: You may need to refresh the dashboard execution cache or reload the page to see changes immediately.*`;
+
+        return { content: [{ type: 'text', text: output }] };
+    }
+
+    /**
+     * Batch Update Dashboard Layout via SQL
+     * Direct UPDATE to report_dashboardcard
+     */
+    async handleUpdateLayoutSql(args) {
+        const { dashboard_id, updates } = args;
+
+        // Default to DB 6 if no other info
+        let internalDbId;
+        try {
+            internalDbId = await this.metadataHandler.getInternalDbId();
+        } catch (e) {
+            internalDbId = 6;
+        }
+
+        const results = [];
+        const errors = [];
+
+        logger.info(`Updating layout for ${updates.length} cards on dashboard ${dashboard_id} (DB: ${internalDbId})`);
+
+        for (const update of updates) {
+            try {
+                if (!update.card_id) continue;
+
+                const setParts = [];
+                if (update.row !== undefined) setParts.push(`row = ${update.row}`);
+                if (update.col !== undefined) setParts.push(`col = ${update.col}`);
+                if (update.size_x !== undefined) setParts.push(`size_x = ${update.size_x}`);
+                if (update.size_y !== undefined) setParts.push(`size_y = ${update.size_y}`);
+
+                setParts.push(`updated_at = NOW()`);
+
+                const sql = `
+            UPDATE report_dashboardcard
+            SET ${setParts.join(', ')}
+            WHERE dashboard_id = ${dashboard_id} AND card_id = ${update.card_id}
+        `;
+
+                await this.metabaseClient.executeNativeQuery(internalDbId, sql, { enforcePrefix: false });
+                results.push(`✅ Card ${update.card_id}`);
+
+            } catch (error) {
+                errors.push(`❌ Card ${update.card_id}: ${error.message}`);
+            }
+        }
+
+        return {
+            content: [{
+                type: 'text',
+                text: `🏗️ **Layout Update Results**\nDashboard: ${dashboard_id}\nSuccess: ${results.length}\nErrors: ${errors.length}\n\n${errors.join('\n')}`
+            }]
+        };
+    }
+
+    /**
+     * Create Parametric Native SQL Question
+     * Constructs the complex dataset_query JSON and inserts directly
+     */
+    async handleCreateParametricQuestionSql(args) {
+        const { name, description, database_id, query_sql, parameters, collection_id } = args;
+
+        // 1. Get Internal DB ID
+        let internalDbId;
+        try {
+            internalDbId = await this.metadataHandler.getInternalDbId();
+        } catch (e) {
+            internalDbId = 6;
+        }
+
+        // 2. Construct Template Tags
+        const templateTags = {};
+        if (parameters && Array.isArray(parameters)) {
+            for (const param of parameters) {
+                // Generate a UUID-like key or just use the name
+                const tagId = `tag_${Date.now()}_${Math.floor(Math.random() * 1000)}`;
+                templateTags[param.name] = {
+                    "id": tagId,
+                    "name": param.name,
+                    "display-name": param.display_name || param.name,
+                    "type": param.type || "text", // text, number, date, dimension
+                    "default": param.default || null,
+                    "required": param.required || false
+                };
+
+                // Add widget type if specified (e.g. category filter)
+                if (param.widget_type) {
+                    templateTags[param.name]["widget-type"] = param.widget_type;
+                }
+            }
+        }
+
+        // 3. Construct Dataset Query
+        const datasetQuery = {
+            "type": "native",
+            "native": {
+                "query": query_sql,
+                "template-tags": templateTags
+            },
+            "database": database_id
+        };
+
+        const display = "table"; // Default display type
+        const vizSettings = "{}"; // Default empty viz settings
+
+        // 4. Construct SQL Insert
+        // Note: collection_id can be NULL
+        const collectionVal = collection_id ? collection_id : 'NULL';
+
+        // creator_id fallback (usually 1 for admin)
+        const creatorId = 1;
+
+        // Escaping for SQL string literals (basic)
+        const safeName = name.replace(/'/g, "''");
+        const safeDesc = (description || '').replace(/'/g, "''");
+        const safeQueryJson = JSON.stringify(datasetQuery).replace(/'/g, "''");
+
+        const sql = `
+            INSERT INTO report_card 
+            (name, description, display, dataset_query, visualization_settings, 
+             creator_id, database_id, query_type, created_at, updated_at, 
+             collection_id, type, parameters, archived)
+            VALUES 
+            (
+                '${safeName}',
+                '${safeDesc}',
+                '${display}',
+                '${safeQueryJson}',
+                '${vizSettings}',
+                ${creatorId},
+                ${database_id},
+                'native',
+                NOW(),
+                NOW(),
+                ${collectionVal},
+                'question',
+                '[]',
+                false
+            )
+        `;
+
+        try {
+            await this.metabaseClient.executeNativeQuery(internalDbId, sql, { enforcePrefix: false });
+            return {
+                content: [{
+                    type: 'text',
+                    text: `✅ **Parametric Question Created**\n\nName: ${name}\nDB Source: ${database_id}\nParameters: ${Object.keys(templateTags).length}\n\n*Note: Use 'meta_advanced_search' to find the new Card ID.*`
+                }]
+            };
+        } catch (error) {
+            logger.error(`Failed to create parametric question: ${error.message}`);
+            throw new McpError(ErrorCode.InternalError, `Failed to create question via SQL: ${error.message}`);
+        }
+    }
+
+    /**
+     * Link Dashboard Filter to Card Parameter
+     * Updates parameter_mappings JSONB
+     */
+    async handleLinkDashboardFilter(args) {
+        const { dashboard_id, card_id, mappings } = args;
+
+        // 1. Get Internal DB ID
+        let internalDbId;
+        try {
+            internalDbId = await this.metadataHandler.getInternalDbId();
+        } catch (e) {
+            internalDbId = 6;
+        }
+
+        // 2. Construct Mappings JSON
+        const mappingArray = mappings.map(m => {
+            const mapObj = {
+                "parameter_id": m.parameter_id,
+                "card_id": card_id,
+                "target": m.target_value // already formatted based on type? 
+                // Wait, implementation plan said type enum.
+                // We need to construct the target array structure based on type.
+            };
+
+            if (m.target_type === 'variable') {
+                mapObj.target = ["variable", ["template-tag", m.target_value]];
+            } else if (m.target_type === 'dimension') {
+                // Dimension format: ["dimension", ["field", id, null]] or similar
+                // For now, assume user passes the raw dimension array or string if they know it.
+                // OR simplify: require target_value to be the full target structure if complex.
+                // Let's stick to variable support as primary goal.
+                if (Array.isArray(m.target_value)) {
+                    mapObj.target = m.target_value;
+                } else {
+                    mapObj.target = ["dimension", ["field", m.target_value, null]];
+                }
+            }
+            return mapObj;
+        });
+
+        const jsonMappings = JSON.stringify(mappingArray);
+
+        // 3. Execute Update
+        const sql = `
+            UPDATE report_dashboardcard 
+            SET parameter_mappings = '${jsonMappings}',
+                updated_at = NOW()
+            WHERE dashboard_id = ${dashboard_id} AND card_id = ${card_id}
+        `;
+
+        try {
+            await this.metabaseClient.executeNativeQuery(internalDbId, sql, { enforcePrefix: false });
+            return {
+                content: [{
+                    type: 'text',
+                    text: `✅ **Filter Linked**\nDashboard: ${dashboard_id}\nCard: ${card_id}\nMappings Applied: ${mappings.length}`
+                }]
+            };
+        } catch (error) {
+            logger.error(`Failed to link filters: ${error.message}`);
+            throw new McpError(ErrorCode.InternalError, `Link Filter SQL Failed: ${error.message}`);
+        }
+    }
+}

package/src/mcp/handlers/metadata.js

@@ -0,0 +1,199 @@
+import { McpError, ErrorCode, McpError as McpErrorSdk } from '@modelcontextprotocol/sdk/types.js';
+import { logger } from '../../utils/logger.js';
+import { config } from '../../utils/config.js';
+
+/**
+ * Handler for Advanced Metadata Operations
+ * Uses direct SQL access to Metabase internal database
+ */
+export class MetadataHandler {
+    constructor(metabaseClient) {
+        this.metabaseClient = metabaseClient;
+    }
+
+    /**
+     * Helper to get Internal DB ID with fallback
+     */
+    async getInternalDbId(providedId) {
+        // 1. Use provided ID if any
+        if (providedId) return providedId;
+
+        // 2. Use Env Var
+        if (config.METABASE_INTERNAL_DB_ID) return config.METABASE_INTERNAL_DB_ID;
+
+        // 3. Throw error (Auto-detect should be explicit tool call)
+        throw new Error('Internal Database ID not configured. Use `meta_find_internal_db` to find it, or set METABASE_INTERNAL_DB_ID env var.');
+    }
+
+    /**
+     * Auto-detect Metabase Internal DB
+     */
+    async handleFindInternalDb() {
+        try {
+            const databases = await this.metabaseClient.getDatabases();
+            const candidates = [];
+
+            for (const db of databases) {
+                try {
+                    // Try to query a core table
+                    await this.metabaseClient.executeNativeQuery(db.id, 'SELECT count(*) FROM report_card');
+                    candidates.push({ id: db.id, name: db.name, engine: db.engine });
+                } catch (e) {
+                    // Ignore failures, not the internal DB
+                }
+            }
+
+            if (candidates.length === 0) {
+                return {
+                    content: [{ type: 'text', text: '❌ Could not find Internal Database. Please add Metabase Application DB as a source.' }]
+                };
+            }
+
+            let output = `✅ **Internal Database Candidates Found:**\n\n`;
+            candidates.forEach(c => {
+                output += `- **${c.name}** (ID: ${c.id}, Engine: ${c.engine})\n`;
+            });
+            output += `\n💡 Recommended: Set \`METABASE_INTERNAL_DB_ID=${candidates[0].id}\` in .env`;
+
+            return { content: [{ type: 'text', text: output }] };
+
+        } catch (error) {
+            return { content: [{ type: 'text', text: `❌ Discovery failed: ${error.message}` }] };
+        }
+    }
+
+    /**
+     * Audit Logs - Query Performance & Usage
+     */
+    async handleAuditLogs(args) {
+        const dbId = await this.getInternalDbId(args.internal_db_id);
+        const days = args.days || 30;
+        const limit = args.limit || 50;
+
+        const sql = `
+      SELECT 
+        c.name as card_name,
+        c.id as card_id,
+        u.email as runner_email,
+        qe.started_at,
+        qe.running_time as duration_ms,
+        qe.native as is_native,
+        qe.error
+      FROM query_execution qe
+      LEFT JOIN report_card c ON qe.card_id = c.id
+      LEFT JOIN core_user u ON qe.executor_id = u.id
+      WHERE qe.started_at > NOW() - INTERVAL '${days} days'
+      ORDER BY qe.running_time DESC
+      LIMIT ${limit}
+    `;
+
+        // Re-use logic from sql_execute via client
+        const result = await this.metabaseClient.executeNativeQuery(dbId, sql);
+        const rows = result.data.rows || [];
+
+        let output = `📊 **Audit Logs (Last ${days} days)**\n`;
+        output += `Found ${rows.length} execution records (Top Slowest)\n\n`;
+
+        // Helper to format table
+        if (rows.length > 0) {
+            output += `| Card | Runner | Duration (ms) | Date | Error |\n`;
+            output += `|---|---|---|---|---|\n`;
+            rows.forEach(row => {
+                const [card, cardId, runner, date, duration, isNative, error] = row;
+                const name = card ? `${card} (${cardId})` : (isNative ? 'Ad-hoc SQL' : 'Unknown');
+                const errIcon = error ? '❌' : '✅';
+                output += `| ${name} | ${runner || 'System'} | ${duration} | ${new Date(date).toLocaleDateString()} | ${errIcon} |\n`;
+            });
+        }
+
+        return { content: [{ type: 'text', text: output }] };
+    }
+
+    /**
+     * Lineage - Dependency Graph
+     */
+    async handleLineage(args) {
+        const dbId = await this.getInternalDbId(args.internal_db_id);
+        const term = args.search_term;
+
+        // 1. Find Questions using this table/field string in their query
+        const sqlQuestions = `
+      SELECT id, name, collection_id 
+      FROM report_card 
+      WHERE dataset_query LIKE '%${term}%' 
+      AND archived = false
+      LIMIT 50
+    `;
+
+        const resultQ = await this.metabaseClient.executeNativeQuery(dbId, sqlQuestions);
+        const questions = resultQ.data.rows || [];
+
+        // 2. Find Dashboards using these questions (if any questions found)
+        let dashboards = [];
+        if (questions.length > 0) {
+            const qIds = questions.map(r => r[0]).join(',');
+            const sqlDash = `
+        SELECT DISTINCT d.id, d.name 
+        FROM report_dashboard d
+        JOIN report_dashboardcard dc ON d.id = dc.dashboard_id
+        WHERE dc.card_id IN (${qIds})
+        AND d.archived = false
+      `;
+            const resultD = await this.metabaseClient.executeNativeQuery(dbId, sqlDash);
+            dashboards = resultD.data.rows || [];
+        }
+
+        let output = `🔗 **Lineage Analysis for:** \`${term}\`\n\n`;
+
+        if (questions.length === 0) {
+            output += `No direct dependencies found in active questions.\n`;
+        } else {
+            output += `**📉 Dependent Questions (${questions.length}):**\n`;
+            questions.forEach(q => output += `- [${q[0]}] ${q[1]}\n`);
+
+            output += `\n**📊 Impacted Dashboards (${dashboards.length}):**\n`;
+            dashboards.forEach(d => output += `- [${d[0]}] ${d[1]}\n`);
+        }
+
+        return { content: [{ type: 'text', text: output }] };
+    }
+
+    /**
+     * Advanced Search
+     */
+    async handleAdvancedSearch(args) {
+        const dbId = await this.getInternalDbId(args.internal_db_id);
+        const query = args.query;
+
+        const sql = `
+      SELECT id, name, 'Question' as type, description 
+      FROM report_card 
+      WHERE name ILIKE '%${query}%' 
+         OR description ILIKE '%${query}%' 
+         OR dataset_query ILIKE '%${query}%'
+      UNION ALL
+      SELECT id, name, 'Dashboard' as type, description
+      FROM report_dashboard
+      WHERE name ILIKE '%${query}%'
+         OR description ILIKE '%${query}%'
+      LIMIT 20
+    `;
+
+        const result = await this.metabaseClient.executeNativeQuery(dbId, sql);
+        const rows = result.data.rows || [];
+
+        let output = `🔍 **Advanced Search Results for:** \`${query}\`\n\n`;
+        if (rows.length === 0) {
+            output += "No results found.";
+        } else {
+            rows.forEach(row => {
+                const [id, name, type, desc] = row;
+                output += `**[${type}] ${name}** (ID: ${id})\n`;
+                if (desc) output += `> ${desc}\n`;
+                output += `\n`;
+            });
+        }
+
+        return { content: [{ type: 'text', text: output }] };
+    }
+}

package/src/mcp/server.js

@@ -24,6 +24,8 @@ import {
   isReadOnlyMode,
   detectWriteOperation,
 } from './handlers/index.js';
+import { MetadataHandler } from './handlers/metadata.js';
+import { DashboardDirectHandler } from './handlers/dashboard_direct.js';
 
 // Utils
 import { CacheManager, CacheKeys, globalCache } from '../utils/cache.js';
@@ -99,6 +101,12 @@ class MetabaseMCPServer {
         apiKey: process.env.METABASE_API_KEY,
       });
 
+      // Initialize Metadata Handler
+      this.metadataHandler = new MetadataHandler(this.metabaseClient);
+
+      // Initialize Direct Dashboard Handler
+      this.dashboardDirectHandler = new DashboardDirectHandler(this.metabaseClient, this.metadataHandler);
+
       await this.metabaseClient.authenticate();
       logger.info('Metabase client initialized');
 
@@ -569,6 +577,115 @@ class MetabaseMCPServer {
               required: ['dashboard_id', 'question_id'],
             },
           },
+          {
+            name: 'mb_dashboard_add_card_sql',
+            description: 'Add multiple cards to a dashboard using direct SQL inserts. Bypasses API limits, ensures precise positioning, and prevents timeouts. Use this for complex layouts.',
+            inputSchema: {
+              type: 'object',
+              properties: {
+                dashboard_id: {
+                  type: 'number',
+                  description: 'Target Dashboard ID'
+                },
+                cards: {
+                  type: 'array',
+                  description: 'List of cards to add with layout config',
+                  items: {
+                    type: 'object',
+                    properties: {
+                      card_id: { type: 'number' },
+                      row: { type: 'number', description: 'Grid row (0-based)' },
+                      col: { type: 'number', description: 'Grid col (0-based)' },
+                      size_x: { type: 'number', default: 4 },
+                      size_y: { type: 'number', default: 4 },
+                      visualization_settings: { type: 'object', description: 'Optional override settings' },
+                      parameter_mappings: { type: 'array', description: 'Optional filter mappings' }
+                    },
+                    required: ['card_id', 'row', 'col']
+                  }
+                }
+              },
+              required: ['dashboard_id', 'cards']
+            }
+          },
+          {
+            name: 'mb_dashboard_update_layout',
+            description: 'Batch update position and size of multiple dashboard cards via direct SQL. Guarantees layout application.',
+            inputSchema: {
+              type: 'object',
+              properties: {
+                dashboard_id: { type: 'number' },
+                updates: {
+                  type: 'array',
+                  items: {
+                    type: 'object',
+                    properties: {
+                      card_id: { type: 'number' },
+                      row: { type: 'number' },
+                      col: { type: 'number' },
+                      size_x: { type: 'number' },
+                      size_y: { type: 'number' }
+                    },
+                    required: ['card_id']
+                  }
+                }
+              },
+              required: ['dashboard_id', 'updates']
+            }
+          },
+          {
+            name: 'mb_create_parametric_question',
+            description: 'Create a native SQL question with parameters (variables) directly via SQL. Essential for creating cards that accept dashboard filters.',
+            inputSchema: {
+              type: 'object',
+              properties: {
+                name: { type: 'string' },
+                description: { type: 'string' },
+                database_id: { type: 'number', description: 'ID of the database to query against (not the internal one)' },
+                query_sql: { type: 'string', description: 'SQL query with {{variable}} tags' },
+                parameters: {
+                  type: 'array',
+                  items: {
+                    type: 'object',
+                    properties: {
+                      name: { type: 'string' },
+                      display_name: { type: 'string' },
+                      type: { type: 'string', enum: ['text', 'number', 'date', 'dimension'] },
+                      required: { type: 'boolean' },
+                      default: { type: 'string' }
+                    },
+                    required: ['name', 'type']
+                  }
+                },
+                collection_id: { type: 'number', description: 'Optional collection to place question in' }
+              },
+              required: ['name', 'database_id', 'query_sql']
+            }
+          },
+          {
+            name: 'mb_link_dashboard_filter',
+            description: 'Link a dashboard filter to a card parameter via SQL. Updates parameter_mappings.',
+            inputSchema: {
+              type: 'object',
+              properties: {
+                dashboard_id: { type: 'number' },
+                card_id: { type: 'number' },
+                mappings: {
+                  type: 'array',
+                  items: {
+                    type: 'object',
+                    properties: {
+                      parameter_id: { type: 'string', description: 'The GUID of the dashboard parameter' },
+                      target_type: { type: 'string', enum: ['variable', 'dimension'] },
+                      target_value: { type: 'string', description: 'Variable name (without {{}}) or Field ID for dimension' }
+                    },
+                    required: ['parameter_id', 'target_type', 'target_value']
+                  }
+                }
+              },
+              required: ['dashboard_id', 'card_id', 'mappings']
+            }
+          },
           {
             name: 'web_fetch_metabase_docs',
             description: 'Fetch specific Metabase documentation page for API details, best practices, and feature information',
@@ -638,12 +755,80 @@ class MetabaseMCPServer {
                   description: 'Maximum number of relevant pages to return',
                   default: 5,
                   minimum: 1,
-                  maximum: 20
+                  maximum: 3
                 }
               },
               required: ['query'],
             },
           },
+          // === ADVANCED METADATA TOOLS (Internal DB) ===
+          {
+            name: 'meta_find_internal_db',
+            description: 'Auto-detect the Metabase Internal Application Database ID from connected databases. Required for advanced metadata tools.',
+            inputSchema: {
+              type: 'object',
+              properties: {},
+            },
+          },
+          {
+            name: 'meta_audit_logs',
+            description: 'Analyze query performance and usage history from internal logs. Finds slow queries and top users.',
+            inputSchema: {
+              type: 'object',
+              properties: {
+                days: {
+                  type: 'number',
+                  description: 'Number of days to analyze (default: 30)',
+                  default: 30
+                },
+                limit: {
+                  type: 'number',
+                  description: 'Max results to return (default: 50)',
+                  default: 50
+                },
+                internal_db_id: {
+                  type: 'number',
+                  description: 'Internal Database ID (optional if configured in env)'
+                }
+              },
+            },
+          },
+          {
+            name: 'meta_lineage',
+            description: 'Find dependencies: Which dashboards and questions use a specific table or field? (Impact Analysis)',
+            inputSchema: {
+              type: 'object',
+              properties: {
+                search_term: {
+                  type: 'string',
+                  description: 'Table name, field name, or SQL fragment to search for usage'
+                },
+                internal_db_id: {
+                  type: 'number',
+                  description: 'Internal Database ID (optional if configured in env)'
+                }
+              },
+              required: ['search_term']
+            },
+          },
+          {
+            name: 'meta_advanced_search',
+            description: 'Deep search within SQL code, visualization settings, and descriptions across all questions and dashboards.',
+            inputSchema: {
+              type: 'object',
+              properties: {
+                query: {
+                  type: 'string',
+                  description: 'Search query (searches SQL, names, descriptions)'
+                },
+                internal_db_id: {
+                  type: 'number',
+                  description: 'Internal Database ID (optional if configured in env)'
+                }
+              },
+              required: ['query']
+            },
+          },
           {
             name: 'web_metabase_api_reference',
             description: 'Get comprehensive Metabase API reference with endpoints, parameters, examples, and response formats',
@@ -3263,7 +3448,15 @@ class MetabaseMCPServer {
           case 'mb_question_create_parametric':
             return await this.handleCreateParametricQuestion(args);
           case 'mb_dashboard_add_card':
-            return await this.handleAddCardToDashboard(args);
+            return await this.handlers.dashboard.handleAddCardToDashboard(args, context);
+          case 'mb_dashboard_add_card_sql':
+            return await this.dashboardDirectHandler.handleAddCardSql(args);
+          case 'mb_dashboard_update_layout':
+            return await this.dashboardDirectHandler.handleUpdateLayoutSql(args);
+          case 'mb_create_parametric_question':
+            return await this.dashboardDirectHandler.handleCreateParametricQuestionSql(args);
+          case 'mb_link_dashboard_filter':
+            return await this.dashboardDirectHandler.handleLinkDashboardFilter(args);
           case 'mb_metric_create':
             return await this.handleCreateMetric(args);
           case 'mb_dashboard_add_filter':
@@ -3540,6 +3733,16 @@ class MetabaseMCPServer {
           case 'mb_meta_auto_cleanup':
             return await this.handleMetadataAutoCleanup(args);
 
+          // Advanced Metadata (Internal DB)
+          case 'meta_find_internal_db':
+            return await this.metadataHandler.handleFindInternalDb(args);
+          case 'meta_audit_logs':
+            return await this.metadataHandler.handleAuditLogs(args);
+          case 'meta_lineage':
+            return await this.metadataHandler.handleLineage(args);
+          case 'meta_advanced_search':
+            return await this.metadataHandler.handleAdvancedSearch(args);
+
           default:
             throw new McpError(
               ErrorCode.MethodNotFound,

package/src/utils/config.js

@@ -26,6 +26,9 @@ const envSchema = z.object({
         .default('true')
         .transform(val => val.toLowerCase() === 'true'),
 
+    // Internal Database ID (for advanced metadata features)
+    METABASE_INTERNAL_DB_ID: z.string().optional().transform(val => val ? parseInt(val, 10) : undefined),
+
     // Database Configuration
     DATABASE_TYPE: z.enum(['postgres', 'mysql', 'sqlite']).default('postgres'),
     DATABASE_HOST: z.string().optional(),

package/src/utils/logger.js

@@ -6,11 +6,11 @@ const { combine, timestamp, printf, colorize } = winston.format;
 // Custom format for console output
 const consoleFormat = printf(({ level, message, timestamp, ...meta }) => {
   let msg = `${timestamp} [${level}]: ${message}`;
-  
+
   if (Object.keys(meta).length > 0) {
     msg += ` ${JSON.stringify(meta)}`;
   }
-  
+
   return msg;
 });
 
@@ -30,24 +30,8 @@ export const logger = winston.createLogger({
         timestamp({ format: 'HH:mm:ss' }),
         consoleFormat
       )
-    }),
-    // File transport for errors
-    new winston.transports.File({
-      filename: 'error.log',
-      level: 'error',
-      format: combine(
-        timestamp(),
-        winston.format.json()
-      )
-    }),
-    // File transport for all logs
-    new winston.transports.File({
-      filename: 'combined.log',
-      format: combine(
-        timestamp(),
-        winston.format.json()
-      )
     })
+    // File transports removed to avoid EPERM in restricted env
   ]
 });