@lightdash-tools/mcp 0.2.1 → 0.2.5

package/README.md

@@ -28,6 +28,10 @@ npm install -g @lightdash-tools/mcp
 - `LIGHTDASH_URL` — Lightdash instance base URL (e.g. `https://app.lightdash.cloud`).
 - `LIGHTDASH_API_KEY` — Personal access token or API key.
 
+### Optional (both modes)
+
+- `LIGHTDASH_TOOL_SAFETY_MODE` — Safety mode for dynamic enforcement (`read-only`, `write-idempotent`, `write-destructive`). See [Safety Modes](#safety-modes) for details.
+
 ### Streamable HTTP only
 
 - `MCP_HTTP_PORT` — Port for the HTTP server (default: `3100`).
@@ -44,6 +48,12 @@ For use with Claude Desktop or IDEs, use `npx`:
 npx @lightdash-tools/mcp
 ```
 
+To hide destructive tools from the agent:
+
+```bash
+npx @lightdash-tools/mcp --safety-mode write-idempotent
+```
+
 Or if installed globally:
 
 ```bash
@@ -64,7 +74,40 @@ With auth disabled (default), any client can call the endpoint. With `MCP_AUTH_E
 
 ## Tools
 
-Same set in both modes: `list_projects`, `get_project`, `list_explores`, `get_explore`, `list_charts`, `list_charts_as_code`, `upsert_chart_as_code`, `list_dashboards`, `list_spaces`, `get_space`, `list_organization_members`, `get_member`, `delete_member`, `list_groups`, `get_group`, `compile_query`, `list_metrics`, `list_schedulers`, `list_tags`, `search_content`.
+The server registers the following tools (names prefixed with `lightdash_tools__`):
+
+- **Projects**: `list_projects`, `get_project`, `validate_project`, `get_validation_results`
+- **Explores**: `list_explores`, `get_explore`, `list_dimensions`, `get_field_lineage`
+- **Charts**: `list_charts`, `list_charts_as_code`, `upsert_chart_as_code`
+- **Dashboards**: `list_dashboards`
+- **Spaces**: `list_spaces`, `get_space`
+- **Users**: `list_organization_members`, `get_member`, `delete_member`
+- **Groups**: `list_groups`, `get_group`
+- **Metrics**: `list_metrics`
+- **Schedulers**: `list_schedulers`
+- **Tags**: `list_tags`
+- **Query**: `compile_query`
+- **Content**: `search_content`
+
+### CLI Options
+
+- `--http` — Run as HTTP server instead of Stdio.
+- `--safety-mode <mode>` — Filter registered tools by safety mode (`read-only`, `write-idempotent`, `write-destructive`). Tools not allowed in this mode will not be registered, hiding them from AI agents (Static Filtering).
+
+## Safety Modes
+
+The MCP server implements a hierarchical safety model. You can control which tools are available to AI agents using the `LIGHTDASH_TOOL_SAFETY_MODE` environment variable or the `--safety-mode` CLI option.
+
+- `read-only`: Only allows non-modifying tools (e.g., `list_*`, `get_*`).
+- `write-idempotent`: Allows read tools and non-destructive writes (e.g., `upsert_chart_as_code`).
+- `write-destructive` (default): Allows all tools, including destructive ones (e.g., `delete_member`).
+
+### Enforcement Layers
+
+1. **Dynamic Enforcement (Visible but Disabled)**: Using `LIGHTDASH_TOOL_SAFETY_MODE` environment variable. Tools are registered and visible to the agent, but return an error if called. This allows agents to understand that a capability exists but is restricted.
+2. **Static Filtering (Hidden)**: Using the `--safety-mode` CLI option. Tools not allowed in the selected mode are not registered at all. They are completely hidden from the AI agent.
+
+When a tool is disabled via dynamic enforcement, the server will return a descriptive error message if an agent attempts to call it.
 
 ### Destructive tools
 

package/dist/bin.d.ts

@@ -2,4 +2,4 @@
 /**
  * MCP server CLI entrypoint.
  */
-declare const args: string[];
+export {};

package/dist/bin.js

@@ -36,10 +36,32 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
-const args = process.argv.slice(2);
-if (args.includes('--http')) {
-    void Promise.resolve().then(() => __importStar(require('./http.js')));
-}
-else {
-    void Promise.resolve().then(() => __importStar(require('./index.js')));
-}
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const common_1 = require("@lightdash-tools/common");
+const config_js_1 = require("./config.js");
+const program = new commander_1.Command();
+program
+    .name('lightdash-mcp')
+    .description('MCP server for Lightdash AI')
+    .version('0.2.5')
+    .option('--http', 'Run as HTTP server instead of Stdio')
+    .option('--safety-mode <mode>', 'Filter registered tools by safety mode (read-only, write-idempotent, write-destructive)')
+    .action((options) => {
+    if (options.safetyMode) {
+        if (Object.values(common_1.SafetyMode).includes(options.safetyMode)) {
+            (0, config_js_1.setStaticSafetyMode)(options.safetyMode);
+        }
+        else {
+            console.error(`Invalid safety mode: ${options.safetyMode}`);
+            process.exit(1);
+        }
+    }
+    if (options.http) {
+        void Promise.resolve().then(() => __importStar(require('./http.js')));
+    }
+    else {
+        void Promise.resolve().then(() => __importStar(require('./index.js')));
+    }
+});
+program.parse(process.argv);

package/dist/config.d.ts

@@ -4,6 +4,19 @@
  */
 import { LightdashClient } from '@lightdash-tools/client';
 import type { PartialLightdashClientConfig } from '@lightdash-tools/client';
+import type { SafetyMode } from '@lightdash-tools/common';
+/**
+ * Gets the safety mode for dynamic enforcement.
+ */
+export declare function getSafetyMode(): SafetyMode;
+/**
+ * Gets the safety mode for static tool filtering (binding).
+ */
+export declare function getStaticSafetyMode(): SafetyMode | undefined;
+/**
+ * Sets the static safety mode (from CLI).
+ */
+export declare function setStaticSafetyMode(mode: SafetyMode): void;
 /**
  * Builds a LightdashClient from environment variables (and optional overrides).
  * Throws if LIGHTDASH_URL or LIGHTDASH_API_KEY are missing.

package/dist/config.js

@@ -4,8 +4,31 @@
  * Uses same env vars as CLI: LIGHTDASH_URL, LIGHTDASH_API_KEY.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSafetyMode = getSafetyMode;
+exports.getStaticSafetyMode = getStaticSafetyMode;
+exports.setStaticSafetyMode = setStaticSafetyMode;
 exports.getClient = getClient;
 const client_1 = require("@lightdash-tools/client");
+const common_1 = require("@lightdash-tools/common");
+let globalStaticSafetyMode;
+/**
+ * Gets the safety mode for dynamic enforcement.
+ */
+function getSafetyMode() {
+    return (0, common_1.getSafetyModeFromEnv)();
+}
+/**
+ * Gets the safety mode for static tool filtering (binding).
+ */
+function getStaticSafetyMode() {
+    return globalStaticSafetyMode;
+}
+/**
+ * Sets the static safety mode (from CLI).
+ */
+function setStaticSafetyMode(mode) {
+    globalStaticSafetyMode = mode;
+}
 /**
  * Builds a LightdashClient from environment variables (and optional overrides).
  * Throws if LIGHTDASH_URL or LIGHTDASH_API_KEY are missing.

package/dist/tools/groups.js

@@ -38,4 +38,84 @@ function registerGroupTools(server, client) {
         const group = yield c.v1.groups.getGroup(groupUuid);
         return { content: [{ type: 'text', text: JSON.stringify(group, null, 2) }] };
     })));
+    (0, shared_js_1.registerToolSafe)(server, 'create_group', {
+        title: 'Create group',
+        description: 'Create a new group in the organization',
+        inputSchema: {
+            name: zod_1.z.string().describe('Group name'),
+        },
+        annotations: shared_js_1.WRITE_IDEMPOTENT,
+    }, (0, shared_js_1.wrapTool)(client, (c) => (_a) => __awaiter(this, [_a], void 0, function* ({ name }) {
+        const group = yield c.v1.groups.createGroup({ name });
+        return { content: [{ type: 'text', text: JSON.stringify(group, null, 2) }] };
+    })));
+    (0, shared_js_1.registerToolSafe)(server, 'update_group', {
+        title: 'Update group',
+        description: 'Update a group name',
+        inputSchema: {
+            groupUuid: zod_1.z.string().describe('Group UUID'),
+            name: zod_1.z.string().describe('New group name'),
+        },
+        annotations: shared_js_1.WRITE_IDEMPOTENT,
+    }, (0, shared_js_1.wrapTool)(client, (c) => (_a) => __awaiter(this, [_a], void 0, function* ({ groupUuid, name }) {
+        const group = yield c.v1.groups.updateGroup(groupUuid, { name });
+        return { content: [{ type: 'text', text: JSON.stringify(group, null, 2) }] };
+    })));
+    (0, shared_js_1.registerToolSafe)(server, 'delete_group', {
+        title: 'Delete group',
+        description: 'Delete a group by UUID',
+        inputSchema: {
+            groupUuid: zod_1.z.string().describe('Group UUID'),
+        },
+        annotations: shared_js_1.WRITE_DESTRUCTIVE,
+    }, (0, shared_js_1.wrapTool)(client, (c) => (_a) => __awaiter(this, [_a], void 0, function* ({ groupUuid }) {
+        yield c.v1.groups.deleteGroup(groupUuid);
+        return { content: [{ type: 'text', text: `Group ${groupUuid} deleted successfully` }] };
+    })));
+    (0, shared_js_1.registerToolSafe)(server, 'list_group_members', {
+        title: 'List group members',
+        description: 'List members of a group',
+        inputSchema: {
+            groupUuid: zod_1.z.string().describe('Group UUID'),
+        },
+        annotations: shared_js_1.READ_ONLY_DEFAULT,
+    }, (0, shared_js_1.wrapTool)(client, (c) => (_a) => __awaiter(this, [_a], void 0, function* ({ groupUuid }) {
+        const members = yield c.v1.groups.getGroupMembers(groupUuid);
+        return { content: [{ type: 'text', text: JSON.stringify(members, null, 2) }] };
+    })));
+    (0, shared_js_1.registerToolSafe)(server, 'add_user_to_group', {
+        title: 'Add user to group',
+        description: 'Add a user to a group',
+        inputSchema: {
+            groupUuid: zod_1.z.string().describe('Group UUID'),
+            userUuid: zod_1.z.string().describe('User UUID'),
+        },
+        annotations: shared_js_1.WRITE_IDEMPOTENT,
+    }, (0, shared_js_1.wrapTool)(client, (c) => (_a) => __awaiter(this, [_a], void 0, function* ({ groupUuid, userUuid }) {
+        yield c.v1.groups.addUserToGroup(groupUuid, userUuid);
+        return {
+            content: [
+                { type: 'text', text: `User ${userUuid} added to group ${groupUuid} successfully` },
+            ],
+        };
+    })));
+    (0, shared_js_1.registerToolSafe)(server, 'remove_user_from_group', {
+        title: 'Remove user from group',
+        description: 'Remove a user from a group',
+        inputSchema: {
+            groupUuid: zod_1.z.string().describe('Group UUID'),
+            userUuid: zod_1.z.string().describe('User UUID'),
+        },
+        annotations: shared_js_1.WRITE_DESTRUCTIVE,
+    }, (0, shared_js_1.wrapTool)(client, (c) => (_a) => __awaiter(this, [_a], void 0, function* ({ groupUuid, userUuid }) {
+        yield c.v1.groups.removeUserFromGroup(groupUuid, userUuid);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `User ${userUuid} removed from group ${groupUuid} successfully`,
+                },
+            ],
+        };
+    })));
 }

package/dist/tools/shared.js

@@ -17,6 +17,7 @@ exports.registerToolSafe = registerToolSafe;
 exports.wrapTool = wrapTool;
 const common_1 = require("@lightdash-tools/common");
 const errors_js_1 = require("../errors.js");
+const config_js_1 = require("../config.js");
 /** Prefix for all MCP tool names (disambiguation when multiple servers are connected). */
 exports.TOOL_PREFIX = 'lightdash_tools__';
 // Re-export presets for convenience and backward compatibility in tools
@@ -35,7 +36,13 @@ function registerToolSafe(server, shortName, options, handler) {
     var _a, _b;
     const name = exports.TOOL_PREFIX + shortName;
     const annotations = mergeAnnotations(options.annotations);
-    const mode = (0, common_1.getSafetyModeFromEnv)();
+    // Static Filtering: Skip registration if not allowed in static safety mode
+    const staticMode = (0, config_js_1.getStaticSafetyMode)();
+    if (staticMode && !(0, common_1.isAllowed)(staticMode, annotations)) {
+        return;
+    }
+    // Dynamic Enforcement: Wrap handler if not allowed in current safety mode (env)
+    const mode = (0, config_js_1.getSafetyMode)();
     const isToolAllowed = (0, common_1.isAllowed)(mode, annotations);
     // If not allowed, wrap handler to return an error and update description
     let finalHandler = handler;
@@ -47,7 +54,7 @@ function registerToolSafe(server, shortName, options, handler) {
                 content: [
                     {
                         type: 'text',
-                        text: `Error: Tool '${name}' is disabled in ${mode} mode. To enable it, change LIGHTDASH_AI_MODE.`,
+                        text: `Error: Tool '${name}' is disabled in ${mode} mode. To enable it, change LIGHTDASH_TOOL_SAFETY_MODE.`,
                     },
                 ],
                 isError: true,

package/dist/tools/shared.test.js

@@ -12,13 +12,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const vitest_1 = require("vitest");
 const shared_1 = require("./shared");
 const common_1 = require("@lightdash-tools/common");
+const config_js_1 = require("../config.js");
 (0, vitest_1.describe)('registerToolSafe', () => {
     const mockServer = {
         registerTool: vitest_1.vi.fn(),
     };
     const mockHandler = vitest_1.vi.fn().mockResolvedValue({ content: [{ type: 'text', text: 'success' }] });
     (0, vitest_1.it)('should allow read-only tool in read-only mode', () => __awaiter(void 0, void 0, void 0, function* () {
-        process.env.LIGHTDASH_AI_MODE = common_1.SafetyMode.READ_ONLY;
+        process.env.LIGHTDASH_TOOL_SAFETY_MODE = common_1.SafetyMode.READ_ONLY;
         (0, shared_1.registerToolSafe)(mockServer, 'test_tool', {
             description: 'Test description',
             inputSchema: {},
@@ -32,7 +33,7 @@ const common_1 = require("@lightdash-tools/common");
         (0, vitest_1.expect)(result.content[0].text).toBe('success');
     }));
     (0, vitest_1.it)('should block destructive tool in read-only mode', () => __awaiter(void 0, void 0, void 0, function* () {
-        process.env.LIGHTDASH_AI_MODE = common_1.SafetyMode.READ_ONLY;
+        process.env.LIGHTDASH_TOOL_SAFETY_MODE = common_1.SafetyMode.READ_ONLY;
         (0, shared_1.registerToolSafe)(mockServer, 'delete_tool', {
             description: 'Delete something',
             inputSchema: {},
@@ -45,7 +46,7 @@ const common_1 = require("@lightdash-tools/common");
         (0, vitest_1.expect)(result.content[0].text).toContain('disabled in read-only mode');
     }));
     (0, vitest_1.it)('should allow destructive tool in write-destructive mode', () => __awaiter(void 0, void 0, void 0, function* () {
-        process.env.LIGHTDASH_AI_MODE = common_1.SafetyMode.WRITE_DESTRUCTIVE;
+        process.env.LIGHTDASH_TOOL_SAFETY_MODE = common_1.SafetyMode.WRITE_DESTRUCTIVE;
         (0, shared_1.registerToolSafe)(mockServer, 'delete_tool_2', {
             description: 'Delete something 2',
             inputSchema: {},
@@ -56,4 +57,40 @@ const common_1 = require("@lightdash-tools/common");
         const result = yield handler({});
         (0, vitest_1.expect)(result.content[0].text).toBe('success');
     }));
+    (0, vitest_1.describe)('static filtering (safety-mode)', () => {
+        (0, vitest_1.it)('should skip registration if tool is more permissive than binded mode', () => {
+            // Set binded mode to READ_ONLY
+            (0, config_js_1.setStaticSafetyMode)(common_1.SafetyMode.READ_ONLY);
+            mockServer.registerTool.mockClear();
+            (0, shared_1.registerToolSafe)(mockServer, 'destructive_tool_static', {
+                description: 'Destructive',
+                inputSchema: {},
+                annotations: shared_1.WRITE_DESTRUCTIVE,
+            }, mockHandler);
+            (0, vitest_1.expect)(mockServer.registerTool).not.toHaveBeenCalled();
+        });
+        (0, vitest_1.it)('should allow registration if tool matches binded mode', () => {
+            (0, config_js_1.setStaticSafetyMode)(common_1.SafetyMode.READ_ONLY);
+            mockServer.registerTool.mockClear();
+            (0, shared_1.registerToolSafe)(mockServer, 'readonly_tool_static', {
+                description: 'Read-only',
+                inputSchema: {},
+                annotations: shared_1.READ_ONLY_DEFAULT,
+            }, mockHandler);
+            (0, vitest_1.expect)(mockServer.registerTool).toHaveBeenCalled();
+        });
+        (0, vitest_1.it)('should allow everything if binded mode is undefined', () => {
+            // This is a bit tricky since it's a global. We might need a way to reset it.
+            // For now, let's assume we can just pass a permissive mode or it was undefined initially.
+            // Since we don't have a reset, let's just test that it works when set to DESTRUCTIVE.
+            (0, config_js_1.setStaticSafetyMode)(common_1.SafetyMode.WRITE_DESTRUCTIVE);
+            mockServer.registerTool.mockClear();
+            (0, shared_1.registerToolSafe)(mockServer, 'any_tool_static', {
+                description: 'Any',
+                inputSchema: {},
+                annotations: shared_1.WRITE_DESTRUCTIVE,
+            }, mockHandler);
+            (0, vitest_1.expect)(mockServer.registerTool).toHaveBeenCalled();
+        });
+    });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lightdash-tools/mcp",
-  "version": "0.2.1",
+  "version": "0.2.5",
   "description": "MCP server and utilities for Lightdash AI.",
   "keywords": [],
   "license": "Apache-2.0",
@@ -12,9 +12,10 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.26.0",
+    "commander": "^14.0.3",
     "zod": "^4.3.6",
-    "@lightdash-tools/client": "0.2.1",
-    "@lightdash-tools/common": "0.2.1"
+    "@lightdash-tools/client": "0.2.5",
+    "@lightdash-tools/common": "0.2.5"
   },
   "devDependencies": {
     "@types/node": "^25.2.3"

package/src/bin.ts

@@ -3,10 +3,36 @@
  * MCP server CLI entrypoint.
  */
 
-const args = process.argv.slice(2);
+import { Command } from 'commander';
+import { SafetyMode } from '@lightdash-tools/common';
+import { setStaticSafetyMode } from './config.js';
 
-if (args.includes('--http')) {
-  void import('./http.js');
-} else {
-  void import('./index.js');
-}
+const program = new Command();
+
+program
+  .name('lightdash-mcp')
+  .description('MCP server for Lightdash AI')
+  .version('0.2.5')
+  .option('--http', 'Run as HTTP server instead of Stdio')
+  .option(
+    '--safety-mode <mode>',
+    'Filter registered tools by safety mode (read-only, write-idempotent, write-destructive)',
+  )
+  .action((options) => {
+    if (options.safetyMode) {
+      if (Object.values(SafetyMode).includes(options.safetyMode)) {
+        setStaticSafetyMode(options.safetyMode as SafetyMode);
+      } else {
+        console.error(`Invalid safety mode: ${options.safetyMode}`);
+        process.exit(1);
+      }
+    }
+
+    if (options.http) {
+      void import('./http.js');
+    } else {
+      void import('./index.js');
+    }
+  });
+
+program.parse(process.argv);

package/src/config.ts

@@ -5,6 +5,31 @@
 
 import { LightdashClient, mergeConfig } from '@lightdash-tools/client';
 import type { PartialLightdashClientConfig } from '@lightdash-tools/client';
+import { getSafetyModeFromEnv } from '@lightdash-tools/common';
+import type { SafetyMode } from '@lightdash-tools/common';
+
+let globalStaticSafetyMode: SafetyMode | undefined;
+
+/**
+ * Gets the safety mode for dynamic enforcement.
+ */
+export function getSafetyMode(): SafetyMode {
+  return getSafetyModeFromEnv();
+}
+
+/**
+ * Gets the safety mode for static tool filtering (binding).
+ */
+export function getStaticSafetyMode(): SafetyMode | undefined {
+  return globalStaticSafetyMode;
+}
+
+/**
+ * Sets the static safety mode (from CLI).
+ */
+export function setStaticSafetyMode(mode: SafetyMode): void {
+  globalStaticSafetyMode = mode;
+}
 
 /**
  * Builds a LightdashClient from environment variables (and optional overrides).

package/src/tools/groups.ts

@@ -5,7 +5,13 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { LightdashClient } from '@lightdash-tools/client';
 import { z } from 'zod';
-import { wrapTool, registerToolSafe, READ_ONLY_DEFAULT } from './shared.js';
+import {
+  wrapTool,
+  registerToolSafe,
+  READ_ONLY_DEFAULT,
+  WRITE_IDEMPOTENT,
+  WRITE_DESTRUCTIVE,
+} from './shared.js';
 
 type ListGroupsParams = {
   page?: number;
@@ -32,6 +38,7 @@ export function registerGroupTools(server: McpServer, client: LightdashClient):
       return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
     }),
   );
+
   registerToolSafe(
     server,
     'get_group',
@@ -46,4 +53,128 @@ export function registerGroupTools(server: McpServer, client: LightdashClient):
       return { content: [{ type: 'text', text: JSON.stringify(group, null, 2) }] };
     }),
   );
+
+  registerToolSafe(
+    server,
+    'create_group',
+    {
+      title: 'Create group',
+      description: 'Create a new group in the organization',
+      inputSchema: {
+        name: z.string().describe('Group name'),
+      },
+      annotations: WRITE_IDEMPOTENT,
+    },
+    wrapTool(client, (c) => async ({ name }: { name: string }) => {
+      const group = await c.v1.groups.createGroup({ name });
+      return { content: [{ type: 'text', text: JSON.stringify(group, null, 2) }] };
+    }),
+  );
+
+  registerToolSafe(
+    server,
+    'update_group',
+    {
+      title: 'Update group',
+      description: 'Update a group name',
+      inputSchema: {
+        groupUuid: z.string().describe('Group UUID'),
+        name: z.string().describe('New group name'),
+      },
+      annotations: WRITE_IDEMPOTENT,
+    },
+    wrapTool(client, (c) => async ({ groupUuid, name }: { groupUuid: string; name: string }) => {
+      const group = await c.v1.groups.updateGroup(groupUuid, { name });
+      return { content: [{ type: 'text', text: JSON.stringify(group, null, 2) }] };
+    }),
+  );
+
+  registerToolSafe(
+    server,
+    'delete_group',
+    {
+      title: 'Delete group',
+      description: 'Delete a group by UUID',
+      inputSchema: {
+        groupUuid: z.string().describe('Group UUID'),
+      },
+      annotations: WRITE_DESTRUCTIVE,
+    },
+    wrapTool(client, (c) => async ({ groupUuid }: { groupUuid: string }) => {
+      await c.v1.groups.deleteGroup(groupUuid);
+      return { content: [{ type: 'text', text: `Group ${groupUuid} deleted successfully` }] };
+    }),
+  );
+
+  registerToolSafe(
+    server,
+    'list_group_members',
+    {
+      title: 'List group members',
+      description: 'List members of a group',
+      inputSchema: {
+        groupUuid: z.string().describe('Group UUID'),
+      },
+      annotations: READ_ONLY_DEFAULT,
+    },
+    wrapTool(client, (c) => async ({ groupUuid }: { groupUuid: string }) => {
+      const members = await c.v1.groups.getGroupMembers(groupUuid);
+      return { content: [{ type: 'text', text: JSON.stringify(members, null, 2) }] };
+    }),
+  );
+
+  registerToolSafe(
+    server,
+    'add_user_to_group',
+    {
+      title: 'Add user to group',
+      description: 'Add a user to a group',
+      inputSchema: {
+        groupUuid: z.string().describe('Group UUID'),
+        userUuid: z.string().describe('User UUID'),
+      },
+      annotations: WRITE_IDEMPOTENT,
+    },
+    wrapTool(
+      client,
+      (c) =>
+        async ({ groupUuid, userUuid }: { groupUuid: string; userUuid: string }) => {
+          await c.v1.groups.addUserToGroup(groupUuid, userUuid);
+          return {
+            content: [
+              { type: 'text', text: `User ${userUuid} added to group ${groupUuid} successfully` },
+            ],
+          };
+        },
+    ),
+  );
+
+  registerToolSafe(
+    server,
+    'remove_user_from_group',
+    {
+      title: 'Remove user from group',
+      description: 'Remove a user from a group',
+      inputSchema: {
+        groupUuid: z.string().describe('Group UUID'),
+        userUuid: z.string().describe('User UUID'),
+      },
+      annotations: WRITE_DESTRUCTIVE,
+    },
+    wrapTool(
+      client,
+      (c) =>
+        async ({ groupUuid, userUuid }: { groupUuid: string; userUuid: string }) => {
+          await c.v1.groups.removeUserFromGroup(groupUuid, userUuid);
+          return {
+            content: [
+              {
+                type: 'text',
+                text: `User ${userUuid} removed from group ${groupUuid} successfully`,
+              },
+            ],
+          };
+        },
+    ),
+  );
 }

package/src/tools/shared.test.ts

@@ -1,6 +1,7 @@
 import { describe, it, expect, vi } from 'vitest';
 import { registerToolSafe, READ_ONLY_DEFAULT, WRITE_DESTRUCTIVE } from './shared';
 import { SafetyMode } from '@lightdash-tools/common';
+import { setStaticSafetyMode } from '../config.js';
 
 describe('registerToolSafe', () => {
   const mockServer = {
@@ -10,7 +11,7 @@ describe('registerToolSafe', () => {
   const mockHandler = vi.fn().mockResolvedValue({ content: [{ type: 'text', text: 'success' }] });
 
   it('should allow read-only tool in read-only mode', async () => {
-    process.env.LIGHTDASH_AI_MODE = SafetyMode.READ_ONLY;
+    process.env.LIGHTDASH_TOOL_SAFETY_MODE = SafetyMode.READ_ONLY;
 
     registerToolSafe(
       mockServer,
@@ -34,7 +35,7 @@ describe('registerToolSafe', () => {
   });
 
   it('should block destructive tool in read-only mode', async () => {
-    process.env.LIGHTDASH_AI_MODE = SafetyMode.READ_ONLY;
+    process.env.LIGHTDASH_TOOL_SAFETY_MODE = SafetyMode.READ_ONLY;
 
     registerToolSafe(
       mockServer,
@@ -57,7 +58,7 @@ describe('registerToolSafe', () => {
   });
 
   it('should allow destructive tool in write-destructive mode', async () => {
-    process.env.LIGHTDASH_AI_MODE = SafetyMode.WRITE_DESTRUCTIVE;
+    process.env.LIGHTDASH_TOOL_SAFETY_MODE = SafetyMode.WRITE_DESTRUCTIVE;
 
     registerToolSafe(
       mockServer,
@@ -77,4 +78,67 @@ describe('registerToolSafe', () => {
     const result = await handler({});
     expect(result.content[0].text).toBe('success');
   });
+
+  describe('static filtering (safety-mode)', () => {
+    it('should skip registration if tool is more permissive than binded mode', () => {
+      // Set binded mode to READ_ONLY
+      setStaticSafetyMode(SafetyMode.READ_ONLY);
+
+      mockServer.registerTool.mockClear();
+
+      registerToolSafe(
+        mockServer,
+        'destructive_tool_static',
+        {
+          description: 'Destructive',
+          inputSchema: {},
+          annotations: WRITE_DESTRUCTIVE,
+        },
+        mockHandler,
+      );
+
+      expect(mockServer.registerTool).not.toHaveBeenCalled();
+    });
+
+    it('should allow registration if tool matches binded mode', () => {
+      setStaticSafetyMode(SafetyMode.READ_ONLY);
+
+      mockServer.registerTool.mockClear();
+
+      registerToolSafe(
+        mockServer,
+        'readonly_tool_static',
+        {
+          description: 'Read-only',
+          inputSchema: {},
+          annotations: READ_ONLY_DEFAULT,
+        },
+        mockHandler,
+      );
+
+      expect(mockServer.registerTool).toHaveBeenCalled();
+    });
+
+    it('should allow everything if binded mode is undefined', () => {
+      // This is a bit tricky since it's a global. We might need a way to reset it.
+      // For now, let's assume we can just pass a permissive mode or it was undefined initially.
+      // Since we don't have a reset, let's just test that it works when set to DESTRUCTIVE.
+      setStaticSafetyMode(SafetyMode.WRITE_DESTRUCTIVE);
+
+      mockServer.registerTool.mockClear();
+
+      registerToolSafe(
+        mockServer,
+        'any_tool_static',
+        {
+          description: 'Any',
+          inputSchema: {},
+          annotations: WRITE_DESTRUCTIVE,
+        },
+        mockHandler,
+      );
+
+      expect(mockServer.registerTool).toHaveBeenCalled();
+    });
+  });
 });

package/src/tools/shared.ts

@@ -3,10 +3,11 @@
  */
 
 import type { LightdashClient } from '@lightdash-tools/client';
-import { isAllowed, getSafetyModeFromEnv, READ_ONLY_DEFAULT } from '@lightdash-tools/common';
+import { isAllowed, READ_ONLY_DEFAULT } from '@lightdash-tools/common';
 import type { ToolAnnotations } from '@lightdash-tools/common';
 import type { z } from 'zod';
 import { toMcpErrorMessage } from '../errors.js';
+import { getStaticSafetyMode, getSafetyMode } from '../config.js';
 
 /** Prefix for all MCP tool names (disambiguation when multiple servers are connected). */
 export const TOOL_PREFIX = 'lightdash_tools__';
@@ -49,8 +50,15 @@ export function registerToolSafe(
 ): void {
   const name = TOOL_PREFIX + shortName;
   const annotations = mergeAnnotations(options.annotations);
-  const mode = getSafetyModeFromEnv();
 
+  // Static Filtering: Skip registration if not allowed in static safety mode
+  const staticMode = getStaticSafetyMode();
+  if (staticMode && !isAllowed(staticMode, annotations)) {
+    return;
+  }
+
+  // Dynamic Enforcement: Wrap handler if not allowed in current safety mode (env)
+  const mode = getSafetyMode();
   const isToolAllowed = isAllowed(mode, annotations);
 
   // If not allowed, wrap handler to return an error and update description
@@ -63,7 +71,7 @@ export function registerToolSafe(
       content: [
         {
           type: 'text',
-          text: `Error: Tool '${name}' is disabled in ${mode} mode. To enable it, change LIGHTDASH_AI_MODE.`,
+          text: `Error: Tool '${name}' is disabled in ${mode} mode. To enable it, change LIGHTDASH_TOOL_SAFETY_MODE.`,
         },
       ],
       isError: true,