snowflake-analytics-mcp-server 0.1.0

package/README.md

@@ -0,0 +1,110 @@
+# snowflake-analytics-mcp-server
+
+A [Model Context Protocol](https://modelcontextprotocol.io) server for **Snowflake**, built for the Analytics Model platform. It connects to Snowflake via the official `snowflake-sdk` driver (pure Node — no client binary needed, unlike the Oracle server) and exposes table-discovery and query tools over stdio. Runnable directly with `npx`.
+
+The `list_tables` tool returns the platform's exact table-discovery envelope, so it drops straight into the same `fetchMcpTables` flow as the Clio, Dropbox and Shopify servers.
+
+## Install
+
+```bash
+npm install -g snowflake-analytics-mcp-server
+# or run directly (no install):
+npx -y snowflake-analytics-mcp-server
+```
+
+## Configuration
+
+All credentials come from environment variables.
+
+| Variable | Required | Default | Description |
+|---|---|---|---|
+| `SNOWFLAKE_ACCOUNT` | ✅ | — | Account identifier, e.g. `xy12345.eu-central-1` or `orgname-account_name` |
+| `SNOWFLAKE_USERNAME` | ✅ | — | Login name |
+| `SNOWFLAKE_PASSWORD` | ✅ (password auth) | — | Password (required unless using key-pair/OAuth) |
+| `SNOWFLAKE_WAREHOUSE` | — | — | Virtual warehouse to use |
+| `SNOWFLAKE_DATABASE` | recommended | — | Default database (used by `list_tables` when no arg is given) |
+| `SNOWFLAKE_SCHEMA` | recommended | — | Default schema |
+| `SNOWFLAKE_ROLE` | — | — | Role to assume |
+| `SNOWFLAKE_AUTHENTICATOR` | — | `SNOWFLAKE` | `SNOWFLAKE` (password), `SNOWFLAKE_JWT` (key-pair), `OAUTH` |
+| `SNOWFLAKE_PRIVATE_KEY` | key-pair | — | PEM private key contents |
+| `SNOWFLAKE_PRIVATE_KEY_PATH` | key-pair | — | Path to a PEM private key file (alternative to above) |
+| `SNOWFLAKE_PRIVATE_KEY_PASSPHRASE` | — | — | Passphrase, if the key is encrypted |
+| `SNOWFLAKE_TOKEN` | OAuth | — | OAuth access token (with `SNOWFLAKE_AUTHENTICATOR=OAUTH`) |
+| `SNOWFLAKE_READ_ONLY` | — | `true` | Blocks writes/DDL in `execute_query`. Set `false` to allow them |
+| `SNOWFLAKE_ROW_LIMIT` | — | `1000` | Hard cap on returned rows |
+| `QUERY_TIMEOUT_MS` | — | `60000` | Client-side query timeout |
+
+### Account identifier tip
+
+Use hyphens, not underscores, in the account identifier if a client has trouble connecting (e.g. `orgname-account-name`).
+
+## Claude Desktop config
+
+Add to `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "snowflake": {
+      "command": "npx",
+      "args": ["-y", "snowflake-analytics-mcp-server"],
+      "env": {
+        "SNOWFLAKE_ACCOUNT": "xy12345.eu-central-1",
+        "SNOWFLAKE_USERNAME": "ANALYTICS_USER",
+        "SNOWFLAKE_PASSWORD": "••••••••",
+        "SNOWFLAKE_WAREHOUSE": "COMPUTE_WH",
+        "SNOWFLAKE_DATABASE": "ANALYTICS_DB",
+        "SNOWFLAKE_SCHEMA": "PUBLIC",
+        "SNOWFLAKE_ROLE": "ANALYST"
+      }
+    }
+  }
+}
+```
+
+### Key-pair auth example
+
+```json
+"env": {
+  "SNOWFLAKE_ACCOUNT": "xy12345.eu-central-1",
+  "SNOWFLAKE_USERNAME": "ANALYTICS_USER",
+  "SNOWFLAKE_AUTHENTICATOR": "SNOWFLAKE_JWT",
+  "SNOWFLAKE_PRIVATE_KEY_PATH": "/path/to/rsa_key.p8",
+  "SNOWFLAKE_PRIVATE_KEY_PASSPHRASE": "••••••••",
+  "SNOWFLAKE_DATABASE": "ANALYTICS_DB",
+  "SNOWFLAKE_SCHEMA": "PUBLIC"
+}
+```
+
+## Tools
+
+| Tool | Args | Description |
+|---|---|---|
+| `list_tables` | `database?`, `schema?`, `include_views?` | **Platform contract.** Returns `{ table_name }[]` in the double-wrapped envelope for `fetchMcpTables` |
+| `test_connection` | — | Returns version, account, user, role, warehouse, database, schema |
+| `list_databases` | — | Databases visible to the current role |
+| `list_schemas` | `database?` | Schemas in a database |
+| `list_warehouses` | — | Warehouses with size/state |
+| `describe_table` | `table`, `database?`, `schema?` | Columns, types, nullability, defaults |
+| `get_table_sample` | `table`, `database?`, `schema?`, `limit?` | Preview rows from a table |
+| `execute_query` | `query` | Run SQL. Read-only unless `SNOWFLAKE_READ_ONLY=false` |
+
+## Platform integration note
+
+`list_tables` matches the confirmed envelope used by the Shopify/Clio servers:
+
+```jsonc
+{
+  "is_success": true,
+  "status_code": 200,
+  "data": "[{\"table_name\":\"ORDERS\"},{\"table_name\":\"CUSTOMERS\"}]", // double-stringified
+  "message": "Found 2 table(s).",
+  "requestedPayload": { "database": "ANALYTICS_DB", "schema": "PUBLIC", "include_views": true }
+}
+```
+
+Because Snowflake exposes **arbitrary** user tables (unlike Clio's fixed resource categories, which each had a `list_<resource>` tool), there is no per-table tool. When a user selects a table in the platform, the backend should fetch its rows via `get_table_sample` (preview) or `execute_query` (`SELECT * FROM <table>`), rather than calling a tool named after the table. Confirm this mapping with the backend before wiring the row-fetch step.
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":""}

package/dist/index.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+/**
+ * snowflake-analytics-mcp-server
+ *
+ * A Model Context Protocol server that exposes a Snowflake connection over
+ * stdio, runnable via `npx`. Built for the Analytics Model platform: the
+ * `list_tables` tool follows the platform's table-discovery envelope contract,
+ * while the remaining tools are standard SQL helpers.
+ *
+ * Credentials come entirely from environment variables (see README).
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { registerTools } from "./tools/index.js";
+async function main() {
+    const server = new McpServer({
+        name: "snowflake-analytics-mcp-server",
+        version: "0.1.0",
+        title: "Snowflake Analytics MCP Server",
+    });
+    registerTools(server);
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    // Log to stderr only — stdout is reserved for the MCP protocol stream.
+    process.stderr.write("snowflake-analytics-mcp-server running on stdio\n");
+}
+main().catch((err) => {
+    process.stderr.write(`Fatal: ${err instanceof Error ? err.stack || err.message : String(err)}\n`);
+    process.exit(1);
+});

package/dist/snowflake.d.ts

@@ -0,0 +1,37 @@
+export interface SnowflakeConfig {
+    account: string;
+    username: string;
+    password?: string;
+    authenticator: string;
+    token?: string;
+    privateKey?: string;
+    privateKeyPass?: string;
+    warehouse?: string;
+    database?: string;
+    schema?: string;
+    role?: string;
+    queryTimeoutMs: number;
+    rowLimit: number;
+    readOnly: boolean;
+}
+export declare function loadConfig(): SnowflakeConfig;
+export declare function getConfig(): SnowflakeConfig;
+export interface QueryResult {
+    rows: Record<string, unknown>[];
+    rowCount: number;
+}
+export declare function runQuery(sqlText: string, binds?: unknown[]): Promise<QueryResult>;
+/**
+ * Validate and quote a Snowflake identifier (database / schema / table / column).
+ * Snowflake identifiers may contain letters, digits, underscores and $ .
+ * Anything else is rejected to prevent SQL injection through identifier slots.
+ * The result is wrapped in double quotes with internal quotes doubled.
+ */
+export declare function quoteIdent(name: string): string;
+/**
+ * Build a fully-qualified name from optional database/schema plus a table.
+ * Falls back to the connection's configured database/schema when omitted.
+ */
+export declare function qualify(table: string, database?: string, schema?: string): string;
+export declare function isReadOnlyStatement(sql: string): boolean;
+//# sourceMappingURL=snowflake.d.ts.map

package/dist/snowflake.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"snowflake.d.ts","sourceRoot":"","sources":["../src/snowflake.ts"],"names":[],"mappings":"AAuBA,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,MAAM,CAAC;IACtB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,cAAc,EAAE,MAAM,CAAC;IACvB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,OAAO,CAAC;CACnB;AAUD,wBAAgB,UAAU,IAAI,eAAe,CAsC5C;AAKD,wBAAgB,SAAS,IAAI,eAAe,CAG3C;AAiCD,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;IAChC,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,wBAAsB,QAAQ,CAC5B,OAAO,EAAE,MAAM,EACf,KAAK,GAAE,OAAO,EAAO,GACpB,OAAO,CAAC,WAAW,CAAC,CAsBtB;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAO/C;AAED;;;GAGG;AACH,wBAAgB,OAAO,CACrB,KAAK,EAAE,MAAM,EACb,QAAQ,CAAC,EAAE,MAAM,EACjB,MAAM,CAAC,EAAE,MAAM,GACd,MAAM,CASR;AAKD,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAExD"}

package/dist/snowflake.js

@@ -0,0 +1,160 @@
+/**
+ * snowflake.ts — thin wrapper around the official `snowflake-sdk` driver.
+ *
+ * Responsibilities:
+ *   - Read connection config from environment variables.
+ *   - Maintain a single, lazily-established connection that is reused across
+ *     tool calls (stdio is single-user, so a connection pool is overkill).
+ *   - Reconnect transparently if the session has dropped.
+ *   - Provide a promisified query runner and safe identifier quoting.
+ *
+ * Auth modes (pick via SNOWFLAKE_AUTHENTICATOR, default = password):
+ *   - SNOWFLAKE            : username + password
+ *   - SNOWFLAKE_JWT        : key-pair (SNOWFLAKE_PRIVATE_KEY or _PATH, optional passphrase)
+ *   - OAUTH                : username + SNOWFLAKE_TOKEN
+ *   - EXTERNALBROWSER      : interactive SSO (not usable under stdio automation)
+ */
+import { readFileSync } from "node:fs";
+import snowflake from "snowflake-sdk";
+// Keep the driver quiet — its default logger writes to stdout, which would
+// corrupt the MCP stdio stream. Route everything to stderr at ERROR level.
+snowflake.configure({ logLevel: "ERROR" });
+function req(name) {
+    const v = process.env[name];
+    if (!v || !v.trim()) {
+        throw new Error(`Missing required environment variable: ${name}`);
+    }
+    return v.trim();
+}
+export function loadConfig() {
+    const authenticator = (process.env.SNOWFLAKE_AUTHENTICATOR || "SNOWFLAKE")
+        .trim()
+        .toUpperCase();
+    let privateKey;
+    if (authenticator === "SNOWFLAKE_JWT") {
+        if (process.env.SNOWFLAKE_PRIVATE_KEY) {
+            privateKey = process.env.SNOWFLAKE_PRIVATE_KEY;
+        }
+        else if (process.env.SNOWFLAKE_PRIVATE_KEY_PATH) {
+            privateKey = readFileSync(process.env.SNOWFLAKE_PRIVATE_KEY_PATH.trim(), "utf8");
+        }
+        else {
+            throw new Error("SNOWFLAKE_AUTHENTICATOR=SNOWFLAKE_JWT requires SNOWFLAKE_PRIVATE_KEY or SNOWFLAKE_PRIVATE_KEY_PATH");
+        }
+    }
+    return {
+        account: req("SNOWFLAKE_ACCOUNT"),
+        username: req("SNOWFLAKE_USERNAME"),
+        password: authenticator === "SNOWFLAKE" ? req("SNOWFLAKE_PASSWORD") : process.env.SNOWFLAKE_PASSWORD?.trim(),
+        authenticator,
+        token: process.env.SNOWFLAKE_TOKEN?.trim(),
+        privateKey,
+        privateKeyPass: process.env.SNOWFLAKE_PRIVATE_KEY_PASSPHRASE?.trim(),
+        warehouse: process.env.SNOWFLAKE_WAREHOUSE?.trim(),
+        database: process.env.SNOWFLAKE_DATABASE?.trim(),
+        schema: process.env.SNOWFLAKE_SCHEMA?.trim(),
+        role: process.env.SNOWFLAKE_ROLE?.trim(),
+        queryTimeoutMs: Number(process.env.QUERY_TIMEOUT_MS || 60000),
+        rowLimit: Number(process.env.SNOWFLAKE_ROW_LIMIT || 1000),
+        readOnly: (process.env.SNOWFLAKE_READ_ONLY || "true").toLowerCase() !== "false",
+    };
+}
+let cfg = null;
+let conn = null;
+export function getConfig() {
+    if (!cfg)
+        cfg = loadConfig();
+    return cfg;
+}
+function buildConnection(c) {
+    const opts = {
+        account: c.account,
+        username: c.username,
+        authenticator: c.authenticator,
+        clientSessionKeepAlive: true,
+        application: "AnalyticsModel_MCP",
+    };
+    if (c.password)
+        opts.password = c.password;
+    if (c.token)
+        opts.token = c.token;
+    if (c.privateKey)
+        opts.privateKey = c.privateKey;
+    if (c.privateKeyPass)
+        opts.privateKeyPass = c.privateKeyPass;
+    if (c.warehouse)
+        opts.warehouse = c.warehouse;
+    if (c.database)
+        opts.database = c.database;
+    if (c.schema)
+        opts.schema = c.schema;
+    if (c.role)
+        opts.role = c.role;
+    return snowflake.createConnection(opts);
+}
+async function ensureConnection() {
+    const c = getConfig();
+    if (conn && conn.isUp())
+        return conn;
+    const connection = buildConnection(c);
+    await new Promise((resolve, reject) => {
+        connection.connect((err) => (err ? reject(err) : resolve()));
+    });
+    conn = connection;
+    return conn;
+}
+export async function runQuery(sqlText, binds = []) {
+    const c = getConfig();
+    const connection = await ensureConnection();
+    const rows = await new Promise((resolve, reject) => {
+        connection.execute({
+            sqlText,
+            binds: binds,
+            // Cap runaway queries at the configured timeout.
+            // (SDK-level; server-side statement_timeout can also be set.)
+            complete: (err, _stmt, r) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve(r || []);
+            },
+        });
+        // Best-effort client-side timeout guard.
+        setTimeout(() => {
+            /* no-op: snowflake-sdk resolves via complete; this keeps types simple */
+        }, c.queryTimeoutMs).unref?.();
+    });
+    return { rows, rowCount: rows.length };
+}
+/**
+ * Validate and quote a Snowflake identifier (database / schema / table / column).
+ * Snowflake identifiers may contain letters, digits, underscores and $ .
+ * Anything else is rejected to prevent SQL injection through identifier slots.
+ * The result is wrapped in double quotes with internal quotes doubled.
+ */
+export function quoteIdent(name) {
+    if (!/^[A-Za-z0-9_$]+$/.test(name)) {
+        throw new Error(`Invalid identifier "${name}". Only letters, digits, _ and $ are allowed.`);
+    }
+    return `"${name.replace(/"/g, '""')}"`;
+}
+/**
+ * Build a fully-qualified name from optional database/schema plus a table.
+ * Falls back to the connection's configured database/schema when omitted.
+ */
+export function qualify(table, database, schema) {
+    const c = getConfig();
+    const db = database || c.database;
+    const sc = schema || c.schema;
+    const parts = [];
+    if (db)
+        parts.push(quoteIdent(db));
+    if (sc)
+        parts.push(quoteIdent(sc));
+    parts.push(quoteIdent(table));
+    return parts.join(".");
+}
+const WRITE_RE = /^\s*(INSERT|UPDATE|DELETE|MERGE|CREATE|DROP|ALTER|TRUNCATE|GRANT|REVOKE|CALL|COPY|PUT|REMOVE|USE)\b/i;
+export function isReadOnlyStatement(sql) {
+    return !WRITE_RE.test(sql);
+}

package/dist/tools/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * tools/index.ts — registers every tool on the MCP server.
+ *
+ * `list_tables` is registered first and follows the platform's double-wrapped
+ * envelope contract (see listTables.ts). The remaining tools are standard
+ * SQL-database helpers that return clean JSON rows, mirroring the shape of the
+ * oracle-sqlplus-mcp server (test_connection, describe_table, get_table_sample,
+ * execute_query, list_schemas, ...).
+ */
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerTools(server: McpServer): void;
+//# sourceMappingURL=index.d.ts.map

package/dist/tools/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tools/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AA+BzE,wBAAgB,aAAa,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAqNrD"}

package/dist/tools/index.js

@@ -0,0 +1,180 @@
+import { z } from "zod";
+import { getConfig, runQuery, quoteIdent, qualify, isReadOnlyStatement, } from "../snowflake.js";
+import { registerListTables } from "./listTables.js";
+function jsonText(value) {
+    return { content: [{ type: "text", text: JSON.stringify(value, null, 2) }] };
+}
+function errText(err) {
+    return {
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify({ error: err instanceof Error ? err.message : String(err) }, null, 2),
+            },
+        ],
+        isError: true,
+    };
+}
+export function registerTools(server) {
+    // 1) Platform-contract table discovery.
+    registerListTables(server);
+    // 2) Connectivity / context probe.
+    server.registerTool("test_connection", {
+        title: "Test connection",
+        description: "Verify connectivity and return the current Snowflake version, account, user, role, warehouse, database and schema.",
+        inputSchema: {},
+    }, async () => {
+        try {
+            const { rows } = await runQuery("SELECT CURRENT_VERSION() AS VERSION, CURRENT_ACCOUNT() AS ACCOUNT, " +
+                "CURRENT_USER() AS \"USER\", CURRENT_ROLE() AS ROLE, " +
+                "CURRENT_WAREHOUSE() AS WAREHOUSE, CURRENT_DATABASE() AS DATABASE, " +
+                "CURRENT_SCHEMA() AS SCHEMA");
+            return jsonText({ connected: true, ...(rows[0] || {}) });
+        }
+        catch (err) {
+            return errText(err);
+        }
+    });
+    // 3) List databases.
+    server.registerTool("list_databases", {
+        title: "List databases",
+        description: "List all databases the current role can access.",
+        inputSchema: {},
+    }, async () => {
+        try {
+            const { rows } = await runQuery("SELECT DATABASE_NAME FROM SNOWFLAKE.INFORMATION_SCHEMA.DATABASES ORDER BY DATABASE_NAME");
+            return jsonText(rows.map((r) => r.DATABASE_NAME ?? r.database_name).filter(Boolean));
+        }
+        catch {
+            // Fallback for roles without SNOWFLAKE db access.
+            try {
+                const { rows } = await runQuery("SHOW DATABASES");
+                return jsonText(rows.map((r) => r.name));
+            }
+            catch (err) {
+                return errText(err);
+            }
+        }
+    });
+    // 4) List schemas.
+    server.registerTool("list_schemas", {
+        title: "List schemas",
+        description: "List schemas in a database. Defaults to SNOWFLAKE_DATABASE when `database` is omitted.",
+        inputSchema: {
+            database: z.string().optional().describe("Database name. Defaults to SNOWFLAKE_DATABASE."),
+        },
+    }, async (args) => {
+        try {
+            const db = args.database || getConfig().database;
+            if (!db)
+                throw new Error("No database. Set SNOWFLAKE_DATABASE or pass `database`.");
+            const { rows } = await runQuery(`SELECT SCHEMA_NAME FROM ${quoteIdent(db)}.INFORMATION_SCHEMA.SCHEMATA ORDER BY SCHEMA_NAME`);
+            return jsonText(rows.map((r) => r.SCHEMA_NAME ?? r.schema_name).filter(Boolean));
+        }
+        catch (err) {
+            return errText(err);
+        }
+    });
+    // 5) List warehouses.
+    server.registerTool("list_warehouses", {
+        title: "List warehouses",
+        description: "List virtual warehouses the current role can see, with size and state.",
+        inputSchema: {},
+    }, async () => {
+        try {
+            const { rows } = await runQuery("SHOW WAREHOUSES");
+            return jsonText(rows.map((r) => {
+                const o = r;
+                return { name: o.name, size: o.size, state: o.state, type: o.type };
+            }));
+        }
+        catch (err) {
+            return errText(err);
+        }
+    });
+    // 6) Describe a table's columns.
+    server.registerTool("describe_table", {
+        title: "Describe table",
+        description: "Return column names, data types, nullability and defaults for a table (or view).",
+        inputSchema: {
+            table: z.string().describe("Table name (unqualified)."),
+            database: z.string().optional().describe("Defaults to SNOWFLAKE_DATABASE."),
+            schema: z.string().optional().describe("Defaults to SNOWFLAKE_SCHEMA."),
+        },
+    }, async (args) => {
+        try {
+            const c = getConfig();
+            const db = args.database || c.database;
+            const sc = args.schema || c.schema;
+            if (!db)
+                throw new Error("No database. Set SNOWFLAKE_DATABASE or pass `database`.");
+            const conditions = ["TABLE_NAME = ?"];
+            const binds = [args.table];
+            if (sc) {
+                conditions.push("TABLE_SCHEMA = ?");
+                binds.push(sc);
+            }
+            const { rows } = await runQuery(`SELECT COLUMN_NAME, DATA_TYPE, IS_NULLABLE, COLUMN_DEFAULT, ` +
+                `CHARACTER_MAXIMUM_LENGTH, NUMERIC_PRECISION, NUMERIC_SCALE ` +
+                `FROM ${quoteIdent(db)}.INFORMATION_SCHEMA.COLUMNS ` +
+                `WHERE ${conditions.join(" AND ")} ORDER BY ORDINAL_POSITION`, binds);
+            if (!rows.length)
+                throw new Error(`Table "${args.table}" not found or no columns visible.`);
+            return jsonText(rows);
+        }
+        catch (err) {
+            return errText(err);
+        }
+    });
+    // 7) Sample rows from a table.
+    server.registerTool("get_table_sample", {
+        title: "Get table sample",
+        description: "Fetch a sample of rows from a table. Use this to preview data for a selected table.",
+        inputSchema: {
+            table: z.string().describe("Table name (unqualified)."),
+            database: z.string().optional().describe("Defaults to SNOWFLAKE_DATABASE."),
+            schema: z.string().optional().describe("Defaults to SNOWFLAKE_SCHEMA."),
+            limit: z.number().int().positive().optional().describe("Row limit. Default 10."),
+        },
+    }, async (args) => {
+        try {
+            const c = getConfig();
+            const limit = Math.min(args.limit ?? 10, c.rowLimit);
+            const fqn = qualify(args.table, args.database, args.schema);
+            const { rows } = await runQuery(`SELECT * FROM ${fqn} LIMIT ${limit}`);
+            return jsonText(rows);
+        }
+        catch (err) {
+            return errText(err);
+        }
+    });
+    // 8) Run an arbitrary query (read-only unless SNOWFLAKE_READ_ONLY=false).
+    server.registerTool("execute_query", {
+        title: "Execute query",
+        description: "Run a SQL query and return rows as JSON. Read-only by default (SELECT/SHOW/DESCRIBE/WITH). " +
+            "Set SNOWFLAKE_READ_ONLY=false to allow writes/DDL.",
+        inputSchema: {
+            query: z.string().describe("The SQL statement to execute."),
+        },
+    }, async (args) => {
+        try {
+            const c = getConfig();
+            if (c.readOnly && !isReadOnlyStatement(args.query)) {
+                throw new Error("Write/DDL statements are blocked. The server is read-only " +
+                    "(set SNOWFLAKE_READ_ONLY=false to allow them).");
+            }
+            const { rows, rowCount } = await runQuery(args.query);
+            // Guard against dumping enormous result sets into the context window.
+            const capped = rows.slice(0, c.rowLimit);
+            return jsonText({
+                row_count: rowCount,
+                returned: capped.length,
+                truncated: rowCount > capped.length,
+                rows: capped,
+            });
+        }
+        catch (err) {
+            return errText(err);
+        }
+    });
+}

package/dist/tools/listTables.d.ts

@@ -0,0 +1,21 @@
+/**
+ * listTables.ts — table-discovery tool for the Analytics Model platform.
+ *
+ * The platform's MCP connector flow (fetchMcpTables) expects every MCP server
+ * to expose a `list_tables` tool whose result text, once unwrapped, yields a
+ * flat array of { table_name } objects.
+ *
+ * OUTPUT SHAPE — copied byte-for-byte from the working Shopify / Clio servers.
+ * The platform parser expects:
+ *   1. The tool result text is JSON.stringify of an object with a `data` field.
+ *   2. `data` is ITSELF a JSON string of the [{ table_name }] array.
+ * i.e. the array is DOUBLE-stringified. Do not "simplify" this to a raw array
+ * or the backend parse fails and the table dropdown stays empty.
+ *
+ * Unlike Clio (a REST API with fixed resource categories), Snowflake is a real
+ * database, so we query INFORMATION_SCHEMA for the live table list scoped to the
+ * connection's database/schema (overridable via arguments).
+ */
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerListTables(server: McpServer): void;
+//# sourceMappingURL=listTables.d.ts.map

package/dist/tools/listTables.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"listTables.d.ts","sourceRoot":"","sources":["../../src/tools/listTables.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AA0BzE,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAyF1D"}

package/dist/tools/listTables.js

@@ -0,0 +1,83 @@
+import { z } from "zod";
+import { getConfig, runQuery, quoteIdent } from "../snowflake.js";
+function envelope(tableNames, requestedPayload, message) {
+    return {
+        is_success: true,
+        status_code: 200,
+        data: JSON.stringify(tableNames.map((t) => ({ table_name: t }))),
+        message,
+        requestedPayload,
+    };
+}
+export function registerListTables(server) {
+    server.registerTool("list_tables", {
+        title: "List tables",
+        description: "List available Snowflake tables (and views) for analytics table discovery. " +
+            "Returns a flat array of { table_name } objects. Scoped to the connection's " +
+            "database/schema unless overridden.",
+        inputSchema: {
+            database: z
+                .string()
+                .optional()
+                .describe("Database to list from. Defaults to SNOWFLAKE_DATABASE."),
+            schema: z
+                .string()
+                .optional()
+                .describe("Schema to list from. Defaults to SNOWFLAKE_SCHEMA."),
+            include_views: z
+                .boolean()
+                .optional()
+                .describe("Include views alongside base tables. Default true."),
+        },
+    }, async (args) => {
+        const c = getConfig();
+        const database = args.database || c.database;
+        const schema = args.schema || c.schema;
+        const includeViews = args.include_views !== false;
+        const requestedPayload = { database, schema, include_views: includeViews };
+        try {
+            if (!database) {
+                throw new Error("No database available. Set SNOWFLAKE_DATABASE or pass `database`.");
+            }
+            // INFORMATION_SCHEMA lives inside each database.
+            const infoSchema = `${quoteIdent(database)}.INFORMATION_SCHEMA.TABLES`;
+            const conditions = [];
+            const binds = [];
+            if (schema) {
+                conditions.push("TABLE_SCHEMA = ?");
+                binds.push(schema);
+            }
+            else {
+                // Exclude Snowflake's own metadata schema for a cleaner list.
+                conditions.push("TABLE_SCHEMA <> 'INFORMATION_SCHEMA'");
+            }
+            if (!includeViews) {
+                conditions.push("TABLE_TYPE = 'BASE TABLE'");
+            }
+            const where = conditions.length
+                ? `WHERE ${conditions.join(" AND ")}`
+                : "";
+            const sql = `SELECT TABLE_NAME FROM ${infoSchema} ${where} ORDER BY TABLE_NAME`;
+            const { rows } = await runQuery(sql, binds);
+            const names = rows
+                .map((r) => (r.TABLE_NAME ?? r.table_name))
+                .filter(Boolean);
+            const payload = envelope(names, requestedPayload, `Found ${names.length} table(s).`);
+            return { content: [{ type: "text", text: JSON.stringify(payload) }] };
+        }
+        catch (err) {
+            // Keep the platform envelope even on failure so the parser doesn't choke.
+            const payload = {
+                is_success: false,
+                status_code: 500,
+                data: JSON.stringify([]),
+                message: err instanceof Error ? err.message : String(err),
+                requestedPayload,
+            };
+            return {
+                content: [{ type: "text", text: JSON.stringify(payload) }],
+                isError: true,
+            };
+        }
+    });
+}

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "snowflake-analytics-mcp-server",
+  "version": "0.1.0",
+  "description": "Snowflake MCP server for the Analytics Model platform. Exposes list_tables, describe_table, query and schema-discovery tools over stdio, runnable via npx.",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "snowflake-analytics-mcp-server": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc && node -e \"require('fs').chmodSync('dist/index.js', 0o755)\"",
+    "start": "node dist/index.js",
+    "prepublishOnly": "npm run build"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "keywords": [
+    "mcp",
+    "snowflake",
+    "analytics",
+    "database",
+    "model-context-protocol"
+  ],
+  "author": "sagar1012",
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.30.0",
+    "snowflake-sdk": "^3.2.0",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@types/node": "^26.2.0",
+    "@types/snowflake-sdk": "^1.6.24",
+    "typescript": "^7.0.2"
+  }
+}