Tag: cortex

When I first started using Cortex Code, cost was the last thing on my mind. It’s right there in the Snowsight UI, it feels like a built-in feature, and nothing in the interface tells you that tokens are being consumed behind the scenes.

Then I went digging through the official docs properly — not just the feature overview, but the cost controls section — and found something I hadn’t seen covered anywhere: Snowflake has a native, dedicated cost control system for Cortex Code that most people don’t know exists. Two specific parameters. Per-user. Per-surface. Configurable by any ACCOUNTADMIN in seconds.

This article is specifically about that. If you’re running Cortex Code in your Snowflake account — especially with a team — you need to set these up.

How Cortex Code Billing Works

If you’re new to Cortex Code, I’d recommend reading my earlier post What Is Snowflake Cortex Code and How I Taught Myself to Use It first — it covers what the tool actually does and how to access it in Snowsight. This article picks up at the cost control layer.

Cortex Code runs on two surfaces, each with its own billing model:

Cortex Code in Snowsight — the browser-based UI. Token-based billing tied to your existing Snowflake account. Snowflake will notify users before charges formally begin, but AI service costs are already accumulating underneath.

Cortex Code CLI — the command-line agent. Already billing via token consumption — pay-as-you-go for existing Snowflake accounts, or a subscription model for individual sign-ups.

The key thing to understand: unlike virtual warehouses where you can set a Resource Monitor with a credit quota, Cortex Code has its own separate cost control parameters that standard Resource Monitors don’t cover. You need to set these explicitly.

For the full official billing breakdown, see Snowflake’s Cortex Code billing documentation.

The Two Parameters You Need to Know

Snowflake provides exactly two parameters for Cortex Code cost control. Both are set by ACCOUNTADMIN only, operate on a rolling 24-hour window per user, and are completely independent of each other.

And here’s what the values actually mean:

Full parameter reference: Cost controls for Cortex Code — Snowflake Docs

Setting Account-Level Limits

This is the first thing I’d do — set a sensible default for all users at the account level. If someone goes over it, they’re blocked until the rolling window resets. No silent runaway spend.

-- Cap all users at 20 credits per day for CLI
ALTER ACCOUNT SET CORTEX_CODE_CLI_DAILY_EST_CREDIT_LIMIT_PER_USER = 20;

-- Cap all users at 20 credits per day in Snowsight
ALTER ACCOUNT SET CORTEX_CODE_SNOWSIGHT_DAILY_EST_CREDIT_LIMIT_PER_USER = 20;

To remove an account-level limit and restore unlimited access:

ALTER ACCOUNT UNSET CORTEX_CODE_CLI_DAILY_EST_CREDIT_LIMIT_PER_USER;
ALTER ACCOUNT UNSET CORTEX_CODE_SNOWSIGHT_DAILY_EST_CREDIT_LIMIT_PER_USER;

For the full ALTER ACCOUNT syntax reference, see ALTER ACCOUNT — Snowflake Docs.

Setting Per-User Limits (Override)

User-level settings override the account-level setting for that specific user. Everyone else keeps the account default.

-- Power user gets a higher CLI limit than the account default
ALTER USER power_user SET CORTEX_CODE_CLI_DAILY_EST_CREDIT_LIMIT_PER_USER = 50;

-- Junior analyst gets a tighter Snowsight limit
ALTER USER junior_analyst SET CORTEX_CODE_SNOWSIGHT_DAILY_EST_CREDIT_LIMIT_PER_USER = 5;

-- Block a service account or contractor from Snowsight entirely
ALTER USER contractor_account SET CORTEX_CODE_SNOWSIGHT_DAILY_EST_CREDIT_LIMIT_PER_USER = 0;

Setting the value to 0 blocks access completely for that user on that surface. Useful for service accounts that should never be touching Cortex Code interactively.

To remove a user-level override and fall back to the account default:

ALTER USER junior_analyst UNSET CORTEX_CODE_SNOWSIGHT_DAILY_EST_CREDIT_LIMIT_PER_USER;

See ALTER USER — Snowflake Docs for the full syntax.

A Practical Setup for a Real Team

Here’s how I’d configure this for a typical data engineering team — let’s say you have senior engineers, analysts, and a few service accounts:

-- Step 1: Set sensible defaults for the whole account
ALTER ACCOUNT SET CORTEX_CODE_CLI_DAILY_EST_CREDIT_LIMIT_PER_USER = 20;
ALTER ACCOUNT SET CORTEX_CODE_SNOWSIGHT_DAILY_EST_CREDIT_LIMIT_PER_USER = 20;

-- Step 2: Give senior engineers more headroom on CLI
ALTER USER senior_eng_1 SET CORTEX_CODE_CLI_DAILY_EST_CREDIT_LIMIT_PER_USER = 50;
ALTER USER senior_eng_2 SET CORTEX_CODE_CLI_DAILY_EST_CREDIT_LIMIT_PER_USER = 50;

-- Step 3: Block service accounts from both surfaces
ALTER USER airflow_svc SET CORTEX_CODE_CLI_DAILY_EST_CREDIT_LIMIT_PER_USER = 0;
ALTER USER airflow_svc SET CORTEX_CODE_SNOWSIGHT_DAILY_EST_CREDIT_LIMIT_PER_USER = 0;

ALTER USER dbt_svc SET CORTEX_CODE_CLI_DAILY_EST_CREDIT_LIMIT_PER_USER = 0;
ALTER USER dbt_svc SET CORTEX_CODE_SNOWSIGHT_DAILY_EST_CREDIT_LIMIT_PER_USER = 0;

If you’re using dbt projects natively inside Snowflake, you’ll already have dedicated service accounts set up — I covered that in detail in How I Wired Snowflake’s Native dbt Projects to Airflow. Those same service accounts should be blocked from Cortex Code with a 0 limit.

Service accounts should never be using Cortex Code. Setting them to 0 explicitly means even if someone accidentally grants CORTEX_AGENT_USER to a service role, the credit limit acts as a safety net.

Auditing Who Has Custom Limits

Snowflake provides a script in the official docs to list all users with per-user overrides. This is exactly what you need for a quarterly governance review:

-- Audit all users with a custom CLI credit limit override
EXECUTE IMMEDIATE $$
DECLARE
  current_user STRING;
  rs_users RESULTSET;
  res      RESULTSET;
BEGIN
  CREATE OR REPLACE TEMPORARY TABLE _param_overrides (user_name STRING, param_value STRING);

  SHOW USERS;
  rs_users := (SELECT "name" FROM TABLE(RESULT_SCAN(LAST_QUERY_ID())));

  FOR record IN rs_users DO
    current_user := record."name";

    EXECUTE IMMEDIATE
      'SHOW PARAMETERS LIKE ''CORTEX_CODE_CLI_DAILY_EST_CREDIT_LIMIT_PER_USER'' IN USER "' || :current_user || '"';

    INSERT INTO _param_overrides (user_name, param_value)
      SELECT :current_user, "value"
      FROM TABLE(RESULT_SCAN(LAST_QUERY_ID()))
      WHERE "level" = 'USER';
  END FOR;

  res := (SELECT * FROM _param_overrides);
  RETURN TABLE(res);
END;
$$;

To audit Snowsight overrides instead, swap CORTEX_CODE_CLI_DAILY_EST_CREDIT_LIMIT_PER_USER for CORTEX_CODE_SNOWSIGHT_DAILY_EST_CREDIT_LIMIT_PER_USER in the SHOW PARAMETERS LIKE clause. Run both regularly. This script is taken directly from the official Snowflake cost controls page — I haven’t modified it.

What Happens When a User Hits Their Limit

When a user’s rolling 24-hour usage exceeds the configured threshold, that surface returns an error telling them the daily credit limit has been reached. They can’t use it again until enough time passes for usage to drop below the limit. The other surface is unaffected — hitting the CLI limit doesn’t lock them out of Snowsight.

Admins can adjust or remove the limit at any time to restore access immediately, without waiting for the window to roll.

This is worth communicating to your team before you set limits — nobody likes being surprised by a sudden block mid-workflow. Set the limits, tell people what they are, and tell them who to contact if they need a temporary increase.

One More Layer: Monitor Actual Usage Too

The credit limits control access — they stop runaway spend. But you also want visibility into what’s being consumed before limits are hit. Pair your limits with a monitoring query:

sql

SELECT
    DATE_TRUNC('day', start_time)   AS usage_day,
    function_name,
    model_name,
    SUM(tokens_used)                AS total_tokens,
    SUM(credits_used)               AS total_credits
FROM snowflake.account_usage.cortex_functions_usage_history
WHERE start_time >= CURRENT_DATE - 30
GROUP BY 1, 2, 3
ORDER BY usage_day DESC, total_credits DESC;

This tells you which models and functions are driving costs across your account. The credit limits stop the bleeding. This query tells you where the bleeding is coming from.

For a deeper look at how Snowflake bills for AI functions generally — token rates, model pricing differences, and what “output tokens” means for your bill — see my post Snowflake Cortex Pricing — What Every Data Engineer Should Know and the official Snowflake Service Consumption Table which is the source of truth for current credit rates.

The Bottom Line

The right Cortex Code cost control setup in 2026 takes about 10 minutes and covers you completely:

1. Set account-level daily limits for both CLI and Snowsight — start with 20 credits as a reasonable default
2. Override upward for power users who legitimately need more headroom
3. Override to 0 for all service accounts
4. Run the audit script quarterly to catch drift as people join or leave the team
5. Monitor cortex_functions_usage_history for spend patterns alongside your limits

The alternative is the default: -1 for every user, unlimited spend, and a bill that arrives before anyone realized the meter was running.

Nobody told me to do this.

No manager pinged me. No sprint ticket had “explore Cortex Code” written on it. I stumbled across it one evening while clicking around Snowsight after a long day of debugging dbt models, and three hours later I looked up and realized I hadn’t thought about Jira or Slack once.

That doesn’t happen to me.

I run this blog because I genuinely love poking around the parts of Snowflake that most people scroll past. Cortex Code is exactly that kind of thing — it’s been sitting quietly inside Snowsight, doing something remarkable, and I feel like almost nobody in the data engineering world is talking about it properly. So let’s fix that.

What Cortex Code Actually Is (And What It Is Not)

Before I go any further, I want to be really clear about something that tripped me up when I first read the Snowflake docs — and that I’ve seen cause confusion in the community too.

Cortex Code is not a SQL function you call.

It is not SELECT SNOWFLAKE.CORTEX.CODE_ASSIST(...). It doesn’t live in your query editor the way CORTEX.COMPLETE() or CORTEX.SENTIMENT() do. I wasted about 45 minutes trying to invoke it via SQL the first time, so I’m saving you that pain right now.

Cortex Code is a natural language interface built into Snowsight — Snowflake’s web UI. You access it by navigating to Snowsight, finding the Cortex Code section, uploading or referencing your files, and then literally just… talking to it in plain English. You describe what you want to do with your code or data files, and it responds. Think of it as having an AI pair programmer that lives inside your Snowflake environment, already understands your data context, and doesn’t need you to install anything.

This distinction matters a lot for how you think about using it in production versus exploration.

How to Actually Access Cortex Code in Snowsight

Here’s the step-by-step, because the docs skip over some of this:

Step 1: Log into Snowsight

Go to your Snowflake account URL and log in. Make sure you’re on an account that has Cortex features enabled — Enterprise edition or higher, with the right region support.

Step 2: Navigate to the Cortex Code Section

In the left sidebar, look for the AI/ML or Cortex section. This UI location has shifted slightly across Snowflake releases, so if you don’t see it immediately, use the search bar at the top of Snowsight and type “Cortex.”

Step 3: Upload Your Files Using a PUT Command

This is where it gets interesting. If you want Cortex Code to analyze a specific file — say a Python script, a dbt model, a JSON file, or a CSV — you first upload it to a Snowflake stage using a PUT command in a worksheet:

-- Create a stage if you don't have one
CREATE OR REPLACE STAGE my_cortex_stage;

-- Upload your file from your local machine
PUT file:///Users/yourname/projects/my_dbt_model.sql @my_cortex_stage;

-- Verify it landed
LIST @my_cortex_stage;

Step 4: Reference Your File in the Cortex Code Interface

Once staged, you can reference the file in the Cortex Code interface and start asking questions about it in plain English.

Step 5: Start Prompting

You don’t write SQL. You write sentences. That’s the whole point.

Real Example 1: Analyzing a dbt Model for Performance Issues

This is the first thing I tried, and it immediately earned its keep.

I had a dbt model — let’s call it fct_orders_daily.sql — that was consistently running for 14 minutes in production. I’d stared at it, I’d checked clustering, I’d looked at query profiles. I was going in circles.

I uploaded the file:

PUT file:///Users/bug/dbt_project/models/marts/fct_orders_daily.sql @my_cortex_stage;

Then in Cortex Code I typed something like:

“I’ve uploaded a dbt SQL model called fct_orders_daily.sql. It’s running for 14 minutes. Can you review the logic and tell me where the performance problems likely are? Suggest specific rewrites.”

What came back wasn’t a generic “add a WHERE clause” response. It identified a specific pattern I had — a correlated subquery inside a CASE statement that was executing per-row. It rewrote the logic using a LEFT JOIN with a pre-aggregated CTE instead. The rewrite took the query from 14 minutes to under 3 minutes when I tested it.

Did I feel a little embarrassed that an AI caught something I missed? Absolutely. Did I care? Not really. The model shipped.

Real Example 2: Explaining Someone Else’s Legacy Code

Every data engineer has that one Snowflake procedure. The one that nobody touches. The one with variable names like tmp_ctr2 and no comments anywhere. The one that was written by someone who left the company in 2021.

I had one of those. It was a stored procedure managing some SCD2 logic on a customer dimension table. About 200 lines. No documentation.

I staged the file:

PUT file:///Users/bug/legacy/sp_customer_dim_scd2.sql @my_cortex_stage;

Then in Cortex Code:

“This is a Snowflake stored procedure. Can you explain what it does step by step, in plain English? Then flag any parts that look fragile or risky.”

It produced a section-by-section breakdown that I turned directly into an internal wiki page. It also flagged that the procedure was doing a full table merge without any row count validation before and after — which, it noted, meant a failed intermediate step could silently produce a partial merge with no error thrown.

That was a legitimate production risk I had never noticed. I added the validation. Nobody told me to. I just did it because now I knew.

Real Example 3: Generating New Transformation Code from a Description

This one genuinely surprised me. I described a transformation I needed in plain language — no file, just a description — and asked Cortex Code to write the SQL.

My prompt was roughly:

“I have a table called SALES_EVENTS with columns: event_id, customer_id, event_type (values: ‘purchase’, ‘return’, ‘browse’), event_timestamp, and amount. I want to build a daily summary table that shows, for each customer and each day: total purchases, total returns, net revenue (purchases minus returns), and a flag if they had any browse events that didn’t convert to a purchase on the same day. Write me the Snowflake SQL for this.”

Here’s essentially what it produced (I’ve cleaned it up slightly for readability):

WITH daily_events AS (
    SELECT
        customer_id,
        DATE(event_timestamp) AS event_date,
        SUM(CASE WHEN event_type = 'purchase' THEN amount ELSE 0 END) AS total_purchases,
        SUM(CASE WHEN event_type = 'return' THEN amount ELSE 0 END) AS total_returns,
        SUM(CASE WHEN event_type = 'purchase' THEN amount ELSE 0 END) -
        SUM(CASE WHEN event_type = 'return' THEN amount ELSE 0 END) AS net_revenue,
        MAX(CASE WHEN event_type = 'browse' THEN 1 ELSE 0 END) AS had_browse,
        MAX(CASE WHEN event_type = 'purchase' THEN 1 ELSE 0 END) AS had_purchase
    FROM SALES_EVENTS
    GROUP BY customer_id, DATE(event_timestamp)
)

SELECT
    customer_id,
    event_date,
    total_purchases,
    total_returns,
    net_revenue,
    CASE 
        WHEN had_browse = 1 AND had_purchase = 0 THEN TRUE 
        ELSE FALSE 
    END AS browse_no_convert_flag
FROM daily_events
ORDER BY customer_id, event_date;

That’s clean, readable, and correct. It took maybe 30 seconds from my prompt to a working query. Normally I’d have spent 10-15 minutes writing and testing that from scratch.

Real Example 4: Reviewing Python Scripts for Data Quality Issues

I had a Python ingestion script that was pulling data from a REST API and writing to a Snowflake stage. I staged it:

PUT file:///Users/bug/scripts/api_ingest.py @my_cortex_stage;

My prompt: “Review this Python script. It ingests data from a REST API into a Snowflake stage. Are there any data quality risks, error handling gaps, or things that might fail silently in production?”

The response flagged three things:

• No retry logic on the API call, so a transient network failure would abort the entire run with no retry
• The script was casting all numeric fields as strings before writing to the stage, which would cause downstream type errors in the COPY INTO command
• There was no check on API response status codes — a 429 (rate limit) or 500 was being handled the same way as a 200

All three were real issues. None of them were obvious from a quick read. Finding them manually would have required either running the thing and watching it fail, or very careful code review.

Where Cortex Code Fits in Your Daily Workflow

I want to be honest here: Cortex Code is not a replacement for knowing what you’re doing. If you give it a bad prompt, you’ll get a bad answer. If you blindly paste its output into production without reading it, eventually something will break and you’ll deserve it.

But used as a thinking partner — as a way to get a first draft, spot what you might have missed, or understand something unfamiliar faster — it’s genuinely useful in a way that saves real time.

Here’s how I’ve actually worked it into my day:

Morning code review pass: Before I open a PR for anything significant, I stage the file and run a quick “what could go wrong with this?” prompt. It takes 2 minutes and has caught things twice in the last month.

Legacy code archaeology: Any time I have to touch something old that I didn’t write, I stage it and ask for an explanation before I touch a single line. This alone is worth it.

First-draft SQL: When I have a new transformation to build and I know exactly what the output should look like but I’m not in the mood to write boilerplate aggregations, I describe the output and let Cortex Code give me a starting point. I always read and edit what it gives me — but starting from something is faster than starting from nothing.

Onboarding help: I’ve started pointing people who are new to the team at Cortex Code for understanding existing models. “Stage the file, ask it to explain it, then come ask me questions.” It makes onboarding conversations much more productive because they’ve already done some of the basic reading.

What It Can’t Do (And Where You Still Need to Think)

I don’t want this to sound like a Snowflake brochure. There are real limitations.

It doesn’t know your data. It can reason about code logic and SQL patterns, but it doesn’t have context about what’s actually in your tables — so it can’t tell you whether a join is correct because it doesn’t know your actual cardinality or data distribution.

Complex business logic still needs you. If your transformation encodes ten years of institutional knowledge about how a specific business process works, Cortex Code can write syntactically correct SQL but it can’t know if the business logic is right.

You have to read the output. Every time. No exceptions.

And the Snowsight UI for it, as of my exploration, is still evolving — some things feel a little rough around the edges. That’s fine. So did Cortex Analyst when it launched, and it’s much smoother now.

A Few Prompting Tips That Actually Help

After spending time with this, here’s what I’ve learned about getting better results:

Be specific about what you want back. “Review this code” is okay. “Review this code and give me three specific things to change, written as SQL snippets I can copy” is much better.

Tell it the context it’s missing. “This table has 2 billion rows and is clustered on event_date” is useful information that shapes the advice you’ll get.

Ask follow-up questions. If the first answer is good but you want to go deeper on one part, just ask. The interface supports back-and-forth.

Tell it what you’ve already tried. If you’ve already checked clustering and it didn’t help, say so. Otherwise it’ll suggest clustering.

Why I Think This Matters

I started this blog because I noticed that a lot of the Snowflake content online is either too shallow (“here’s what the feature is”) or too abstract (“here’s why AI in data warehouses matters”). What’s missing is the honest, practical, “here’s what I actually did and what happened” stuff.

Cortex Code is one of those features that I think is genuinely going to change how data engineers do their day-to-day work — not in a science fiction way, but in the quiet, unglamorous way where you just realize one day that you’re spending three hours less per week on the boring parts and three hours more on the interesting parts.

Nobody told me to learn this. I’m glad I did.

If you try it, tell me how it goes. I’m genuinely curious whether your experience matches mine.

Why Document Processing Matters in 2026

Enterprises store approximately 80-90% of their business data in unstructured formats—PDFs, Word documents, scanned images, contracts, invoices, and reports. Yet most enterprise data warehouses, including Snowflake, were built to handle structured data.

Snowflake’s AI_PARSE_DOCUMENT function, a Cortex AI SQL function that extracts text, data, and layout elements from documents with high fidelity, bridges this gap by allowing you to extract and structure document content directly within Snowflake using AI.

This guide covers everything you need to know about implementing AI_PARSE_DOCUMENT for production use—from understanding the two processing modes, to pricing calculations, to end-to-end RAG pipeline optimization.

What is AI_PARSE_DOCUMENT?

AI_PARSE_DOCUMENT is a fully managed SQL function that transforms unstructured documents into AI-ready structured data. It extracts text or layout from documents stored on internal or external stages, preserving structure like tables, headers, and reading order.

Key capabilities:

• Optical Character Recognition (OCR) and layout extraction modes
• Extract images embedded in PDF and Word documents alongside text, data, and layout elements
• Horizontal scalability for efficient batch processing of multiple documents
• Support for 12+ languages
• Markdown-formatted structured output

Why Should You Use AI_PARSE_DOCUMENT?

Real Business Problems It Solves

Problem 1: Manual Document Processing Bottleneck Extracting data from 10,000 PDFs manually takes 500+ hours at $50/hour = $25,000+ cost. AI_PARSE_DOCUMENT does it in minutes for ~$50-100.

Problem 2: RAG Pipeline Quality Issues Generic text extraction loses document structure (tables, relationships, context), making RAG systems retrieve wrong information. AI_PARSE_DOCUMENT provides high-fidelity extraction that ensures retrieval systems find relevant content with proper context, dramatically improving answer quality.

Problem 3: Unstructured Data Can’t Be Queried 20,000 customer contracts sit in S3 but you can’t answer “How many customers have SLA clauses?” AI_PARSE_DOCUMENT converts them to queryable structured data.

Problem 4: Building Knowledge Bases at Scale Creating searchable knowledge bases from 100,000+ documents requires extracting, validating, and embedding structured content. AI_PARSE_DOCUMENT enables structured output for semantic search and AI reasoning across large document collections.

LAYOUT Mode vs. OCR Mode: Which One Do You Need?

LAYOUT Mode: Perfect for Retaining Precise Layout and Formatting

The preferred choice for most use cases, especially for complex documents is the Layout mode. It’s specifically optimized for extracting text and layout elements like tables, making it the best option for building knowledge bases, optimizing retrieval systems, and enhancing AI based applications.

Best for:

• Technical manuals and documentation
• Financial reports with tables and charts
• Legal documents with structured sections
• Business presentations with layouts
• Any document where structure = meaning

Output format: Markdown with tables, headers, and sections preserved

Real SQL example:

SELECT 
  SNOWFLAKE.CORTEX.AI_PARSE_DOCUMENT(
    TO_FILE('@documents_stage', 'quarterly_report.pdf'),
    {'mode': 'LAYOUT', 'page_split': TRUE}
  ) as parsed_content
FROM document_queue;

OCR Mode: Fast Text Extraction

OCR mode is recommended for quick, high-quality text extraction from documents such as manuals, agreements or contracts, product detail pages, insurance policies and claims, and SharePoint documents.

Best for:

• Scanned documents and images
• Contracts and agreements (when structure doesn’t matter)
• SharePoint documents
• Quick text extraction without layout preservation
• Flat documents without complex formatting

Output format: Plain text only (no tables or structure)

Real SQL example:

SELECT 
  SNOWFLAKE.CORTEX.AI_PARSE_DOCUMENT(
    TO_FILE('@documents_stage', 'insurance_claim.pdf'),
    {'mode': 'OCR'}
  ) as extracted_text
FROM claims_queue;

Image Extraction: New in January 2026

The AI_PARSE_DOCUMENT AI Function can now extract images embedded in PDF and Word documents, alongside text, data, and layout elements. Extracted images can be written to stages or passed directly to other Cortex AI Functions for further analysis.

Use cases for image extraction:

• Enrich data: Extract images from documents to add visual context for deeper insights
• Multimodal RAG: Combine images and text for retrieval-augmented generation (RAG) to improve model responses
• Image classification: Use extracted images with AI_EXTRACT or AI_COMPLETE for automatic tagging and analysis
• Compliance: Extract and analyze images (e.g., charts, signatures) for regulatory and audit workflows

Important: There is no additional cost for image extraction beyond the standard page-based billing for AI_PARSE_DOCUMENT.

How AI_PARSE_DOCUMENT Is Priced

Page-Based Billing Model

The Cortex AI_PARSE_DOCUMENT function incurs compute costs based on the number of pages per document processed.

How pages are counted:

Paged document formats such as PDF and DOCX are billed per page in the file.Image formats including JPEG, JPG, PNG, TIF, and TIFF are billed as one page per image file.For HTML and TXT files, billing is based on every 3,000 characters, with each 3,000‑character block counted as one page. The final block is also billed as a page, even if it contains fewer than 3,000 characters.

Cost Examples by Document Type

PDF Documents:

Word Documents (.DOCX): Same page-based billing as PDFs. 10-page document = 10 pages charged.

Image Files (JPG, PNG, TIF):

Text/HTML Files: Every 3,000 characters = 1 page charged

Supported File Formats

AI_PARSE_DOCUMENT supports:

• PDF files (.pdf)
• Microsoft Word (.docx)
• Images (JPEG, JPG, PNG, TIF, TIFF)
• HTML files (.html)
• Plain text files (.txt)
• Multi-page documents with page filtering

End-to-End Implementation Guide

Step 1: Create a Document Stage

-- Create encrypted internal stage for documents
CREATE STAGE IF NOT EXISTS parse_documents
  DIRECTORY = (ENABLE = TRUE)
  ENCRYPTION = (TYPE = 'SNOWFLAKE_SSE');

-- Create external stage for S3/Azure/GCS documents
CREATE STAGE IF NOT EXISTS external_documents
  URL = 's3://your-bucket/documents/'
  CREDENTIALS = (AWS_KEY_ID = '...' AWS_SECRET_KEY = '...');

Step 2: Upload Documents to Stage

1. Using Snowflake UI (Snowsight)

1. Navigate to Data → Databases → Your DB → Stages
2. Select parse_documents stage
3. Click “Upload Files”
4. Select PDFs/documents to upload

Method 2: Using SQL PUT Command

PUT file:///local/path/invoice.pdf @parse_documents;

Method 3: External Stages (S3, Azure Blob, GCS) Documents auto-discovered from S3 bucket path

Step 3: Parse Single Document

-- Simple parse with LAYOUT mode
SELECT 
  SNOWFLAKE.CORTEX.AI_PARSE_DOCUMENT(
    TO_FILE('@parse_documents', 'invoice_001.pdf'),
    {'mode': 'LAYOUT'}
  ) as parsed_json

Output format:

{
  "metadata": {
    "pageCount": 2
  },
  "content": "# Invoice\n\n## Header\n...",
  "pages": [
    {
      "index": 0,
      "content": "# Invoice 001..."
    },
    {
      "index": 1,
      "content": "# Page 2..."
    }
  ]
}

Step 4: Parse Multiple Documents in Batch

-- Batch parse all PDFs in stage
CREATE OR REPLACE PROCEDURE parse_documents_batch()
RETURNS TABLE(
  file_name VARCHAR,
  page_count INT,
  parsed_content VARIANT
)
LANGUAGE SQL
AS
$$
  SELECT 
    file_name,
    (parsed_output:metadata:pageCount)::INT as page_count,
    parsed_output
  FROM (
    SELECT 
      'document_' || ROW_NUMBER() OVER (ORDER BY relative_path) as file_name,
      SNOWFLAKE.CORTEX.AI_PARSE_DOCUMENT(
        TO_FILE('@parse_documents', relative_path),
        {'mode': 'LAYOUT', 'page_split': TRUE}
      ) as parsed_output
    FROM DIRECTORY('@parse_documents')
  );
$$;

-- Execute batch parsing
CALL parse_documents_batch();

Step 5: Extract Structured Data

Once parsed, extract specific fields using AI_EXTRACT:

-- Extract invoice details from parsed content
SELECT 
  file_name,
  SNOWFLAKE.CORTEX.AI_EXTRACT(
    parsed_content:content::VARCHAR,
    'Extract invoice number, vendor name, total amount, and payment terms'
  ) as extracted_fields
FROM parsed_documents
WHERE parsed_content:metadata:pageCount > 0;

Step 6: Load Into Table

-- Create table for structured invoice data
CREATE TABLE invoices_extracted (
  file_name VARCHAR,
  invoice_number VARCHAR,
  vendor_name VARCHAR,
  total_amount DECIMAL(10, 2),
  payment_terms VARCHAR,
  parsed_at TIMESTAMP
);

-- Load extracted data
INSERT INTO invoices_extracted
SELECT 
  file_name,
  (extracted:invoice_number)::VARCHAR,
  (extracted:vendor_name)::VARCHAR,
  (extracted:total_amount)::DECIMAL(10, 2),
  (extracted:payment_terms)::VARCHAR,
  CURRENT_TIMESTAMP
FROM parsed_documents
WHERE extracted IS NOT NULL;

Real-World Use Cases

Use Case 1: Invoice Processing Automation

Scenario: Process 10,000 vendor invoices/month from email attachments

-- Step 1: Parse invoices
WITH parsed_invoices AS (
  SELECT 
    file_name,
    SNOWFLAKE.CORTEX.AI_PARSE_DOCUMENT(
      TO_FILE('@invoice_stage', file_name),
      {'mode': 'LAYOUT'}
    ) as parsed
  FROM invoice_queue
)
-- Step 2: Extract structured data
SELECT 
  file_name,
  SNOWFLAKE.CORTEX.AI_EXTRACT(
    parsed:content::VARCHAR,
    'Extract: invoice_id, vendor, amount, invoice_date, due_date, line_items'
  ) as invoice_data
FROM parsed_invoices;

Cost breakdown:

• 10,000 invoices × 1 page × ~$0.04/page = $400/month
• Compared to manual processing: $25,000/month
• ROI: $24,600/month savings

Use Case 2: Legal Document Analysis

Scenario: Analyze 5,000 contracts for SLA clauses, payment terms, renewal dates

-- Parse contracts with LAYOUT mode (important for structure)
WITH parsed_contracts AS (
  SELECT 
    contract_id,
    SNOWFLAKE.CORTEX.AI_PARSE_DOCUMENT(
      TO_FILE('@contracts_stage', contract_filename),
      {
        'mode': 'LAYOUT',
        'page_split': TRUE,
        'page_filter': [{'start': 0, 'end': 3}]  -- First 3 pages only
      }
    ) as parsed
  FROM active_contracts
)
-- Extract legal terms
SELECT 
  contract_id,
  SNOWFLAKE.CORTEX.AI_EXTRACT(
    parsed:content::VARCHAR,
    'Extract SLA terms, payment schedule, termination clause, and renewal date'
  ) as legal_terms
FROM parsed_contracts;

Cost:

• 5,000 contracts × 3 pages × $0.04 = $600/month
• Saves 100+ hours of legal review time

Use Case 3: Insurance Claims Processing

Scenario: Extract data from 20,000 insurance claim forms (mixed scanned + digital)

-- Use OCR for scanned documents, LAYOUT for digital
WITH claims_data AS (
  SELECT 
    claim_id,
    SNOWFLAKE.CORTEX.AI_PARSE_DOCUMENT(
      TO_FILE('@claims_stage', claim_filename),
      {
        'mode': CASE 
          WHEN claim_type = 'SCANNED' THEN 'OCR'
          ELSE 'LAYOUT'
        END
      }
    ) as parsed
  FROM claims_queue
  WHERE status = 'pending'
)
-- Extract claim fields
SELECT 
  claim_id,
  SNOWFLAKE.CORTEX.AI_EXTRACT(
    parsed:content::VARCHAR,
    'Extract claimant name, claim amount, incident date, claim type, supporting documents list'
  ) as claim_info
FROM claims_data;

Cost: 20,000 × 1 page × $0.04 = $800/month

Use Case 4: Building RAG-Ready Knowledge Bases

Scenario: Create searchable knowledge base from 50,000 product manuals

-- Parse all manuals with LAYOUT mode (preserves structure = better RAG)
CREATE OR REPLACE TASK parse_manuals_daily
  WAREHOUSE = compute_wh
  SCHEDULE = 'USING CRON 0 2 * * * UTC'
AS
WITH parsed_manuals AS (
  SELECT 
    manual_id,
    section_number,
    SNOWFLAKE.CORTEX.AI_PARSE_DOCUMENT(
      TO_FILE('@manuals_stage', file_path),
      {
        'mode': 'LAYOUT',
        'page_split': TRUE
      }
    ) as parsed_content
  FROM manual_queue
)
-- Create embeddings for semantic search
INSERT INTO manual_embeddings
SELECT 
  manual_id,
  section_number,
  parsed_content:content::VARCHAR as content,
  SNOWFLAKE.CORTEX.AI_EMBED(
    'snowflake-arctic-embed-m-v2',
    parsed_content:content::VARCHAR
  ) as embedding
FROM parsed_manuals
WHERE parsed_content:metadata:pageCount > 0;

Benefits:

• Preserves table structure from manuals
• Better semantic search accuracy
• Enables multimodal RAG with extracted images (new Jan 2026)
• Cost: 50,000 pages × $0.04 = $2,000 initial + ongoing embeddings

Page Filtering: Process Specific Pages Only

Sometimes you don’t need to parse entire documents. Use page_filter:

-- Extract only first 5 pages of long contracts
SELECT 
  SNOWFLAKE.CORTEX.AI_PARSE_DOCUMENT(
    TO_FILE('@contracts_stage', 'long_contract.pdf'),
    {
      'mode': 'LAYOUT',
      'page_filter': [{'start': 0, 'end': 5}]  -- Pages 0-4 only
    }
  ) as first_pages
;

-- Extract only page 10 (index 9)
SELECT 
  SNOWFLAKE.CORTEX.AI_PARSE_DOCUMENT(
    TO_FILE('@documents_stage', 'report.pdf'),
    {
      'mode': 'LAYOUT',
      'page_filter': [{'start': 9, 'end': 10}]  -- Only page 10
    }
  ) as page_10
;

Cost reduction: Parsing 100-page contract’s first 5 pages costs $0.20 vs. $4.00 for all pages

Performance Optimization Tips

Tip 1: Use Appropriate Warehouse Size

Snowflake recommends executing queries that call the Cortex AI_PARSE_DOCUMENT function in a smaller warehouse (no larger than MEDIUM). Larger warehouses do not increase performance.

Wrong:

-- Uses 4 credits/hour, no speed benefit
USE WAREHOUSE large_wh;
SELECT SNOWFLAKE.CORTEX.AI_PARSE_DOCUMENT(...);

Right:

-- Uses 1 credit/hour, same speed
USE WAREHOUSE xsmall_wh;
SELECT SNOWFLAKE.CORTEX.AI_PARSE_DOCUMENT(...);

Cost difference: Small vs. Large warehouse = 4x cost reduction.
For more AI-powered optimization techniques, see how Cortex Code can cut dbt build times by 48%.

Tip 2: Batch Processing

Process multiple documents in a single query rather than individual calls:

-- GOOD: Batch processing
SELECT 
  file_name,
  SNOWFLAKE.CORTEX.AI_PARSE_DOCUMENT(TO_FILE('@stage', file_name), {'mode': 'LAYOUT'})
FROM DIRECTORY('@stage')
;

-- BAD: Individual queries (loop overhead)
FOR each_file IN (SELECT file_name FROM stage_list) LOOP
  SELECT SNOWFLAKE.CORTEX.AI_PARSE_DOCUMENT(...);
END LOOP;

Tip 3: Cache Parsed Results

Don’t re-parse same documents:

-- Cache parsed documents
CREATE TABLE parsed_documents_cache AS
SELECT 
  file_name,
  file_hash,
  parsed_json,
  parsed_at
FROM (
  SELECT 
    file_name,
    MD5(file_content) as file_hash,
    SNOWFLAKE.CORTEX.AI_PARSE_DOCUMENT(...) as parsed_json,
    CURRENT_TIMESTAMP as parsed_at
  FROM documents
);

-- Check cache before parsing
SELECT 
  COALESCE(
    (SELECT parsed_json FROM parsed_documents_cache WHERE file_hash = MD5(doc_content)),
    SNOWFLAKE.CORTEX.AI_PARSE_DOCUMENT(...)
  ) as parsed_content
FROM documents;

Tip 4: Use Page_Split Strategically

Split documents only when needed:

-- DON'T: Split for simple text extraction
SELECT SNOWFLAKE.CORTEX.AI_PARSE_DOCUMENT(
  TO_FILE('@stage', 'document.pdf'),
  {'mode': 'OCR', 'page_split': TRUE}  -- Unnecessary split
);

-- DO: Split only for layout analysis or per-page processing
SELECT SNOWFLAKE.CORTEX.AI_PARSE_DOCUMENT(
  TO_FILE('@stage', 'document.pdf'),
  {'mode': 'LAYOUT', 'page_split': TRUE}  -- Needed for table extraction
);

FAQ: Common Questions About AI_PARSE_DOCUMENT

How accurate is AI_PARSE_DOCUMENT?

AI_PARSE_DOCUMENT uses proprietary Arctic-TILT model to extract text, tables, and entities from PDFs and images with 90% ANLS benchmark accuracy, outperforming GPT-4.

For specific domains (invoices, contracts, forms), accuracy is 93-97% with proper document quality.

What languages does it support?

AI_PARSE_DOCUMENT supports 12+ languages including English, Spanish, French, German, Italian, Dutch, Portuguese, Chinese, Japanese, Korean, Russian, and Arabic.

Can I extract images with no extra cost?

There is no additional cost for image extraction beyond the standard page-based billing for AI_PARSE_DOCUMENT.

What happens if parsing fails?

If a document can’t be parsed, the response includes error information in the errorInformation field. Common causes:

• Corrupted PDF file
• Unsupported file format
• Encrypted/password-protected document
• Extreme image quality degradation

Should I use OCR or LAYOUT mode?

Use LAYOUT if:

• Document contains tables or complex formatting
• Building RAG system (structure improves retrieval)
• Financial/legal documents with sections
• Structure = meaning

Use OCR if:

• Simple text extraction needed
• Scanned documents/images
• Fast processing is priority
• Layout doesn’t matter

How do I integrate this with Cortex Search?

-- 1. Parse documents
-- 2. Create embeddings
-- 3. Build Cortex Search service

CREATE CORTEX SEARCH SERVICE manual_search ON
  SELECT 
    manual_id,
    parsed_content,
    embedding
  FROM parsed_manual_embeddings
  WHERE embedding IS NOT NULL
;

Troubleshooting Common Issues

Issue 1: “Permission denied” Error

Solution: Grant CORTEX_USER role

GRANT DATABASE ROLE SNOWFLAKE.CORTEX_USER TO ROLE your_role;

Issue 2: Parsing Takes Too Long

Solution: Use smaller warehouse + batch processing

USE WAREHOUSE xsmall_wh;  -- Not medium/large
-- Batch process instead of individual calls

Issue 3: Extracted Data Quality Poor

Solution: Use LAYOUT mode instead of OCR for structured docs

-- Before (poor quality)
SELECT SNOWFLAKE.CORTEX.AI_PARSE_DOCUMENT(..., {'mode': 'OCR'});

-- After (better quality)
SELECT SNOWFLAKE.CORTEX.AI_PARSE_DOCUMENT(..., {'mode': 'LAYOUT'});

Key Takeaways

1. AI_PARSE_DOCUMENT bridges the unstructured data gap – Transform 80-90% of enterprise data (PDFs, contracts, forms) into queryable structured data
2. Two modes for different needs:
   • LAYOUT: Best for complex documents, tables, RAG systems
   • OCR: Best for scanned documents, simple text extraction
3. Page-based pricing – Cost scales with document pages, not complexity
   • ~$0.04 per page (varies by region/contract)
   • 1,000 invoices = ~$40/month
4. Image extraction (new Jan 2026) – No extra cost, enables multimodal RAG
5. RAG optimization – LAYOUT mode + page structure preservation = better retrieval accuracy
6. Batch > Individual – Process multiple documents in one query for efficiency
7. Smaller warehouse = same speed, lower cost – Don’t use Large/Medium warehouses
8. Page filtering reduces costs – Process only pages you need

External References (Official Snowflake Documentation)

• AI_PARSE_DOCUMENT Official Documentation
• AISQL AI_PARSE_DOCUMENT Function Reference
• Document Processing with Cortex
• Image Extraction from Documents (Jan 2026)
• Document Processing Playground
• Cortex Search Documentation

Next Steps

1. Start small: Upload 10-20 test documents to Snowflake stage
2. Test both modes: Compare OCR vs. LAYOUT output quality
3. Calculate costs: Count pages in your document inventory
4. Integrate: Connect to Cortex Search or AI_EXTRACT for downstream processing
5. Scale: Batch process entire document library

Disclaimer: Pricing and features current as of January 2026. Always verify with official Snowflake documentation for most current information.

Why I Started Exploring Snowflake Cortex AI

Three months ago, I was sitting in a meeting where someone asked, “Can we analyze sentiment in these 50,000 customer reviews?” My immediate thought was: “Sure, but that’s going to be a whole project—export the data, set up API calls to OpenAI, manage rate limits, handle errors…”

Then someone mentioned Snowflake Cortex.

I didn’t know what to expect. We already use Snowflake for our data warehouse, but AI capabilities built directly into SQL? That sounded too good to be true. Turns out, it wasn’t just marketing talk—it actually works, and it’s changed how we approach problems that used to require separate ML infrastructure.

This guide is everything I wish someone had shown me when I started. No fluff, no hand-waving—just practical examples of what Cortex can do and how to actually use it.

What is Snowflake Cortex AI? (The Real Story)

Snowflake Cortex is a set of AI and machine learning functions that run directly inside Snowflake. Think of it as having ChatGPT, vector databases, and various AI models available as SQL functions—no need to export data, manage API keys, or set up external services.

Here’s what makes it different from other AI platforms:

The old way of doing AI with data:

1. Export data from Snowflake
2. Send to external API (OpenAI, Anthropic, etc.)
3. Handle authentication, rate limits, retries
4. Store results somewhere
5. Bring results back to Snowflake
6. Hope nothing broke along the way

The Cortex way:

1. Write SQL query
2. That’s it

Your data never leaves Snowflake’s security boundary. You don’t manage API keys and rate limits (Snowflake handles that). You just write SQL.

The Cortex Function Categories (What Can You Actually Do?)

Cortex has evolved significantly since its launch. As of 2026, here are the main categories:

1. LLM Functions (Text Generation & Understanding)

• Text generation and completion
• Summarization
• Translation
• Question answering
• Text extraction

2. ML Functions (Traditional Machine Learning)

• Sentiment analysis
• Classification
• Forecasting
• Anomaly detection

3. Vector Functions (Semantic Search)

• Text embeddings
• Vector similarity search
• Semantic retrieval

4. Document AI (New in 2025-2026)

• PDF text extraction
• Document classification
• Form processing
• OCR capabilities

Let me walk through each category with real examples I’ve actually used.

Part 1: LLM Functions – The Workhorses

COMPLETE – Text Generation

This is probably the function I use most. It takes a prompt and generates text using various LLM models.

Available Models (as of 2026):

• llama3.1-8b – Fast, cost-effective, good for simple tasks
• llama3.1-70b – More powerful, better reasoning
• llama3.1-405b – Most capable, highest quality (newer)
• mistral-large2 – Alternative to Llama models
• mixtral-8x7b – Good balance of speed and quality

Real Example: Customer Support Categorization

We get thousands of support tickets. Before Cortex, we had a manual tagging system. Now:

-- Create a sample support tickets table
CREATE OR REPLACE TABLE support_tickets (
    ticket_id INTEGER,
    customer_email STRING,
    subject STRING,
    message TEXT,
    created_at TIMESTAMP_LTZ
);

-- Sample data
INSERT INTO support_tickets VALUES
(1, '[email protected]', 'Cannot access my account', 
 'I have been trying to log in for the past hour but keep getting an error message saying my password is incorrect. I tried the forgot password link but did not receive any email. This is urgent as I need to access my reports for a client meeting.', 
 CURRENT_TIMESTAMP()),

(2, '[email protected]', 'Question about pricing', 
 'Hi, I am currently on the Standard plan but considering upgrading to Enterprise. Could you provide more details about what additional features I would get? Specifically interested in the API rate limits and dedicated support options.', 
 CURRENT_TIMESTAMP()),

(3, '[email protected]', 'Data export issue', 
 'When I try to export my data to CSV, the download fails after a few seconds. The file is around 2GB. Is there a file size limit? I need to get this data to my finance team by end of day.', 
 CURRENT_TIMESTAMP());

-- Use COMPLETE to categorize tickets
SELECT 
    ticket_id,
    subject,
    LEFT(message, 100) || '...' as message_preview,
    SNOWFLAKE.CORTEX.COMPLETE(
        'llama3.1-70b',
        CONCAT(
            'Categorize this support ticket into ONE of these categories: ',
            'Login/Access Issue, Billing/Pricing Question, Technical Problem, Feature Request, General Question. ',
            'Return ONLY the category name, nothing else.\n\n',
            'Ticket: ', subject, '\n',
            'Message: ', message
        )
    ) as ticket_category,
    SNOWFLAKE.CORTEX.COMPLETE(
        'llama3.1-70b',
        CONCAT(
            'Based on this support ticket, suggest a priority level (Low, Medium, High, Urgent) and explain why in one sentence.\n\n',
            'Ticket: ', subject, '\n',
            'Message: ', message
        )
    ) as priority_assessment
FROM support_tickets;

What I love about this: it understands context. The first ticket gets flagged as “Urgent” because the customer mentions a client meeting. That’s the kind of nuance that simple keyword matching misses.

Real Example: Product Description Generation

We have a catalog with technical specifications but needed customer-friendly descriptions:

-- Product specifications table
CREATE OR REPLACE TABLE product_specs (
    product_id STRING,
    product_name STRING,
    category STRING,
    technical_specs VARIANT
);

INSERT INTO product_specs 
SELECT 
    'PROD-001',
    'UltraBook Pro 15',
    'Laptop',
    OBJECT_CONSTRUCT(
        'processor', 'Intel Core i7-13700H',
        'ram', '32GB DDR5',
        'storage', '1TB NVMe SSD',
        'display', '15.6 inch 4K OLED',
        'weight', '1.8kg',
        'battery', '12 hours'
    );

-- Generate customer-friendly descriptions
SELECT 
    product_id,
    product_name,
    technical_specs,
    SNOWFLAKE.CORTEX.COMPLETE(
        'llama3.1-70b',
        CONCAT(
            'Write a compelling 2-paragraph product description for an e-commerce site. ',
            'Make it engaging and highlight key benefits for customers. ',
            'Technical specs: ', technical_specs::STRING
        )
    ) as marketing_description,
    SNOWFLAKE.CORTEX.COMPLETE(
        'llama3.1-8b',
        CONCAT(
            'Write a short 1-sentence product tagline that is catchy and memorable. ',
            'Product: ', product_name, ' - ', technical_specs::STRING
        )
    ) as tagline
FROM product_specs;

Notice I used the smaller 8b model for the tagline. For simple tasks, the smaller model is faster and cheaper—no need to use the 70b model for everything.

SUMMARIZE – Text Condensation

This function takes long text and creates concise summaries. Way better than just truncating text.

Real Example: Meeting Notes Summaries

-- Meeting transcripts table
CREATE OR REPLACE TABLE meeting_transcripts (
    meeting_id STRING,
    title STRING,
    date DATE,
    full_transcript TEXT
);

INSERT INTO meeting_transcripts VALUES
('MTG-2026-001', 'Q1 Product Planning', '2026-01-15',
'Sarah: Thanks everyone for joining. Let us discuss Q1 priorities. We have three major initiatives: launching the mobile app, improving API performance, and expanding our European presence. Mike, want to start with mobile?

Mike: Sure. The mobile app beta testing has been going well. We have 500 beta users and feedback is mostly positive. Main complaint is the search function is slow. We are working on optimization. Target launch is end of February, but might push to early March to get search right.

Emily: That makes sense. On the API front, we have identified the bottleneck - database queries are not optimized. We are implementing caching and expect 40% performance improvement. Should be done by end of January.

Sarah: Great. David, Europe expansion?

David: We have legal approval for UK and Germany. Setting up local servers in Frankfurt. Main challenge is GDPR compliance for data processing. Working with legal team. Timeline is March for UK, April for Germany.

Sarah: Perfect. Any blockers? 

Mike: We need two more mobile developers to hit the February deadline.

Emily: I need approval for the Redis cluster for caching.

Sarah: I will work on hiring and Redis approval this week. Let us meet again in two weeks to check progress.');

-- Generate summaries
SELECT 
    meeting_id,
    title,
    date,
    SNOWFLAKE.CORTEX.SUMMARIZE(full_transcript) as executive_summary,
    SNOWFLAKE.CORTEX.COMPLETE(
        'llama3.1-70b',
        CONCAT(
            'Extract all action items from this meeting transcript. ',
            'Format as a bulleted list with the person responsible.\n\n',
            full_transcript
        )
    ) as action_items,
    SNOWFLAKE.CORTEX.COMPLETE(
        'llama3.1-70b',
        CONCAT(
            'List all key decisions made in this meeting. Be specific.\n\n',
            full_transcript
        )
    ) as key_decisions
FROM meeting_transcripts;

The SUMMARIZE function gives you a concise overview, while COMPLETE extracts structured information like action items. This is how we went from “meeting notes that nobody reads” to “actionable summaries people actually use.”

TRANSLATE – Language Translation

This one surprised me with how well it works. We have customers in 15 countries, and translating support content used to be a manual nightmare.

Real Example: Multi-Language Product Updates

-- Product announcements
CREATE OR REPLACE TABLE product_announcements (
    announcement_id INTEGER,
    title STRING,
    content STRING,
    created_date DATE
);

INSERT INTO product_announcements VALUES
(1, 'New Feature: Real-time Collaboration',
'We are excited to announce real-time collaboration features! Multiple team members can now work on the same project simultaneously. Changes sync instantly across all devices. This feature is available on all paid plans starting today.',
'2026-01-20');

-- Translate to multiple languages
SELECT 
    announcement_id,
    'English' as language,
    title,
    content
FROM product_announcements

UNION ALL

SELECT 
    announcement_id,
    'Spanish' as language,
    SNOWFLAKE.CORTEX.TRANSLATE(title, 'en', 'es') as title,
    SNOWFLAKE.CORTEX.TRANSLATE(content, 'en', 'es') as content
FROM product_announcements

UNION ALL

SELECT 
    announcement_id,
    'French' as language,
    SNOWFLAKE.CORTEX.TRANSLATE(title, 'en', 'fr') as title,
    SNOWFLAKE.CORTEX.TRANSLATE(content, 'en', 'fr') as content
FROM product_announcements

UNION ALL

SELECT 
    announcement_id,
    'German' as language,
    SNOWFLAKE.CORTEX.TRANSLATE(title, 'en', 'de') as title,
    SNOWFLAKE.CORTEX.TRANSLATE(content, 'en', 'de') as content
FROM product_announcements

ORDER BY announcement_id, language;

The quality is good enough for customer communications. We still have humans review for legal stuff, but for general updates, it works perfectly.

EXTRACT_ANSWER – Targeted Information Retrieval

This is like having a research assistant. Give it a document and a question, and it finds the answer.

Real Example: Contract Analysis

-- Contracts table
CREATE OR REPLACE TABLE vendor_contracts (
    contract_id STRING,
    vendor_name STRING,
    contract_text TEXT
);

INSERT INTO vendor_contracts VALUES
('CONTRACT-001', 'CloudServe Inc',
'This Service Agreement is between ACME Corp and CloudServe Inc. Services include cloud hosting and managed database services. Service Level Agreement guarantees 99.9% uptime. In the event of downtime exceeding the SLA, customer is entitled to service credits equal to 10% of monthly fees for each hour of excess downtime. Payment terms are Net 30. Contract term is 24 months beginning January 1, 2026. Either party may terminate with 90 days written notice. Renewal is automatic unless terminated.');

-- Extract specific information
SELECT 
    contract_id,
    vendor_name,
    SNOWFLAKE.CORTEX.EXTRACT_ANSWER(
        contract_text,
        'What is the uptime guarantee?'
    ) as uptime_sla,
    SNOWFLAKE.CORTEX.EXTRACT_ANSWER(
        contract_text,
        'What are the payment terms?'
    ) as payment_terms,
    SNOWFLAKE.CORTEX.EXTRACT_ANSWER(
        contract_text,
        'How long is the contract term?'
    ) as contract_duration,
    SNOWFLAKE.CORTEX.EXTRACT_ANSWER(
        contract_text,
        'What is the termination notice period?'
    ) as termination_notice
FROM vendor_contracts;

Before this, someone had to manually read through contracts to answer these questions. Now it’s automated. We used this to audit 200+ vendor contracts in an afternoon.

Part 2: ML Functions – The Analyzers

SENTIMENT – Understanding Emotion in Text

This one is straightforward but incredibly useful. Returns a score from -1 (very negative) to 1 (very positive).

Real Example: Product Review Analysis

-- Product reviews
CREATE OR REPLACE TABLE product_reviews (
    review_id INTEGER,
    product_name STRING,
    customer_name STRING,
    rating INTEGER,
    review_text TEXT,
    review_date DATE
);

INSERT INTO product_reviews VALUES
(1, 'SmartHome Hub', 'Jennifer K', 5,
'This device has completely transformed my home! Setup was incredibly easy, took less than 10 minutes. The app is intuitive and responsive. I love how it integrates with all my smart devices seamlessly. Customer support was also excellent when I had a question. Highly recommend!',
'2026-01-10'),

(2, 'SmartHome Hub', 'Robert M', 2,
'Very disappointed. The device keeps disconnecting from WiFi every few hours. I have tried everything - rebooting, changing networks, factory reset. Nothing works. The app crashes frequently. For the price, I expected much better quality. Returning it.',
'2026-01-12'),

(3, 'SmartHome Hub', 'Lisa T', 4,
'Pretty good overall. Works as advertised and the interface is nice. Only complaint is that it is a bit pricey and the initial setup was confusing. Once I got it working though, it has been solid. Would buy again but maybe wait for a sale.',
'2026-01-15');

-- Analyze sentiment
SELECT 
    review_id,
    product_name,
    rating as star_rating,
    ROUND(SNOWFLAKE.CORTEX.SENTIMENT(review_text), 3) as sentiment_score,
    CASE 
        WHEN SNOWFLAKE.CORTEX.SENTIMENT(review_text) >= 0.5 THEN '😊 Very Positive'
        WHEN SNOWFLAKE.CORTEX.SENTIMENT(review_text) >= 0.1 THEN '🙂 Positive'
        WHEN SNOWFLAKE.CORTEX.SENTIMENT(review_text) >= -0.1 THEN '😐 Neutral'
        WHEN SNOWFLAKE.CORTEX.SENTIMENT(review_text) >= -0.5 THEN '🙁 Negative'
        ELSE '😞 Very Negative'
    END as sentiment_category,
    LEFT(review_text, 100) || '...' as review_preview
FROM product_reviews
ORDER BY sentiment_score DESC;

-- Compare sentiment vs star rating
SELECT 
    product_name,
    COUNT(*) as total_reviews,
    ROUND(AVG(rating), 2) as avg_star_rating,
    ROUND(AVG(SNOWFLAKE.CORTEX.SENTIMENT(review_text)), 3) as avg_sentiment_score,
    -- Flag mismatches (high stars but negative sentiment)
    COUNT(CASE 
        WHEN rating >= 4 AND SNOWFLAKE.CORTEX.SENTIMENT(review_text) < 0 
        THEN 1 
    END) as positive_rating_negative_sentiment,
    -- Or low stars but positive sentiment
    COUNT(CASE 
        WHEN rating <= 2 AND SNOWFLAKE.CORTEX.SENTIMENT(review_text) > 0 
        THEN 1 
    END) as negative_rating_positive_sentiment
FROM product_reviews
GROUP BY product_name;

Here’s something interesting we discovered: sometimes people give 5 stars but their review text is actually mixed or even negative (they’re being nice about problems). Sentiment analysis catches this. It’s helped us identify issues that we’d miss if we only looked at star ratings.

FORECAST – Time Series Prediction

This is newer (added in late 2025) and still improving, but it’s useful for basic forecasting without needing to build custom models.

Real Example: Sales Forecasting

-- Historical sales data
CREATE OR REPLACE TABLE daily_sales (
    sale_date DATE,
    product_category STRING,
    revenue DECIMAL(10,2)
);

-- Generate sample historical data (last 90 days)
INSERT INTO daily_sales
SELECT 
    DATEADD(day, -seq.seq, CURRENT_DATE()) as sale_date,
    'Electronics' as product_category,
    5000 + (seq.seq * 50) + (RANDOM() * 1000 - 500) as revenue
FROM (
    SELECT ROW_NUMBER() OVER (ORDER BY SEQ4()) - 1 as seq
    FROM TABLE(GENERATOR(ROWCOUNT => 90))
) seq;

-- Create forecasting model
SELECT 
    SNOWFLAKE.CORTEX.FORECAST(
        sale_date,
        revenue,
        30  -- Forecast next 30 days
    ) OVER (PARTITION BY product_category ORDER BY sale_date) as forecast_data
FROM daily_sales
WHERE product_category = 'Electronics'
ORDER BY sale_date;

I’ll be honest: this function is not as sophisticated as dedicated forecasting tools like Prophet or AutoML solutions. But for quick “what if” scenarios and basic projections, it’s incredibly convenient. We use it for capacity planning and rough budget estimates.

Part 3: Vector Functions – Semantic Search Revolution

This is where things get really interesting. Vector embeddings let you search by meaning, not just keywords.

EMBED_TEXT_1024 – Creating Vector Representations

Real Example: Building a Searchable Knowledge Base

-- Knowledge base articles
CREATE OR REPLACE TABLE knowledge_articles (
    article_id INTEGER,
    title STRING,
    category STRING,
    content TEXT,
    content_embedding VECTOR(FLOAT, 1024)
);

-- Sample articles
INSERT INTO knowledge_articles (article_id, title, category, content)
VALUES
(1, 'How to Reset Your Password',
'Account Management',
'If you have forgotten your password, click the Forgot Password link on the login page. Enter your email address and we will send you a password reset link. Check your spam folder if you do not see the email within 5 minutes. The reset link expires after 24 hours for security reasons.'),

(2, 'Understanding Our Pricing Plans',
'Billing',
'We offer three pricing tiers: Basic ($10/month), Professional ($50/month), and Enterprise (custom pricing). Basic includes up to 5 users and 10GB storage. Professional includes up to 50 users and 100GB storage plus priority support. Enterprise includes unlimited users, storage, and dedicated account management.'),

(3, 'Troubleshooting Connection Issues',
'Technical Support',
'If you are experiencing connection problems, first check your internet connection. Try accessing other websites to confirm connectivity. Clear your browser cache and cookies. Try a different browser. If problems persist, check our status page for any ongoing incidents. Contact support if the issue continues.');

-- Generate embeddings for all articles
UPDATE knowledge_articles
SET content_embedding = SNOWFLAKE.CORTEX.EMBED_TEXT_1024(
    'snowflake-arctic-embed-l',
    content
);

-- Now we can do semantic search!
-- User asks: "I can't log into my account"
WITH user_query AS (
    SELECT SNOWFLAKE.CORTEX.EMBED_TEXT_1024(
        'snowflake-arctic-embed-l',
        'I cannot log into my account'
    ) as query_embedding
)
SELECT 
    ka.article_id,
    ka.title,
    ka.category,
    -- Calculate similarity using vector distance
    VECTOR_COSINE_SIMILARITY(
        ka.content_embedding,
        uq.query_embedding
    ) as similarity_score,
    LEFT(ka.content, 150) || '...' as content_preview
FROM knowledge_articles ka
CROSS JOIN user_query uq
ORDER BY similarity_score DESC
LIMIT 3;

Here’s what’s magic about this: the user said “I can’t log into my account” but the article is titled “How to Reset Your Password.” Traditional keyword search wouldn’t find this connection. Vector search understands that login problems often mean password issues.

Real Example: Similar Product Recommendations

-- Products with descriptions
CREATE OR REPLACE TABLE products (
    product_id STRING,
    name STRING,
    description TEXT,
    price DECIMAL(10,2),
    description_embedding VECTOR(FLOAT, 1024)
);

INSERT INTO products (product_id, name, description, price)
VALUES
('P001', 'Wireless Noise-Cancelling Headphones',
'Premium over-ear headphones with active noise cancellation. Perfect for travel and work. 30-hour battery life. Comfortable padding.',
299.99),

('P002', 'Bluetooth Earbuds with Charging Case',
'Compact wireless earbuds with touch controls. Comes with portable charging case. Great for workouts and commuting. 8-hour playtime.',
149.99),

('P003', 'Studio Monitor Speakers',
'Professional-grade speakers for music production. Flat frequency response. Ideal for mixing and mastering audio.',
599.99);

-- Generate embeddings
UPDATE products
SET description_embedding = SNOWFLAKE.CORTEX.EMBED_TEXT_1024(
    'snowflake-arctic-embed-l',
    description
);

-- Find similar products (given a user viewed P001)
WITH viewed_product AS (
    SELECT description_embedding
    FROM products
    WHERE product_id = 'P001'
)
SELECT 
    p.product_id,
    p.name,
    p.price,
    VECTOR_COSINE_SIMILARITY(
        p.description_embedding,
        vp.description_embedding
    ) as similarity_score
FROM products p
CROSS JOIN viewed_product vp
WHERE p.product_id != 'P001'  -- Exclude the viewed product itself
ORDER BY similarity_score DESC
LIMIT 3;

The wireless headphones and Bluetooth earbuds score high similarity (both are portable audio devices) while studio monitors score lower (different use case). This powers our “customers also viewed” feature.

CORTEX SEARCH – The Game Changer

This is the newest addition (fully released in late 2025) and it’s phenomenal. It’s a managed search service that handles all the complexity of vector search for you.

Real Example: Building a Document Search System

-- Create a table for company documents
CREATE OR REPLACE TABLE company_documents (
    doc_id STRING,
    title STRING,
    document_type STRING,
    content TEXT,
    created_date DATE,
    department STRING
);

-- Sample documents
INSERT INTO company_documents VALUES
('DOC-001', 'Employee Onboarding Guide', 'HR Policy',
'Welcome to the company! This guide covers your first 30 days. Week 1: Complete mandatory training modules, set up your workspace, meet your team. Week 2: Begin shadowing experienced team members, attend department orientation. Week 3-4: Start taking on small projects with supervision. You will have check-ins with your manager every Friday.',
'2026-01-01', 'Human Resources'),

('DOC-002', 'Remote Work Policy', 'HR Policy',
'Employees may work remotely up to 3 days per week with manager approval. Core hours (10 AM - 3 PM local time) require availability for meetings. Home office must meet security requirements - VPN required, physical document security, locked screens when away. Monthly stipend of $50 provided for internet costs.',
'2026-01-15', 'Human Resources'),

('DOC-003', 'Q1 Sales Strategy', 'Business Plan',
'Q1 focus areas: 1) Expand into healthcare vertical, 2) Launch new enterprise tier, 3) Improve customer retention (target 95%). Key initiatives: Hire 3 enterprise sales reps, develop healthcare-specific case studies, implement customer success program. Budget allocated: $500K for hiring, $100K for marketing.',
'2026-01-10', 'Sales');

-- Create Cortex Search Service
CREATE OR REPLACE CORTEX SEARCH SERVICE company_doc_search
ON content
WAREHOUSE = compute_wh
TARGET_LAG = '1 minute'
AS (
    SELECT
        doc_id,
        content,
        OBJECT_CONSTRUCT(
            'title', title,
            'document_type', document_type,
            'department', department,
            'created_date', created_date
        ) as metadata
    FROM company_documents
);

-- Search the documents
SELECT *
FROM TABLE(
    company_doc_search!SEARCH(
        QUERY => 'what is the remote work policy?',
        LIMIT => 3
    )
);

-- More specific search with filters
SELECT *
FROM TABLE(
    company_doc_search!SEARCH(
        QUERY => 'onboarding process',
        FILTER => {'department': 'Human Resources'},
        LIMIT => 5
    )
);

What makes Cortex Search special:

1. Hybrid search – Combines keyword matching with semantic search automatically
2. Auto-scaling – Handles query load without manual tuning
3. Near real-time – New documents searchable within the TARGET_LAG period
4. Metadata filtering – Combine semantic search with structured filters

We replaced our old Elasticsearch setup with this. Simpler to maintain, and honestly, the results are better.

Part 4: Document AI – The New Frontier

This is the newest category (rolled out throughout 2025) and it’s still expanding. These functions help process documents that aren’t just plain text.

PARSE_DOCUMENT – Extract Text from Files

Real Example: Processing Uploaded Invoices

-- Table to store uploaded documents
CREATE OR REPLACE TABLE uploaded_invoices (
    invoice_id STRING,
    vendor_name STRING,
    upload_date DATE,
    file_path STRING,  -- Path to file in Snowflake stage
    file_content BINARY  -- Or reference to stage
);

-- In practice, you'd load files into a Snowflake stage first
-- Then use PARSE_DOCUMENT to extract text

-- Example structure (actual implementation depends on your file storage)
SELECT 
    invoice_id,
    vendor_name,
    SNOWFLAKE.CORTEX.PARSE_DOCUMENT(
        file_path,
        {'document_type': 'invoice'}
    ) as extracted_data
FROM uploaded_invoices
WHERE upload_date >= CURRENT_DATE() - 7;

I haven’t used this one extensively yet (we’re still in testing phase), but early results are promising for extracting structured data from PDFs. Particularly useful for invoices, receipts, and forms.

CLASSIFY_TEXT – Automatic Categorization

Real Example: Email Routing

-- Incoming emails
CREATE OR REPLACE TABLE incoming_emails (
    email_id INTEGER,
    sender STRING,
    subject STRING,
    body TEXT,
    received_at TIMESTAMP_LTZ
);

INSERT INTO incoming_emails VALUES
(1, '[email protected]', 'Billing question',
'Hello, I was charged twice this month. Can you please check my account and refund the duplicate charge? My account number is 12345. Thank you.',
CURRENT_TIMESTAMP()),

(2, '[email protected]', 'Demo request',
'Hi, I am interested in learning more about your product. Can we schedule a demo next week? We are a team of 50 looking for a solution that handles X, Y, and Z.',
CURRENT_TIMESTAMP()),

(3, '[email protected]', 'Service outage',
'Your service has been down for 3 hours! This is completely unacceptable. We have a critical project deadline and cannot access our data. This is costing us money. I demand an explanation and compensation.',
CURRENT_TIMESTAMP());

-- Classify and route emails
SELECT 
    email_id,
    subject,
    SNOWFLAKE.CORTEX.COMPLETE(
        'llama3.1-70b',
        CONCAT(
            'Classify this email into ONE category: Support, Sales, Billing, Complaint, General. ',
            'Return only the category name.\n\nSubject: ', subject, '\nBody: ', body
        )
    ) as email_category,
    SNOWFLAKE.CORTEX.COMPLETE(
        'llama3.1-70b',
        CONCAT(
            'Rate the urgency of this email: Low, Medium, High, Critical. ',
            'Return only the urgency level.\n\nSubject: ', subject, '\nBody: ', body
        )
    ) as urgency_level,
    SNOWFLAKE.CORTEX.SENTIMENT(body) as sentiment_score
FROM incoming_emails;

We built an automated email router using this. It categorizes incoming emails, assigns priority, and routes to the right department. Reduced mis-routed emails by 70%.

Part 5: Real-World Applications (What We Built)

Let me show you some complete applications we’ve built using Cortex functions together.

Application 1: Intelligent Customer Support System

This combines multiple Cortex functions to create a smart support ticket handler.

-- Complete ticket processing pipeline
WITH ticket_analysis AS (
    SELECT 
        ticket_id,
        subject,
        message,
        -- Categorize the ticket
        SNOWFLAKE.CORTEX.COMPLETE(
            'llama3.1-70b',
            CONCAT('Categorize this support ticket into ONE category: ',
                   'Technical Issue, Billing Question, Feature Request, Account Access, General Inquiry. ',
                   'Return only the category.\n\nSubject: ', subject, '\nMessage: ', message)
        ) as category,
        -- Assess urgency
        SNOWFLAKE.CORTEX.COMPLETE(
            'llama3.1-8b',
            CONCAT('Rate urgency as: Low, Medium, High, or Urgent. ',
                   'Return only the urgency level.\n\nSubject: ', subject, '\nMessage: ', message)
        ) as urgency,
        -- Analyze sentiment
        SNOWFLAKE.CORTEX.SENTIMENT(message) as sentiment_score,
        -- Generate suggested response
        SNOWFLAKE.CORTEX.COMPLETE(
            'llama3.1-70b',
            CONCAT('Generate a professional, helpful response to this support ticket. ',
                   'Be empathetic and provide clear next steps.\n\n',
                   'Subject: ', subject, '\nMessage: ', message)
        ) as suggested_response
    FROM support_tickets
)
SELECT 
    ticket_id,
    subject,
    category,
    urgency,
    CASE 
        WHEN sentiment_score < -0.5 THEN '🔴 Very Unhappy Customer'
        WHEN sentiment_score < 0 THEN '🟡 Frustrated'
        ELSE '🟢 Neutral/Positive'
    END as customer_mood,
    suggested_response,
    -- Route to appropriate team
    CASE category
        WHEN 'Technical Issue' THEN '[email protected]'
        WHEN 'Billing Question' THEN '[email protected]'
        WHEN 'Account Access' THEN '[email protected]'
        ELSE '[email protected]'
    END as route_to
FROM ticket_analysis;

This single query processes a ticket through multiple AI functions and outputs everything our support team needs: category, urgency, customer sentiment, a suggested response draft, and the correct routing. What used to take 5-10 minutes per ticket now happens instantly.

Application 2: Content Moderation System

We run a platform where users post reviews. Before Cortex, we had basic keyword filtering. Now we have intelligent moderation:

-- User-generated content table
CREATE OR REPLACE TABLE user_posts (
    post_id INTEGER,
    user_id STRING,
    post_content TEXT,
    posted_at TIMESTAMP_LTZ
);

INSERT INTO user_posts VALUES
(1, 'user123', 
'This product is amazing! Best purchase I have made all year. The quality is outstanding and customer service was helpful when I had questions.',
CURRENT_TIMESTAMP()),

(2, 'user456',
'Complete garbage. Do not waste your money. The company is full of liars and thieves. I am reporting them to the BBB.',
CURRENT_TIMESTAMP()),

(3, 'user789',
'Decent product but a bit overpriced. Works as described. Shipping took longer than expected but arrived safely. Would recommend waiting for a sale.',
CURRENT_TIMESTAMP());

-- Moderation pipeline
WITH content_check AS (
    SELECT 
        post_id,
        user_id,
        post_content,
        -- Check for inappropriate content
        SNOWFLAKE.CORTEX.COMPLETE(
            'llama3.1-70b',
            CONCAT('Analyze this user post for: profanity, personal attacks, spam, or inappropriate content. ',
                   'Return a JSON object with: {has_issues: true/false, issue_type: "profanity/attack/spam/none", severity: "low/medium/high/none"}. ',
                   'Return ONLY valid JSON, nothing else.\n\nPost: ', post_content)
        ) as moderation_result,
        -- Sentiment analysis
        SNOWFLAKE.CORTEX.SENTIMENT(post_content) as sentiment_score,
        -- Helpfulness assessment
        SNOWFLAKE.CORTEX.COMPLETE(
            'llama3.1-8b',
            CONCAT('Rate how helpful this review would be to other customers. ',
                   'Return only: Very Helpful, Somewhat Helpful, or Not Helpful.\n\nReview: ', post_content)
        ) as helpfulness_rating
    FROM user_posts
)
SELECT 
    post_id,
    user_id,
    LEFT(post_content, 100) || '...' as content_preview,
    TRY_PARSE_JSON(moderation_result) as moderation_flags,
    sentiment_score,
    helpfulness_rating,
    -- Decision logic
    CASE 
        WHEN TRY_PARSE_JSON(moderation_result):severity::STRING = 'high' 
            THEN '❌ Auto-reject'
        WHEN TRY_PARSE_JSON(moderation_result):severity::STRING = 'medium' 
            THEN '⚠️ Flag for review'
        WHEN sentiment_score < -0.7 AND helpfulness_rating = 'Not Helpful'
            THEN '⚠️ Flag for review'
        ELSE '✅ Approve'
    END as moderation_action
FROM content_check;

This catches about 95% of problematic content automatically. The remaining 5% gets flagged for human review. Before this, we had to manually review everything—it was taking hours per day.

Application 3: Market Intelligence System

We track competitor mentions and market trends from various data sources:

-- News articles and social mentions
CREATE OR REPLACE TABLE market_mentions (
    mention_id INTEGER,
    source STRING,
    content TEXT,
    published_date DATE
);

INSERT INTO market_mentions VALUES
(1, 'TechNews', 
'Company X announced their new AI features today, including automated data analysis and predictive modeling. Industry analysts predict this could disrupt the traditional analytics market. The stock rose 15% on the news.',
'2026-01-20'),

(2, 'Twitter',
'Just tried Company Y new product. Interface is clunky and slow. Missing basic features that competitors have had for years. Not impressed.',
'2026-01-21'),

(3, 'Industry Report',
'Market analysis shows growing demand for embedded AI in data platforms. Customers prioritize ease of use over raw power. Companies offering no-code AI solutions gaining market share rapidly.',
'2026-01-22');

-- Extract market intelligence
WITH intelligence_extraction AS (
    SELECT 
        mention_id,
        source,
        published_date,
        content,
        -- Extract companies mentioned
        SNOWFLAKE.CORTEX.COMPLETE(
            'llama3.1-70b',
            CONCAT('List all company names mentioned in this text. ',
                   'Return as comma-separated list, or "none" if no companies mentioned.\n\nText: ', content)
        ) as companies_mentioned,
        -- Extract key topics
        SNOWFLAKE.CORTEX.COMPLETE(
            'llama3.1-70b',
            CONCAT('Extract 3 main topics or themes from this text. ',
                   'Return as comma-separated list.\n\nText: ', content)
        ) as key_topics,
        -- Sentiment about market/products
        SNOWFLAKE.CORTEX.SENTIMENT(content) as overall_sentiment,
        -- Extract competitive insights
        SNOWFLAKE.CORTEX.COMPLETE(
            'llama3.1-70b',
            CONCAT('Summarize any competitive advantages, product features, or market trends mentioned. ',
                   'Be specific and concise (2-3 sentences max).\n\nText: ', content)
        ) as competitive_insights
    FROM market_mentions
)
SELECT 
    mention_id,
    source,
    published_date,
    companies_mentioned,
    key_topics,
    ROUND(overall_sentiment, 3) as sentiment,
    competitive_insights
FROM intelligence_extraction
ORDER BY published_date DESC;

We run this daily on thousands of mentions. It’s how our product team stays on top of market trends without manually reading everything. The insights feed directly into our roadmap planning.

Application 4: Smart Data Quality Checker

This one’s a bit different—using Cortex to improve data quality:

-- Customer data with potential issues
CREATE OR REPLACE TABLE customer_data (
    customer_id STRING,
    company_name STRING,
    industry STRING,
    contact_email STRING,
    phone STRING,
    address TEXT
);

INSERT INTO customer_data VALUES
('C001', 'Acme Corp', 'Manufacturing', '[email protected]', '555-0123', '123 Main St, Springfield'),
('C002', 'TechStart Inc.', 'Tech Startup', '[email protected]', '5551234567', 'San Francisco, CA'),
('C003', 'ABC Company', 'Retail', '[email protected]', '555.987.6543', '456 Oak Avenue, New York, NY 10001');

-- Data quality assessment using AI
SELECT 
    customer_id,
    company_name,
    -- Validate industry classification
    SNOWFLAKE.CORTEX.COMPLETE(
        'llama3.1-8b',
        CONCAT('Given this company name: "', company_name, '". ',
               'Is "', industry, '" a reasonable industry classification? ',
               'Answer only: Valid, Questionable, or Invalid with brief reason.')
    ) as industry_validation,
    -- Suggest standardized industry
    SNOWFLAKE.CORTEX.COMPLETE(
        'llama3.1-8b',
        CONCAT('What standard industry category best fits: "', company_name, '"? ',
               'Choose from: Technology, Manufacturing, Retail, Healthcare, Finance, Services, Other. ',
               'Return only the category name.')
    ) as suggested_industry,
    -- Check address completeness
    SNOWFLAKE.CORTEX.COMPLETE(
        'llama3.1-8b',
        CONCAT('Is this a complete mailing address with street, city, and state/ZIP? "', address, '". ',
               'Answer: Complete, Incomplete, or Needs Review. Explain briefly.')
    ) as address_quality,
    -- Suggest phone format standardization
    SNOWFLAKE.CORTEX.COMPLETE(
        'llama3.1-8b',
        CONCAT('Convert this phone number to standard format (XXX) XXX-XXXX: "', phone, '". ',
               'Return only the formatted number or "Invalid" if cannot format.')
    ) as standardized_phone
FROM customer_data;

This helps us clean up messy imported data. The AI understands context—it knows “TechStart Inc.” is probably a technology company even if it was miscategorized.

Part 6: Cost Management and Optimization

Let me be real with you—Cortex functions cost money. Here’s what I’ve learned about managing costs:

Understanding the Pricing Model

Cortex uses credit-based pricing. Different functions consume different amounts:

• Small models (8b): Cheapest, ~0.0001 credits per token
• Large models (70b): More expensive, ~0.0005 credits per token
• Embeddings: ~0.00002 credits per token
• Sentiment: Fixed small cost per call

The actual costs vary, so check Snowflake’s current pricing.

Cost Optimization Strategies That Actually Work

Strategy 1: Response Caching

-- Create a cache table for common queries
CREATE OR REPLACE TABLE llm_response_cache (
    query_hash STRING PRIMARY KEY,
    query_text STRING,
    response_text STRING,
    model_used STRING,
    created_at TIMESTAMP_LTZ,
    hit_count INTEGER DEFAULT 1
);

-- Function to check cache before calling LLM
CREATE OR REPLACE FUNCTION get_cached_or_generate(
    prompt STRING,
    model STRING
)
RETURNS STRING
LANGUAGE SQL
AS
$$
    SELECT COALESCE(
        -- Try to get from cache
        (SELECT response_text 
         FROM llm_response_cache 
         WHERE query_hash = SHA2(prompt || model)
         AND created_at >= DATEADD(day, -7, CURRENT_TIMESTAMP())
         LIMIT 1),
        -- Generate new response if not cached
        SNOWFLAKE.CORTEX.COMPLETE(model, prompt)
    )
$$;

We implemented this and cut our Cortex costs by 40%. Turns out, many queries are repeated (like categorizing support tickets that have similar wording).

Strategy 2: Use Smaller Models When Possible

-- Smart model selection based on task complexity
CREATE OR REPLACE FUNCTION smart_complete(
    prompt STRING,
    complexity STRING  -- 'simple', 'medium', 'complex'
)
RETURNS STRING
LANGUAGE SQL
AS
$$
    SELECT 
        CASE complexity
            WHEN 'simple' THEN SNOWFLAKE.CORTEX.COMPLETE('llama3.1-8b', prompt)
            WHEN 'medium' THEN SNOWFLAKE.CORTEX.COMPLETE('mixtral-8x7b', prompt)
            ELSE SNOWFLAKE.CORTEX.COMPLETE('llama3.1-70b', prompt)
        END
$$;

-- Usage examples
SELECT 
    ticket_id,
    -- Simple task: use small model
    smart_complete(
        'Categorize as: Bug, Feature, Question. Return category only.\n' || message,
        'simple'
    ) as category,
    -- Complex task: use large model
    smart_complete(
        'Write detailed response addressing all concerns raised:\n' || message,
        'complex'
    ) as response
FROM support_tickets;

The 8b model is 5x cheaper than the 70b model. For simple classification or extraction tasks, it works just as well.

Strategy 3: Batch Processing

-- Instead of processing one at a time, batch them
-- Bad: Real-time processing on every insert
-- Good: Batch process every 5 minutes

CREATE OR REPLACE TASK batch_sentiment_analysis
    WAREHOUSE = compute_wh
    SCHEDULE = '5 MINUTE'
AS
    UPDATE product_reviews
    SET 
        sentiment_score = SNOWFLAKE.CORTEX.SENTIMENT(review_text),
        last_analyzed = CURRENT_TIMESTAMP()
    WHERE sentiment_score IS NULL
    AND review_date >= DATEADD(hour, -1, CURRENT_TIMESTAMP());

ALTER TASK batch_sentiment_analysis RESUME;

Batching lets you use smaller warehouses and reduces per-call overhead.

Strategy 4: Monitor and Alert

-- Track Cortex usage
CREATE OR REPLACE TABLE cortex_usage_tracking (
    date DATE,
    function_name STRING,
    call_count INTEGER,
    estimated_cost DECIMAL(10,4)
);

-- Daily summary (run as scheduled task)
INSERT INTO cortex_usage_tracking
SELECT 
    CURRENT_DATE() as date,
    'COMPLETE' as function_name,
    COUNT(*) as call_count,
    COUNT(*) * 0.001 as estimated_cost  -- Rough estimate
FROM support_tickets
WHERE analyzed_at >= CURRENT_DATE();

-- Alert if costs spike
SELECT 
    date,
    SUM(estimated_cost) as daily_cost,
    CASE 
        WHEN SUM(estimated_cost) > 100 THEN '⚠️ High usage day'
        ELSE '✅ Normal'
    END as cost_status
FROM cortex_usage_tracking
WHERE date >= DATEADD(day, -7, CURRENT_DATE())
GROUP BY date
ORDER BY date DESC;

We set up Slack alerts when daily Cortex costs exceed our threshold. Catches issues early.

Part 7: Common Pitfalls and How to Avoid Them

I’ve made plenty of mistakes with Cortex. Here are the big ones:

Pitfall 1: Not Handling NULL Values

-- Bad: This will fail on NULL values
SELECT 
    SNOWFLAKE.CORTEX.SENTIMENT(review_text)
FROM reviews;

-- Good: Defensive coding
SELECT 
    CASE 
        WHEN review_text IS NULL OR LENGTH(TRIM(review_text)) < 10
        THEN NULL
        ELSE SNOWFLAKE.CORTEX.SENTIMENT(review_text)
    END as sentiment_score
FROM reviews;

Always add NULL checks. We had a production incident where NULL values caused a whole batch to fail.

Pitfall 2: Not Validating AI Outputs

-- Bad: Blindly trusting AI outputs
SELECT 
    SNOWFLAKE.CORTEX.COMPLETE('llama3.1-8b', 
        'Categorize as: Bug, Feature, Question. Return only the category.\n' || message
    ) as category
FROM tickets;

-- Good: Validate and have fallback
SELECT 
    ticket_id,
    CASE 
        WHEN ai_category IN ('Bug', 'Feature', 'Question') THEN ai_category
        ELSE 'Needs Review'
    END as validated_category
FROM (
    SELECT 
        ticket_id,
        SNOWFLAKE.CORTEX.COMPLETE('llama3.1-70b', 
            'Categorize as: Bug, Feature, Question. Return ONLY one of these three words.\n' || message
        ) as ai_category
    FROM tickets
);

AI models sometimes hallucinate or don’t follow instructions perfectly. Always validate outputs.

Pitfall 3: Ignoring Token Limits

-- Bad: Trying to process huge documents
SELECT 
    SNOWFLAKE.CORTEX.SUMMARIZE(entire_book_text)  -- May fail or truncate
FROM documents;

-- Good: Chunk large documents first
WITH chunked_docs AS (
    SELECT 
        doc_id,
        chunk.value::STRING as chunk_text
    FROM documents,
    LATERAL FLATTEN(
        input => SNOWFLAKE.CORTEX.SPLIT_TEXT_RECURSIVE_CHARACTER(
            entire_book_text,
            2000  -- Reasonable chunk size
        )
    ) chunk
)
SELECT 
    doc_id,
    LISTAGG(
        SNOWFLAKE.CORTEX.SUMMARIZE(chunk_text),
        '\n\n'
    ) as comprehensive_summary
FROM chunked_docs
GROUP BY doc_id;

Most models have token limits (typically 8K-32K tokens). Break large content into chunks.

Pitfall 4: Not Testing Prompts

-- Create a test dataset for prompt engineering
CREATE OR REPLACE TABLE prompt_testing (
    test_id INTEGER,
    test_input STRING,
    expected_output STRING,
    actual_output STRING,
    prompt_version STRING
);

-- Test different prompts
INSERT INTO prompt_testing (test_id, test_input, expected_output, prompt_version)
VALUES
(1, 'I cannot login', 'Account Access', 'v1'),
(2, 'Billing question about charges', 'Billing', 'v1'),
(3, 'Feature does not work', 'Bug', 'v1');

-- Run tests with different prompt versions
UPDATE prompt_testing
SET actual_output = SNOWFLAKE.CORTEX.COMPLETE(
    'llama3.1-70b',
    CONCAT('Categorize this support ticket into ONE category: ',
           'Bug, Feature Request, Billing, Account Access, General. ',
           'Return ONLY the category name, nothing else.\n\nTicket: ', test_input)
)
WHERE prompt_version = 'v1';

-- Check accuracy
SELECT 
    prompt_version,
    COUNT(*) as total_tests,
    SUM(CASE WHEN actual_output = expected_output THEN 1 ELSE 0 END) as correct,
    ROUND(SUM(CASE WHEN actual_output = expected_output THEN 1 ELSE 0 END) * 100.0 / COUNT(*), 2) as accuracy_pct
FROM prompt_testing
GROUP BY prompt_version;

We maintain a test suite of 100+ examples. Every time we modify a prompt, we run the tests. Catches regressions immediately.

Wrapping Up: Is Cortex Worth It?

After six months of heavy Cortex usage, here’s my honest take:

The Good:

• Dramatically lowers barrier to AI adoption
• No infrastructure to manage
• Data stays in Snowflake (huge security win)
• SQL interface means anyone on data team can use it
• Costs are predictable and controllable
• Actually works reliably at scale

The Challenges:

• Still need prompt engineering skills
• Costs can creep up if not monitored
• Not as flexible as custom ML models for specialized needs
• Some functions still maturing (Document AI, fine-tuning)
• Need to validate AI outputs carefully

Bottom Line:
If you already use Snowflake and have use cases for AI/ML, Cortex is absolutely worth exploring. Start small—pick one painful manual process and automate it. See the results. Then expand.

We’ve eliminated entire manual workflows, improved data quality, and built features that would have required a dedicated ML team. All with SQL and Cortex functions.

The future of data platforms is built-in AI. Cortex is leading that charge, and it’s only getting better.

Additional Resources

Official Documentation:

• Snowflake Cortex Documentation
• Cortex LLM Functions Reference
• Cortex Search Guide

Frequently Asked Questions

Q: Do I need to know Python or machine learning to use Cortex?
A: Nope. If you know SQL, you can use Cortex. That’s the whole point.

Q: How much does it cost?
A: Varies by function and model. Start small and monitor costs. In our experience, most use cases cost $0.01-$0.10 per operation. Check Snowflake’s pricing page for current rates.

Q: Can I use my own custom models?
A: Not yet, but fine-tuning capabilities are coming. Currently you work with Snowflake’s provided models.

Q: Is my data used to train models?
A: No. Your data stays private and is not used to train or improve models.

Q: What about data residency and compliance?
A: Cortex respects your Snowflake account’s data residency settings. Data processing happens in your region.

Q: Can I use this for sensitive data?
A: Yes, but review your compliance requirements. Cortex operates within Snowflake’s security boundary, which is SOC 2, HIPAA, and other compliance-certified.

Q: How do I handle errors?
A: Use TRY_PARSE_JSON for JSON outputs, implement NULL checks, and always have fallback logic for critical workflows.

Q: What if the AI generates incorrect results?
A: Always implement validation logic. For critical applications, use human-in-the-loop review for a sample of outputs.