snowflake-analytics-mcp-server 0.1.0 → 0.2.0

package/README.md

@@ -1,8 +1,6 @@
 # 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.
+A [Model Context Protocol](https://modelcontextprotocol.io) server for **Snowflake**. It connects to Snowflake via the official `snowflake-sdk` driver (pure Node — no client binary needed) and exposes table-discovery, SQL query, and Cortex AI tools over stdio. Runnable directly with `npx`.
 
 ## Install
 
@@ -22,7 +20,7 @@ All credentials come from environment variables.
 | `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_DATABASE` | recommended | — | Default database (used by `list_tables`, and as the fallback when a caller passes an inaccessible database) |
 | `SNOWFLAKE_SCHEMA` | recommended | — | Default schema |
 | `SNOWFLAKE_ROLE` | — | — | Role to assume |
 | `SNOWFLAKE_AUTHENTICATOR` | — | `SNOWFLAKE` | `SNOWFLAKE` (password), `SNOWFLAKE_JWT` (key-pair), `OAUTH` |
@@ -33,6 +31,8 @@ All credentials come from environment variables.
 | `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 |
+| `SNOWFLAKE_CORTEX_ENABLED` | — | `true` | Register the Cortex AI tools. Set `false` to hide them |
+| `SNOWFLAKE_CORTEX_MODEL` | — | `llama3.1-8b` | Default model for Cortex AI_COMPLETE / text-to-SQL |
 
 ### Account identifier tip
 
@@ -78,9 +78,11 @@ Add to `claude_desktop_config.json`:
 
 ## Tools
 
+### SQL & discovery
+
 | Tool | Args | Description |
 |---|---|---|
-| `list_tables` | `database?`, `schema?`, `include_views?` | **Platform contract.** Returns `{ table_name }[]` in the double-wrapped envelope for `fetchMcpTables` |
+| `list_tables` | `database?`, `schema?`, `include_views?` | Returns `{ table_name }[]` for table discovery |
 | `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 |
@@ -89,21 +91,26 @@ Add to `claude_desktop_config.json`:
 | `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
+### Cortex AI
 
-`list_tables` matches the confirmed envelope used by the Shopify/Clio servers:
+These are additive generative-AI tools (token-billed, higher latency than the SQL tools). Each is invoked as a `SELECT`, so they work with `SNOWFLAKE_READ_ONLY=true`. Disable them with `SNOWFLAKE_CORTEX_ENABLED=false`.
 
-```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 }
-}
-```
+| Tool | Args | Description |
+|---|---|---|
+| `cortex_ask` | `question`, `database?`, `schema?`, `model?` | Natural-language question → generated read-only SQL → answer. Best for analytics like "what is total revenue" |
+| `cortex_complete` | `prompt`, `model?` | Free-form LLM completion via AI_COMPLETE |
+| `cortex_sentiment` | `text` | Sentiment of a text via AI_SENTIMENT |
+| `cortex_summarize` | `text` | Concise summary of a text |
+| `cortex_classify` | `text`, `categories[]` | Classify text into your categories via AI_CLASSIFY |
+| `cortex_translate` | `text`, `to_language`, `from_language?` | Translate text (source auto-detected when omitted) |
+
+`cortex_ask` generates SQL and always restricts it to read-only statements, regardless of `SNOWFLAKE_READ_ONLY`.
+
+**Cortex prerequisites:** the account must be in a region that supports Cortex, and the connecting role needs the `SNOWFLAKE.CORTEX_USER` database role plus the `USE AI FUNCTIONS` privilege. If a Cortex call fails on region or privileges, the tool returns a hint explaining what to grant.
+
+## Database resolution
 
-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.
+`list_tables`, `describe_table`, `get_table_sample`, `list_schemas`, and `cortex_ask` accept an optional `database`. If the value passed isn't an accessible database, the tool falls back to `SNOWFLAKE_DATABASE` instead of erroring — so a stray or wrong database name from an upstream caller doesn't cause a failed lookup.
 
 ## License
 

package/dist/index.js

@@ -3,11 +3,8 @@
  * 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).
+ * stdio, runnable via `npx`. Provides table-discovery, SQL query, and Cortex AI
+ * tools. Credentials come entirely from environment variables (see README).
  */
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
@@ -15,7 +12,7 @@ import { registerTools } from "./tools/index.js";
 async function main() {
     const server = new McpServer({
         name: "snowflake-analytics-mcp-server",
-        version: "0.1.0",
+        version: "0.2.0",
         title: "Snowflake Analytics MCP Server",
     });
     registerTools(server);

package/dist/snowflake.d.ts

@@ -13,6 +13,8 @@ export interface SnowflakeConfig {
     queryTimeoutMs: number;
     rowLimit: number;
     readOnly: boolean;
+    cortexEnabled: boolean;
+    cortexModel: string;
 }
 export declare function loadConfig(): SnowflakeConfig;
 export declare function getConfig(): SnowflakeConfig;
@@ -33,5 +35,15 @@ export declare function quoteIdent(name: string): string;
  * 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 accessibleDatabases(): Promise<Set<string>>;
+/**
+ * Resolve the database a tool should use.
+ *
+ * If `requested` is provided but isn't an accessible database (e.g. an upstream
+ * caller sent a stray value that isn't a real database), fall back to the
+ * configured SNOWFLAKE_DATABASE instead of erroring — so tools self-correct on
+ * the first call rather than taking a failed detour.
+ */
+export declare function resolveDatabase(requested?: string): Promise<string | undefined>;
 export declare function isReadOnlyStatement(sql: string): boolean;
 //# sourceMappingURL=snowflake.d.ts.map

package/dist/snowflake.d.ts.map

@@ -1 +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"}
+{"version":3,"file":"snowflake.d.ts","sourceRoot":"","sources":["../src/snowflake.ts"],"names":[],"mappings":"AAyBA,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;IAClB,aAAa,EAAE,OAAO,CAAC;IACvB,WAAW,EAAE,MAAM,CAAC;CACrB;AAUD,wBAAgB,UAAU,IAAI,eAAe,CA0C5C;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,CAoBtB;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;AAMD,wBAAsB,mBAAmB,IAAI,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAchE;AAED;;;;;;;GAOG;AACH,wBAAsB,eAAe,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAWrF;AAKD,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAExD"}

package/dist/snowflake.js

@@ -7,6 +7,8 @@
  *     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.
+ *   - Resolve a usable database, falling back to SNOWFLAKE_DATABASE when a
+ *     caller passes one that isn't accessible.
  *
  * Auth modes (pick via SNOWFLAKE_AUTHENTICATOR, default = password):
  *   - SNOWFLAKE            : username + password
@@ -56,7 +58,11 @@ export function loadConfig() {
         role: process.env.SNOWFLAKE_ROLE?.trim(),
         queryTimeoutMs: Number(process.env.QUERY_TIMEOUT_MS || 60000),
         rowLimit: Number(process.env.SNOWFLAKE_ROW_LIMIT || 1000),
+        // Read-only by default. Only an explicit "false" opens up writes/DDL.
         readOnly: (process.env.SNOWFLAKE_READ_ONLY || "true").toLowerCase() !== "false",
+        // Cortex AI tools are on by default; set SNOWFLAKE_CORTEX_ENABLED=false to hide them.
+        cortexEnabled: (process.env.SNOWFLAKE_CORTEX_ENABLED || "true").toLowerCase() !== "false",
+        cortexModel: (process.env.SNOWFLAKE_CORTEX_MODEL || "llama3.1-8b").trim(),
     };
 }
 let cfg = null;
@@ -110,8 +116,6 @@ export async function runQuery(sqlText, binds = []) {
         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);
@@ -154,6 +158,50 @@ export function qualify(table, database, schema) {
     parts.push(quoteIdent(table));
     return parts.join(".");
 }
+// ── Database resolution ───────────────────────────────────────────────────────
+// Cached uppercase set of databases the current role can actually see.
+let dbCache = null;
+export async function accessibleDatabases() {
+    if (dbCache && dbCache.size)
+        return dbCache;
+    const names = new Set();
+    try {
+        const { rows } = await runQuery("SHOW DATABASES");
+        for (const r of rows) {
+            const n = r.name;
+            if (typeof n === "string")
+                names.add(n.toUpperCase());
+        }
+    }
+    catch {
+        /* ignore — resolveDatabase will trust the caller's input below */
+    }
+    if (names.size)
+        dbCache = names;
+    return names;
+}
+/**
+ * Resolve the database a tool should use.
+ *
+ * If `requested` is provided but isn't an accessible database (e.g. an upstream
+ * caller sent a stray value that isn't a real database), fall back to the
+ * configured SNOWFLAKE_DATABASE instead of erroring — so tools self-correct on
+ * the first call rather than taking a failed detour.
+ */
+export async function resolveDatabase(requested) {
+    const fallback = getConfig().database;
+    const wanted = requested?.trim();
+    if (!wanted)
+        return fallback;
+    const dbs = await accessibleDatabases();
+    // Couldn't enumerate databases — trust the caller, then the default.
+    if (dbs.size === 0)
+        return wanted || fallback;
+    if (dbs.has(wanted.toUpperCase()))
+        return wanted;
+    // Requested database isn't accessible — use the configured default.
+    return fallback || wanted;
+}
 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/cortex.d.ts

@@ -0,0 +1,18 @@
+/**
+ * cortex.ts — Snowflake Cortex AI tools.
+ *
+ * These are additive on top of the fast SQL/discovery tools: Cortex functions
+ * are generative AI calls (token-billed, higher latency), so they are exposed as
+ * their own tools rather than wrapped around metadata operations.
+ *
+ * Every Cortex function here is invoked as a SELECT, so the tools remain fully
+ * compatible with SNOWFLAKE_READ_ONLY=true. The text-to-SQL tool additionally
+ * enforces read-only on the *generated* SQL regardless of server settings.
+ *
+ * Model is configurable via SNOWFLAKE_CORTEX_MODEL (default: llama3.1-8b).
+ * Availability depends on the account's region and the role holding the
+ * SNOWFLAKE.CORTEX_USER database role — errors are surfaced with a hint.
+ */
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerCortexTools(server: McpServer): void;
+//# sourceMappingURL=cortex.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cortex.d.ts","sourceRoot":"","sources":["../../src/tools/cortex.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AA+EzE,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CA6L3D"}

package/dist/tools/cortex.js

@@ -0,0 +1,216 @@
+import { z } from "zod";
+import { getConfig, runQuery, quoteIdent, resolveDatabase, isReadOnlyStatement, } from "../snowflake.js";
+function jsonText(value) {
+    return { content: [{ type: "text", text: JSON.stringify(value, null, 2) }] };
+}
+function cortexErr(err) {
+    const raw = err instanceof Error ? err.message : String(err);
+    // Surface a helpful hint for the two most common Cortex setup failures.
+    const hintable = /cortex|not enabled|unknown function|privilege|not authorized|CORTEX_USER|region/i.test(raw);
+    const message = hintable
+        ? `${raw}\n\nHint: Cortex AI requires an account in a supported region and a role holding the SNOWFLAKE.CORTEX_USER database role (plus USE AI FUNCTIONS). Confirm both, or set SNOWFLAKE_CORTEX_ENABLED=false to hide these tools.`
+        : raw;
+    return {
+        content: [{ type: "text", text: JSON.stringify({ error: message }, null, 2) }],
+        isError: true,
+    };
+}
+// A Cortex model identifier is a simple slug — validate before inlining it.
+function safeModel(model) {
+    const m = (model || getConfig().cortexModel).trim();
+    if (!/^[A-Za-z0-9._-]+$/.test(m)) {
+        throw new Error(`Invalid model name "${m}".`);
+    }
+    return m;
+}
+// Strip markdown fences and trailing semicolons; keep only the first statement.
+function cleanSql(text) {
+    let s = text.trim();
+    s = s.replace(/^```(?:sql)?\s*/i, "").replace(/\s*```$/i, "").trim();
+    // Take up to the first semicolon so we execute a single statement.
+    const semi = s.indexOf(";");
+    if (semi !== -1)
+        s = s.slice(0, semi);
+    return s.trim();
+}
+// Build a compact schema description for the configured database/schema.
+async function schemaContext(database, schema) {
+    const conditions = ["TABLE_SCHEMA <> 'INFORMATION_SCHEMA'"];
+    const binds = [];
+    if (schema) {
+        conditions[0] = "TABLE_SCHEMA = ?";
+        binds.push(schema);
+    }
+    const { rows } = await runQuery(`SELECT TABLE_SCHEMA, TABLE_NAME, COLUMN_NAME, DATA_TYPE ` +
+        `FROM ${quoteIdent(database)}.INFORMATION_SCHEMA.COLUMNS ` +
+        `WHERE ${conditions.join(" AND ")} ` +
+        `ORDER BY TABLE_SCHEMA, TABLE_NAME, ORDINAL_POSITION ` +
+        `LIMIT 800`, binds);
+    const tables = new Map();
+    for (const r of rows) {
+        const o = r;
+        const key = `${o.TABLE_SCHEMA}.${o.TABLE_NAME}`;
+        if (!tables.has(key))
+            tables.set(key, []);
+        tables.get(key).push(`${o.COLUMN_NAME} ${o.DATA_TYPE}`);
+    }
+    const lines = [];
+    for (const [tbl, cols] of tables) {
+        lines.push(`${tbl} (${cols.join(", ")})`);
+    }
+    return lines.join("\n");
+}
+export function registerCortexTools(server) {
+    // ── cortex_ask: natural language → SQL → answer ─────────────────────────────
+    server.registerTool("cortex_ask", {
+        title: "Ask (Cortex text-to-SQL)",
+        description: "Answer a natural-language question about the data. Reads the schema, uses " +
+            "Cortex AI_COMPLETE to generate a read-only SQL query, runs it, and returns " +
+            "the rows plus the generated SQL. Best for analytical questions like " +
+            "'what is total revenue' or 'top 5 customers by orders'.",
+        inputSchema: {
+            question: z.string().describe("The natural-language question to answer."),
+            database: z.string().optional().describe("Defaults to SNOWFLAKE_DATABASE."),
+            schema: z.string().optional().describe("Defaults to SNOWFLAKE_SCHEMA."),
+            model: z.string().optional().describe("Cortex model. Defaults to SNOWFLAKE_CORTEX_MODEL."),
+        },
+    }, async (args) => {
+        try {
+            const c = getConfig();
+            const database = (await resolveDatabase(args.database)) || c.database;
+            const schema = args.schema || c.schema;
+            if (!database)
+                throw new Error("No database. Set SNOWFLAKE_DATABASE or pass `database`.");
+            const model = safeModel(args.model);
+            const ctx = await schemaContext(database, schema);
+            if (!ctx)
+                throw new Error(`No tables found in ${database}${schema ? "." + schema : ""}.`);
+            const prompt = `You are a Snowflake SQL expert. Using ONLY the schema below, write a single ` +
+                `read-only Snowflake SQL query (SELECT or WITH only) that answers the question. ` +
+                `Fully qualify tables as ${database}.<schema>.<table>. Return ONLY the SQL with no ` +
+                `explanation and no markdown fences.\n\nSchema:\n${ctx}\n\nQuestion: ${args.question}\n\nSQL:`;
+            const gen = await runQuery(`SELECT AI_COMPLETE('${model}', ?) AS SQL_TEXT`, [prompt]);
+            const generatedSql = cleanSql(String((gen.rows[0]?.SQL_TEXT ?? "")));
+            if (!generatedSql)
+                throw new Error("Model did not return any SQL.");
+            // Generated SQL is ALWAYS restricted to read-only, regardless of server config.
+            if (!isReadOnlyStatement(generatedSql)) {
+                return jsonText({
+                    question: args.question,
+                    generated_sql: generatedSql,
+                    error: "Generated SQL was not read-only and was blocked. Rephrase the question.",
+                });
+            }
+            const result = await runQuery(generatedSql);
+            const capped = result.rows.slice(0, c.rowLimit);
+            return jsonText({
+                question: args.question,
+                generated_sql: generatedSql,
+                row_count: result.rowCount,
+                returned: capped.length,
+                truncated: result.rowCount > capped.length,
+                rows: capped,
+            });
+        }
+        catch (err) {
+            return cortexErr(err);
+        }
+    });
+    // ── cortex_complete: general LLM completion ─────────────────────────────────
+    server.registerTool("cortex_complete", {
+        title: "Complete (Cortex AI_COMPLETE)",
+        description: "Generate a free-form LLM completion for a prompt using Cortex AI_COMPLETE. " +
+            "Use for summaries, explanations, or generation that isn't a SQL query.",
+        inputSchema: {
+            prompt: z.string().describe("The prompt to send to the model."),
+            model: z.string().optional().describe("Cortex model. Defaults to SNOWFLAKE_CORTEX_MODEL."),
+        },
+    }, async (args) => {
+        try {
+            const model = safeModel(args.model);
+            const { rows } = await runQuery(`SELECT AI_COMPLETE('${model}', ?) AS RESPONSE`, [
+                args.prompt,
+            ]);
+            return jsonText({ model, response: rows[0]?.RESPONSE ?? null });
+        }
+        catch (err) {
+            return cortexErr(err);
+        }
+    });
+    // ── cortex_sentiment: sentiment of a text ───────────────────────────────────
+    server.registerTool("cortex_sentiment", {
+        title: "Sentiment (Cortex AI_SENTIMENT)",
+        description: "Return the sentiment of a text string using Cortex AI_SENTIMENT.",
+        inputSchema: { text: z.string().describe("The text to analyze.") },
+    }, async (args) => {
+        try {
+            const { rows } = await runQuery(`SELECT AI_SENTIMENT(?) AS SENTIMENT`, [args.text]);
+            return jsonText({ sentiment: rows[0]?.SENTIMENT ?? null });
+        }
+        catch (err) {
+            return cortexErr(err);
+        }
+    });
+    // ── cortex_summarize: summarize a text ──────────────────────────────────────
+    server.registerTool("cortex_summarize", {
+        title: "Summarize (Cortex SUMMARIZE)",
+        description: "Return a concise summary of a text string using Cortex.",
+        inputSchema: { text: z.string().describe("The text to summarize.") },
+    }, async (args) => {
+        try {
+            const { rows } = await runQuery(`SELECT SNOWFLAKE.CORTEX.SUMMARIZE(?) AS SUMMARY`, [
+                args.text,
+            ]);
+            return jsonText({ summary: rows[0]?.SUMMARY ?? null });
+        }
+        catch (err) {
+            return cortexErr(err);
+        }
+    });
+    // ── cortex_classify: classify into user categories ──────────────────────────
+    server.registerTool("cortex_classify", {
+        title: "Classify (Cortex AI_CLASSIFY)",
+        description: "Classify a text string into one of the provided categories using Cortex AI_CLASSIFY.",
+        inputSchema: {
+            text: z.string().describe("The text to classify."),
+            categories: z
+                .array(z.string())
+                .min(2)
+                .describe("Two or more category labels to choose from."),
+        },
+    }, async (args) => {
+        try {
+            // Build a SQL array literal of escaped string categories; bind the input.
+            const cats = args.categories
+                .map((x) => `'${String(x).replace(/'/g, "''")}'`)
+                .join(", ");
+            const { rows } = await runQuery(`SELECT AI_CLASSIFY(?, [${cats}]) AS CLASSIFICATION`, [args.text]);
+            return jsonText({ classification: rows[0]?.CLASSIFICATION ?? null });
+        }
+        catch (err) {
+            return cortexErr(err);
+        }
+    });
+    // ── cortex_translate: translate text ────────────────────────────────────────
+    server.registerTool("cortex_translate", {
+        title: "Translate (Cortex TRANSLATE)",
+        description: "Translate text to a target language using Cortex. Source language is " +
+            "auto-detected when omitted.",
+        inputSchema: {
+            text: z.string().describe("The text to translate."),
+            to_language: z.string().describe("Target language code, e.g. 'en', 'hi', 'es'."),
+            from_language: z
+                .string()
+                .optional()
+                .describe("Source language code. Empty = auto-detect."),
+        },
+    }, async (args) => {
+        try {
+            const { rows } = await runQuery(`SELECT SNOWFLAKE.CORTEX.TRANSLATE(?, ?, ?) AS TRANSLATION`, [args.text, args.from_language || "", args.to_language]);
+            return jsonText({ translation: rows[0]?.TRANSLATION ?? null });
+        }
+        catch (err) {
+            return cortexErr(err);
+        }
+    });
+}

package/dist/tools/index.d.ts

@@ -3,9 +3,9 @@
  *
  * `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, ...).
+ * SQL-database helpers (test_connection, describe_table, get_table_sample,
+ * execute_query, list_schemas, ...). Cortex AI tools are registered last and
+ * only when enabled.
  */
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 export declare function registerTools(server: McpServer): void;

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

@@ -1 +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"}
+{"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;AAiCzE,wBAAgB,aAAa,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CA2NrD"}

package/dist/tools/index.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
-import { getConfig, runQuery, quoteIdent, qualify, isReadOnlyStatement, } from "../snowflake.js";
+import { getConfig, runQuery, quoteIdent, qualify, resolveDatabase, isReadOnlyStatement, } from "../snowflake.js";
 import { registerListTables } from "./listTables.js";
+import { registerCortexTools } from "./cortex.js";
 function jsonText(value) {
     return { content: [{ type: "text", text: JSON.stringify(value, null, 2) }] };
 }
@@ -65,7 +66,7 @@ export function registerTools(server) {
         },
     }, async (args) => {
         try {
-            const db = args.database || getConfig().database;
+            const db = (await resolveDatabase(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`);
@@ -104,7 +105,7 @@ export function registerTools(server) {
     }, async (args) => {
         try {
             const c = getConfig();
-            const db = args.database || c.database;
+            const db = (await resolveDatabase(args.database)) || c.database;
             const sc = args.schema || c.schema;
             if (!db)
                 throw new Error("No database. Set SNOWFLAKE_DATABASE or pass `database`.");
@@ -140,7 +141,8 @@ export function registerTools(server) {
         try {
             const c = getConfig();
             const limit = Math.min(args.limit ?? 10, c.rowLimit);
-            const fqn = qualify(args.table, args.database, args.schema);
+            const db = (await resolveDatabase(args.database)) || c.database;
+            const fqn = qualify(args.table, db, args.schema);
             const { rows } = await runQuery(`SELECT * FROM ${fqn} LIMIT ${limit}`);
             return jsonText(rows);
         }
@@ -177,4 +179,8 @@ export function registerTools(server) {
             return errText(err);
         }
     });
+    // 9) Cortex AI tools (opt-out via SNOWFLAKE_CORTEX_ENABLED=false).
+    if (getConfig().cortexEnabled) {
+        registerCortexTools(server);
+    }
 }

package/dist/tools/listTables.d.ts

@@ -1,20 +1,19 @@
 /**
  * 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.
+ * The platform's connector flow expects 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:
+ * OUTPUT SHAPE — 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).
+ * Snowflake is a real database, so the live table list is read from
+ * INFORMATION_SCHEMA, scoped to the connection's database/schema (overridable
+ * via arguments). If a caller passes a database that isn't accessible, the tool
+ * falls back to the configured SNOWFLAKE_DATABASE.
  */
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 export declare function registerListTables(server: McpServer): void;

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

@@ -1 +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"}
+{"version":3,"file":"listTables.d.ts","sourceRoot":"","sources":["../../src/tools/listTables.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AA0BzE,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CA0F1D"}

package/dist/tools/listTables.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { getConfig, runQuery, quoteIdent } from "../snowflake.js";
+import { getConfig, runQuery, quoteIdent, resolveDatabase } from "../snowflake.js";
 function envelope(tableNames, requestedPayload, message) {
     return {
         is_success: true,
@@ -31,7 +31,8 @@ export function registerListTables(server) {
         },
     }, async (args) => {
         const c = getConfig();
-        const database = args.database || c.database;
+        // Resolve to an accessible database, falling back to SNOWFLAKE_DATABASE.
+        const database = (await resolveDatabase(args.database)) || c.database;
         const schema = args.schema || c.schema;
         const includeViews = args.include_views !== false;
         const requestedPayload = { database, schema, include_views: includeViews };

package/package.json

@@ -1,7 +1,7 @@
 {
   "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.",
+  "version": "0.2.0",
+  "description": "Snowflake MCP server for the Analytics Model platform. Table discovery, SQL query, and Cortex AI tools over stdio, runnable via npx.",
   "type": "module",
   "main": "dist/index.js",
   "bin": {
@@ -35,4 +35,4 @@
     "@types/snowflake-sdk": "^1.6.24",
     "typescript": "^7.0.2"
   }
-}
+}