View Categories

How to Connect Snowflake to Claude / Cursor via MCP (Snowflake MCP Server Setup)

31 min read

MCP SERVER SNOWFLAKE

Connect Snowflake to Claude or Cursor via MCP.

Connect Snowflake — your account, your warehouses, your databases, your schemas — to Claude or Cursor with one MCP key. Schema Intelligence handles Snowflake’s analytics-warehouse idioms (QUALIFY, LATERAL FLATTEN, time-travel AT(OFFSET => ...), semi-structured VARIANT / OBJECT / ARRAY) so the AI writes valid Snowflake SQL on its first try.

No firewall holes One key, every connector Live data, no cache lag Bring your own AI tool

Query Streams is a secure, real-time data integration platform that brings every database and SaaS API in your account into Claude, Cursor, ChatGPT, and Grok — through a single MCP key with no firewall changes. This guide walks through wiring up the Snowflake MCP connector specifically, so your AI tool can answer plain-English questions about your Snowflake data warehouse — multi-database analytics, customer cohorts, revenue rollups, time-travel comparisons, semi-structured VARIANT traversal — without you copy-pasting CSV exports out of Snowsight, DBeaver, or DataGrip. Learn more at QueryStreams.com and sign up for free to start asking your AI tool real Snowflake questions.

What Query Streams MCP gives you for Snowflake

Snowflake ships its own AI surfaces — Cortex Agents for in-warehouse AI workloads, plus community and partner Snowflake MCP servers that point Claude or Cursor at a Snowflake account directly. They work, but each makes a different trade. Cortex Agents keep the AI workload inside Snowflake’s compute (only Snowflake data, only Snowflake-side semantic models). Direct Snowflake MCP servers need either a publicly reachable Snowflake account or a VPN / PrivateLink path between the LLM and Snowflake. Query Streams’ Snowflake MCP server solves a wider problem: outbound-only Network Agent, multi-connector single key (Snowflake plus your Postgres, your Stripe, your HubSpot, all under one MCP config block), agent-layer read-only enforcement, and full audit trail. We’ll cover the comparison in detail further down; first, the basics.

Zero inbound firewall holes

The Network Agent opens a single outbound encrypted cloud link to Query Streams. Your AI client connects to the cloud, never to your Snowflake account. No port to open, no Snowflake network policy to weaken, no PrivateLink hop required, no VPN tunnel between the LLM and your Snowflake region.

One key, every connector

The same MCP key reaches every database and SaaS API your account has connected. Add a Stripe or PostgreSQL connector tomorrow and the AI tool sees it next to your Snowflake databases without re-keying. Snowflake Cortex Agents and direct Snowflake MCP servers see Snowflake only; Query Streams sees the whole stack.

Schema Intelligence baked in

The AI sees AI-curated descriptions, semantic types, enum value lists, and discovered foreign keys for every Snowflake column — plus Snowflake-aware hints for QUALIFY top-N, DATEADD date math, and VARIANT colon-path traversal. It writes valid Snowflake SQL on the first try, even on warehouses with hundreds of databases and uppercase legacy identifiers.

Read-only enforced at the agent

Even if your Snowflake role grants INSERT / UPDATE / DELETE (because the role is also used by ETL pipelines), the agent rejects anything that isn’t SELECT, WITH, or EXPLAIN before Snowflake ever sees the SQL. A hallucinating LLM can’t TRUNCATE a Snowflake table even if the role technically allows it.

Per-key rate limits

Default 60 requests per minute and 10 execute calls per minute, configurable per key. A runaway AI tool-call loop hits a token bucket, not your Snowflake virtual warehouse credit budget. (Snowflake credits are billed by Snowflake separately — Query Streams limits the call rate, Snowflake limits the compute spend.)

How it works without opening firewall ports

The Query Streams Network Agent installs once on a machine that can reach your Snowflake account over outbound HTTPS to *.snowflakecomputing.com, runs SQL through the official Snowflake driver using your account’s preferred auth (key-pair RSA recommended), and dials one outbound TLS link to the cloud — nothing inbound is ever exposed, and the AI tool never sees your Snowflake account URL or your private key. how the outbound-only connection works →

AI Client

Cursor, Claude,
ChatGPT, Grok

QS MCP Server

Streamable HTTP
X-MCP-Key auth

Network Agent

On your network
Cloud link out

Snowflake

account.warehouse
.database

No inbound port required — the agent dials out, never the other way around

The MCP key you give Cursor or Claude is scoped (read / analyze / execute), revocable at any time, and rate-limited per-key. The AI tool calls these MCP tools to do its work:

querystreams-mcp · tool catalog
qs_list_organizationsread
Returns the org bound to the calling key.
qs_list_agentsread
Lists Network Agents and online state.
qs_list_connectorsread
Lists data connectors (one entry per database server or API).
qs_get_connector_schemaread
Returns the Snowflake databases, schemas, tables, and columns the AI can query, with Schema Intelligence enrichment when available.
qs_profile_tableanalyze
Sample values, distributions, enum detection, semantic types — on demand.
qs_list_saved_queriesread
Pre-built parameterized SQL templates the team trusts. The AI runs them without ever seeing the SQL.
qs_run_saved_queryexecute
Executes a saved query by pattern_key with optional parameter overrides.
qs_run_queryexecute
Executes a SELECT against a connector. Read-only validator runs at the agent, before Snowflake sees the SQL.

Why Schema Intelligence makes Query Streams MCP different

Most “MCP for Snowflake” servers hand your AI tool the bare INFORMATION_SCHEMA, leaving the LLM to guess what STATUS = '3' means, what EVENTS.PAYLOAD holds under its VARIANT wrapper, or whether LINE_ITEMS.ORDER_ID joins to ORDERS.ID (Snowflake foreign keys are advisory, not enforced) — which is why the first SQL against a bare warehouse schema is usually wrong. why bare schema makes LLMs guess →

Query Streams MCP returns that same schema enriched with Schema Intelligence (SI) — AI-curated metadata generated by profiling your actual Snowflake data, so every schema tool (qs_get_connector_schema, qs_get_table_schema, qs_profile_table, qs_get_relationships) returns the bare schema plus warehouse-specific hints that STATUS is a five-value enum, EVENTS.PAYLOAD is a VARIANT with discoverable colon-paths like :user_id::STRING, and time-travel queries can use AT(OFFSET => -3600). The LLM stops guessing.

To make this concrete, here is what the AI client gets back from a single qs_get_table_schema call against a typical Snowflake analytics warehouse (ANALYTICS_DB.PUBLIC.ORDERS, LINE_ITEMS, CUSTOMERS, PRODUCTS, EVENTS) — first without Schema Intelligence, then with it.

Without Schema Intelligence data_source: captured_schema
// what the LLM sees == TABLE: ANALYTICS_DB.PUBLIC.ORDERS == – ID NUMBER(38,0) [PK, NOT NULL] – CUSTOMER_ID NUMBER(38,0) NOT NULL – AMOUNT NUMBER(18,2) NOT NULL – STATUS VARCHAR(20) NOT NULL – ORDER_DATE DATE NOT NULL – SHIPPED_AT TIMESTAMP_NTZ == TABLE: ANALYTICS_DB.PUBLIC.LINE_ITEMS == – ID NUMBER(38,0) [PK] – ORDER_ID NUMBER(38,0) NOT NULL – PRODUCT_SKU VARCHAR(64) NOT NULL – QTY NUMBER(10,0) NOT NULL – UNIT_PRICE NUMBER(18,2) NOT NULL == TABLE: ANALYTICS_DB.PUBLIC.CUSTOMERS == – ID NUMBER(38,0) [PK] – EMAIL VARCHAR(255) – NAME VARCHAR(200) == TABLE: ANALYTICS_DB.PUBLIC.EVENTS == – ID NUMBER(38,0) [PK] – EVENT_TYPE VARCHAR(50) – PAYLOAD VARIANT – OCCURRED_AT TIMESTAMP_NTZ Foreign Keys: (advisory only, not enforced) si_recommendation: state: “not_run” what_youre_missing_for_this_call: – AI-discovered foreign keys – Per-column sample values + enum detection – VARIANT colon-path discovery (PAYLOAD:user_id, etc.) – Table and column descriptions – Semantic type classifications – Business domain tagging note: “types only, no semantic context”
With Schema Intelligence data_source: schema_intelligence
// what the LLM sees == TABLE: ANALYTICS_DB.PUBLIC.ORDERS [FACT, domain:sales] == “Customer order header rows; one per checkout. AMOUNT is the order grand total in USD.” – ID NUMBER(38,0) [PK] identifier – CUSTOMER_ID NUMBER(38,0) identifier FK -> CUSTOMERS.ID (100% overlap, conf 0.99) – AMOUNT NUMBER(18,2) currency_usd Range: 0.00 – 4,820.00 · mean 142.30 – STATUS VARCHAR(20) status_code (enum) paid (54%) | shipped (24%) | delivered (12%) pending (5%) | cancelled (3%) | refunded (2%) – ORDER_DATE DATE date_iso Sample: 2026-04-28 – SHIPPED_AT TIMESTAMP_NTZ timestamp (nullable) == TABLE: ANALYTICS_DB.PUBLIC.LINE_ITEMS [FACT, domain:sales] == “One row per product per order. Revenue = SUM(QTY * UNIT_PRICE).” – ORDER_ID NUMBER(38,0) identifier FK -> ORDERS.ID (98% overlap, conf 0.95) – PRODUCT_SKU VARCHAR(64) identifier FK -> PRODUCTS.SKU (100% overlap, conf 0.99) – QTY NUMBER(10,0) counter – UNIT_PRICE NUMBER(18,2) currency_usd == TABLE: ANALYTICS_DB.PUBLIC.EVENTS [FACT, domain:product] == “Application event stream; PAYLOAD is VARIANT.” – EVENT_TYPE VARCHAR(50) status_code (enum) login | logout | purchase | view_item | add_to_cart | search – PAYLOAD VARIANT semi_structured Discovered colon-paths: PAYLOAD:user_id::STRING (100%) PAYLOAD:session_id::STRING (98%) PAYLOAD:source.channel::STRING (62%) – OCCURRED_AT TIMESTAMP_NTZ timestamp == TABLE: ANALYTICS_DB.PUBLIC.CUSTOMERS [DIM, domain:customers] == – EMAIL VARCHAR(255) email Sample: [email protected], [email protected] – NAME VARCHAR(200) person_name

The six layers Schema Intelligence adds

Each layer addresses a class of question the LLM would otherwise guess at. The opt-in SI profiling pass runs against your Snowflake data without changing your schema — and because profiling consumes Snowflake compute credits like any read query, the agent uses a small warehouse and respects your warehouse-suspension settings. what Schema Intelligence adds and how it stays current →

AI-curated descriptions

Plain-English purpose for every database, schema, table, and column — generated once, refreshed when your schema changes. Confidence-scored; user-authored descriptions always win.

ORDERS: “Customer order headers;
one row per checkout.”

Table classifications

Each table tagged FACT (transactional events), DIM (descriptive reference), or LOOKUP (small code maps), plus a business domain — sales, hr, seo, finance, support, and 14 more.

ORDERS [FACT, domain:sales]
CUSTOMERS [DIM, domain:customers]

Semantic types per column

Eighteen types — currency_usd, email, date_iso, status_code, percentage, ranking_position, identifier, url, person_name, semi_structured, and more. The AI generates dialect-correct Snowflake SQL appropriate to each type.

AMOUNT: currency_usd
PAYLOAD: semi_structured (VARIANT)

Sample values from real data

Random rows surfaced to the LLM so it recognises patterns no schema can show — uppercase identifiers, formatting conventions, VARIANT shapes, abbreviation styles, and the actual contents of your warehouse.

PRODUCT_SKU: [‘QS-001-MINT’,
‘QS-014-DARK’,’QS-027-AMBER’]

Enum detection with distributions

Low-cardinality columns (50 or fewer distinct values, at most 5% of rows unique) mapped to their full value list with row counts. The AI never guesses casing or spelling on a Snowflake VARCHAR enum.

STATUS: paid (54%) | shipped (24%)
| delivered (12%) | pending (5%)

Implicit foreign-key discovery

Cross-table data overlap analysis finds joins Snowflake never declared (warehouse FKs are advisory anyway). Stored alongside any formal FKs with confidence scores, returned by qs_get_relationships.

LINE_ITEMS.ORDER_ID -> ORDERS.ID
(98% overlap, conf 0.95)

Same prompt, different SQL

The proof is in the SQL the AI tool actually writes. Same Cursor session, same Claude model, same prompt — “What’s our top 10 customer revenue ranking for the last 30 days?” Without Schema Intelligence the LLM has to guess at Snowflake-specific idioms. With it, the LLM knows.

Without Schema Intelligence
— LLM’s first attempt against bare schema: SELECT customer_id, SUM(amount) AS revenue FROM orders WHERE order_date >= NOW() – INTERVAL ’30’ DAY ORDER BY revenue DESC LIMIT 10 ERROR: invalid identifier ‘orders’ Snowflake needs DATABASE.SCHEMA.TABLE INTERVAL ’30’ DAY — not Snowflake syntax forgot WHERE status = ‘paid’ filter missed Snowflake’s QUALIFY for ranked top-N no GROUP BY — aggregation will fail
With Schema Intelligence
— LLM’s first attempt with SI enabled: SELECT customer_id, SUM(amount) AS revenue, COUNT(DISTINCT id) AS orders FROM analytics_db.public.orders WHERE order_date >= DATEADD(‘day’, –30, CURRENT_DATE()) AND status = ‘paid’ GROUP BY customer_id QUALIFY ROW_NUMBER() OVER (ORDER BY SUM(amount) DESC) <= 10 10 rows. Correct first try. 3-part name analytics_db.public.orders DATEADD(‘day’, -30, CURRENT_DATE()) QUALIFY ROW_NUMBER() for ranked top-N enum-aware status = ‘paid’ filter NUMBER(p,s) precision-aware aggregation
Don’t want to run Schema Intelligence? MCP still works — schema tools return bare metadata (types, primary keys, advisory foreign keys, clustering keys) and every degraded response carries an si_recommendation block telling the AI what it’s missing, including a one-call option to enable SI mid-conversation via qs_request_si_analysis. how Schema Intelligence runs and how long it takes →

Query Streams MCP vs Snowflake Cortex Agents and Snowflake MCP servers

Snowflake ships its own AI surfaces for warehouse data. Snowflake Cortex Agents run AI workloads inside Snowflake’s compute, with semantic-model templates and direct access to your Snowflake-resident data. Direct Snowflake MCP servers (community projects, including Snowflake Labs’ own) point Claude or Cursor at a Snowflake account over the official Snowflake driver. Both work. Both are appropriate for some teams. Query Streams’ Snowflake MCP solves a different shape of problem — outbound-only, multi-connector, agent-layer enforced — and it’s worth knowing where each fits before you pick.

Dimension Query Streams MCP Snowflake Cortex Agents Direct Snowflake MCP servers
Where the AI workload runs Your network (Network Agent dials out) Inside Snowflake compute Wherever the MCP server is hosted; the LLM still hits Snowflake’s HTTPS endpoints
Inbound firewall hole None — agent dials out only N/A — AI runs inside Snowflake Required — LLM/host must reach Snowflake (public IP, VPN, or PrivateLink)
Multi-database / multi-cloud reach Yes — Snowflake + Postgres + MySQL + Stripe + HubSpot + Shopify under one key Snowflake only Snowflake only (one MCP server per account)
Read-only enforcement layer Agent-side hardcoded validator (rejects non-SELECT/WITH/EXPLAIN) Snowflake roles + Cortex permissions Snowflake roles only
Saved queries (LLM never sees SQL) Yes via qs_run_saved_query Limited Cortex semantic-model templates No
Audit trail event_logs per call (org / user / key / scope / latency / error) Snowflake QUERY_HISTORY Depends on MCP server implementation
Per-key rate limiting Token-bucket, two-tier, configurable per key Cortex usage-based None at the MCP layer
Works with ChatGPT / Claude / Cursor / Grok / Gemini CLI / Windsurf / Zed / Continue / Cline / Codex Yes — one key, one config block Cortex is Snowflake-API-bound — no MCP transport Per-MCP-server per-client config (one entry per Snowflake account in every client)

Both Cortex Agents and Query Streams MCP are valid answers — they coexist. Pick Snowflake Cortex Agents when the AI work happens entirely inside Snowflake’s compute on Snowflake-resident data and you want the AI workload colocated with the warehouse. Pick a direct Snowflake MCP server when you only need Claude or Cursor pointed at one Snowflake account, you’re comfortable with the network exposure, and the per-account configuration overhead is acceptable. Pick Query Streams MCP when the AI tool also needs to read your Postgres, your Stripe data, your HubSpot CRM, or your Shopify orders under one access plane — or when audit trail and agent-layer read-only enforcement are non-negotiable for compliance. Many teams deploy both Cortex Agents (for in-warehouse AI workflows) and Query Streams MCP (for cross-system AI tooling) on the same Snowflake account; they don’t overlap.

Nova AI

MCP not for you? Try Nova AI instead.

Skip the JSON config entirely: Nova AI is built into the Query Streams web portal and asks the same plain-English questions across your Snowflake connector plus every other connector on your account — same agent, same read-only enforcement, same Schema Intelligence, no MCP plumbing.

Meet Nova AI

Prerequisites

Before you start, make sure you have:

  1. A free Query Streams account at my.querystreams.com.
  2. The Query Streams Network Agent installed on a machine that can reach your Snowflake account over outbound HTTPS — see Download the Query Streams Agent. For best performance the agent should sit in the same cloud / region as your Snowflake account (e.g. an EC2 instance in the same AWS region as a Snowflake-on-AWS account).
  3. A Snowflake connector configured against the agent — account URL (account.region.cloud.snowflakecomputing.com), default warehouse, and credentials. Key-pair (RSA) authentication is recommended over username/password; the agent stores the encrypted private key and the AI tool never touches it. Snowflake user role only needs SELECT on the databases you want the AI to query.
  4. Any MCP-capable AI client. We’ll show Cursor, Claude Desktop, ChatGPT, and Grok in this guide; if you use Windsurf, Zed, Continue, Cline, VS Code Copilot, Codex, or Goose, the config block is essentially the same.
  5. Five minutes.
You only set up the agent once. The same agent that powers Query Streams’ Excel and Google Sheets add-ons, the web Query Builder, and Nova AI also serves MCP. Adding MCP to an existing Query Streams account is just generating a key — the agent and Snowflake connector are already running.
1

Generate an MCP key

From the /mcp page in Query Streams, mint a key with the scopes you want.

2

Drop it into your AI client

One JSON snippet for Cursor, Claude, ChatGPT, or Grok. Same key everywhere.

3

Ask a question

“What were our top 10 customers by lifetime value?” — the AI calls the right tools, you get the answer.

Step 1: Generate an MCP key in Query Streams

Sign in to Query Streams and open the MCP page (or sign in first at my.querystreams.com and click MCP in the left navigation). Click Generate key, give the key a recognizable name (something like cursor-laptop or claude-desktop), and pick the scopes you want this key to have:

  • read — the AI can browse connectors and read schema. Required for everything else.
  • analyze — the AI can profile tables and discover relationships (sample values, distributions, semantic types). Strongly recommended for Snowflake work because VARIANT colon-path discovery, enum detection, and implicit FK inference all rely on it — warehouse schemas rarely declare enforced FKs.
  • execute — the AI can actually run SQL. Without this, the AI is read-only against schema metadata only.

For a typical “let Claude analyse my Snowflake warehouse” workflow, all three scopes are appropriate. For a key you’re handing to a teammate or a less-trusted client, drop execute and let them browse only. You can revoke any key at any time from the same page; the AI client will see MCP_KEY_REVOKED on its next call and stop working immediately. There’s no propagation delay.

Copy the key now — Query Streams shows it once, then stores only a hash. If you lose it, generate a new one. The key looks like qsmcp_ followed by 48 random characters and is what your AI client sends in the X-MCP-Key request header.

Step 2: Add Query Streams MCP to your AI client

The configuration is the same shape across every MCP-capable client — an MCP server entry pointing at https://mcp.querystreams.com with your key in the X-MCP-Key header. Pick your client below.

Cursor
Cursor ~/.cursor/mcp.json
// Edit ~/.cursor/mcp.json
{
  "mcpServers": {
    "querystreams": {
      "url": "https://mcp.querystreams.com",
      "headers": {
        "X-MCP-Key": "qsmcp_PASTE_KEY_HERE"
      }
    }
  }
}
Claude Desktop
Claude Desktop claude_desktop_config.json
// Settings → Developer → Edit Config
{
  "mcpServers": {
    "querystreams": {
      "url": "https://mcp.querystreams.com",
      "headers": {
        "X-MCP-Key": "qsmcp_PASTE_KEY_HERE"
      }
    }
  }
}
ChatGPT
ChatGPT Apps & Connectors
// Settings → Apps & Connectors → Add MCP
Server URL  https://mcp.querystreams.com
Auth header X-MCP-Key
Header value qsmcp_PASTE_KEY_HERE

// Requires a paid ChatGPT plan
// (Plus / Pro / Team / Enterprise).
Grok
Grok Remote MCP Tools
// Grok → Settings → Tools
{
  "mcp_servers": [{
    "name": "querystreams",
    "url": "https://mcp.querystreams.com",
    "auth_header": "X-MCP-Key",
    "auth_value": "qsmcp_..."
  }]
}

Restart your AI client. On its next start it will discover the eight Query Streams MCP tools listed above and surface them in its tool palette. In Cursor and Claude Desktop you can verify by typing “list connectors” — the AI should call qs_list_connectors and return your Snowflake connector along with anything else you have configured.

Step 3: Ask the AI a Snowflake question

You don’t write SQL — the AI does. You ask a question, the AI picks the right MCP tool, the agent runs the query against your Snowflake warehouse, and the answer comes back as text plus tables. Three example prompts to try first:

“What’s our quarterly revenue by region with year-over-year deltas?”
Revenue
The AI calls qs_get_connector_schema to discover the ORDERS / CUSTOMERS / REGIONS tables in ANALYTICS_DB.PUBLIC, then qs_run_query with a Snowflake-idiomatic SELECT that uses DATE_TRUNC('quarter', ORDER_DATE) to bucket by quarter, joins ORDERS to CUSTOMERS to REGIONS, applies WHERE STATUS = 'paid' to filter completed transactions, and computes SUM(AMOUNT) alongside a window-function lag for the prior-year comparison. You’ll see the ranked table inline plus a written interpretation — which regions accelerated, which decelerated, and where the YoY delta is statistically meaningful versus normal seasonality.
“Show me the top 50 customers by lifetime value, segmented by acquisition channel.”
Customers
The AI joins CUSTOMERS to ORDERS to LINE_ITEMS, traverses the EVENTS.PAYLOAD:source.channel::STRING colon-path that Schema Intelligence discovered on the VARIANT column, and uses QUALIFY ROW_NUMBER() OVER (ORDER BY SUM(QTY * UNIT_PRICE) DESC) <= 50 — the Snowflake-idiomatic way to express “top 50 ranked rows” without an outer SELECT. The result is broken down by acquisition channel with each customer’s LTV, order count, and first-order date. The AI typically calls out which channel produces the highest-LTV customers versus which produces the highest volume, even if you didn’t ask.
“Which products had inventory drops greater than 30% in the last 14 days?”
Operations
The AI uses Snowflake’s time-travel capability — SELECT ... FROM PRODUCTS AT(OFFSET => -1209600) (14 days ago, in seconds) joined against the current PRODUCTS table to compute the INVENTORY_QTY delta. Schema Intelligence flagged INVENTORY_QTY as a counter semantic type, so the AI knows ratio-of-change math is appropriate. The result is a ranked list with current stock, stock-14-days-ago, percent drop, and recent order velocity to give context. The AI usually flags the most concerning rows as restock candidates rather than rounding errors. You can drill in by asking “why did SKU QS-014-DARK drop so fast?” and the AI pulls the relevant LINE_ITEMS rows.

The first time the AI calls a tool, your client may pop up a confirmation prompt asking you to approve the tool call — that’s MCP’s standard consent flow, not anything Query Streams adds. Approve once and the AI proceeds with the rest of the conversation freely. You can revisit the consent at any time in your client’s settings.

Honest billing notice: MCP usage is charged on uncompressed bytes

Query Streams’ Excel add-in, Google Sheets add-on, web Query Builder, and Nova AI all run over our compressed cloud link — we measure and bill compressedBytes against your data realm. The MCP transport (Streamable HTTP per the official MCP spec) does not reliably support compression end-to-end across every client and intermediate proxy, so we measure and bill uncompressedBytes for MCP traffic.

  • What this means: a 4 MB Snowflake aggregate result set costs ~4 MB of your data realm when fetched via MCP, vs. ~600–900 KB via Excel / Sheets / Nova / the Query Builder. Snowflake data with repeated VARCHAR enum values, date partitions, and uppercase-identifier-heavy column names compresses 6–8x via LZ4 on the other transports. Same data, different transport, different billable size.
  • What this isn’t: a markup — we pass through actual bytes shipped, and the other clients are simply cheaper because compression works reliably there. Note also: the Snowflake compute-credit cost (warehouse credit-seconds) is independent of Query Streams data realm usage — a query that scans 50 GB of micro-partitions and returns 4 MB of aggregates costs you N credits at Snowflake plus 4 MB at Query Streams MCP, and Schema Intelligence’s clustering and partition hints help the LLM minimise both.
  • What you can do: for very large recurring queries (e.g. 100K+ row exports), prefer the Excel / Sheets / Nova path. For interactive AI tool calls (the typical 1,000–50,000 row Snowflake aggregate that fits in an LLM context), MCP is the right choice and the cost difference is in cents per call.

Frequently asked questions

Do I need to open ports or run a VPN to use this? +
No inbound rules, port-forwarding, NAT punchthrough, or VPN. The Network Agent makes one outbound TLS connection (port 443) and your AI client reaches https://mcp.querystreams.com from the public internet — if outbound HTTPS works on the agent host, MCP works. See how the outbound-only connection works →
Which AI tools can I use with Query Streams MCP? +
Any client that speaks the open Model Context Protocol — Claude Desktop, Claude Code, Cursor, ChatGPT (paid), Grok, Gemini CLI, Windsurf, Zed, and 500+ more. Bring your own AI tool; you don’t have to switch. Full list of supported AI clients →
Can I revoke an MCP key? +
Yes — three independent kill-switches (per-key from the /mcp page, per-org via plan settings, and platform-level), none of which need a database password rotation or agent restart. More on MCP key security →
How is MCP usage billed against my data realm? +
MCP execute calls deduct from the same data-realm budget your Excel, Google Sheets, web Query Builder, and Nova AI usage already draws on — one consumption budget across every access method. The size measured for MCP differs. The other clients run over our compressed cloud link (we bill compressedBytes); MCP runs over Streamable HTTP, which doesn’t reliably support compression end-to-end through every client and proxy, so we bill uncompressedBytes. A 4 MB Snowflake aggregate result returned to Excel typically costs ~600–900 KB of your data realm; the same 4 MB result returned to Cursor over MCP costs ~4 MB. (Snowflake compute credits are billed by Snowflake separately from Query Streams data realm usage — the two are independent metrics.) We’re transparent about it because we’d rather you know up front than be surprised at the end of the billing cycle.
Does Query Streams MCP work with Snowflake Standard / Enterprise / Business Critical / VPS, key-pair authentication, and data-sharing inbound shares? +
Yes. Query Streams MCP works with every Snowflake edition — Standard, Enterprise, Business Critical, and Virtual Private Snowflake (VPS) — using the official Snowflake driver. Cloud platform doesn’t matter either: AWS, Azure, and GCP Snowflake accounts all use the same connection model. Key-pair (RSA) authentication is the recommended auth method, not username/password — the agent stores the encrypted private key in its credential store; key rotation is a key swap rather than a password reset and supports overlapping RSA_PUBLIC_KEY and RSA_PUBLIC_KEY_2 for zero-downtime rotation. OAuth and SSO via SAML are also supported when your Snowflake account requires them. Data-sharing inbound shares (where another Snowflake account shares a database into yours) are queryable transparently — the agent treats them as read-only databases like any other; the LLM doesn’t need to know they’re shared. Snowflake network policies (the allowlist of source IPs that can connect) need to allowlist the agent’s egress IP, but no inbound rule changes are needed at your end — the agent dials out to Snowflake on outbound HTTPS, and only that egress IP needs to be on the network policy. Each Snowflake account is a separate connector, so the LLM can pick “production analytics” vs “marketing warehouse” by name — helpful when you have separate accounts for prod, staging, and dev workloads.
How does this differ from running an open-source Snowflake MCP server myself? +
A direct Snowflake MCP server (community projects on GitHub do exist; Snowflake Labs has one too) is one MCP per data source. To get Claude reading from your Snowflake + Google Search Console + your Stripe account + your PostgreSQL operational database you’d need four MCP servers configured separately in every AI client, each with its own credentials, each with its own scope model, each with its own audit story. Query Streams MCP is one key reaching every connector your account has paired. You also pick up Schema Intelligence, agent-layer read-only enforcement, per-key rate limits, audit trail in event_logs, and the same data-realm billing pipeline you already use — none of which a direct Snowflake MCP gives you. (For the deeper Cortex Agents vs direct Snowflake MCP server vs Query Streams MCP comparison, see the dedicated section above.)
What happens if the AI tries to write or delete data? +
It’s rejected at the agent before the data source sees the SQL. Every qs_run_query call is parsed by a hardcoded read-only validator that allows only SELECT, WITH, and EXPLAIN statements; anything else returns READONLY_VIOLATION and never reaches Snowflake. The validator runs in the agent process on your network, not in the cloud, so a compromised cloud surface couldn’t bypass it. This matters more for Snowflake than for an OLTP database, because Snowflake roles are often shared between ETL pipelines and analytics users — the same role might grant INSERT/UPDATE/DELETE for the pipeline path even though the human analyst never uses those privileges. The agent’s read-only validator is independent of whatever Snowflake grants the role has, so a hallucinating LLM can’t TRUNCATE TABLE even if the role technically allows it. (You can layer a Snowflake-side read-only role — USAGE + SELECT only on the warehouses and databases you want exposed — on top if you want belt-and-suspenders.)
Can I see what the AI actually asked? +
Yes. Every MCP tool call writes a row to event_logs with the org, user, key, scope, latency, and result code. The org-admin can answer “who used MCP last week, which connector, and what did they ask?” with a single query. Note that we log the tool name and metadata, not the SQL text or returned rows — those flow through the cloud link and never land in cloud logs. If you want full SQL audit, enable database-side audit on the underlying engine; for Snowflake that’s the SNOWFLAKE.ACCOUNT_USAGE.QUERY_HISTORY view (or INFORMATION_SCHEMA.QUERY_HISTORY within a single account), which captures every executed statement with the user, role, warehouse, byte counts, and credit consumption. Combine the two and you have full attribution: Query Streams’ event_logs tells you which AI client / user / key initiated the call; Snowflake’s QUERY_HISTORY tells you exactly what SQL it ran.
Do I have to run Schema Intelligence to use Query Streams MCP? +
No — Schema Intelligence is opt-in per (connector, database) pair, and MCP works fine without it. The AI gets bare schema (types, primary keys, advisory foreign keys, clustering keys) and writes basic queries. With SI enabled, the AI gets six additional layers of curated metadata: (1) AI-curated descriptions on every database, schema, table, and column; (2) table classifications (FACT for transactional events, DIM for descriptive reference, LOOKUP for small code maps) plus a business domain tag (sales, hr, seo, finance, support, and 14 more); (3) a semantic type on every column (currency_usd, email, date_iso, status_code, percentage, ranking_position, identifier, url, person_name, semi_structured, and others) that drives dialect-correct Snowflake SQL generation — including QUALIFY ROW_NUMBER() for top-N, DATEADD() for date math, and :-path traversal for VARIANT columns; (4) sample values from your real data so the LLM recognises patterns no schema can show; (5) enum detection with full value distributions for low-cardinality columns; and (6) AI-discovered foreign keys based on cross-table data overlap, surfaced through qs_get_relationships (especially valuable on Snowflake where formal FKs are advisory only). Without SI, every schema-tool response also carries an si_recommendation block listing exactly what’s missing for the call — the AI can read this and offer to trigger SI mid-conversation via qs_request_si_analysis. Run time scales with table count: a small database under 100 tables completes in around 10 minutes; a typical mid-size database (a few hundred tables) finishes in 15–25 minutes; a large enterprise database with 1,500+ tables can take 45–60 minutes for a full scan. SI runs through your Network Agent against your data (never in the cloud), never writes to your warehouse, never changes your schema, and refreshes incrementally when your schema changes — so subsequent runs after you add or alter tables are much faster than the first one. The end-to-end effect: with SI enabled, your AI client writes correct Snowflake SQL on the first try far more often than it does against any “MCP for X” server that just hands the LLM INFORMATION_SCHEMA.
What if I add another connector later, like Stripe or PostgreSQL? +
Nothing changes client-side — the same key reaches the new connector the moment the agent pairs it (qs_list_connectors picks it up automatically). One config block buys your whole account, present and future. Why one key covers every connector →
Do I have to set up MCP just to chat with my data? +
No — Nova AI is built into the Query Streams portal and works against every connector (Snowflake included) with no MCP setup or config files. Use Nova to chat with your data inside Query Streams; use MCP when you want your own AI client (Claude, Cursor, ChatGPT, …) to reach the same data — same agent, same connectors, same Schema Intelligence underneath. Learn more about Nova AI →
Why use Query Streams MCP if Snowflake ships Cortex Agents and there’s already a Snowflake MCP server? +
Three reasons, all about problem shape rather than feature parity. (1) Outbound-only architecture. Cortex Agents run inside Snowflake’s compute, so the AI workload and your data stay co-located inside Snowflake’s cloud — appropriate when AI work is Snowflake-bound. Direct Snowflake MCP servers (community projects, Snowflake Labs’ own) connect Claude or Cursor to Snowflake over the official driver, but the LLM (or your developer’s laptop, or the host that runs the MCP server) still has to reach Snowflake’s HTTPS endpoints — which means either a publicly reachable Snowflake account, a VPN to Snowflake, or a PrivateLink hop. Query Streams’ Network Agent dials OUT from your existing network to the Query Streams cloud link, and Claude / Cursor / ChatGPT connect to Query Streams. There’s no inbound rule, no public-IP exposure, no VPN. (2) Multi-connector single key. A single Query Streams MCP key reaches Snowflake AND your on-prem PostgreSQL, your AWS RDS MySQL, your Stripe data, your HubSpot CRM, your Shopify orders — all under ONE config block in your AI client. Cortex Agents only see Snowflake. Direct Snowflake MCP servers are one-MCP-per-Snowflake-account; if you have prod / staging / dev Snowflake accounts, you configure three MCP entries in every AI client. (3) Agent-layer read-only enforcement. Even if your Snowflake role grants INSERT / UPDATE / DELETE (because that role is also used by ETL pipelines), Query Streams’ agent runs every dispatched query through a hardcoded read-only validator and returns READONLY_VIOLATION for non-SELECT / non-WITH / non-EXPLAIN statements — even if the LLM asks for them. Cortex Agents and direct-DB MCPs rely entirely on Snowflake-side roles for safety, which is correct but adds DBA overhead the customer didn’t want. You can use both. Query Streams MCP and Cortex Agents address different problem shapes — Cortex for in-Snowflake AI workflows on Snowflake-resident data, Query Streams MCP for AI-tools-that-also-need-your-other-data. Many teams deploy both on the same Snowflake account; they don’t compete.

Get started

Connect your AI tool to your Snowflake warehouse in five minutes.

One MCP key reaches Snowflake, every other database, and every API connector in your Query Streams account — with full audit trail, agent-layer read-only enforcement, per-key rate limits, and zero firewall changes. Claude, Cursor, ChatGPT, and Grok all work out of the box. A different model from Snowflake Cortex Agents and direct Snowflake MCP servers — deploy alongside whichever you’re already using.

Related guides: Download the Query Streams Agent | Database Connector Setup | All MCP Server guides | Nova AI text-to-SQL

Category: MCP Server

Tags: mcp, claude, cursor, snowflake, data-warehouse, enterprise, snowflake-cortex, cortex-agents, key-pair-auth, analytics

Meta Description: Connect Snowflake to Claude or Cursor via Query Streams MCP. Outbound-only, read-only, multi-connector. 5-min setup.

Updated on June 16, 2026

Powered by BetterDocs