Forem: Tsubasa Kanno

Supercharge Cortex Code CLI - A Practical Guide to Skills, SubAgents, Hooks and MCP

Tsubasa Kanno — Tue, 31 Mar 2026 16:25:40 +0000

Introduction

I was originally a Cursor user for AI-assisted coding. But as someone who works with Snowflake data and features daily, I realized how powerful it is to have an AI agent that natively connects to Snowflake's data, functions, and catalog — living right in your terminal. That's when I made Cortex Code CLI (CoCo CLI for short) my primary tool.

As I used CoCo CLI more, I wanted an agent that could work more autonomously. CoCo CLI offers extensive customization capabilities, and I've gone deep — defining 7 custom skills, 5 custom subagents, quality-check hooks with Slack notifications, and MCP integrations with external tools. The result has been a dramatic improvement in my day-to-day productivity.

This article won't cover CoCo CLI basics or installation — for those, check out the official documentation. Instead, I'll dive into the 4 extensibility features (Skills, SubAgents, Hooks, MCP) and AGENTS.md, sharing tips from the official docs combined with practical insights from my own experience.

Note: This article contains many opinions based on my personal experience. This is not an official Snowflake statement, and customization methods or best practices may change with future updates.

The Big Picture of CoCo CLI Extensibility

CoCo CLI customization breaks down into two categories:

AGENTS.md — A Markdown file placed at the project root that communicates project-specific rules and constraints to the agent (Official docs: Cortex Code)
4 Extensibility Features — Mechanisms documented on the official Extensibility page that extend the agent's capabilities

Here's a summary of each feature's role:

Feature	Role	Scope	Format
AGENTS.md	Communicate project-specific rules & constraints	Project	Markdown
Skills	Inject domain-specific expertise & workflows	Project / Global	YAML frontmatter + Markdown
SubAgents	Delegate tasks to independent specialized agents	Project / Global	YAML frontmatter + Markdown
Hooks	Intercept lifecycle events for custom control	Project / Global	JSON + Shell scripts
MCP	Add external tool & service integrations	Global	JSON

Let's explore each feature in detail.

AGENTS.md — Injecting Project Rules

Overview

AGENTS.md is a Markdown file placed at the project root that communicates project-specific rules and coding conventions to the CoCo CLI agent. (Official docs: Cortex Code)

AGENTS.md is separate from the 4 extensibility features (Skills, SubAgents, Hooks, MCP) on the Extensibility page. While extensibility features extend the agent's capabilities, AGENTS.md defines the agent's behavioral guidelines.

Attribute	Details
Location	Project root directory
Format	Free-form Markdown
Loading	Auto-loaded at session start
Effect	Improves agent response quality & consistency

Basic Usage

Simply create an AGENTS.md file in your project root:

# Project Rules

## Coding Standards
- Follow Black formatter for Python code style
- Always include type hints
- Use Google-style docstrings

## Snowflake-Specific Rules
- Write SQL in uppercase
- Use full paths for table names: `DB.SCHEMA.TABLE`
- Use `MY_WH` warehouse

## Testing
- Run tests with pytest: `pytest tests/ -v`
- Maintain 80%+ coverage

Tip: Adding AGENTS.md dramatically improves agent responses. For team development, documenting coding standards and project rules in AGENTS.md ensures consistent AI-assisted quality across all team members.

Effective AGENTS.md Structure

Here's the structure pattern I use in practice:

# Project Overview
(Brief description of purpose and architecture)

# Directory Structure
(Key directories and file roles)

# Tech Stack
(Languages, frameworks, tools)

# Coding Standards (Do)
(Style guide, naming conventions, comment policy)

# Don'ts
(Secrets handling, destructive SQL prohibition, direct production access ban)

# Snowflake-Specific Settings
(Connection info, default warehouse/role, naming conventions)

# Testing & Quality
(Test commands, lint commands, CI/CD notes)

# Custom Skills & SubAgents Guide
(Names and purposes of custom skills/subagents used in the project)

TIPS: Making AGENTS.md Work Effectively

AGENTS.md can also be placed at .cortex/AGENTS.md or in subdirectories, and you can use multiple files. However, keep these points in mind:

AGENTS.md is an Instruction at the start of task execution. Writing too many rules tends to dilute compliance. Focus on high-priority items and keep it concise.
Explicit Do / Don't sections are effective. Clearly separating "what to do" from "what not to do" improves the agent's decision accuracy.
Include directory structure. Documenting your project's folder structure helps the agent choose appropriate file locations.
Add a custom skills/subagents guide. Listing names, purposes, and invocation methods of your custom skills/subagents helps the agent use them at the right time.

Important: AGENTS.md is just an Instruction — there's no guarantee the agent will always follow it. For higher compliance rates, clear and concise writing is key. To enforce rules, consider using Hooks (e.g., PreToolUse to block dangerous operations).

Since CoCo CLI is natively integrated with Snowflake, leveraging Snowflake governance features like RBAC (roles), masking policies, and Row Access Policies for data access control is highly effective. Rather than writing "don't directly modify production tables" in AGENTS.md, simply restricting write permissions via roles is far more reliable. Soft guidelines in AGENTS.md, hard enforcement via Hooks and Snowflake governance — this separation is another strength of CoCo CLI.

Skills — Injecting Domain Knowledge

Official docs: Extensibility - Skills

Overview

Skills are Markdown files that define domain-specific expertise and workflows, injected into the agent's context when needed. For example, "demo environment setup procedures," "periodic report creation workflows," or "PoC documentation templates" — by defining frequently-used business workflows as skills, you eliminate the need to instruct from scratch every time.

There are 2 ways to invoke skills:

Explicit invocation — Use the $skill-name prefix to directly specify a skill
Automatic activation — The agent matches your question against skill description fields and auto-loads relevant skills

Many built-in skills have a [REQUIRED] tag, causing them to activate automatically when questions hit their domain. For instance, simply typing "I want to create a Dynamic Table pipeline" automatically loads the dynamic-tables skill with specialized guidance.

Skill Locations

Skills are loaded from multiple locations (highest to lowest priority). (Official docs: Extensibility)

Scope	Path	Description
Project	`.cortex/skills/` or `.claude/skills/`	Project-specific
User	`~/.snowflake/cortex/skills/` or `~/.claude/skills/`	User-specific
Global	`~/.snowflake/cortex/skills/`	Shared across all projects
Session	Added temporarily during session	Disappears when session ends
Remote	Cloned from Git repository	Cached
Bundled	Built into CoCo CLI	Official Snowflake skills

Custom skill creation directories are also documented as .cortex/commands/ or .claude/commands/.

Creating SKILL.md

Skills are Markdown files named SKILL.md with YAML frontmatter at the top:

---
name: my-custom-skill
description: "Description of this skill (shown in skill listings)"
tools:
  - snowflake_sql_execute
  - snowflake_object_search
  - web_search
---

# Purpose
(What this skill does)

# Prerequisites
(Required environment/data for execution)

# Workflow
1. Step 1: ...
2. Step 2: ...
3. Step 3: ...

# Output
(Expected deliverables)

Frontmatter	Required	Description
`name`	Yes	Unique identifier
`description`	Yes	Skill description (shown in `/skill list`)
`tools`	No	Tools to enable when skill is active

CLI Commands

cortex skill list
cortex skill add /path/to/.cortex/skills/my-skill
cortex skill add https://github.com/org/my-skills.git
cortex skill remove /path/to/.cortex/skills/my-skill

Invoking Skills in a Session

There are two main approaches — explicit invocation and automatic activation:

Method	Action	Description
Skill listing	Type `/skill` or `$` in session	Shows available skill candidates
Explicit invocation	`$skill-name instruction`	Loads the specified skill and executes the task
Auto-activation	Just ask your question normally	Agent auto-selects skills matching the `description`

$demo-builder Set up a demo environment
$code-review Review @src/app.py following $security-guidelines

For auto-activation, you don't need to specify skill names. Many built-in skills have [REQUIRED] tags and automatically load when relevant domain questions are asked.

> I want to create a Streamlit app
→ developing-with-streamlit skill auto-activates

> Analyze my costs
→ cost-intelligence skill auto-activates

Tip: Use cortex skill list from outside a session to check available skills. Before creating custom skills, explore what's already built-in.

Built-in Skills

CoCo CLI ships with 33 built-in skills covering major Snowflake capabilities (as of v1.0.45). From data engineering to governance, ML, and cost analysis — everything is ready out of the box, making it one of CoCo CLI's biggest strengths.

Category	Skills
Data Foundation	`dynamic-tables`, `iceberg`, `lineage`, `data-quality`
Development	`developing-with-streamlit`, `build-react-app`, `snowpark-python`, `snowpark-connect`, `snowflake-notebooks`, `dbt-projects-on-snowflake`
AI / ML	`cortex-agent`, `cortex-ai-functions`, `semantic-view`, `machine-learning`
Governance / Security	`data-governance`, `trust-center`, `network-security`, `key-and-secret-management`
Operations / Cost	`cost-intelligence`, `workload-performance-analysis`, `organization-management`
Data Sharing	`data-cleanrooms`, `declarative-sharing`, `internal-marketplace-org-listing`
Infrastructure	`deploy-to-spcs`, `integrations`, `openflow`, `snowflake-postgres`
Migration / Admin	`snowconvert-assessment`, `dcm`, `dashboard`, `skill-development`, `cortex-code-guide`

Built-in skills may change with CoCo CLI version updates. The above list is as of v1.0.45. Check the latest with cortex skill list.

Practical Example: Demo Environment Builder Skill

Here's an example skill for building customer demo environments:

---
name: demo-builder
description: "Build and clean up Snowflake demo environments"
tools:
  - snowflake_sql_execute
  - snowflake_object_search
  - web_search
---

# Demo Builder Skill

## Goal
Build and manage Snowflake demo environments tailored to
customer use cases, in a reproducible manner.

## Workflow
### Phase 1: Requirements
Confirm demo theme, target features, and required datasets.

### Phase 2: Environment Setup
Create DB/schema/warehouse, load sample data,
deploy Streamlit apps as needed.

### Phase 3: Verification
Test all queries/apps and create demo scenarios.

### Phase 4: Cleanup
Generate scripts to safely tear down the environment post-demo.

With this skill defined, simply invoking $demo-builder Set up a Cortex AI demo kicks off the entire workflow automatically.

SubAgents — Specialized Agent Delegation

Official docs: Extensibility - Subagents

Overview

SubAgents are independent, specialized AI agents that operate separately from the main agent. Each can have its own model, tools, and prompts, with parallel execution support.

Feature	Description
Independence	Operates in separate context from main agent
Specialization	Specify optimal model and tools per task
Parallel execution	Up to 50 concurrent agents
Worktree Isolation	Isolate changes using Git worktrees

Built-in SubAgents

CoCo CLI includes these built-in subagent types: (Official docs: Extensibility)

Type	Purpose
`general-purpose`	Full tool access, general-purpose agent
`explore`	Codebase exploration specialist (`quick` / `medium` / `very thorough`)
`plan`	Implementation planning & design
`feedback`	Structured feedback collection

Creating Custom SubAgents

SubAgents are defined as .md files:

Scope	Path
Project	`.cortex/agents/<name>.md` or `.claude/agents/<name>.md`
Global	`~/.snowflake/cortex/agents/<name>.md`
User	`~/.claude/agents/<name>.md`

Agent Definition Example

---
name: critic-reviewer
description: "Performs critical review from code quality and best practices perspective"
tools:
  - Read
  - Grep
  - Glob
  - Bash
model: openai-gpt-5.2
---

# Critic Reviewer Agent

You are a senior software engineer performing code reviews.

## Review Criteria
1. Code readability & maintainability
2. Performance bottlenecks
3. Security concerns
4. Error handling adequacy

## Output Format
- 🔴 Critical: Must fix
- 🟡 Warning: Recommended fix
- 🟢 Info: Room for improvement

Model Selection — The Greatest Strength of SubAgents

Custom subagents let you specify a model per agent via the model field. This is SubAgents' greatest strength.

model: claude-opus-4-6     # For high-accuracy tasks
model: claude-sonnet-4-6   # For lightweight, fast tasks
model: openai-gpt-5.2      # Leverage different model perspectives
model: auto                # Cost-optimized auto-selection

TIPS: Cross-model diversity improves quality

When your main agent uses claude-opus-4-6, deliberately assigning openai-gpt-5.2 to your review subagent enables critical review from a different model's perspective. A different model family can catch blind spots and mistakes that the same model tends to miss.

Meanwhile, for simpler tasks like knowledge curation or log summarization, assigning a lightweight model like claude-sonnet-4-6 keeps costs down while boosting overall throughput.

Use Case	Model Selection Strategy
Main agent	High-accuracy model (`claude-opus-4-6`, etc.)
Critical review	Deliberately use a different model family (`openai-gpt-5.2`, etc.) for diverse perspectives
Knowledge curation / summarization	Lightweight model (`claude-sonnet-4-6`, etc.) for cost efficiency
Exploration / research	`auto` for cost optimization

Session-wide model can also be overridden via the CORTEX_AGENT_MODEL environment variable. (Official docs: Settings)

Invocation

# Auto-delegation (agent decides)
> Search all test files under src/

# Explicit specification
> Use the Explore agent to find all SQL files

# Parallel execution
> In parallel, search for test files and check config files

# Background execution
> Run a background agent to refactor the code

# Worktree Isolation (runs in an isolated git branch)
> Implement feature X with worktree isolation

# Agent management
/agents                    # Agent list (Ctrl-B also works)
> Get the output from agent abc1234
> kill agent abc1234
> Resume agent abc1234 and continue from where it left off

Practical Example: Specialized Agent Configuration

Here's my setup with purpose-specific agents:

Agent	Model	Purpose
critic-reviewer	`openai-gpt-5.2`	Critical review using a different model from main
research-analyst	`auto`	Web research & document analysis
code-implementer	`claude-opus-4-6`	Complex code implementation
qa-validator	`claude-opus-4-6`	Test design & execution
knowledge-curator	`claude-sonnet-4-6`	Knowledge organization & documentation

Hooks — Lifecycle Control

Official docs: Extensibility - Hooks

Overview

Hooks execute custom logic at key lifecycle points in CoCo CLI.

Personally, I consider Hooks the most important of the four extensibility features. As AI agents evolve, we'll increasingly delegate tasks asynchronously. But this creates common pain points:

Unaware — The agent finishes work, but the user doesn't notice and leaves it idle
Stuck — The agent is waiting for user input, but the user doesn't realize it's blocked
Settling — The agent produces low-quality output and completes without improvement

Hooks address these challenges. For example:

Send Slack notifications on Notification events so you never miss an input request or completion
Run quality checks on Stop events and force the agent to continue if results don't meet standards

Hooks have many configuration options and may require some trial-and-error to get the behavior you want. But they're incredibly powerful — I personally receive Slack notifications to issue next instructions and use quality-check hooks to force the agent to self-review and elevate output quality, achieving a truly "set it and forget it" workflow.

Configuration File Locations

Hooks are configured in the following locations (highest to lowest priority):

Scope	Path
Local (highest)	`.cortex/settings.local.json` or `.claude/settings.local.json`
Project	`.cortex/settings.json` or `.claude/settings.json`
User	`~/.claude/settings.json`
Global	`~/.snowflake/cortex/hooks.json`

Available Events

The 11 hook events defined in official docs:

Event	Timing	Can Block?
`PreToolUse`	Before tool execution	Yes
`PostToolUse`	After successful tool execution	No
`PermissionRequest`	When permission is needed	Yes
`UserPromptSubmit`	When user submits prompt	No
`SessionStart`	When session starts	No
`SessionEnd`	When session ends	No
`PreCompact`	Before context compaction	No
`Stop`	When agent response completes	No
`SubagentStop`	When subagent completes	No
`Notification`	On notification (e.g., waiting for user input)	No
`Setup`	During initialization	No

Hook Types

Two types of hooks are available: (Official docs: Extensibility)

Type	Description	Example
`command`	Execute shell commands	`bash /path/to/script.sh`
`prompt`	Evaluate natural language prompt via LLM	`Is this command safe? $ARGUMENTS`

Exit Code Semantics

Hook script exit codes control CoCo CLI behavior:

Exit Code	Meaning	Behavior
0	Success	Process stdout JSON and continue
2	Block	stderr / JSON `reason` sent to agent; operation blocked
Other	Error	Non-blocking. stderr shown only in verbose mode; execution continues

Configuration Format

Example hooks.json:

{
  "hooks": {
    "Stop": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "bash /path/to/hooks/quality_review.sh",
            "timeout": 60
          }
        ]
      }
    ],
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": "bash /path/to/hooks/validate_bash.sh",
            "timeout": 30
          }
        ]
      }
    ]
  }
}

Matcher Patterns

The matcher field narrows which tools trigger hooks. Regex is supported.

Pattern	Target
`*`	All tools
`Bash`	Bash only
`Edit\|Write`	Edit or Write
`mcp__.*`	All MCP tools
`Notebook.*`	NotebookEdit, NotebookExecute, etc.

Hook Input (stdin)

Hook scripts receive JSON via stdin:

{
  "session_id": "abc123",
  "hook_event_name": "Stop",
  "cwd": "/Users/my-project",
  "transcript_path": "/path/to/transcript.jsonl",
  "tool_name": "Bash",
  "tool_input": {
    "command": "ls -la"
  }
}

Available Environment Variables

These environment variables are available within hook scripts:

Variable	Description
`CORTEX_PROJECT_DIR`	Project directory path
`CORTEX_CODE_REMOTE`	`"true"` in web context
`CORTEX_ENV_FILE`	Persistent environment file path

Example 1: Quality Review Hook (Stop Event)

A hook that performs LLM-based quality checks when the agent tries to complete a task, blocking and continuing work if quality is insufficient:

#!/bin/bash
# quality_review_on_stop.sh

INPUT=$(cat)

# Infinite loop prevention (critical!)
if [ "$(echo "$INPUT" | jq -r '.stop_hook_active')" = "true" ]; then
  exit 0
fi

TRANSCRIPT=$(echo "$INPUT" | jq -r '.transcript_path')

# Get recent interactions and run LLM quality check
REVIEW_RESULT=$(snow sql -q "
  SELECT SNOWFLAKE.CORTEX.COMPLETE(
    'claude-sonnet-4-6',
    'Rate the task completion from 1-10: ...'
  )
" --connection MY_CONN)

SCORE=$(echo "$REVIEW_RESULT" | jq -r '.score')

if [ "$SCORE" -lt 7 ]; then
  echo "Quality score below threshold ($SCORE/10). Please improve." >&2
  exit 2  # Block → agent continues working
fi

exit 0  # Allow → agent stops

Critical: Infinite loop prevention in Stop Hooks is mandatory. When a Stop Hook returns block (exit 2), the agent continues working and the Stop event fires again. Always pass through with exit 0 when the stop_hook_active flag is true.

Example 2: Slack Notification Hook (Notification Event)

A hook that sends Slack notifications when the agent is waiting for user input:

#!/bin/bash
# notify_slack_on_notification.sh

INPUT=$(cat)
MESSAGE=$(echo "$INPUT" | jq -r '.message // "Waiting for input"')

curl -s -X POST "$SLACK_WEBHOOK_URL" \
  -H 'Content-type: application/json' \
  -d "{\"text\": \"🔔 Cortex Code: $MESSAGE\"}"

exit 0

MCP — External Tool Integration

Official docs: Extensibility - MCP

Overview

MCP (Model Context Protocol) is an open standard protocol for connecting external tools and services to AI agents. The key point here is that CoCo CLI itself functions as an MCP client. This means you can add any publicly available MCP server to give your agent new capabilities.

For example, draw.io MCP for diagrams, GitHub MCP for PR operations, Context7 MCP for latest library documentation — the possibilities are vast. MCP servers are growing daily, so definitely explore MCP servers and mcp.so to find servers that fit your workflow.

Transport Types

Type	Use Case	Communication
`stdio`	Local tools, CLI wrappers	Subprocess (stdin/stdout)
`http`	Web services, APIs	HTTP requests
`sse`	Real-time services	Server-Sent Events

OAuth authentication is supported for HTTP servers. Tokens are stored in ~/.snowflake/cortex/mcp_oauth/ and auto-refreshed.

Configuration File

MCP server configuration goes in ~/.snowflake/cortex/mcp.json:

{
  "mcpServers": {
    "drawio": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@drawio/mcp"]
    },
    "github": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "${GITHUB_TOKEN}"
      }
    }
  }
}

Environment Variable Expansion

Both ${VAR} and $VAR syntax are supported for environment variable expansion in configuration files. (Official docs: Extensibility)

{
  "headers": {
    "Authorization": "Bearer ${MY_API_TOKEN}"
  }
}

Never hardcode API keys in mcp.json. Set them as environment variables in ~/.bashrc or ~/.zshrc like export MY_API_TOKEN="your_token_here" — this is the officially recommended approach.

CLI Commands

cortex mcp add drawio npx -y @drawio/mcp
cortex mcp add my-api https://api.example.com --type http
cortex mcp add my-server npx my-mcp-server -e API_KEY=secret
cortex mcp add my-server https://api.example.com -H "Authorization: Bearer token"
cortex mcp list
cortex mcp get drawio
cortex mcp remove drawio
cortex mcp start drawio    # Connection test

Tool Naming Convention

MCP tools are namespaced for agent access:

mcp__{server-name}__{tool-name}

e.g.: mcp__drawio__open_drawio_xml
      mcp__github__create_pull_request

Session Management

/mcp    # Open MCP status viewer

Practical Example: draw.io MCP

Adding the draw.io MCP server lets you instruct the agent to "create an architecture diagram for this design" and it generates the diagram in the draw.io editor.

cortex mcp add drawio npx -y @drawio/mcp

Usage in session:

> Create an architecture diagram for this system in draw.io

Putting It All Together

The AGENTS.md and 4 extensibility features become even more powerful when combined. Here's a workflow pattern I use daily.

Pattern: AI-Assisted Development Workflow

By combining these features:

AGENTS.md always applies project-specific rules
Skills standardize repetitive workflows
SubAgents process specialized tasks in parallel
MCP connects to external tools
Hooks automate quality checks and notifications on task completion

This creates a truly integrated workflow.

Configuration File Overview

Here's a partial extract of my CoCo CLI configuration structure — the actual setup has many more files, but these are the key ones. (Official docs: Settings)

~/.snowflake/cortex/
├── settings.json           # Main settings (theme, env vars, hooks)
├── mcp.json                # MCP server config
├── hooks.json              # Global hooks
├── permissions.json        # Permission settings
├── hooks/                  # Hook scripts
│   ├── quality_review_on_stop.sh
│   ├── notify_slack_on_stop.sh
│   └── ...
├── agents/                 # Custom SubAgents
│   ├── critic-reviewer.md
│   ├── research-analyst.md
│   └── ...
├── skills/                 # Global Skills
│   ├── demo-builder/SKILL.md
│   ├── competitive-analysis/SKILL.md
│   └── ...
├── memory/                 # Persistent memory
└── ...

Conclusion

Cortex Code CLI is not just an AI coding assistant — by leveraging AGENTS.md for project rules and the 4 extensibility features (Skills, SubAgents, Hooks, MCP), you can build a powerful AI development environment tailored to your workflow.

Personally, shifting from Cursor to CoCo CLI has been transformative. Being able to use customized agents while natively connected to Snowflake data and functions has dramatically improved my daily productivity. Here's what I find most valuable:

Skills for workflow standardization: Defining repetitive workflows like demo setup and documentation as skills eliminates starting from scratch every time
SubAgents for parallel execution: Running research tasks in parallel dramatically reduces processing time for complex tasks
Hooks for quality gates & notifications: Auto-executing quality checks on task completion via Stop Hook and forcing continued work when quality is insufficient has been incredibly effective for raising output quality
MCP for external tool integration: Calling external tools like draw.io and GitHub directly from the agent dramatically reduces context-switching overhead

CoCo CLI's customization features will continue to evolve. I encourage you to dive into customization and build your own AI development environment!

Reference Links

Document	URL
Cortex Code CLI official	https://docs.snowflake.com/en/user-guide/cortex-code/cortex-code-cli
Extensibility (Skills, SubAgents, Hooks, MCP)	https://docs.snowflake.com/en/user-guide/cortex-code/extensibility
Settings (Configuration & Priority)	https://docs.snowflake.com/en/user-guide/cortex-code/settings
Security	https://docs.snowflake.com/en/user-guide/cortex-code/security

Promotion

Snowflake What's New Updates on X

I share Snowflake What's New updates on X. Follow for the latest insights:

English Version

Snowflake What's New Bot (English Version)

Japanese Version

Snowflake's What's New Bot (Japanese Version)

Change Log

(20260401) Initial post

Original Japanese Article

Cortex Code CLI 実践カスタマイズガイド

zenn.dev

Snowflake Data UI Guide - Choose the Right Tool for Every Analytics Use Case

Tsubasa Kanno — Sun, 15 Feb 2026 05:54:49 +0000

Introduction

It's been about two years since I joined Snowflake, and the transformation I've witnessed in data analytics UI has been nothing short of remarkable. Back in early 2024, when it came to working with data in Snowflake, your options were essentially Snowsight worksheets and dashboards, plus third-party BI tools. Streamlit in Snowflake (hereafter referred to as SiS) and Snowpark Container Services (hereafter referred to as SPCS) had just launched but weren't yet mainstream.

Fast forward to today, and the landscape looks completely different. Snowflake Intelligence, Snowflake Workspaces, Snowflake Notebooks, Snowflake Managed MCP Server, Cortex Code, Vercel v0 integration - the list of new options keeps growing. In my daily conversations with customers, one question has become increasingly common: "With all these tools available, which one should we use?"

That's exactly what this article aims to answer. I'll provide a comprehensive overview of every UI option for working with data in Snowflake, covering their strengths, limitations, target users, and ideal use cases. Whether you're a business user, data analyst, data scientist, or developer, I hope this guide helps you find the right tool for your needs!

Note (2026/2/5): Some features mentioned in this article are still in development or Public Preview. They may be significantly updated in the future.

Note: This article represents my personal views and not those of Snowflake. The tool evaluations and use case classifications are based on my personal experience and may vary depending on your organization and project requirements. Please treat this as one perspective.

The Evolution of Snowflake's Data UI

As I mentioned, in early 2024, worksheets, dashboards, and BI tools were the primary ways to interact with Snowflake data. In just two years, this has diversified dramatically. Workspaces has evolved worksheets into a full IDE experience. Intelligence enables business users to query data using natural language without writing SQL. Notebooks brings data science workflows entirely within Snowflake. And with SiS Container Runtime, you can now run lightweight dashboards at a fraction of the cost. On the AI front, Copilot has evolved into Cortex Code, and MCP Server enables AI Agent integration with Snowflake data.

Behind this evolution are two major trends: democratization of data access and AI-native analytics experiences. Data utilization, once dominated by data engineers and analysts, is now extending to business users - with AI serving as the bridge.

UI Options at a Glance

Here's a categorized overview of every UI option available for working with data in Snowflake.

Category	Tool	Primary Users
Snowflake Native UI (Analytics)	Snowflake Workspaces	Data Engineers, Data Analysts, Data Scientists
	Snowflake Intelligence	Business Users, Data Analysts
	Snowflake Notebooks	Data Scientists, ML Engineers
Snowflake Native UI (Apps)	SiS	Data Analysts, Data Scientists → Business Users
	Native Apps	App Developers, ISVs
	SPCS	ML Engineers, App Developers
AI-Assisted Development	Cortex Code in Snowsight	Data Engineers, Data Analysts, Data Scientists
	Cortex Code CLI	Developers, Data Engineers
	Vercel v0 Integration	Developers
AI Agent / MCP Integration	Snowflake Managed MCP Server	Developers, AI Agent Users
	OSS Snowflake MCP Server	Developers, AI Agent Users
Programmatic Access	Snowflake CLI	Developers, DevOps Engineers
	Snowpark Python SDK	Data Engineers, Data Scientists
	SQL API and Connectors	Developers
Third-Party Integration	BI Tools (Tableau, Power BI, etc.)	Data Analysts, Business Users
	Custom Applications	Developers → Business Users

Let's dive into each category in detail.

Snowflake Native UI (Analytics)

Tools available within Snowsight for analyzing and exploring data using SQL or natural language.

Snowflake Workspaces

Overview:
Snowflake Workspaces is an integrated development environment (IDE) available within Snowsight. GA since September 2025, it represents a significant evolution from the traditional worksheet experience. Originally focused on SQL editing, Workspaces now supports Notebooks running directly within the environment, unifying SQL and Python/Notebook development. Shared Workspaces became GA in January 2026 for team collaboration, and Notebooks in Workspaces went GA in February 2026.

Attribute	Details
Key Features	SQL execution, Notebooks, dbt projects, data preview, object management, Git integration, Cortex Code AI assistance
Primary Users	Data Engineers, Data Analysts, Data Scientists
Status	Workspaces: GA (2025/9), Shared Workspaces: GA (2026/1), Notebooks in Workspaces: GA (2026/2)

Pros:

Zero-setup: start working immediately
Unified environment for SQL, Python (Notebooks), and dbt
Cortex Code AI assistance for natural language code generation and editing
Git integration for version control
Shared Workspaces for team collaboration
Role-based access control (RBAC) for easy permission management
Parallel query execution from a single file
Share pre-built queries with your team so anyone can run them anytime and view the latest data in tabular format

Cons / Considerations:

Not suited for advanced visualizations

Best Use Cases:

Ad-hoc SQL / Python analysis
Data pipeline development and debugging
dbt project development and execution
ML model prototyping (via Notebooks)
Schema design and data modeling
Team collaboration
Sharing standardized queries for day-to-day data monitoring

Snowflake Intelligence

Overview:
Snowflake Intelligence is an AI-native analytics platform that lets you ask questions about your data in natural language. Business users can perform data analysis directly without specialized SQL knowledge. Under the hood, Cortex Agents serve as the core AI orchestrator, combining the following tools to fulfill requests:

Cortex Analyst: Text2SQL analysis on structured data
Cortex Search: Hybrid search (vector search + keyword search + semantic reranking) on unstructured data (documents, etc.)
Custom Tools: User-defined Stored Procedures and UDFs (User Defined Functions)

Cortex Agents interpret user requests, select the appropriate tools, execute them, and generate responses - delivering an agentic analytics experience.

Attribute	Details
Key Features	Natural language Q&A, automatic chart generation, insight surfacing, custom tool execution
Primary Users	Business Users, Data Analysts
Status	GA (2025/11)
Highlight	Semantic Models / Semantic Views for high-accuracy answers

Pros:

No SQL required - analyze data with natural language
Fully contained within Snowflake for security
Easy to scale across the entire organization
Semantic Models unify business terminology and data lineage
Cross-analyze structured and unstructured data

Cons / Considerations:

Requires upfront preparation of Semantic Models / Semantic Views

Best Use Cases:

KPI reporting for executives
Self-service analytics for sales/marketing teams
Instant answers to recurring business questions
Analysis combining internal documents and data

Snowflake Notebooks

Overview:
Snowflake Notebooks is a Jupyter-style notebook environment available within Snowsight. It supports interactive analysis combining Python, SQL, and Markdown, and you can create Streamlit-powered visualizations directly within cells. GA since November 2024.

Two runtime options are available:

Runtime	Characteristics
Warehouse Runtime	Runs kernels on a warehouse. Fast startup, ideal for standard SQL analysis and Python processing
Container Runtime	Runs on Snowpark Container Services (SPCS). GPU support and flexible package management via `pip`

Attribute	Details
Key Features	Python/SQL execution, Streamlit visualizations, collaborative editing, Git integration
Primary Users	Data Scientists, ML Engineers
Status	GA (2024/11)

Pros:

Complete data science environment within Snowflake
Python libraries (pandas, matplotlib, scikit-learn, etc.) available
Create interactive Streamlit visualizations directly in cells
Cortex Code AI assistance for natural language code generation and editing
Easy documentation of analysis processes
Built for team collaboration
Snowpark ML integration for ML workflows
Container Runtime enables deep learning and large-scale ML with GPU (PyTorch, TensorFlow pre-installed)

Cons / Considerations:

Some feature differences compared to local Jupyter Notebooks
Container Runtime requires External Access Integration setup for external packages

Best Use Cases:

Exploratory Data Analysis (EDA)
ML model prototyping
Deep learning model training and inference with GPU (Container Runtime)
Creating and sharing analysis reports

Snowflake Native UI (Apps)

Tools for building and running business-user-facing applications, accessible from Snowsight. Typically, developers build the apps and business users consume them.

Streamlit in Snowflake (SiS)

Overview:
SiS is a service for developing and deploying web applications using Python. You can rapidly build data apps without any frontend knowledge. Apps are created, edited, and run directly from Snowsight, with full integration into Snowflake's authentication and authorization.

Attribute	Details
Key Features	Python web app development, Snowflake auth integration, Cortex AI integration
Primary Users	Data Analysts, Data Scientists → Business Users
Status	GA (AWS/Azure: 2024/1, GCP: 2024/5)
Highlight	Streamlit's simplicity + Snowflake's security

Pros:

End-to-end app development using only Python
Full integration with Snowflake authentication and authorization
Rapidly build custom analytics tools for business users
Easy to integrate AI capabilities (chat, summarization, classification, etc.) via Cortex AI
Cortex Code AI-assisted coding in the Snowsight editor

Cons / Considerations:

Limited flexibility for highly custom UI designs
For cost optimization or flexible package management, consider Container Runtime below

Best Use Cases:

Custom analytics dashboards and visualization apps for teams
Data entry and update applications
AI/ML model demo apps
Internal self-service analytics tools

SiS Container Runtime (Preview)

Traditional SiS uses Warehouse Runtime, but a Container Runtime option is now also available (currently in Preview). Container Runtime executes app code on SPCS while queries run on a separate warehouse.

The development experience is identical to standard SiS. You write and deploy code in the same Snowsight SiS editor, and Cortex Code AI-assisted coding is fully available. You can create, edit, and run apps without worrying about the underlying runtime differences.

Key Benefits of Container Runtime:

Feature	Description
Separated App and Query Execution	App code runs on a compute pool, queries on a warehouse. Optimize each resource independently
Lightweight Resource Options	Run on compute pools cheaper than warehouses (e.g., `CPU_X64_XS` at 0.06 credits/hour)
Shared Instance Efficiency	All users share a single instance. Second user onward connects instantly
Full Cache Support	`@st.cache_data` caches are shared across users, reducing query execution
Flexible Package Management	Install any package from PyPI, use the latest Streamlit version

This is especially impactful for always-on dashboards and lightweight visualization apps from a cost perspective. If you need a team dashboard that runs continuously within Snowflake, SiS Container Runtime is a compelling choice - low cost and built entirely in Python.

For a deep dive into SiS Container Runtime, check out my previous article: SiS Container Runtime - Run Streamlit Apps at a Fraction of the Cost

Snowflake Native Apps

Overview:
Snowflake Native Apps is a framework for developing and distributing packaged applications on Snowflake. Multiple distribution methods are available: public distribution via Snowflake Marketplace, direct distribution to specific accounts via Private Listing, and distribution to non-Snowflake customers via Reader Accounts. Apps can use SiS for the UI or build custom frontends with SPCS.

Attribute	Details
Key Features	App packaging, Marketplace / Private Listing / Reader Account distribution, version management
Primary Users	App Developers, ISVs
Status	GA (2024/1)
Highlight	Combine data sharing and apps for distribution

Pros:

Distribute apps and data as a package
Consumers use apps + data without copying data
Continuous update delivery
Monetization via Marketplace

Cons / Considerations:

Relatively steep learning curve
Primarily for ISVs and data providers

Best Use Cases:

Commercial application distribution
Data Product offerings
Cross-organization solution sharing

Snowpark Container Services (SPCS)

Overview:
SPCS is a fully managed service for running containerized applications on Snowflake. The core value proposition is "bringing compute to the data, rather than moving data to the compute." Deploy Docker images and run ML inference or custom applications with GPU/CPU resources - all within Snowflake. Available on AWS, Azure, and GCP.

Attribute	Details
Key Features	Container execution, GPU support, ML model serving, batch jobs
Primary Users	ML Engineers, App Developers
Status	GA (AWS: 2024/8, Azure: 2025/2, GCP: 2025/8)
Highlight	Any programming language or framework

Pros:

Data never leaves Snowflake: Meets security and compliance requirements
Any programming language or library (Docker-compatible)
GPU support for ML model inference and private LLM execution
No Kubernetes knowledge required for container operations
Inherits Snowflake's security, governance, and access controls
Can serve as the backend for Native Apps

Cons / Considerations:

Requires containerization knowledge
More setup effort compared to SiS
External internet access disabled by default (requires External Access Integration)

When to choose SiS vs. SPCS:

Simple dashboards and visualization apps → SiS
Custom apps, ML inference, batch processing, non-Python languages → SPCS

Best Use Cases:

ML model inference endpoints (including private LLM execution)
Batch data processing with sensitive data
Applications requiring custom runtimes
Migrating existing Docker apps to Snowflake
Native Apps backend

AI-Assisted Development

Tools that leverage AI to accelerate data and app development.

Cortex Code

Overview:
Cortex Code, released in February 2026, is a Snowflake-native AI coding agent - a truly revolutionary next-generation coding agent that transforms the Snowflake development experience. It is positioned as the successor to Snowflake Copilot, significantly expanding and evolving Copilot's capabilities. If you've been using Copilot, Cortex Code is your upgrade path.

It enables complex tasks in data engineering, analytics, machine learning, and agent development through natural language. What sets it apart is its deep understanding of Snowflake's data, compute, governance, and operations.

Available in two forms:

Form	Description	Status
Cortex Code in Snowsight	AI coding assistance within Snowsight	Near GA
Cortex Code CLI	Use from your local terminal, VS Code, Cursor, and other editors	GA

Pros:

Code generation with awareness of your Snowflake data context
Accelerates data pipeline, analytics, and AI app development
Enterprise-grade security and governance
Integrates into existing development workflows (local IDE)

Cons / Considerations:

This is a developer-oriented tool - generated code should be reviewed by technical users before use
Cortex Code CLI requires environment setup

Best Use Cases:

SQL query authoring and optimization
Data pipeline construction
Cortex Agents development and tuning
Day-to-day data development task acceleration

Vercel v0 Integration

⚠️ Note: Vercel v0 integration was announced in November 2025 but is still under development as of this article (February 2026) and is not yet available to general users. The information below is based on the announcement and specifications may change at GA.

Overview:
The Vercel v0 integration, announced in November 2025, will enable generating and deploying Next.js applications powered by Snowflake data using natural language. v0 is Vercel's AI assistant for full-stack application development. Generated apps are deployed on SPCS.

Attribute	Details
Key Features	Natural language data querying, app generation, deployment to Snowflake
Primary Users	Developers
Status	Under Development (Coming Soon)

SiS vs. Vercel v0 Integration:

Aspect	Streamlit in Snowflake (SiS)	Vercel v0 Integration
Language	Python	TypeScript / JavaScript (Next.js)
Target Users	Data Analysts, Data Scientists	Frontend / Full-stack Developers
App Nature	Dynamic web apps from data analysis (Python-first)	Production-grade native web apps from the start
UI Flexibility	Streamlit components	React-based, highly customizable
Deploy Target	Snowflake (Warehouse / Container Runtime)	SPCS

SiS is ideal for data analysts and scientists who want to quickly turn their analyses into interactive apps using Python. Vercel v0 integration is for frontend developers who want to build production-quality native web apps from the start.

Capabilities:

Ask questions about data: Query schemas, table structures, and data content in natural language
Generate applications: Create Next.js apps for data visualization, dashboards, internal tools, etc.
Deploy to Snowflake: Deploy generated apps on SPCS

Architecture:
Vercel's "Secure Vibe Coding Architecture" ensures application and auth layers are managed by Vercel while compute and data stay within Snowflake. Data never leaves Snowflake, and existing security policies and access controls apply.

Example Use Cases:

Sales pipeline dashboards
Inventory monitoring tools
Customer analytics applications
Financial reporting interfaces

Official blog: Build and deploy data applications on Snowflake with v0

AI Agent / MCP Integration

Interfaces for accessing Snowflake data and capabilities from AI Agents.

Who should consider MCP? If you're already using AI Agents like Claude Desktop, Cursor, or GitHub Copilot and want to add Snowflake to your AI ecosystem, this is for you. MCP (Model Context Protocol) - often called the "USB-C for AI" - provides unified access to Snowflake data from multiple AI tools with a single configuration.

Key Value of MCP Integration:

Value	Description
Reduced Integration Cost	No need for individual connectors per AI tool - unified access via MCP
Less Context Switching	Access Snowflake data directly within your AI assistant without interrupting workflow
Existing Governance	Leverage Snowflake's RBAC and security model as-is
Future Investment	MCP is becoming the de facto standard for agent communication

Snowflake Managed MCP Server

Overview:
Snowflake Managed MCP Server is an MCP server hosted and managed by Snowflake. Configure it from Snowsight and connect MCP Clients like Claude Desktop or Cursor to Snowflake capabilities. GA since November 2025.

Attribute	Details
Key Features	Cortex Search / Analyst / Agents connectivity, SQL execution
Primary Users	Developers, AI Agent Users
Status	GA (2025/11)

Pros:

Easy setup (configure from Snowsight, ~15-25 minutes)
Operates within Snowflake's security model
Seamless integration with Cortex features (Analyst / Search / Agents)
Officially supported, no infrastructure management required

Cons / Considerations:

Requires separate MCP Client setup

Best Use Cases:

Access Snowflake data from Claude Desktop / Cursor and other MCP Clients
Automated data analysis via AI Agents
RAG application backends

OSS Snowflake MCP Server

Overview:
An open-source MCP Server published by Snowflake Labs on GitHub. Runs locally and connects with MCP Clients.

Attribute	Details
Key Features	Cortex Search / Analyst / Agents, SQL execution, object management, Semantic View queries
Primary Users	Developers, AI Agent Users
Highlight	Fine-grained permission control, local execution, early access to new features

Pros:

Fine-grained SQL execution permissions (e.g., allow SELECT only)
Flexible customization in local environments
Early access to the latest features

Cons / Considerations:

Requires local setup and management
Community support (not officially supported)

Best Use Cases:

Snowflake data analysis in development environments
Ad-hoc analysis from IDEs like Cursor
AI Agent integration PoCs

For a deep dive into using the Snowflake MCP Server with Cursor, check out my previous article: Unlock Advanced Data Analytics in Cursor with Snowflake MCP Server

Programmatic Access

Tools for connecting to Snowflake via command line or code for development and operations.

Snowflake CLI

Overview:
Snowflake CLI is Snowflake's official open-source command-line interface. Positioned as the successor to SnowSQL, it includes SnowSQL's capabilities plus integrated development and deployment features for Snowpark apps, Streamlit apps, Native Apps, and more. Snowflake recommends migrating from SnowSQL to Snowflake CLI.

Attribute	Details
Key Features	SQL execution, Snowpark / Streamlit / Native Apps deployment, Git integration, automation scripts
Primary Users	Developers, DevOps Engineers
Highlight	Open source, modern development workflow support

Pros:

CI/CD pipeline integration
Deploy Snowpark, Streamlit, and Native Apps from the command line
Open source with community-driven extensions
Usable from SSH-connected servers

Cons / Considerations:

No GUI - not ideal for visual data exploration
Some command syntax differences when migrating from SnowSQL

If you're currently using SnowSQL, refer to the official migration guide to plan your transition to Snowflake CLI.

Snowpark Python SDK

Overview:
A Python SDK for natively interacting with Snowflake. Provides intuitive data manipulation through the DataFrame API.

Attribute	Details
Key Features	DataFrame API, UDF/UDTF/UDAF creation, ML integration
Primary Users	Data Engineers, Data Scientists
Highlight	Write in Python, execute server-side (pushdown)

Pros:

pandas-like interface
Performance gains through Snowflake-side pushdown execution
Snowpark ML integration for machine learning workflows

Cons / Considerations:

Some advanced SQL features require direct SQL

SQL API and Connectors

Overview:
Snowflake provides a REST API and drivers/connectors for various programming languages, enabling applications to connect to Snowflake for data operations.

SQL REST API

The Snowflake SQL REST API (/api/v2/statements) enables SQL execution via HTTP requests.

Endpoint	Purpose
`POST /api/v2/statements`	Execute SQL statements
`GET /api/v2/statements/<handle>`	Check execution status
`POST /api/v2/statements/<handle>/cancel`	Cancel execution

Authentication supports OAuth and JWT (key-pair authentication).

Drivers / Connectors

A comprehensive set of drivers and connectors for various programming languages:

Category	Drivers / Connectors
Database Drivers	JDBC, ODBC, Go, .NET, Node.js, PHP PDO
Python Ecosystem	Snowflake Connector for Python, Snowpark, Snowpark ML, SQLAlchemy
Data Integration	Snowflake Connector for Kafka, Snowflake Connector for Spark

Attribute	Details
Key Features	SQL execution, data operations, multi-language support, system integration
Primary Users	Developers
Highlight	Broad language support: Java, Python, Node.js, Go, .NET, ODBC, JDBC, and more

REST API vs. Connectors:

Aspect	SQL REST API	Drivers / Connectors
Access Method	HTTP requests	Library-based
Best For	Lightweight integrations, async processing, serverless environments	High-volume data processing, complex workflows
Session Management	Stateless	Auto-managed by connector

Pros:

Easy integration into existing applications
Fits microservice architectures well
Broad programming language support
REST API works in serverless environments (AWS Lambda, etc.)

Cons / Considerations:

REST API is best for lightweight operations; connectors recommended for high-volume data processing

Third-Party Integration

Methods for connecting to Snowflake from external tools and applications.

BI Tools

Overview:
Connect to Snowflake from existing BI tools like Tableau, Power BI, Looker, Sigma, ThoughtSpot, and others for visualization.

Attribute	Details
Representative Tools	Tableau, Power BI, Looker, Sigma, ThoughtSpot, Metabase, etc.
Primary Users	Data Analysts, Business Users
Highlight	Rich visualizations, leverage existing skills

Pros:

Extensive visualization capabilities
Leverage existing BI skills and expertise
Integrate with tools already in your organization
Enterprise-grade features (scheduling, permissions, distribution, etc.)

Cons / Considerations:

Additional BI tool licensing costs
Data freshness concerns with extract mode
Some tools may lag in supporting latest Snowflake features

Best Use Cases:

Executive dashboards
Scheduled report distribution
Complex visualizations
Large-scale BI deployments

Custom Applications

Overview:
Build custom applications using Snowflake Connectors or SQL API.

Attribute	Details
Tech Stack	React, Vue.js, Flask, Django, or any framework
Primary Users	Developers → Business Users
Highlight	Complete customization control

Pros:

Full control over UI/UX
Deep integration with existing systems
Custom business logic implementation

Cons / Considerations:

Security design is your responsibility
Authentication and authorization must be implemented

Use Case-Based Selection Guide

For those asking "So which one should I actually use?" - here's a practical selection guide.

Recommended Tools by User Type

User Type	Recommended Tool	Why
Business User	Snowflake Intelligence	No SQL required - analyze with natural language. Cortex Agents combine tools to answer
Data Analyst	Workspaces	Flexible analysis with SQL / Python
Data Scientist	Snowflake Notebooks	Interactive analysis with Python + SQL + Streamlit. GPU via Container Runtime
Data Engineer	Workspaces + Snowflake CLI	SQL / Notebooks / dbt development, CI/CD integration
App Developer (Python)	SiS	Rapid app development in Python. Container Runtime for cost optimization
App Developer (Custom)	SPCS	Any language/framework, GPU, data stays in Snowflake
AI Agent User	Snowflake Managed MCP Server	Connect existing AI Agents (Claude Desktop, Cursor, etc.) to Snowflake
Full-Stack Developer	Vercel v0 Integration (Coming Soon)	Generate Next.js apps with natural language, deploy to SPCS

Recommended Tools by Use Case

Use Case	Recommended Tool	Notes
Ad-hoc SQL / Python analysis	Workspaces	Notebooks also available
Natural language analytics	Intelligence	Cortex Agents + Analyst / Search / Custom Tools
Exploratory Data Analysis (EDA)	Notebooks (Warehouse Runtime)	Python + SQL + Streamlit visualizations
Deep learning / Large-scale ML	Notebooks (Container Runtime)	GPU available, PyTorch / TensorFlow pre-installed
Team dashboards / KPI monitoring	SiS (Container Runtime)	Low-cost always-on, shared caching, Python-only development
Custom app development	SiS (Warehouse Runtime)	Rapid development, Snowflake auth integration
ML model inference / LLM execution	SPCS	GPU support, data stays in Snowflake
App distribution / monetization	Native Apps	Marketplace / Private Listing / Reader Account distribution
AI Agent integration	Snowflake Managed MCP Server	Easy setup, officially supported
AI Agent integration (custom)	OSS Snowflake MCP Server	Fine-grained permissions, local execution
Advanced visualizations	BI Tools (Tableau, Power BI, etc.)	Proven enterprise features
dbt project development	Workspaces	dbt Projects on Snowflake integration
CI/CD / automation	Snowflake CLI	Automate Snowpark / SiS / Native Apps deployment

Cortex Code AI Assistance: Workspaces, Notebooks, and SiS all support Cortex Code for AI-assisted coding. Generate and edit code with natural language to dramatically boost development productivity. For local IDEs (VS Code, Cursor, etc.), Cortex Code CLI is also available.

Key Decision Factors

SQL / Python skills: Proficient → Workspaces / Notebooks. Not proficient → Intelligence
Need dashboards / visualizations? Simple ones → SiS (Container Runtime) at low cost. Advanced → BI tools
Customization needs: High → SiS / SPCS / custom development
GPU required? → Notebooks (Container Runtime) or SPCS
Can data leave Snowflake? No → Snowflake native UI (SiS / SPCS / Notebooks)
Existing tools: Already have BI tools → connect them to Snowflake. Already using AI Agents → connect via MCP Server
Scale of deployment: Organization-wide → Intelligence. Team-level → Intelligence / SiS
AI strategy: Heavy AI Agent use → MCP Server. Development assistance → Cortex Code. App generation → Vercel v0 (coming soon)

Conclusion

Snowflake's data UI has diversified remarkably in just two years. While the abundance of options can feel overwhelming, it also means you can now choose the tool that's truly optimal for your organization and use case.

Personally, I find the most value in:

Snowflake Intelligence for data democratization: Business users who can't write SQL can now query data directly
Snowflake Managed MCP Server for AI Agent integration: Analyze data without leaving your development tools
SiS simplicity with Container Runtime: Build custom dashboards and analytics tools in Python alone, with Container Runtime enabling low-cost always-on operation
Cortex Code / Vercel v0 integration potential: AI-assisted development dramatically accelerating data and app development

The analytics experience is evolving from static reports to interactive conversations with data, gaining insights alongside AI. I hope this guide helps you find the right tools to accelerate your data journey!

Promotion

Snowflake What's New Updates on X

I share Snowflake What's New updates on X. Follow for the latest insights:

English Version

Snowflake What's New Bot (English Version)

Japanese Version

Snowflake's What's New Bot (Japanese Version)

Change Log

(20260205) Initial post

Original Japanese Article

Snowflake データ活用 UI ガイド - 最適なツール選択で分析体験を向上させる

zenn.dev

Revolutionize Your Search with Snowflake Cortex Search Multi-Index and Index-Specific Boosts

Tsubasa Kanno — Mon, 12 Jan 2026 03:52:54 +0000

Introduction

Snowflake's Cortex Search just received a major upgrade with Multi-Index and Index-Specific Boosts! These powerful features dramatically enhance search flexibility and precision, enabling scenarios like "exact match on product codes while semantic search on descriptions."

In this article, I'll walk you through these new features using hands-on examples with dummy data in Snowsight, demonstrating their value and practical implementation.

For a comprehensive overview of Cortex Search fundamentals, check out the official Snowflake documentation.

Note (2026/1/12): Cortex Search Multi-Index is currently in Public Preview. Features may be significantly updated in the future.

Note: A Custom Embedding (BYO Embed: Bring Your Own Embedding) feature was also released alongside these features, but is not covered in this article.

Note: This article represents my personal views and not those of Snowflake.

Cortex Search Quick Recap

Let me briefly explain what Cortex Search is. Cortex Search is a fully-managed enterprise search service provided by Snowflake.

Key Features

Hybrid Search: Combines vector search (semantic similarity) with keyword search (lexical similarity) for high-precision results
Automatic Embedding Generation: Automatically and regularly vectorizes text data to enable semantic search capabilities
Fully Managed: No infrastructure management or tuning required - ready to use immediately
Snowflake Native: Complete integration with Snowflake's data governance and security features

What is Multi-Index?

Multi-Index enables you to create separate indexes for multiple columns with different characteristics, and combine them during search.

Previously, Cortex Search was primarily designed for searching a single column. However, real-world business scenarios often require searching across multiple fields like "product code," "product name," and "product description." With Multi-Index, you can integrate these into a single search service and apply the most appropriate search method for each field's characteristics.

Multi-Index Use Cases

Use Case	Description
Cross-field Search	Search across product codes, names, and descriptions with different characteristics simultaneously
Field-specific Search Logic	Apply strict keyword matching to product codes while using semantic search for descriptions
Precise Result Control	Adjust the importance of each field to achieve optimal search results for your business requirements

What are Index-Specific Boosts?

Index-Specific Boosts enable you to adjust the weights of individual columns within the same index type in Multi-Index searches.

For example, if you have product_code and product_name as TEXT INDEXes, even when searching with the same keyword, the optimal results differ depending on whether you want to prioritize "matches in product code" or "matches in product name." Index-Specific Boosts let you flexibly control this balance per search query.

Parameter	Purpose	Description
weights	Search type weighting	Adjusts the overall balance between keyword search (texts), vector search (vectors), and reranker scores
text_boosts	TEXT INDEX weighting	Adjusts individual column weights within TEXT INDEXes
vector_boosts	VECTOR INDEX weighting	Adjusts individual column weights within VECTOR INDEXes

Official documentation: Customizing Cortex Search scoring - Index-specific boosts

Business Value and Benefits

Transforming Search Experience

Previous Limitation	Multi-Index & Index-Specific Boosts Solution
Limited to single-field search	Cross-field integrated search now possible
Same search logic applied to all fields	Apply optimal search methods (keyword/semantic) per field
Difficult to customize search results	Flexible ranking adjustments with Index-Specific Boosts
Hybrid search balance was automatic	Customize each field's contribution per search query

Expected Benefits

E-commerce Product Search — Prioritize exact matches on SKUs and product codes while supporting semantic search on product descriptions
Internal Knowledge Search — Balance strict matching on document titles with semantic search on document bodies
Customer Support — Apply different weights to FAQ titles and bodies to deliver results that better match user intent

Cortex Search Integration Scenarios

Cortex Search maximizes its value when combined with various Snowflake features beyond standalone use.

AI Agent Context

Snowflake Managed MCP Server — When AI Agents access data within Snowflake, they can search and retrieve enterprise-specific domain knowledge through Cortex Search. Multi-Index enables flexible searching across both structured and unstructured data.
Snowflake Intelligence — Cortex Search serves as the foundation for searching relevant documents and knowledge to generate more accurate responses to natural language queries.

Data App Context

Streamlit in Snowflake — Easily build user-friendly search interfaces by calling Cortex Search within Streamlit apps. With Index-Specific Boosts, you can dynamically control search weighting from the application layer.

The Biggest Value I See

Personally, I find tremendous value in "being able to flexibly control the balance between exact match and fuzzy search for multiple fields per search query." Previously, you could only search with a uniform balance across the entire search service, but by combining Multi-Index with Index-Specific Boosts, you can now dynamically change search behavior based on user intent and business requirements.

Furthermore, I believe enterprise search will serve as a core component for complementing enterprise-specific domain knowledge in RAG and AI Agent applications. In other words, improvements in search flexibility and precision directly translate to improvements in RAG response quality and AI Agent decision accuracy. In this sense, Multi-Index and Index-Specific Boosts represent a significant update that contributes to elevating enterprise AI adoption overall, not just a mere search feature improvement.

Important Considerations

Please keep the following points in mind when using Multi-Index:

Consideration	Details
Cost	Creating and maintaining multiple indexes may increase compute and storage costs
Performance	Search performance may be affected by the number and configuration of indexes, so proper design is important
Data Size	Query results under 1 million rows are recommended for optimal performance (contact Snowflake if exceeding 1 million rows)

Official documentation:

Hands-on Tutorial

Let's try out Multi-Index and Index-Specific Boosts! We'll use dummy product catalog data to create a Cortex Search service in Snowsight and verify the behavior with SQL queries.

Demo Scenario

For this demo, we'll simulate an e-commerce product search scenario:

product_code: Product code (exact match is critical, like SKUs)
product_name: Product name (balance between exact match and keyword matching)
description: Product description (semantic fuzzy search is effective)

We'll create a Multi-Index on these three fields and experience how search results change when we adjust each field's importance based on the search context.

Step 1: Prepare Demo Data

First, let's create a table and insert sample data in Snowsight's SQL Worksheets. Run the following query (feel free to use your own data if available):

-- Create demo database and schema
CREATE DATABASE IF NOT EXISTS cortex_search_demo;
CREATE SCHEMA IF NOT EXISTS cortex_search_demo.multi_index_demo;

USE DATABASE cortex_search_demo;
USE SCHEMA multi_index_demo;

-- Create warehouse (you can use your existing warehouse)
CREATE WAREHOUSE IF NOT EXISTS cortex_search_wh WITH
   WAREHOUSE_SIZE = 'X-SMALL';

-- Create product catalog table
CREATE OR REPLACE TABLE product_catalog (
    product_id NUMBER,
    product_code VARCHAR,
    product_name VARCHAR,
    description VARCHAR,
    category VARCHAR,
    price NUMBER(10,2)
);

-- Insert sample data (fictional products)
INSERT INTO product_catalog VALUES
    (1, 'CBP-16-X9-PRO', 'CloudBook Pro 16 X9', 'The latest 16-inch professional laptop featuring the X9 processor. Known for high-performance graphics processing and extended battery life. Ideal for video editing and CAD work.', 'Laptop', 3988.00),
    (2, 'CBP-14-X7', 'CloudBook Pro 14 X7', 'Compact 14-inch model with X7 processor. Lightweight 1.2kg design perfect for mobile workers.', 'Laptop', 2488.00),
    (3, 'CBA-15-X5', 'CloudBook Air 15 X5', 'Amazingly thin and light 15-inch large-screen laptop. Handles everything from daily use to creative work.', 'Laptop', 1988.00),
    (4, 'PPD-13-Z4', 'PixelPad Pro 13 Z4', 'Top-tier tablet with Z4 chip. Perfect for illustration and design work when paired with a stylus pen.', 'Tablet', 2188.00),
    (5, 'ODK-24-X9', 'OmniDesk 24 X9', 'Beautiful all-in-one desktop with 4.5K display. Ideal for home and office use. Quiet design for comfortable extended work sessions.', 'Desktop', 1988.00),
    (6, 'TNB-X1-G12', 'TechNova Business X1 Gen12', 'Lightweight business laptop. A proven model that balances durability and portability. Packed with security features.', 'Laptop', 2980.00),
    (7, 'FXP-11-HYBRID', 'FlexPad 11 Hybrid', 'The definitive 2-in-1 device. Flexible enough to use as both a tablet and laptop. Recommended for frequent travelers.', 'Tablet', 1768.80),
    (8, 'VNS-15-CREATOR', 'VisionStudio 15 Creator Edition', 'High-performance laptop for creators. 4K OLED display ideal for video production. Runs video editing software smoothly.', 'Laptop', 3298.00);

-- Verify data
SELECT * FROM product_catalog;

Verify that the table is created and data is inserted in Snowsight.

Step 2: Create Cortex Search Service with Multi-Index

Next, let's create a Cortex Search service with indexes on multiple columns.

Warning: As of January 2026, Snowsight's GUI does not support creating Multi-Index Cortex Search services. You must use SQL to create Multi-Index services.

Run the following query in Snowflake SQL Worksheets:

-- Create Cortex Search Service with Multi-Index
CREATE OR REPLACE CORTEX SEARCH SERVICE product_multi_search
    TEXT INDEXES product_code, product_name
    VECTOR INDEXES description (model='voyage-multilingual-2')
    ATTRIBUTES category, price
    WAREHOUSE = cortex_search_wh
    TARGET_LAG = '1 hour'
    AS (
        SELECT
            product_id,
            product_code,
            product_name,
            description,
            category,
            price
        FROM product_catalog
    );

Multi-Index uses TEXT INDEXES and VECTOR INDEXES to create indexes:

TEXT INDEXES: Indexes for keyword (lexical) search. Suitable for fields like product_code or product_name where exact match or keyword matching is important.
VECTOR INDEXES: Indexes for vector (semantic) search. Suitable for fields like description where semantic similarity search is important. We explicitly specify the voyage-multilingual-2 model for better multilingual performance.

Note: When creating a Multi-Index service, you must specify at least one column in VECTOR INDEXES. Omitting VECTOR INDEXES will result in an error.

SQL Reference: CREATE CORTEX SEARCH SERVICE

Verify that the service is created in AI Studio's Cortex Search list view or via SHOW CORTEX SEARCH SERVICES;.

Step 3: Testing Multi-Index Search and Index-Specific Boosts

This is where Multi-Index and Index-Specific Boosts really shine!

Warning: As of January 2026, the Playground does not support Index-Specific Boosts, so we'll execute searches via SQL queries.

When querying a Multi-Index service, you can use the multi_index_query parameter to explicitly specify which index receives which query. Additionally, the scoring_config weights parameter lets you adjust the weight balance between keyword search (texts) and vector search (vectors).

Official documentation: Query a Cortex Search Service - Multi-index queries

Demo Scenario Explanation

The key point of Multi-Index is that you can send different appropriate queries to each index. Similar to the official documentation examples, you send keyword-matching strings to TEXT INDEX and semantic queries to VECTOR INDEX.

For this demo, we'll verify the following scenario:

TEXT INDEX (product_name) receives the keyword "CloudBook" → Products with "CloudBook" in the name get keyword matches
VECTOR INDEX (description) receives the semantic query "a PC that's safe to use while traveling" → Products with semantically related descriptions get matches

Product Name	TEXT Match	VECTOR Match
CloudBook Air 15 X5	✓ (contains "CloudBook" in name)	△ (no mention of security)
CloudBook Pro 14 X7	✓ (contains "CloudBook" in name)	△ (no mention of security)
TechNova Business X1 Gen12	✗	✓ ("Packed with security features" → semantically related to "safe")

By changing weights, you can control which type of match is prioritized.

Case 1: Prioritize Keyword Search (texts)

By increasing the texts weight, products with "CloudBook" in their names appear at the top.

-- Prioritize keyword search: set texts weight high
SELECT
    value['product_name']::VARCHAR AS product_name,
    value['description']::VARCHAR AS description
FROM TABLE(FLATTEN(PARSE_JSON(
    SNOWFLAKE.CORTEX.SEARCH_PREVIEW(
        'cortex_search_demo.multi_index_demo.product_multi_search',
        '{
            "multi_index_query": {
                "product_name": [{"text": "CloudBook"}],
                "description": [{"text": "a PC that is safe to use while traveling"}]
            },
            "scoring_config": {
                "weights": {
                    "texts": 5,
                    "vectors": 1,
                    "reranker": 1
                }
            },
            "columns": ["product_name", "description"],
            "limit": 5
        }'
    )
)['results']));

Verify that CloudBook series products appear at the top. This is because the product names contain the keyword "CloudBook." Of course, vector search results are also factored in, albeit with lower weight.

Case 2: Prioritize Vector Search (vectors)

By increasing the vectors weight, products with descriptions semantically related to "a PC that's safe to use while traveling" appear at the top.

-- Prioritize vector search: set vectors weight high
SELECT
    value['product_name']::VARCHAR AS product_name,
    value['description']::VARCHAR AS description
FROM TABLE(FLATTEN(PARSE_JSON(
    SNOWFLAKE.CORTEX.SEARCH_PREVIEW(
        'cortex_search_demo.multi_index_demo.product_multi_search',
        '{
            "multi_index_query": {
                "product_name": [{"text": "CloudBook"}],
                "description": [{"text": "a PC that is safe to use while traveling"}]
            },
            "scoring_config": {
                "weights": {
                    "texts": 1,
                    "vectors": 5,
                    "reranker": 1
                }
            },
            "columns": ["product_name", "description"],
            "limit": 5
        }'
    )
)['results']));

Verify that "TechNova Business X1 Gen12" appears at the top. Its description mentions "Packed with security features," which semantically matches the query "safe to use while traveling."

Case 3: Query Only VECTOR INDEX

With multi_index_query, you can also target only specific indexes. When searching only the VECTOR INDEX without TEXT INDEX, you get results based purely on semantic relevance.

-- Query only VECTOR INDEX (description)
SELECT
    value['product_name']::VARCHAR AS product_name,
    value['description']::VARCHAR AS description
FROM TABLE(FLATTEN(PARSE_JSON(
    SNOWFLAKE.CORTEX.SEARCH_PREVIEW(
        'cortex_search_demo.multi_index_demo.product_multi_search',
        '{
            "multi_index_query": {
                "description": [{"text": "high-spec PC ideal for creative video production"}]
            },
            "columns": ["product_name", "description"],
            "limit": 3
        }'
    )
)['results']));

Verify that products with descriptions mentioning "video editing," "video production," or "creator" (like VisionStudio 15 Creator Edition) appear at the top.

Case 4: Using Index-Specific Boosts (text_boosts)

With text_boosts, you can adjust the weight of each column within TEXT INDEXes individually. In this demo, we have product_code and product_name defined as TEXT INDEXes, so even when searching with the same keyword "Pro," you can control whether to prioritize matches in product code or product name.

Note: multi_index_query requires at least one VECTOR INDEX to be specified. TEXT INDEX-only queries will result in an error.

-- text_boosts: prioritize product_name matches over product_code
SELECT
    value['product_code']::VARCHAR AS product_code,
    value['product_name']::VARCHAR AS product_name,
    value['description']::VARCHAR AS description
FROM TABLE(FLATTEN(PARSE_JSON(
    SNOWFLAKE.CORTEX.SEARCH_PREVIEW(
        'cortex_search_demo.multi_index_demo.product_multi_search',
        '{
            "multi_index_query": {
                "product_code": [{"text": "Pro"}],
                "product_name": [{"text": "Pro"}],
                "description": [{"text": "high-performance laptop"}]
            },
            "scoring_config": {
                "weights": {
                    "texts": 5,
                    "vectors": 1,
                    "reranker": 1
                },
                "functions": {
                    "text_boosts": [
                        {"column": "product_code", "weight": 1},
                        {"column": "product_name", "weight": 3}
                    ]
                }
            },
            "columns": ["product_code", "product_name", "description"],
            "limit": 5
        }'
    )
)['results']));

The keyword "Pro" appears in both product codes (CBP-16-X9-PRO) and product names (CloudBook Pro 16 X9, PixelPad Pro 13 Z4, etc.), but since we've weighted product_name higher, products with "Pro" in their names are prioritized.

Note: When using text_boosts, you must specify weights for all columns defined as TEXT INDEXes. Specifying only some columns will result in an error. The same applies to vector_boosts.

Search Results Comparison Summary

Case	Configuration	Expected Top Products	Reason
Case 1	Prioritize texts	CloudBook series	"CloudBook" keyword matches in product name
Case 2	Prioritize vectors	TechNova Business X1 Gen12	"security features" semantically matches "safe to use while traveling"
Case 3	description only	VisionStudio 15 Creator Edition	"video production" related descriptions semantically match
Case 4	text_boosts with product_name priority	Products with "Pro" in name	text_boosts sets product_name weight higher

As you can see, by sending different queries to TEXT INDEX and VECTOR INDEX, adjusting the weight balance with weights, fine-tuning individual column weights with text_boosts/vector_boosts, and targeting specific indexes, you can flexibly control search results.

Conclusion

How was it? Cortex Search's Multi-Index and Index-Specific Boosts enable flexible cross-field search and fine-grained weight adjustments based on search context.

I see significant value in the following points:

Enhanced Search Flexibility: Integrate and search across fields with different characteristics like product codes, names, and descriptions
Dynamic Search Control: Change boost values per search to switch between exact-match focus ↔ fuzzy-search focus
Business Requirement Alignment: Deliver optimal search experiences across various scenarios including e-commerce, internal knowledge bases, and customer support
AI Agent Accuracy Improvement: Enhanced search flexibility and precision directly improves RAG response quality and AI Agent decision accuracy

In an era where AI Agents are increasingly adopted within enterprises, enterprise search becomes a core component for complementing domain knowledge. Multi-Index and Index-Specific Boosts represent a significant update that contributes to elevating enterprise AI adoption overall, not just a mere search feature improvement.

If you're considering RAG application development or enterprise search system implementation, I highly encourage you to leverage this Multi-Index feature. Snowflake's AI capabilities continue to evolve as the "AI platform for enterprise data"!

Promotion

Snowflake What's New Updates on X

I share Snowflake What's New updates on X. Follow for the latest insights:

English Version

Snowflake What's New Bot (English Version)

Japanese Version

Snowflake's What's New Bot (Japanese Version)

Change Log

(20260112) Initial post

Original Japanese Article

https://zenn.dev/snowflakejp/articles/334e112057725c

SiS Container Runtime - Run Streamlit Apps at a Fraction of the Cost

Tsubasa Kanno — Tue, 23 Dec 2025 12:09:04 +0000

Introduction

Hey everyone! Quick off-topic confession: I've recently gotten into collecting Topps trading cards - MLB and NBA mostly. There's something incredibly satisfying about pulling a rare rookie card after opening a bunch of packs. It's become my new stress-relief hobby and honestly, my happiness levels are through the roof! 🏀⚾ Anyway, back to the tech stuff...

It's finally here! Container Runtime for Streamlit in Snowflake (SiS) is now available in Public Preview!

Previously, SiS used warehouses as the runtime environment. While warehouses are optimized for query execution and work great for data-heavy analytical apps, they were often overkill for many applications. Running a simple visualization app shouldn't require spinning up a full warehouse - and I know many of you felt the same way about the cost implications.

Container Runtime changes everything. It allows you to allocate smaller, more appropriate resources and separates app execution from query execution. This is a game-changer for cost optimization.

In this article, I'll walk you through SiS Container Runtime - from its core concepts and differences from Warehouse Runtime, to costs, considerations, package management, and a hands-on tutorial building a simple data visualization app.

Note (2025/12/23): SiS Container Runtime is currently in Public Preview. Features may be significantly updated in the future.

Note: This article represents my personal views and not those of Snowflake.

What is SiS Container Runtime?

SiS Container Runtime is a new runtime environment for running Streamlit apps on Snowflake. Unlike the traditional Warehouse Runtime, it takes a container-based approach, executing app code on a compute pool.

Key Features

Feature	Description
Long-running Service	Apps run as persistent services where all users accessing the same app share a single instance
Fast Startup	Users connect to an already-running app, resulting in faster access
PyPI Package Support	Install packages from PyPI using `pyproject.toml` or `requirements.txt`
Latest Streamlit	Use Streamlit 1.49+ (including `streamlit-nightly`)
Full Cache Support	Leverage Streamlit's caching features across user sessions

Runtime environments for Streamlit apps (Snowflake Documentation)

Warehouse Runtime vs Container Runtime

Here's a comprehensive comparison of the two runtime environments:

Feature	Warehouse Runtime	Container Runtime
Compute	App code and internal queries run on warehouse	App code runs on compute pool node, internal queries run on warehouse
Base Image	Linux in Python stored procedure	Linux in Snowpark container
Python Version	3.9, 3.10, 3.11	3.11
Streamlit Version	1.22+ (select from Snowflake-provided versions)	1.49+ (any PyPI version, including `streamlit-nightly`)
Dependency Management	`environment.yml` from Snowflake Conda channel	`pyproject.toml` or `requirements.txt` from PyPI
Version Pinning	`=` operator, `*` wildcard	`==` operator, `<, <=, >=, >` with comma-separated lists
Entry Point Location	Root of source directory	Root or subdirectory
Streamlit Server	Temporary individual instance per user session	Persistent shared instance for all user sessions
Caching	No cross-session caching	Full Streamlit caching support
Startup Time	Slower (on-demand app creation per user)	Faster per user (but slower initial deployment)

The Value of Container Runtime

The true value of Container Runtime lies in resource optimization.

1. Separation of App and Query Execution

With Warehouse Runtime, both app code and queries ran on the same warehouse. This meant warehouse resources were consumed even for simple UI rendering.

Container Runtime separates these concerns: app code runs on a compute pool while queries run on a warehouse. You can now allocate minimal compute pool resources for app execution and appropriately-sized warehouses for query execution.

2. Lightweight Resource Options

Compute pools offer more affordable options than warehouses. For example:

Gen1 XS Warehouse: 1 credit/hour
Compute Pool CPU_X64_XS: 0.06 credits/hour

That's approximately 1/16th the cost! For lightweight visualization apps, this difference is significant.

3. Shared Instance Efficiency

With Warehouse Runtime, each user got their own app instance. Container Runtime shares a single instance across all users. The second user onward connects instantly to an already-running app, improving perceived performance.

4. Cross-Session Caching

With Warehouse Runtime, Streamlit's @st.cache_data and @st.cache_resource decorators only cached within individual sessions. If User A cached a query result, User B would still execute the query again.

With Container Runtime, caches are shared across users. When User A caches a query result, User B can reuse that cache, reducing query execution and improving both performance and cost efficiency.

Cost Considerations

Container Runtime involves two types of resources:

1. Compute Pool

Compute pools are billed per node. Costs vary by node size (Instance Family), but options cheaper than the smallest warehouse (XS) are available.

Tip: Streamlit runs as a single process, so multiple CPUs don't provide much benefit. Choose the smallest node size that meets your memory requirements to optimize costs.

Recommended compute pool settings:

Parameter	Recommendation	Reason
`INSTANCE_FAMILY`	Small sizes like `CPU_X64_XS`	Streamlit is single-process, start small
`MIN_NODES`	Number of different apps to run simultaneously	Each app uses one node
`MAX_NODES`	Higher than `MIN_NODES`	Prevent node shortages when adding new apps

2. Query Warehouse

The warehouse for internal queries uses traditional credit-based billing. Choose an appropriate size based on query complexity and data volume.

Working with compute pools (Snowflake Documentation)

Important Considerations

Here are some things to keep in mind when using Container Runtime.

1. Python Version Compatibility

Container Runtime currently supports Python 3.11 only. Ensure your app and all dependencies are compatible with Python 3.11.

2. `_snowflake` Module Not Supported

The _snowflake module available in Warehouse Runtime is not available in Container Runtime. Use native Python libraries like Snowflake Python Connector instead.

For example, to get the active session (commonly used in SiS), change your import:

# NG: Not available in Container Runtime
from _snowflake import get_active_session

# OK: Use this instead
from snowflake.snowpark.context import get_active_session

3. Shared Resources

All users share disk, compute, and memory resources in Container Runtime. Design your app with efficient resource usage in mind.

4. Deployment Time

Container Runtime requires container startup during initial deployment, which may take longer than Warehouse Runtime.

5. External Access Integration

Installing packages from external package indexes like PyPI requires External Access Integration configuration.

External access integrations (Snowflake Documentation)

6. Sleep Timer and Compute Pool Auto-Stop

Warehouse Runtime includes a sleep timer feature that automatically stops apps after a period of inactivity. Container Runtime does not currently support this feature. Additionally, compute pools don't auto-stop when app sessions end.

To minimize costs, consider setting up a Task to stop compute pools during off-hours:

-- Example: Stop compute pool daily at 10 PM
CREATE OR REPLACE TASK STOP_STREAMLIT_POOL_TASK
    WAREHOUSE = SIS_QUERY_WH
    SCHEDULE = 'USING CRON 0 22 * * * America/New_York'
AS
    ALTER COMPUTE POOL STREAMLIT_POOL STOP ALL;

That said, compute pools are very affordable, so running them continuously has limited cost impact. Choose the approach that fits your operational style.

Managing Dependencies

Container Runtime uses pyproject.toml or requirements.txt instead of environment.yml.

requirements.txt Example

streamlit==1.41.0
pandas>=2.0.0
plotly>=5.18.0

pyproject.toml Example

[project]
name = "my-streamlit-app"
version = "1.0.0"

[project.dependencies]
streamlit = "==1.41.0"
pandas = ">=2.0.0"
plotly = ">=5.18.0"

Note: Warehouse Runtime uses = for version pinning, while Container Runtime uses ==.

Item	Warehouse Runtime	Container Runtime
Config File	`environment.yml`	`pyproject.toml` or `requirements.txt`
Package Source	Snowflake Conda channel	PyPI or other external indexes
Version Pinning	`=`	`==`
Range Specification	`*` wildcard	`<, <=, >=, >, !=` with comma-separated lists

Dependency management for Streamlit apps (Snowflake Documentation)

Hands-on: Building a Sales Dashboard

Let's build a simple data visualization app using SiS Container Runtime!

Prerequisites

Snowflake account (AWS, Azure, or GCP commercial region)
Role with the following privileges:

Privilege	Object	Notes
USAGE	Database	Database where you create the app
CREATE STREAMLIT, USAGE	Schema	Schema where you create the app
USAGE	Warehouse	Warehouse for query execution
USAGE	Compute pool	Compute pool for app execution
CREATE COMPUTE POOL	Account	If creating a new compute pool
CREATE INTEGRATION	Account	If creating a new External Access Integration

Privileges required to create and use a Streamlit app (Snowflake Documentation)

Step 1: Set Up the Environment

Let's run the following SQL in Snowsight SQL Worksheets to set up our demo environment!

First, create the database, schema, and stage for source code:

-- Create database and schema
CREATE DATABASE IF NOT EXISTS SIS_CONTAINER_DB;
CREATE SCHEMA IF NOT EXISTS SIS_CONTAINER_DB.APP_SCHEMA;

-- Create stage for source code
CREATE OR REPLACE STAGE SIS_CONTAINER_DB.APP_SCHEMA.APP_STAGE
  ENCRYPTION = (TYPE = 'SNOWFLAKE_SSE')
  DIRECTORY = (ENABLE = TRUE);

-- Create sample data table
CREATE OR REPLACE TABLE SIS_CONTAINER_DB.APP_SCHEMA.SALES_DATA (
    SALE_DATE DATE,
    PRODUCT VARCHAR(100),
    REGION VARCHAR(50),
    SALES_AMOUNT NUMBER(10, 2)
);

-- Insert sample data
INSERT INTO SIS_CONTAINER_DB.APP_SCHEMA.SALES_DATA VALUES
    ('2024-01-01', 'Product A', 'East', 1000.00),
    ('2024-01-01', 'Product B', 'East', 1500.00),
    ('2024-01-01', 'Product A', 'West', 800.00),
    ('2024-01-02', 'Product B', 'West', 1200.00),
    ('2024-01-02', 'Product A', 'East', 1100.00),
    ('2024-01-03', 'Product B', 'East', 1800.00),
    ('2024-01-03', 'Product A', 'West', 950.00),
    ('2024-01-04', 'Product B', 'West', 1400.00),
    ('2024-01-04', 'Product A', 'East', 1050.00),
    ('2024-01-05', 'Product B', 'East', 1600.00);

Step 2: Create Compute Pool

Create a compute pool to run app code:

-- Create compute pool
CREATE COMPUTE POOL IF NOT EXISTS STREAMLIT_POOL
    MIN_NODES = 1
    MAX_NODES = 3
    INSTANCE_FAMILY = CPU_X64_XS;

-- Check compute pool status
SHOW COMPUTE POOLS;
DESCRIBE COMPUTE POOL STREAMLIT_POOL;

Note: Compute pool startup may take a few minutes. Wait until SHOW COMPUTE POOLS shows state as ACTIVE or IDLE.

Step 3: Create External Access Integration

Create an External Access Integration to allow package installation from PyPI.

Snowflake provides a default network rule snowflake.external_access.pypi_rule for PyPI access, so you don't need to create your own:

-- Create External Access Integration (using Snowflake-managed PyPI network rule)
CREATE OR REPLACE EXTERNAL ACCESS INTEGRATION PYPI_ACCESS_INTEGRATION
    ALLOWED_NETWORK_RULES = (snowflake.external_access.pypi_rule)
    ENABLED = TRUE;

External network access examples (Snowflake Documentation)

Step 4: Prepare Application Files

Create these two files and upload them to the stage.

streamlit_app.py

import streamlit as st
import pandas as pd
from snowflake.snowpark.context import get_active_session

# Page configuration
st.set_page_config(layout="wide")

# Get Snowflake session
session = get_active_session()

# Title
st.title("📊 Sales Dashboard")
st.markdown("A simple sales visualization app running on Container Runtime.")

# Load data
@st.cache_data(ttl=60)
def load_data():
    df = session.sql("SELECT * FROM SALES_DATA").to_pandas()
    return df

df = load_data()

# Sidebar filters
st.sidebar.header("Filter Settings")
selected_products = st.sidebar.multiselect(
    "Select Products",
    options=df['PRODUCT'].unique(),
    default=df['PRODUCT'].unique()
)
selected_regions = st.sidebar.multiselect(
    "Select Regions",
    options=df['REGION'].unique(),
    default=df['REGION'].unique()
)

# Filter data
filtered_df = df[
    (df['PRODUCT'].isin(selected_products)) &
    (df['REGION'].isin(selected_regions))
]

# Display metrics
col1, col2, col3 = st.columns(3)
with col1:
    st.metric("Total Sales", f"${filtered_df['SALES_AMOUNT'].sum():,.2f}")
with col2:
    st.metric("Transaction Count", f"{len(filtered_df):,}")
with col3:
    st.metric("Average Sale", f"${filtered_df['SALES_AMOUNT'].mean():,.2f}")

# Charts
st.subheader("Daily Sales Trend")
daily_sales = filtered_df.groupby('SALE_DATE')['SALES_AMOUNT'].sum().reset_index()
st.line_chart(daily_sales, x='SALE_DATE', y='SALES_AMOUNT')

st.subheader("Sales by Product")
product_sales = filtered_df.groupby('PRODUCT')['SALES_AMOUNT'].sum().reset_index()
st.bar_chart(product_sales, x='PRODUCT', y='SALES_AMOUNT')

# Data table
st.subheader("Detailed Data")
st.dataframe(filtered_df, use_container_width=True)

# Footer
st.markdown("---")
st.markdown("🚀 Powered by Streamlit in Snowflake Container Runtime")

requirements.txt

streamlit>=1.41.0
pandas>=2.0.0

Step 5: Upload Files to Stage

Upload the files via Snowsight UI or use PUT commands:

-- Upload via SnowSQL or local environment
PUT file:///path/to/streamlit_app.py @SIS_CONTAINER_DB.APP_SCHEMA.APP_STAGE AUTO_COMPRESS=FALSE OVERWRITE=TRUE;
PUT file:///path/to/requirements.txt @SIS_CONTAINER_DB.APP_SCHEMA.APP_STAGE AUTO_COMPRESS=FALSE OVERWRITE=TRUE;

-- Verify stage contents
LIST @SIS_CONTAINER_DB.APP_SCHEMA.APP_STAGE;

Step 6: Create Streamlit App

Create the Streamlit app with Container Runtime:

-- Create query warehouse (skip if using existing warehouse)
CREATE WAREHOUSE IF NOT EXISTS SIS_QUERY_WH
    WAREHOUSE_SIZE = 'XSMALL'
    AUTO_SUSPEND = 60
    AUTO_RESUME = TRUE;

-- Create Streamlit app
CREATE OR REPLACE STREAMLIT SIS_CONTAINER_DB.APP_SCHEMA.SALES_DASHBOARD_APP
    FROM '@SIS_CONTAINER_DB.APP_SCHEMA.APP_STAGE'
    MAIN_FILE = 'streamlit_app.py'
    QUERY_WAREHOUSE = SIS_QUERY_WH
    RUNTIME_NAME = 'SYSTEM$ST_CONTAINER_RUNTIME_PY3_11'
    COMPUTE_POOL = STREAMLIT_POOL
    EXTERNAL_ACCESS_INTEGRATIONS = (PYPI_ACCESS_INTEGRATION);

Key CREATE STREAMLIT Parameters

Parameter	Description
`FROM`	Stage path containing source code
`MAIN_FILE`	Entry point Python file
`QUERY_WAREHOUSE`	Warehouse for query execution
`RUNTIME_NAME`	Specify `SYSTEM$ST_CONTAINER_RUNTIME_PY3_11`
`COMPUTE_POOL`	Compute pool for app code execution
`EXTERNAL_ACCESS_INTEGRATIONS`	External access integration (for PyPI access)

Step 7: Run the App

In Snowsight, click 'Streamlit' in the left pane and select your SALES_DASHBOARD_APP.

Your app is running! 🎉 You've successfully deployed a Streamlit app on Container Runtime!

Note: Initial startup may take a few minutes for container initialization and package installation. Subsequent startups will be faster due to caching.

Migration Checklist

When migrating existing Warehouse Runtime apps to Container Runtime, use this checklist:

Item	Action
Python 3.11 Compatibility	Verify app and all dependencies work with Python 3.11
`_snowflake` Module Usage	Replace with `snowflake.snowpark.context` etc.
`environment.yml` Conversion	Convert to `requirements.txt` or `pyproject.toml`
Version Specification Syntax	Change `=` to `==`, `*` to `>=` etc.
Compute Pool Creation	Create appropriately-sized compute pool
External Access Integration	Create if PyPI access is needed

Migrate to a container runtime (Snowflake Documentation)

Conclusion

SiS Container Runtime is a long-awaited feature that separates app execution from query execution and enables lightweight resource allocation for apps.

The days of spinning up a warehouse just to run a simple visualization app are over! Container Runtime shines in use cases like:

Always-on Dashboards: Dashboards with frequent multi-user access
Lightweight Visualization Apps: Simple apps without heavy analytical processing
Cache-Leveraging Apps: Apps that cache and reuse query results

While still in Public Preview, I encourage you to try this new feature and make your Snowflake app development more efficient!

I'm excited to explore more ideas using SiS Container Runtime and will share useful apps I create in future blog posts. Stay tuned!

Promotion

Snowflake What's New Updates on X

I share Snowflake What's New updates on X. Follow for the latest insights:

English Version

Snowflake What's New Bot (English Version)

Japanese Version

Snowflake's What's New Bot (Japanese Version)

Change Log

(20251223) Initial post

Original Japanese Article

https://zenn.dev/snowflakejp/articles/abe3379e6e44cd

Auto-Generate Snowflake Semantic Views with AI - A Developer's Fast-Track to Cortex Analyst

Tsubasa Kanno — Thu, 09 Oct 2025 12:53:00 +0000

Introduction

Cortex Analyst is one of Snowflake's most exciting features, enabling revolutionary natural language data analysis. Business users who don't usually write queries can simply ask "What are the top 10 products by sales last month?" and get instant insights without SQL - true data democratization in action!

However, for Cortex Analyst to reach its full potential, you need a well-structured semantic layer as the foundation. Snowflake offers Semantic Models or Semantic Views to accomplish this, but creating semantic layers requires time and effort: understanding table structures, defining business logic, setting appropriate descriptions and synonyms, and more.

If you're thinking "I want to use Cortex Analyst, but setting up the semantic layer is taking forever..." - you're in the right place! Today I'm introducing a stored procedure that auto-generates semantic views using AI. This tool lets you quickly create a baseline semantic view from existing tables, giving you a fast start toward delivering analytics environments to business users.

Note: This stored procedure is designed to assist with initial semantic view creation. We recommend customizing the generated views according to your business requirements.

Note: At the June 2025 Snowflake Summit, an official semantic layer auto-generation feature was announced. This stored procedure serves as a stopgap solution until the official feature is released. When the official feature launches, I'll write about it as well!

Note: This article represents my personal views and not those of Snowflake.

What is a Semantic View?

A semantic view is a Snowflake schema-level object that adds business context to physical database tables. It maps technical column names (e.g., amt_ttl_pre_dsc) to business-friendly concepts (e.g., "Total Sales", "Sales Amount") with detailed descriptions (e.g., "Total sales value for stores in the metropolitan area"), bridging the gap between data and business.

Even more importantly, semantic views help AI correctly understand database structure and business logic. Cortex Analyst can generate high-precision SQL queries from natural language questions precisely because of the semantic layer. Through synonyms and detailed descriptions, AI learns to understand that "last month's sales", "total sales", and "sales amount" all refer to the same concept, enabling it to select the right tables and columns for accurate query generation.

Components of a Semantic View

Semantic views consist of these elements:

Element	Description	Examples
Facts	Primarily numeric fact data (row-level attributes)	Sales quantity, unit price, amount, etc.
Dimensions	Category and attribute data (analysis axes)	Product name, customer ID, date, region, etc.
Metrics	Aggregated indicators (business KPIs)	Total sales, average unit price, sales growth rate, etc.

Each element can be defined with:

Synonyms: Business aliases and natural phrasings (e.g., "sales" → "revenue", "sales amount")
Comment: Business explanations including units, ranges, and other details

Why Semantic Views Matter

Semantic views provide these key values:

Improved Cortex Analyst Accuracy: Serves as the foundation for AI to understand natural language and generate accurate SQL
Consistent Business Definitions: Unified business metrics across the entire organization
Data Democratization: Enables non-technical users to access data

For more details, see the official Snowflake documentation - Semantic View Overview.

Note: For information about Semantic Models (YAML format), see the Cortex Analyst Semantic Model Documentation. This article focuses on the newer Semantic Views feature.

Challenges in Creating Semantic Layers

Creating semantic layers manually involves these tasks:

Understanding table structure (table definitions, column names, data types, sample data review)
Classifying Facts, Dimensions, and Metrics
Identifying business-relevant synonyms actually used in the field
Considering appropriate descriptions (Comments) for each element
Defining the structure in SQL syntax

For large tables or multiple tables, this process takes considerable time. However, spending too much time on preparation delays the delivery of analytics environments to business users - having a quality baseline to start with is extremely valuable!

AI-Powered Auto-Generation Stored Procedure

Overview

The GENERATE_SEMANTIC_VIEW stored procedure I'm introducing auto-generates semantic views through these steps:

Retrieve Table Information: Get column info, data types, and comments using DESCRIBE TABLE
Analyze Sample Data: Infer actual usage and data characteristics from the first 5 rows
AI-Generated SQL: LLM via AI_COMPLETE function (like claude-sonnet-4-5) generates semantic view DDL
Create Semantic View: Execute the generated SQL

Key Features

Feature	Description
Fully Automated	Automatically classifies Facts, Dimensions, and Metrics by just specifying table name
Rich Synonyms	Infers actual usage from sample data to generate natural business-relevant synonyms
Detailed Descriptions	Auto-generates Comments with business meaning for each element
Customizable	Specify which LLM model to use (default: claude-sonnet-4-5)

Stored Procedure Code

The complete code for the GENERATE_SEMANTIC_VIEW stored procedure is provided below.

CREATE OR REPLACE PROCEDURE GENERATE_SEMANTIC_VIEW(
    SOURCE_DATABASE VARCHAR,      -- Source database name
    SOURCE_SCHEMA VARCHAR,        -- Source schema name
    SOURCE_TABLE VARCHAR,         -- Source table name
    TARGET_DATABASE VARCHAR,      -- Target database name
    TARGET_SCHEMA VARCHAR,        -- Target schema name
    TARGET_VIEW_NAME VARCHAR,     -- Semantic view name to create
    LLM_MODEL VARCHAR DEFAULT 'claude-sonnet-4-5' -- LLM model to use
)
RETURNS VARCHAR
LANGUAGE SQL
EXECUTE AS CALLER
AS
$$
DECLARE
    -- Table information
    column_info VARCHAR;
    sample_data_json VARCHAR;
    table_comment VARCHAR;

    -- AI generation results
    ai_response VARCHAR;

    -- Final SQL
    create_view_sql VARCHAR;

BEGIN
    -- ================================================================================
    -- STEP 1: Retrieve table information
    -- ================================================================================

    -- Get column information (using DESCRIBE TABLE)
    DECLARE
        describe_sql VARCHAR;
        rs RESULTSET;
    BEGIN
        describe_sql := 'DESCRIBE TABLE ' || :SOURCE_DATABASE || '.' || :SOURCE_SCHEMA || '.' || :SOURCE_TABLE;
        rs := (EXECUTE IMMEDIATE :describe_sql);

        -- Get information from results
        -- $1: Column name, $2: Data type, $10: Comment
        SELECT LISTAGG(
            $1 || ':' || $2 || CASE WHEN $10 IS NOT NULL AND $10 != '' THEN '(' || $10 || ')' ELSE '' END,
            ', '
        ) INTO column_info
        FROM TABLE(RESULT_SCAN(LAST_QUERY_ID()));

    EXCEPTION
        WHEN OTHER THEN
            RETURN 'Error: Could not retrieve table information - ' || :SOURCE_DATABASE || '.' || :SOURCE_SCHEMA || '.' || :SOURCE_TABLE || '. Error: ' || SQLERRM;
    END;

    -- Error check
    IF (column_info IS NULL OR LENGTH(:column_info) = 0) THEN
        RETURN 'Error: Column information is empty - ' || :SOURCE_DATABASE || '.' || :SOURCE_SCHEMA || '.' || :SOURCE_TABLE;
    END IF;

    -- Get table comment
    SELECT COMMENT INTO table_comment
    FROM INFORMATION_SCHEMA.TABLES
    WHERE TABLE_CATALOG = :SOURCE_DATABASE
      AND TABLE_SCHEMA = :SOURCE_SCHEMA
      AND TABLE_NAME = :SOURCE_TABLE;

    -- Get sample data (first 5 rows)
    DECLARE
        sample_sql VARCHAR;
        sample_rs RESULTSET;
    BEGIN
        sample_sql := 'SELECT * FROM ' || :SOURCE_DATABASE || '.' || :SOURCE_SCHEMA || '.' || :SOURCE_TABLE || ' LIMIT 5';
        sample_rs := (EXECUTE IMMEDIATE :sample_sql);

        -- Get sample data in JSON format
        SELECT TO_VARCHAR(ARRAY_AGG(OBJECT_CONSTRUCT(*))) INTO sample_data_json
        FROM TABLE(RESULT_SCAN(LAST_QUERY_ID()));

    EXCEPTION
        WHEN OTHER THEN
            sample_data_json := 'Sample data unavailable';
    END;

    -- ================================================================================
    -- STEP 2: Generate complete Semantic View definition with AI
    -- ================================================================================

    SELECT SNOWFLAKE.CORTEX.COMPLETE(
        :LLM_MODEL,
        CONCAT(
            '[IMPORTANT] Generate a Snowflake semantic view using the information below.',
            '\n\n★ DO NOT use any column names that do not exist ★',
            '\n\n[TABLE INFORMATION]',
            '\nTable: ', :SOURCE_DATABASE, '.', :SOURCE_SCHEMA, '.', :SOURCE_TABLE,
            '\nAlias: ', :SOURCE_TABLE,
            '\nTable Comment: ', COALESCE(:table_comment, 'None'),
            '\n\n[EXISTING COLUMNS (Use ONLY these)]',
            '\n', :column_info,
            '\n\n[SAMPLE DATA (For understanding data usage)]',
            '\n', SUBSTRING(:sample_data_json, 1, 1000),
            '\n\n[SQL TO GENERATE]',
            '\nCREATE OR REPLACE SEMANTIC VIEW ', :TARGET_DATABASE, '.', :TARGET_SCHEMA, '.', :TARGET_VIEW_NAME,
            '\n  TABLES (',
            '\n    ', :SOURCE_TABLE, ' AS ', :SOURCE_DATABASE, '.', :SOURCE_SCHEMA, '.', :SOURCE_TABLE,
            '\n      WITH SYNONYMS (''alias1'', ''alias2'', ''alias3'', ''alias4'')',
            '\n      COMMENT = ''Detailed table description''',
            '\n  )',
            '\n  FACTS (',
            '\n    ', :SOURCE_TABLE, '.fact_name AS existing_column_name',
            '\n      WITH SYNONYMS (''alias1'', ''alias2'')',
            '\n      COMMENT = ''Detailed column description''',
            '\n  )',
            '\n  DIMENSIONS (',
            '\n    ', :SOURCE_TABLE, '.dim_name AS existing_column_name',
            '\n      WITH SYNONYMS (''alias1'', ''alias2'')',
            '\n      COMMENT = ''Detailed column description''',
            '\n  )',
            '\n  METRICS (',
            '\n    ', :SOURCE_TABLE, '.metric_name AS SUM(existing_column_name)',
            '\n      WITH SYNONYMS (''alias1'', ''alias2'')',
            '\n      COMMENT = ''Detailed column description''',
            '\n  )',
            '\n  COMMENT = ''Detailed semantic view description'';',
            '\n\n[ABSOLUTE RULES]',
            '\n★★★ MOST IMPORTANT ★★★ Use ONLY column names from the above list',
            '\n\n0. Omit Primary Key:',
            '\n   - Do not write PRIMARY KEY clause',
            '\n   - Primary key constraints do not function in Snowflake and are optional',
            '\n\n1. Column Name Usage:',
            '\n   - Column names used on the right side of AS must also exist in the list',
            '\n   - Example OK: YEAR(TRANSACTION_DATE) ← only if TRANSACTION_DATE exists',
            '\n   - Example NG: YEAR(ORDER_DATE) ← if ORDER_DATE does not exist',
            '\n\n2. FACTS (Numeric Data):',
            '\n   - Quantity, amount, price, score, rate - numeric type columns',
            '\n   - Include both simple column references and calculated formulas',
            '\n   - Example (simple): QUANTITY, PRICE, AMOUNT',
            '\n   - Example (calculated): revenue AS QUANTITY * UNIT_PRICE, discount_amount AS TOTAL_PRICE * 0.1',
            '\n\n3. DIMENSIONS (Attribute Data):',
            '\n   - IDs, names, dates, categories, statuses',
            '\n   - Do not overlap with FACTS',
            '\n\n4. No Duplicate Names: All table.name combinations on the left must be unique',
            '\n\n5. Date Derivative Naming: original_column_name_year, original_column_name_month',
            '\n\n6. Rich Synonyms (Critical for Cortex Analyst to understand user requests):',
            '\n   - Tables: 4-5 business-relevant aliases',
            '\n   - Each DIMENSION, FACT, METRIC: 2-3 natural aliases',
            '\n   - Infer appropriate synonyms from sample data actual usage',
            '\n   - Example: sales amount → "total sales", "sales total", "revenue"',
            '\n   - Example: product ID → "product code", "item number", "SKU"',
            '\n\n7. Rich COMMENTS:',
            '\n   - Generate specific descriptions from sample data',
            '\n   - Include business meaning',
            '\n   - Specify units and ranges',
            '\n\n8. Utilize Sample Data:',
            '\n   - Understand actual usage from sample data content',
            '\n   - Generate more concrete, practical synonyms',
            '\n   - Reflect data characteristics (range, units, etc.) in COMMENTS',
            '\n\n9. Generate Abundant FACTS and DIMENSIONS:',
            '\n   - FACTS: Around 5-10 (simple columns + calculated formulas)',
            '\n   - DIMENSIONS: Around 5-15 (original columns + date derivatives)',
            '\n   - METRICS: Around 4-8 (various aggregation patterns)',
            '\n\n10. Output: SQL syntax only (no ```, no explanatory text)',
            '\n\nOutput only the CREATE SEMANTIC VIEW statement:'
        )
    ) INTO ai_response;

    -- Debug: Verify AI response length
    IF (:ai_response IS NULL OR LENGTH(:ai_response) = 0) THEN
        RETURN 'Error: AI_COMPLETE returned an empty response. Column info: ' || SUBSTRING(:column_info, 1, 500);
    END IF;

    -- Remove unnecessary characters
    create_view_sql := :ai_response;
    create_view_sql := REPLACE(:create_view_sql, '```sql', '');
    create_view_sql := REPLACE(:create_view_sql, '```', '');
    create_view_sql := REPLACE(:create_view_sql, '"', '''');
    create_view_sql := REPLACE(:create_view_sql, 'Revised:', '');
    create_view_sql := REPLACE(:create_view_sql, 'Modifications:', '');
    create_view_sql := REPLACE(:create_view_sql, '**', '');
    create_view_sql := TRIM(:create_view_sql);

    -- Final verification: Check SQL statement is not empty
    IF (:create_view_sql IS NULL OR LENGTH(:create_view_sql) < 50) THEN
        RETURN 'Error: Generated SQL is empty or too short. AI response: ' || SUBSTRING(:ai_response, 1, 1000);
    END IF;

    -- ================================================================================
    -- STEP 4: Create semantic view
    -- ================================================================================

    BEGIN
        EXECUTE IMMEDIATE :create_view_sql;
        RETURN 'Semantic view ' || :TARGET_DATABASE || '.' || :TARGET_SCHEMA || '.' || :TARGET_VIEW_NAME || ' created successfully. SQL: ' || :create_view_sql;
    EXCEPTION
        WHEN OTHER THEN
            RETURN 'Error: ' || SQLERRM || ' -- Generated SQL: ' || SUBSTRING(:create_view_sql, 1, 2000);
    END;

END;
$$;

-- ================================================================================
-- Usage Example
-- ================================================================================

/*
-- Basic usage
CALL GENERATE_SEMANTIC_VIEW(
    '<source_database>',
    '<source_schema>',
    '<source_table>',
    '<target_database>',
    '<target_schema>',
    '<semantic_view_name>',
    '<LLM_model_name>'
);

-- Verify created semantic view
DESCRIBE SEMANTIC VIEW <target_database>.<target_schema>.<semantic_view_name>;
*/

Note: You can copy and paste this stored procedure directly into your Snowflake environment for immediate use.

How to Use

Prerequisites

To use this stored procedure, you'll need:

A Snowflake account
An environment where Cortex LLM is available (cross-region inference makes this available in most regions)
Permissions to create semantic views

Basic Usage Example

Here's how to generate a semantic view from the SALES_DATABASE.PUBLIC.ORDERS table:

-- Call the stored procedure
CALL GENERATE_SEMANTIC_VIEW(
    'SALES_DATABASE',           -- Source database
    'PUBLIC',                   -- Source schema
    'ORDERS',                   -- Source table
    'ANALYTICS_DATABASE',       -- Target database
    'SEMANTIC',                 -- Target schema
    'ORDERS_SEMANTIC_VIEW',     -- Semantic view name
    'claude-sonnet-4-5'         -- LLM model (optional)
);

-- Verify the created semantic view
DESCRIBE SEMANTIC VIEW ANALYTICS_DATABASE.SEMANTIC.ORDERS_SEMANTIC_VIEW;

Example Generated Semantic View

For example, given this table structure:

-- Sample table
CREATE TABLE ORDERS (
    ORDER_ID NUMBER,
    CUSTOMER_ID NUMBER,
    ORDER_DATE DATE,
    PRODUCT_NAME VARCHAR,
    QUANTITY NUMBER,
    UNIT_PRICE NUMBER,
    TOTAL_AMOUNT NUMBER
);

The stored procedure auto-generates a semantic view like this:

CREATE OR REPLACE SEMANTIC VIEW ANALYTICS_DATABASE.SEMANTIC.ORDERS_SEMANTIC_VIEW
  TABLES (
    ORDERS AS SALES_DATABASE.PUBLIC.ORDERS
      WITH SYNONYMS ('Order Table', 'Sales Data', 'Purchase History', 'Transactions')
      COMMENT = 'Table managing customer order information'
  )
  FACTS (
    ORDERS.quantity AS QUANTITY
      WITH SYNONYMS ('Qty', 'Amount Ordered', 'Number of Items')
      COMMENT = 'Quantity of products ordered',
    ORDERS.unit_price AS UNIT_PRICE
      WITH SYNONYMS ('Price', 'Item Price', 'Product Price')
      COMMENT = 'Price per product unit',
    ORDERS.total_amount AS TOTAL_AMOUNT
      WITH SYNONYMS ('Total', 'Order Amount', 'Purchase Total')
      COMMENT = 'Total order amount'
  )
  DIMENSIONS (
    ORDERS.order_id AS ORDER_ID
      WITH SYNONYMS ('Order Number', 'Transaction ID', 'Order Ref')
      COMMENT = 'Unique identifier for the order',
    ORDERS.customer_id AS CUSTOMER_ID
      WITH SYNONYMS ('Client ID', 'Customer Number', 'Account ID')
      COMMENT = 'Customer identifier',
    ORDERS.order_date AS ORDER_DATE
      WITH SYNONYMS ('Purchase Date', 'Transaction Date', 'Date Ordered')
      COMMENT = 'Date the order was placed',
    ORDERS.product_name AS PRODUCT_NAME
      WITH SYNONYMS ('Product', 'Item Name', 'Item')
      COMMENT = 'Name of the ordered product'
  )
  METRICS (
    ORDERS.total_sales AS SUM(TOTAL_AMOUNT)
      WITH SYNONYMS ('Total Revenue', 'Sales Total', 'Revenue')
      COMMENT = 'Total sales amount for all orders',
    ORDERS.avg_order_amount AS AVG(TOTAL_AMOUNT)
      WITH SYNONYMS ('Average Order Value', 'AOV', 'Avg Purchase')
      COMMENT = 'Average amount per order',
    ORDERS.total_orders AS COUNT(*)
      WITH SYNONYMS ('Order Count', 'Number of Orders', 'Total Transactions')
      COMMENT = 'Total number of orders'
  )
  COMMENT = 'Semantic view for order data analysis';

Real-World Use Cases

Use Case 1: Fast Start

When introducing Cortex Analyst to a new project, use this stored procedure to quickly generate semantic views for key tables. Then customize only the necessary parts according to business requirements and add relationships between tables - several times faster than building from scratch, helping you set up your semantic layer efficiently.

Use Case 2: Data Catalog

Generated semantic views contain rich synonyms and comments, making them excellent table documentation. They serve as reference material for new team members learning the table structure or can be loaded into AI Agents as an AI-oriented data catalog.

Use Case 3: POC (Proof of Concept)

For POCs validating Cortex Analyst's effectiveness, you often don't want to spend much time creating semantic layers. This stored procedure lets you build a demo environment in minutes and immediately experience Cortex Analyst's value.

Customization Tips

While auto-generated semantic views may work as-is, customizing these points will achieve even more accurate query generation:

Note: You can customize semantic views not just through SQL commands (ALTER SEMANTIC VIEW), but also via GUI in Snowsight's AI/ML Studio. AI/ML Studio lets you visually confirm the semantic view structure while intuitively adding synonyms, editing comments, and adding new Metrics.

1. Adding/Modifying Synonyms

Add industry-specific terms and internal company terminology to help Cortex Analyst better understand users' natural language:

-- Example: Add industry terms
ALTER SEMANTIC VIEW ORDERS_SEMANTIC_VIEW 
MODIFY DIMENSION ORDERS.product_name 
  ADD SYNONYMS ('SKU', 'Item Code', 'Barcode');

2. Adding Complex Calculated Metrics

Add advanced calculation formulas according to business logic:

-- Example: Add profit margin
ALTER SEMANTIC VIEW ORDERS_SEMANTIC_VIEW 
ADD METRIC ORDERS.profit_margin AS (SUM(TOTAL_AMOUNT) - SUM(COST)) / SUM(TOTAL_AMOUNT)
  WITH SYNONYMS ('Margin', 'Profit Rate', 'Return Rate')
  COMMENT = 'Profit ratio relative to sales';

3. Integrating Multiple Tables into a Semantic View

To analyze across multiple tables, integrate individually generated semantic views and define relationships between tables:

-- Example: Create semantic view containing both ORDERS and CUSTOMERS tables
-- First, generate semantic views for each table individually,
-- Then integrate into a new semantic view

CREATE OR REPLACE SEMANTIC VIEW SALES_ANALYSIS_VIEW
  TABLES (
    ORDERS AS SALES_DATABASE.PUBLIC.ORDERS
      WITH SYNONYMS ('Orders', 'Sales Data'),
    CUSTOMERS AS SALES_DATABASE.PUBLIC.CUSTOMERS
      WITH SYNONYMS ('Customers', 'Client Info')
  )
  RELATIONSHIPS (
    ORDERS.CUSTOMER_ID = CUSTOMERS.CUSTOMER_ID
  )
  -- Facts, Dimensions, Metrics omitted
  ;

For detailed customization options, see the official Snowflake documentation - Using SQL commands to create and manage semantic views.

Integration with Cortex Analyst

Generated semantic views are immediately usable with Cortex Analyst.

Verifying in Snowsight

After creating your semantic view, verify it works right away in Snowsight's AI/ML Studio Cortex Analyst playground. For implementation, Snowflake offers various options including calling from Snowflake Intelligence, calling from Cortex Agents, or configuring as a tool in Snowflake MCP Server.

Important Notes

Tool Limitations

This stored procedure has the following constraint:

Single Table Only: This tool generates semantic views from a single table only. To create semantic views combining multiple tables, first generate views for each table individually, then manually add relationships between tables.

Generated Semantic View Quality

As this uses AI auto-generation, please note:

Not Perfect: Always review and customize generated semantic views according to business requirements
Sample Data Dependency: Generated synonyms and descriptions vary based on sample data content
Complex Logic: Advanced business logic requires manual additions and modifications

Conclusion

This AI auto-generation stored procedure is a tool that dramatically accelerates the initial stages of semantic view creation. While semantic layer preparation is essential for Cortex Analyst to deliver "natural language data analysis" - that ideal world - it would be a shame if this necessary work becomes a barrier that delays your start!

Using this stored procedure, you can generate baseline semantic views in seconds, then customize necessary parts from there. As a result, you can deliver analytics environments to business departments in a much shorter timeframe.

Take the first step toward realizing data democratization and empowering business users to extract insights from data themselves - I hope this tool helps you get there!

Promotion

Snowflake What's New Updates on X

I share Snowflake What's New updates on X. Follow for the latest insights:

English Version

Snowflake What's New Bot (English Version)

Japanese Version

Snowflake's What's New Bot (Japanese Version)

Change Log

(20251009) Initial post

Original Japanese Article

https://zenn.dev/tsubasa_tech/articles/ce732d628a9bee

Unlock Advanced Data Analytics in Cursor with Snowflake MCP Server

Tsubasa Kanno — Mon, 01 Sep 2025 11:00:03 +0000

Introduction

The AI agent revolution in development is truly gaining momentum! The Model Context Protocol (MCP), a standardized protocol from Anthropic, now enables seamless connections between LLMs and various tools and APIs. And exciting news - Snowflake has released their official MCP Server as open source!

While Cortex Search and Cortex Analyst were previously available as individual features, the recent addition of SQL execution capabilities means you can now access Snowflake's analytics environment directly from MCP clients (like Cursor or Claude Desktop). Simply give natural language instructions to your AI agent and complete your data analysis - this is a game-changer for developers!

In this article, I'll walk you through setting up and using the Snowflake-Labs MCP Server with Cursor, explore the analytics possibilities it unlocks, and discuss when to use it versus Snowflake Intelligence. If you're an engineer looking to analyze Snowflake data more efficiently, this guide is for you!

Note: Tools provided by Snowflake-Labs are positioned as community tools and are not officially supported by Snowflake Inc.

Note: This article represents my personal views and not those of Snowflake.

What is Snowflake MCP Server?

Snowflake MCP Server is an official OSS tool that integrates various Snowflake features into the MCP ecosystem. By connecting with MCP clients (Cursor, Claude Desktop, fast-agent, etc.), you can operate Snowflake's powerful data analytics capabilities through AI agents.

Key Features

The current Snowflake MCP Server supports these capabilities:

Feature Category	Description
Cortex Search	Search unstructured data
Cortex Analyst	Analyze structured data using semantic models (including Semantic Views)
SQL Execution	Execute LLM-generated SQL queries
Object Management	Create, drop, and update databases, schemas, tables, views, warehouses, etc.

Technical Characteristics

Local Execution: Current version runs locally, initiated by the MCP client
Flexible Permission Management: Fine-grained control over SQL execution permissions (e.g., allowing only SELECT statements)
Multi-Service Support: Configure multiple Cortex Search / Cortex Analyst services simultaneously

Choosing Between Snowflake Intelligence and MCP Server

If you're familiar with Snowflake, you might wonder: "We already have Snowflake Intelligence - how should I choose between them?" Here's my perspective:

When Snowflake Intelligence is Better

Aspect	Details
Target Users	Business users, analysts
Environment	Web browser-based GUI
Main Use Cases	Enterprise data analysis app deployment, report creation
Advantages	Easy setup, intuitive GUI operation. All environments managed by Snowflake for enhanced security
Deployment	Easy organization-wide rollout

When Snowflake MCP Server is Better

Aspect	Details
Target Users	Engineers, developers
Environment	Development tools like Cursor, Claude Desktop
Main Use Cases	Ad-hoc data analysis during development, CI/CD integration
Advantages	Integrates with development workflow, analyze data alongside code
Deployment	Individual or team-level usage

In essence: Choose Intelligence for easy enterprise-wide natural language analysis app deployment, and MCP Server for integrating Snowflake analytics into engineering MCP clients. When in doubt, start with the easier-to-adopt Snowflake Intelligence to clarify business expectations, then consider MCP Server as needed.

Setting Up with Cursor

Let's set up the Snowflake MCP Server with Cursor! I'll demonstrate the convenient approach using PAT (Programmatic Access Token).

1. Prerequisites

Installing uvx

To run Snowflake MCP Server, you need uvx, the execution command for the uv Python package management tool. If you haven't installed it yet:

# For macOS/Linux
curl -LsSf https://astral.sh/uv/install.sh | sh

# Or install with pipx
pipx install uv

After installation, verify success with uvx --version.

Note: uvx is a tool for running Python packages in isolated environments. See uv's official documentation for details.

Generating a PAT

Log into Snowsight and generate a PAT following these steps:

Click your profile icon in the bottom left and select Settings
Navigate to the Authentication section
Click the Generate New Token button
Set the token name and expiration
Select required permissions (role)
Copy the generated token

Note: When generating a PAT, select a role with access to Cortex Search / Cortex Analyst services and the tables you'll analyze.

Important: By default, using a PAT requires a network policy to be configured. Without a network policy setup, PAT authentication may fail. For detailed PAT requirements and configuration, please refer to the official Snowflake documentation.

Preparing Cortex Search / Cortex Analyst

If you plan to use Cortex Search or Cortex Analyst with Snowflake MCP Server, you need to prepare these in advance:

For Cortex Search

You need to create a Cortex Search Service beforehand. Cortex Search Service makes unstructured data (documents, logs, text data, etc.) searchable.

For creation instructions, see the Cortex Search official documentation.

For Cortex Analyst

You need to create a Semantic Model or Semantic View beforehand. These add business context to structured data, enabling natural language query generation (Text2SQL).

Creating Semantic Models (YAML format): Cortex Analyst Semantic Model Documentation
Creating Semantic Views: Semantic View Official Documentation

Note: Creating Cortex Search Services, Semantic Models, or Semantic Views requires appropriate permissions. After creation, verify that the role specified in your PAT can access them.

Creating the Service Configuration File

Next, create a tools_config.yaml file defining Cortex services and SQL permissions. A template is available on GitHub for reference.

Note: The configuration file format may be updated in the future, so always check the latest template on GitHub.

Here's an example configuration:

# Cortex Search Service configuration
search_services:
  - service_name: "<Your Cortex Search Service name in Snowflake>"
    description: >
      "<Detailed description of your Cortex Search Service>"
    database_name: "<Database containing Cortex Search Service>"
    schema_name: "<Schema containing Cortex Search Service>"
    columns: []
    limit: 10

# Cortex Analyst Service configuration
analyst_services:
  - service_name: "<Custom name for your semantic model or semantic view>"
    semantic_model: "<Full path to semantic model or semantic view in Snowflake>"
    description: >
      "<Detailed description of your semantic model or semantic view>"

# SQL execution permission settings
sql_statement_permissions:
  # - All: True           # Uncomment this line to allow all SQL statements
  - Alter: False          # Whether to allow ALTER statements
  - Command: False        # Whether to allow COMMAND statements
  - Comment: False        # Whether to allow COMMENT statements
  - Commit: False         # Whether to allow COMMIT statements
  - Create: False         # Whether to allow CREATE statements
  - Delete: False         # Whether to allow DELETE statements
  - Describe: True        # Whether to allow DESCRIBE statements
  - Drop: False           # Whether to allow DROP statements
  - Insert: False         # Whether to allow INSERT statements
  - Merge: False          # Whether to allow MERGE statements
  - Rollback: False       # Whether to allow ROLLBACK statements
  - Select: True          # Whether to allow SELECT statements
  - Transaction: False    # Whether to allow TRANSACTION statements
  - TruncateTable: False  # Whether to allow TRUNCATE TABLE statements
  - Unknown: False        # Whether to allow undefined SQL statements
  - Update: False         # Whether to allow UPDATE statements
  - Use: True             # Whether to allow USE statements

Cursor interprets this configuration file to utilize various tools. Therefore, provide as much detail as possible in descriptions to help the AI Agent call the appropriate tools.

2. Configuring Cursor MCP

Configure MCP in Cursor. Open MCP&Integrations settings in Cursor, click "New MCP Server" to open the mcp.json editor:

Alternatively, you can directly edit the configuration file (~/.cursor/mcp.json):

{
  "mcpServers": {
    "mcp-server-snowflake": {
      "command": "uvx",
      "args": [
        "--from",
        "git+https://github.com/Snowflake-Labs/mcp",
        "mcp-server-snowflake",
        "--service-config-file",
        "<Full path to your tools_config.yaml>",
        "--account",
        "<Your Snowflake account identifier>",
        "--user",
        "<Your Snowflake username>",
        "--password",
        "<Your PAT created earlier>"
      ]
    }
  }
}

Note: For the --account parameter, if your Snowflake account identifier contains underscores like "ORGNAME-AAA_BBB_CCC", change them to hyphens like "ORGNAME-AAA-BBB-CCC".

Note: Set the PAT you generated earlier for the --password parameter. While regular passwords work, using PATs is recommended for security.

3. Verifying Connection

After configuration, click the MCP Server button you created in Cursor's MCP Server settings to start it. When successfully connected, a green indicator lights up on the MCP Server icon, and Snowflake features become available in Cursor's chat interface.

Practical Examples

Let's explore data analysis using Snowflake MCP Server from Cursor!

Example 1: Natural Language Data Exploration

Type this in Cursor's chat:

List all Snowflake databases.

MCP Server automatically generates and executes appropriate SQL, returning results:

SNOWFLAKE Database List

1. SALES
Database managing customer sales data

2. CUSTOMER
Database managing customer information
...

The AI Agent generates and executes appropriate SQL within your Snowflake role's permissions and the SQL statements allowed in your tools_config.yaml.

Example 2: Searching Unstructured Data with Cortex Search

When searching for specific information from internal documents:

Summarize the operations manual.

The configured Cortex Search Service is automatically called, returning relevant information:

📚 RetailCorp Operations Manual Summary
🏢 Company Philosophy
Mission: "Delivering exceptional customer experiences through innovation and quality"
Core Values:
Customer-first approach
Operational excellence
Sustainable growth
Employee empowerment
...

Example 3: Complex Analysis Queries

Analyze monthly sales trends for H2 2024 and identify variation factors.

Cortex Analyst interprets the semantic model or semantic view, generates appropriate SQL queries, and Cursor's AI Agent executes them, returning results:

📊 H2 2024 Sales Analysis Report

📈 Monthly Sales Trends
Month       Sales ($)   MoM Change  Features
July        152,435     -       H2 Start
August      248,291     +62.8%      Peak month
September   201,762     -18.8%      High level maintained
October     149,698     -25.8%      Sales decline
November    145,386     -2.9%       Lowest month
December    292,847     +101.3%     Holiday surge
Total       1,190,419   -       H2 Total

🔍 Key Variation Factors
1. Seasonal Factors
August: Back-to-school season peak
High-volume sales of electronics and premium products
Product lineup generating $75K per SKU

December: Holiday shopping season
Sales more than doubled from previous month
December 16 ($107,145) and 24 ($106,221) were exceptional days
Black Friday and Cyber Monday impact
...

Best Practices

Permission Configuration Guidelines

Enable secure operations with different permission settings for development and production environments:

Development: Allow Select, Describe, Use, Create, Insert, etc.
Production: Allow only Select, Describe, Use
Admin: Set All: True as needed

Conclusion

Snowflake MCP Server is a revolutionary tool that significantly enhances the developer experience. It delivers particular value through:

Development Flow Integration: Analyze data without leaving Cursor
Natural Language Operations: Execute complex analysis tasks with natural language instructions to AI Agents without writing SQL
Secure Execution Environment: Safe usage through granular permission controls

Having tried it myself, I find it incredibly convenient to complete everything within Cursor without switching tools when wondering "What was that table structure?" or "I need to check sales trends for this period."

While Snowflake Intelligence is a powerful tool for promoting organization-wide data utilization, MCP Server integrated with daily development tools offers different value for engineers and data scientists. By choosing the right tool for each use case, we can achieve more efficient data utilization.

Give Snowflake MCP Server a try today!

Promotion

Snowflake What's New Updates on X

I share Snowflake What's New updates on X. Follow for the latest insights:

English Version

Snowflake What's New Bot (English Version)

Japanese Version

Snowflake's What's New Bot (Japanese Version)

Change Log

(20250901) Initial post

Original Japanese Article

https://zenn.dev/tsubasa_tech/articles/70ab5fb2b5ed99

Snowflake AI_TRANSCRIBE - Transform Audio to Insights with SQL in Seconds

Tsubasa Kanno — Sun, 10 Aug 2025 10:37:14 +0000

Introduction

Snowflake's unstructured data analytics has taken another leap forward! After expanding Cortex AI capabilities for images and documents throughout 2025, we can now work with audio data directly from SQL!

The new AI_TRANSCRIBE function, released in Public Preview as part of Snowflake Cortex AISQL, transforms how we handle audio data. Customer support calls, meeting recordings, interviews - all these previously hard-to-leverage audio assets can now be transcribed with a single SQL query and combined with other AISQL functions for advanced analytics.

With support for images, documents, and now audio - the three major unstructured data formats - Snowflake has dramatically expanded the possibilities for business data analytics. Let's explore how AI_TRANSCRIBE works, its practical applications, and I'll even share a voice-enabled AI chatbot built with Streamlit in Snowflake!

Note: AI_TRANSCRIBE is currently in Public Preview, so features may undergo significant updates in the future.

Note: This article represents my personal views and not those of Snowflake.

What is AI_TRANSCRIBE?

AI_TRANSCRIBE is Snowflake Cortex AISQL's audio-to-text transcription function. Previously, leveraging audio data required external services or third-party packages, but AI_TRANSCRIBE enables direct audio transcription within SQL queries.

Key Features

SQL Native: Call directly from SQL like other AISQL functions for simple integration
Multi-language Support: Supports numerous languages including English, Spanish, French, German, Chinese, and many more
Speaker Identification: Distinguishes and labels multiple speakers
Timestamp Generation: Provides timestamps at word or speaker level
Secure Processing: All data processing occurs within Snowflake's secure environment

Part of the Cortex AISQL Family

AI_TRANSCRIBE becomes even more powerful when combined with existing Cortex AISQL functions:

AI_SENTIMENT: Analyze sentiment in transcribed audio
AI_CLASSIFY: Automatically categorize audio content
AI_COMPLETE: Summarize or answer questions about audio content
AI_AGG: Extract insights from grouped audio data
AI_EMBED: Vectorize audio transcripts for similarity search

Basic Usage

The basic syntax for AI_TRANSCRIBE is straightforward:

AI_TRANSCRIBE( <audio_file> [ , <options> ] )

Parameters

audio_file: FILE type object representing the audio file. Use TO_FILE function to create a reference to staged files
options: Optional OBJECT type with the following fields:
- timestamp_granularity: Specifies timestamp granularity
- "word": Timestamps for each word
- "speaker": Timestamps and labels for each speaker

Example 1: Simple Text Transcription

The simplest use case is converting audio to text:

-- Convert audio file to text
SELECT AI_TRANSCRIBE(
    TO_FILE('@audio_stage', 'customer_call_001.wav')
);

{
  "audio_duration": 19.08,
  "text": "Hi, I'd like to inquire about the product I purchased last week. The packaging was damaged when it arrived, and I'd like to request an exchange if possible. Could you help me with this? Thank you."
}

Processing time for this 19-second audio file was approximately 2 seconds - impressively fast for analytics scenarios!

Example 2: Word-Level Timestamps

For detailed analysis, add word-level timestamps:

-- Transcribe with word-level timestamps
SELECT AI_TRANSCRIBE(
    TO_FILE('@audio_stage', 'meeting_recording.wav'),
    {'timestamp_granularity': 'word'}
);

{
  "audio_duration": 19.08,
  "segments": [
    {
      "end": 1.254,
      "start": 0.993,
      "text": "Hi"
    },
    {
      "end": 1.434,
      "start": 1.254,
      "text": "I'd"
    },
    {
      "end": 1.514,
      "start": 1.434,
      "text": "like"
    }
    // ... more segments
  ],
  "text": "Hi I'd like to inquire about the product..."
}

Example 3: Speaker Identification

For meetings or interviews with multiple speakers, use speaker identification:

-- Transcribe with speaker identification
SELECT AI_TRANSCRIBE(
    TO_FILE('@audio_stage', 'interview_2025.mp3'),
    {'timestamp_granularity': 'speaker'}
);

{
  "audio_duration": 16.2,
  "segments": [
    {
      "end": 8.461,
      "speaker_label": "SPEAKER_00",
      "start": 0.511,
      "text": "Good morning, thank you for joining us today. My name is Sarah."
    },
    {
      "end": 15.153,
      "speaker_label": "SPEAKER_01",
      "start": 9.048,
      "text": "Thank you for having me. I'm John, pleased to be here."
    }
  ],
  "text": "Good morning, thank you for joining us today. My name is Sarah. Thank you for having me. I'm John, pleased to be here."
}

Supported Languages and Formats

Supported Languages

AI_TRANSCRIBE supports an extensive list of languages:

English, Spanish, French, German
Mandarin Chinese, Cantonese
Japanese, Korean
Arabic, Bulgarian, Catalan
Czech, Dutch, Greek
Hungarian, Indonesian, Italian
Latvian, Polish, Portuguese
Romanian, Russian, Serbian
Slovenian, Swedish, Thai
Turkish, Ukrainian

Supported Audio Formats

Major audio formats are supported:

MP3: Most common audio format
WAV: Uncompressed high-quality audio
FLAC: Lossless compressed audio
Ogg: Open-source format
WebM: Web standard format

Limitations and Considerations

Technical Limitations

Limitation	Details
Maximum File Size	700MB
Maximum Duration (without timestamps)	120 minutes
Maximum Duration (with timestamps)	60 minutes
Concurrent Processing	Depends on account compute resources

Usage Considerations

Audio Quality Impact: Background noise or poor audio quality may reduce transcription accuracy
Technical Terminology: Industry-specific terms or proper nouns may not be accurately transcribed
Language-Specific Behavior: Some languages may have unique behaviors with word-level timestamps
Real-time Processing: Currently supports batch processing only, not real-time streaming

Regional Availability

AI_TRANSCRIBE is natively available in:

AWS US West 2 (Oregon)
AWS US East 1 (N. Virginia)
AWS EU Central 1 (Frankfurt)
Azure East US 2 (Virginia)

For other regions: Use cross-region inference to access AI_TRANSCRIBE functionality with potentially slight latency.

Business Use Cases

AI_TRANSCRIBE excels in various business scenarios:

1. Customer Service Quality Enhancement

Transform call center recordings into actionable insights:

Sentiment Analysis: Use AI_SENTIMENT to analyze professionalism, problem resolution, and wait time perspectives
Call Classification: Automatically categorize calls as complaints, inquiries, or praise with AI_CLASSIFY
Speaker Separation: Analyze operator and customer speech separately for detailed insights
Real-time Dashboards: Visualize analysis results for immediate service quality improvements

2. Meeting Automation and Action Item Extraction

Transform meeting recordings into productivity tools:

Automatic Meeting Minutes: Instantly obtain full text from lengthy meetings
Summary Generation: Use AI_COMPLETE to create concise meeting summaries
Action Item Extraction: Automatically identify decisions and to-dos for efficient follow-up
Participant Analysis: Track who said what using speaker identification

3. Legal and Compliance Automation

Strengthen risk management with transcribed legal conversations:

Complete Documentation: Preserve all contract negotiations and legal discussions as text
Compliance Risk Detection: Classify conversation content by risk level using AI_CLASSIFY
Evidence Preservation: Accurately record who said what and when with speaker identification and timestamps
Automated Audit Reports: Extract key points and generate audit-ready documentation

4. Education and Training Enhancement

Maximize learning effectiveness with transcribed educational content:

Lecture Archives: Save course content as searchable text
Subtitle Creation: Add captions to video materials using word-level timestamps
Training Feedback Analysis: Identify improvement areas in training methodologies
Multilingual Support: Transcribe foreign language courses for easier review

5. Healthcare Documentation (with proper privacy controls)

Streamline medical documentation workflows:

Automated Clinical Notes: Generate structured medical records from doctor-patient conversations
EHR Integration: Extract relevant information for electronic health records
Multilingual Patient Care: Support international patients with transcription and translation
Quality Assurance: Analyze consultation content for healthcare improvement

Building a Voice-Enabled AI Chatbot with Streamlit in Snowflake

Let's build a simple voice-enabled AI chatbot using AI_TRANSCRIBE in Streamlit in Snowflake. Users can ask questions via voice, which gets transcribed and answered by AI (including the newly added OpenAI GPT-5!).

Application Overview

This application provides:

Voice Recording: Record audio directly from browser and save to stage
Audio Transcription: Convert to text using AI_TRANSCRIBE
AI Response Generation: Generate answers using AI_COMPLETE

Prerequisites

Environment Requirements

Python Version: 3.11 or higher
Additional Packages: None required (works with standard packages only)
Streamlit in Snowflake: Environment to create and run applications

Regional Verification

Ensure your region supports AI_TRANSCRIBE and AI_COMPLETE functions, or enable cross-region inference.

Implementation Steps

1. Create a New Streamlit in Snowflake App

Navigate to 'Streamlit' in Snowsight's left pane and click '+ Streamlit' to create a new app.

2. Paste the Sample Code

Copy and paste the sample code below directly into the app editor. No modifications needed - stage names are automatically configured.

3. Run the Application

Click the "Run" button to launch the app. The stage will be created automatically on first run.

4. Use the Application

Voice Input: Click the microphone button to speak
Model Selection: Choose your preferred AI model from the sidebar
Text Input: Regular chat input is also available

Sample Code

import streamlit as st
import io
import uuid
import json
from datetime import datetime
from snowflake.snowpark.context import get_active_session
from snowflake.snowpark.functions import ai_complete, to_file

# Get Snowflake session
session = get_active_session()

# Constants
STAGE_NAME = "AUDIO_TRANSCRIBE_STAGE"

# Page configuration
st.set_page_config(layout="wide")
st.title("AI Voice Chatbot")

# Sidebar: Model selection
st.sidebar.title("⚙️ Settings")

# Model options
model_options = [
    "━━━ 🟢 OpenAI ━━━",
    "openai-gpt-oss-120b",
    "openai-gpt-oss-20b",
    "openai-gpt-5",
    "openai-gpt-5-mini",
    "openai-gpt-5-nano",
    "openai-gpt-5-chat",
    "openai-gpt-4.1",
    "openai-o4-mini",
    "━━━ 🔵 Claude ━━━",
    "claude-4-opus",
    "claude-4-sonnet",
    "claude-3-7-sonnet",
    "claude-3-5-sonnet",
    "━━━ 🦙 Llama ━━━",
    "llama4-maverick",
    "llama4-scout",
    "llama3.3-70b",
    "llama3.2-3b",
    "llama3.2-1b",
    "llama3.1-405b",
    "llama3.1-70b",
    "llama3.1-8b",
    "llama3-70b",
    "llama3-8b",
    "━━━ 🟣 Mistral ━━━",
    "mistral-large2",
    "mistral-large",
    "mixtral-8x7b",
    "mistral-7b",
    "━━━ ❄️ Snowflake ━━━",
    "snowflake-arctic",
    "snowflake-llama-3.3-70b",
    "snowflake-llama-3.1-405b",
    "━━━ 🔴 Others ━━━",
    "deepseek-r1",
    "reka-core",
    "reka-flash",
    "jamba-1.5-large",
    "jamba-1.5-mini",
    "jamba-instruct",
    "gemma-7b"
]

# Default model setting
default_model = "llama4-maverick"
default_index = model_options.index(default_model) if default_model in model_options else 1

llm_model = st.sidebar.radio(
    "Select AI Model",
    options=model_options,
    index=default_index,
    format_func=lambda x: x if "━━━" in x else f"  • {x}"
)

# Use next model if separator is selected
if "━━━" in llm_model:
    llm_model = "llama4-maverick"

# Stage setup
@st.cache_resource
def setup_stage():
    """Setup stage for audio file storage"""
    try:
        session.sql(f"DESC STAGE {STAGE_NAME}").collect()
    except:
        session.sql(f"""
            CREATE STAGE IF NOT EXISTS {STAGE_NAME}
            ENCRYPTION = (TYPE = 'SNOWFLAKE_SSE')
            DIRECTORY = (ENABLE = TRUE)
        """).collect()

setup_stage()

# Initialize session state
if 'messages' not in st.session_state:
    st.session_state.messages = []
    st.session_state.chat_history = ""

def extract_text_from_transcript(transcript_result):
    """Extract text from AI_TRANSCRIBE result"""
    if isinstance(transcript_result, str) and transcript_result.startswith('{'):
        try:
            return json.loads(transcript_result).get('text', '')
        except:
            return transcript_result
    return transcript_result

def clean_ai_response(response):
    """Clean up AI response"""
    if isinstance(response, str):
        response = response.strip('"')
        response = response.replace('\\n', '\n')
    return response

def generate_ai_response(prompt, model):
    """Generate AI response"""
    df = session.range(1).select(
        ai_complete(model=model, prompt=prompt).alias("response")
    )
    return clean_ai_response(df.collect()[0]['RESPONSE'])

# Display chat history
for message in st.session_state.messages:
    with st.chat_message(message["role"]):
        st.markdown(message["content"])

# Voice input section
st.subheader("Voice Input")
audio_value = st.audio_input("Click the microphone button to speak")

if st.button("📤 Send Voice", disabled=(audio_value is None), use_container_width=True):
    if audio_value:
        try:
            # Upload audio file
            with st.spinner("🎤 Uploading audio..."):
                audio_filename = f"audio_{datetime.now().strftime('%Y%m%d_%H%M%S')}_{uuid.uuid4().hex[:8]}.wav"
                audio_stream = io.BytesIO(audio_value.getvalue())
                session.file.put_stream(
                    audio_stream,
                    f"@{STAGE_NAME}/{audio_filename}",
                    auto_compress=False,
                    overwrite=True
                )

            # Transcribe
            with st.spinner("📝 Transcribing audio..."):
                query = f"""
                    SELECT AI_TRANSCRIBE(
                        TO_FILE('@{STAGE_NAME}/{audio_filename}')
                    ) as transcript
                """
                result = session.sql(query).collect()

            if result and len(result) > 0:
                transcribed_text = extract_text_from_transcript(result[0]['TRANSCRIPT'])

                if transcribed_text:
                    # Add user message
                    st.session_state.messages.append({"role": "user", "content": transcribed_text})
                    st.session_state.chat_history += f"User: {transcribed_text}\n"

                    # Generate AI response
                    with st.spinner("🤖 AI is generating response..."):
                        full_prompt = st.session_state.chat_history + "AI: "
                        response = generate_ai_response(full_prompt, llm_model)

                    st.session_state.messages.append({"role": "assistant", "content": response})
                    st.session_state.chat_history += f"AI: {response}\n"

                    st.rerun()
                else:
                    st.warning("Transcription failed. Please try again.")
        except Exception as e:
            st.error(f"Error occurred: {str(e)}")

# Text input
if prompt := st.chat_input("Enter your message..."):
    # Add and display user message
    st.session_state.messages.append({"role": "user", "content": prompt})
    st.session_state.chat_history += f"User: {prompt}\n"
    with st.chat_message("user"):
        st.markdown(prompt)

    # Generate and display AI response
    try:
        with st.spinner("🤖 AI is generating response..."):
            full_prompt = st.session_state.chat_history + "AI: "
            response = generate_ai_response(full_prompt, llm_model)

        st.session_state.messages.append({"role": "assistant", "content": response})
        st.session_state.chat_history += f"AI: {response}\n"
        with st.chat_message("assistant"):
            st.markdown(response)
    except Exception as e:
        st.error(f"Error occurred: {str(e)}")

# Clear chat history
if st.button("🗑️ Clear Chat History"):
    st.session_state.messages = []
    st.session_state.chat_history = ""
    st.rerun()

Application Screenshots

Implementation Highlights

Simple Implementation: No additional packages required, works with standard libraries only
Audio Management: Store audio data in stages and process with AI_TRANSCRIBE
Multimodal Support: Supports both voice and text input
Rich Model Selection: Choose from latest models including OpenAI GPT-5

Cost Considerations

AI_TRANSCRIBE pricing follows the same token-based model as other AISQL functions:

Token Consumption and Pricing

50 tokens per second of audio: Consistent across languages and timestamp granularities
1 hour of audio = 180,000 tokens
Estimated cost: At 1.3 credits per million tokens and assuming $3 per credit, 1 hour of audio processing costs approximately $0.117

For example, a 60-second audio file:

60 seconds × 50 tokens = 3,000 tokens

Note: Audio files under 1 minute are billed as 1 minute (3,000 tokens) minimum. For processing many short audio files, consider batching them together for cost optimization.

For latest pricing information, refer to the Snowflake Service Consumption Table.

Summary

AI_TRANSCRIBE represents a breakthrough function that opens the door to audio data analytics. Combined with Snowflake's enhanced support for images and documents in 2025, the addition of audio - the third major unstructured data format - truly positions Snowflake as a comprehensive multimodal data platform.

Key Benefits

Unified Data Processing: Process all data types including audio within Snowflake
AISQL Function Integration: Combine with sentiment analysis, classification, summarization, and vectorization
Secure Environment: No external data movement required, maintaining governance
Development Efficiency: Build audio analytics pipelines with just SQL, no third-party packages needed

From customer service and meeting transcription to healthcare documentation and legal compliance, AI_TRANSCRIBE unlocks valuable insights from previously untapped audio data. Start exploring how this function can transform your business analytics today!

Have you tried audio analytics in your data workflows? What use cases are you most excited about? Share your experiences in the comments below!

Promotion

Snowflake What's New Updates on X

I share Snowflake What's New updates on X. Follow for the latest insights:

English Version

Snowflake What's New Bot (English Version)

Japanese Version

Snowflake's What's New Bot (Japanese Version)

Change Log

(20250810) Initial post

Original Japanese Article

https://zenn.dev/tsubasa_tech/articles/65e96e2bd257ec

Snowflake AI_SENTIMENT - Industry-Leading Sentiment Analysis with 0.92 Accuracy and Multi-Aspect Support

Tsubasa Kanno — Sun, 03 Aug 2025 09:48:49 +0000

Introduction

Snowflake has released the new AI_SENTIMENT function as part of Cortex AISQL, becoming GA on July 25, 2025! This represents a significant accuracy improvement over the previous ENTITY_SENTIMENT function, enabling state-of-the-art sentiment analysis directly from SQL within Snowflake.

AI_SENTIMENT goes beyond simple "positive/negative" classifications to support aspect-based sentiment analysis. For instance, with restaurant reviews, you can analyze sentiment for specific aspects like "food quality," "pricing," and "service" separately, providing much deeper insights into customer feedback.

In this article, I'll walk through the practical value and implementation approaches for the AI_SENTIMENT function, including real-world testing results that demonstrate its capabilities across different scenarios.

Note: This article represents my personal views and not those of Snowflake.

What is AI_SENTIMENT?

The AI_SENTIMENT function is Snowflake Cortex AISQL's latest sentiment analysis function. Compared to the previous ENTITY_SENTIMENT function, it delivers significantly improved accuracy along with advanced features like mixed sentiment detection and nuanced expression understanding.

Key Features

Industry-leading accuracy: Achieves 0.92 accuracy in aspect-based sentiment analysis
Rich sentiment classification: Five-level detailed analysis including positive, negative, neutral, mixed, and unknown
Multilingual support: Native support for 6 languages including English, French, German, Hindi, Italian, and Portuguese
Aspect-based analysis: Simultaneous analysis of up to 10 different aspects
Advanced context understanding: Accurately interprets implicit expressions and figurative language

Benchmark Performance

AI_SENTIMENT demonstrates superior performance compared to major LLMs:

Model	Aspect-based sentiment accuracy (ABSA-mix)	Aspect-based sentiment accuracy (ABSA-multilingual)	Overall sentiment accuracy	Overall sentiment accuracy (multilingual)
AI_SENTIMENT	0.92	0.81	0.83	0.83
claude-4-sonnet	0.84	0.79	0.75	0.82
mistral-large2	0.83	0.80	0.77	0.78
openai-gpt-4.1	0.83	0.73	0.80	0.78
llama4-scout	0.82	0.79	0.71	0.76
llama3.3-70b	0.82	0.79	0.71	0.76
AWS DetectSentiment	-	-	0.62	0.64

This high accuracy makes AI_SENTIMENT reliable for business-critical sentiment analysis tasks.

Basic Usage

AI_SENTIMENT supports two primary usage patterns:

1. Overall Sentiment Analysis

The simplest approach analyzes overall text sentiment:

SELECT AI_SENTIMENT('Text content');

2. Aspect-Based Sentiment Analysis

Analyze sentiment for specific aspects individually:

SELECT AI_SENTIMENT('Text content', ['Aspect1', 'Aspect2', ...]);

You can specify up to 10 aspects, with each aspect limited to 30 characters.

Testing with Unsupported Languages

While Japanese isn't officially supported, I tested AI_SENTIMENT's behavior with non-supported languages to understand its capabilities.

Test: English Aspect Labels

SELECT AI_SENTIMENT(
    'This restaurant''s omelet rice is quite delicious. The eggs were freshly collected this morning. However, it''s quite expensive compared to nearby stores.',
    ['Price', 'Taste', 'Freshness']
);

Result:

{
  "categories": [
    {
      "name": "overall",
      "sentiment": "mixed"
    },
    {
      "name": "Freshness",
      "sentiment": "positive"
    },
    {
      "name": "Price",
      "sentiment": "negative"
    },
    {
      "name": "Taste",
      "sentiment": "positive"
    }
  ]
}

The results show accurate understanding of the content with proper sentiment classification:

overall: mixed (complex emotions)
Freshness: positive (freshness praised)
Price: negative (price criticism)
Taste: positive (taste praised)

Key Insights

This testing revealed that for unsupported languages:

Content understanding: Text content can be understood with reasonable accuracy
Aspect constraints: Aspects should be specified in supported languages (English, etc.)
Practical workaround: Use English aspect labels even for content in unsupported languages

Supported Languages

AI_SENTIMENT natively supports:

English
French
German
Hindi
Italian
Portuguese

While other languages aren't officially supported, the testing above shows that content understanding may work for additional languages when using supported-language aspect labels.

Business Use Cases

AI_SENTIMENT excels in various business scenarios:

1. Social Media Monitoring

Monitor brand and product mentions across social platforms, tracking sentiment changes in real-time:

-- Social media analysis
SELECT 
    post_date,
    AI_SENTIMENT(content, ['Brand', 'Product', 'Service']) as sentiment_analysis
FROM social_media_posts 
WHERE brand_mention = true
ORDER BY post_date DESC;

2. Product Review Analysis

Analyze e-commerce reviews across multiple dimensions to identify improvement areas:

-- Product review analysis
SELECT 
    product_id,
    AI_SENTIMENT(review_text, ['Quality', 'Price', 'Delivery', 'Customer_Service']) as review_sentiment
FROM product_reviews
WHERE review_date >= '2025-01-01';

3. Customer Support Analysis

Measure customer satisfaction from support tickets and chat logs:

-- Customer support sentiment analysis
SELECT 
    ticket_id,
    support_category,
    AI_SENTIMENT(customer_message, ['Response_Time', 'Solution_Quality', 'Agent_Helpfulness']) as support_sentiment
FROM support_tickets
WHERE status = 'closed';

4. Employee Engagement Analysis

Assess organizational health through employee surveys and feedback:

-- Employee satisfaction analysis
SELECT 
    department,
    AI_SENTIMENT(feedback_text, ['Work_Environment', 'Management', 'Career_Growth', 'Compensation']) as employee_sentiment
FROM employee_feedback
WHERE survey_date >= '2025-01-01';

Sentiment Classification Details

AI_SENTIMENT returns these sentiment classifications:

Classification	Description	Example
positive	Clearly positive sentiment	"Excellent quality product"
negative	Clearly negative sentiment	"Completely disappointing experience"
neutral	Neutral sentiment	"Standard product as expected"
mixed	Both positive and negative elements	"Good quality but overpriced"
unknown	Cannot determine sentiment	When specified aspect doesn't exist

The mixed classification is particularly valuable as it accurately captures complex emotions that contain both positive and negative elements.

Limitations and Considerations

Technical Limitations

Limitation	Details
Context Window	2,048 tokens (approximately 1,600 words)
Maximum Aspects	Up to 10 aspects
Aspect Length	30 characters maximum per aspect
Supported Languages	6 languages (others not officially supported)

Usage Guidelines

Long text handling: Split content exceeding 2,048 tokens
Aspect selection: Choose business-relevant aspects carefully, preferably in supported languages
Result validation: Use AI results as reference; verify critical decisions manually

Cost Information

AI_SENTIMENT has a credit consumption rate of 1.6 credits per 1 million tokens, making it quite cost-effective for sentiment analysis workloads. For detailed credit consumption information, refer to the Snowflake Credit Consumption Table.

Cost Benefits

No data movement: All processing occurs within Snowflake's secure environment
No infrastructure required: No dedicated AI infrastructure setup needed
Automated operations: Easy automation through SQL
Pay-per-use: Only pay for actual usage, avoiding waste

Summary

AI_SENTIMENT represents a breakthrough function that combines sentiment analysis accuracy with business applicability. It delivers exceptional value through:

Key Advantages

Industry-leading accuracy: 0.92 accuracy in aspect-based sentiment analysis
Complex emotion understanding: Accurate analysis of mixed sentiments and implicit expressions
SQL integration: Easy integration into existing data pipelines
Cost efficiency: Significant cost savings compared to external services

Recommendations for Global Usage

Based on testing results, even for unsupported languages, practical usage is possible with these approaches:

Use English aspect labels (Price, Quality, Service, etc.)
Content understanding works across languages (though not officially supported)

I encourage you to explore AI_SENTIMENT for customer voice analysis, brand monitoring, employee satisfaction surveys, and other business scenarios to enable secure and fast data-driven decision making!

Have you tried implementing sentiment analysis in your data workflows? Share your experiences in the comments below!

Promotion

Snowflake What's New Updates on X

I share Snowflake What's New updates on X. Follow for the latest insights:

English Version

Snowflake What's New Bot (English Version)

Japanese Version

Snowflake's What's New Bot (Japanese Version)

Change Log

(20250803) Initial post

Original Japanese Article

https://zenn.dev/tsubasa_tech/articles/972c86d2ac2702

Snowflake AI_EMBED Function - Your Gateway to Unified Multimodal Vector Search

Tsubasa Kanno — Sat, 26 Jul 2025 04:50:24 +0000

Introduction

I'm excited to share insights about Snowflake's latest AI_EMBED function, a revolutionary addition to Cortex AISQL! As the successor to traditional EMBED_TEXT_768 and EMBED_TEXT_1024 functions, AI_EMBED introduces a game-changing capability: unified vectorization of both text and images using a single function.

Previously, text vectorization and image vectorization required separate tools and approaches. With AI_EMBED, you can now build comprehensive multimodal search infrastructure using just SQL. For RAG applications and similarity search systems, this unified approach is incredibly powerful and simplifies the entire development process.

If you're building AI applications that need to handle both text and visual content, this feature will transform how you approach multimodal data processing!

Note (2025/7/26): AI_EMBED function is currently in public preview, so features may undergo significant updates in the future.

Note: This article represents my personal views and not those of Snowflake.

Understanding Snowflake Cortex AISQL

Snowflake Cortex AISQL provides a comprehensive set of functions that enable direct AI functionality calls from SQL. A perfect example is the AI_COMPLETE function, which demonstrates the unified approach by processing both text and images using the same function interface:

-- Text processing
SELECT AI_COMPLETE('llama4-maverick', 'Explain the key features of Snowflake');

-- Image processing (same function!)
SELECT AI_COMPLETE('llama4-maverick', 'Describe this image', TO_FILE('@image_stage', 'dog.jpeg'));

Image processed by AI_COMPLETE function (Generated by Google Gemini)

-- Text processing result
"Snowflake is a cloud-based data warehouse solution with the following key features..."

-- Image processing result
This image shows a close-up of a dog's face with white fur and large eyes. The dog has its mouth open...

This same unified multimodal processing capability is now available for vectorization through the AI_EMBED function.

Previous Vectorization Approaches

To better understand AI_EMBED's value, let's review traditional vectorization methods in Snowflake. Previously available embedding functions included:

EMBED_TEXT_768
EMBED_TEXT_1024

For detailed analysis of these functions and their performance characteristics, I covered them extensively in my previous article about Snowflake vectorization options.

The key limitation was that text vectorization used these dedicated functions, while image vectorization required external tools or services, creating a fragmented development experience.

AI_EMBED Function Features

Unified Interface

The primary advantage of AI_EMBED is processing both text and images with the same function. This unified approach delivers several benefits:

Simplified Learning Curve: No need to master multiple functions or methods for different data types
Consistent Model Interface: Same function works across different embedding models
Streamlined Data Governance: All vectorization processing happens within Snowflake's secure environment
Easy Migration: Similar syntax to existing embedding functions enables smooth transitions

Available Models

AI_EMBED supports the following models:

Text Models

snowflake-arctic-embed-l-v2.0
snowflake-arctic-embed-l-v2.0-8k
nv-embed-qa-4
multilingual-e5-large
voyage-multilingual-2

Image Model

voyage-multimodal-3

Important: Only voyage-multimodal-3 supports image vectorization. Interestingly, this image model can also process text data effectively.

Model Characteristics

Understanding model selection is crucial for optimal results:

snowflake-arctic-embed-l-v2.0-8k: Supports up to 8,000 tokens, ideal for technical documents and long articles. This extended context can potentially eliminate chunking preprocessing for certain documents
nv-embed-qa-4: English-only model, not suitable for multilingual environments
Other models: Multilingual support with excellent performance across various languages

Choose snowflake-arctic-embed-l-v2.0-8k for long-form content and any model except nv-embed-qa-4 for multilingual applications.

Multimodal Vectorization Value

Business Value

Multimodal vectorization delivers substantial business benefits:

Enhanced Search Accuracy: Unified text and image search reveals related content that traditional keyword searches miss
Improved Customer Experience: Enables intuitive experiences like image-based product search or text-to-image discovery
Operational Efficiency: Centralized management and search across documents, diagrams, photos, and notes significantly reduces information access time
New Business Models: Enables previously impossible multimodal search services and recommendation engines

Technical Value

The technical advantages are equally compelling:

Data Silo Elimination: Solves the problem of text and image data managed in separate systems through unified vector space
Reduced Development Costs: Single platform approach with Snowflake eliminates system complexity compared to multiple specialized tools
Scalability: Snowflake's cloud-native architecture efficiently handles large-scale multimodal data processing
Security & Governance: Complete data and vectorization processing within Snowflake enables centralized governance management

Business Use Cases

AI_EMBED enables powerful business applications:

1. Multimodal Search Systems
Build e-commerce platforms where customers can search for similar products using both product images and text descriptions.

2. Content Management Systems
Create enterprise CMS solutions that enable unified search and classification of documents and visual assets.

3. Customer Support Enhancement
Develop systems that analyze both inquiry text and attached images to provide comprehensive, context-aware responses.

4. RAG Chatbots
Build enterprise chatbots that search across both textual documents and visual content to incorporate domain knowledge into LLM responses.

Practical Implementation Examples

Text Vectorization

Basic text vectorization is straightforward:

-- Text vectorization
SELECT AI_EMBED('snowflake-arctic-embed-l-v2.0-8k', 'Snowflake Summit 2025 introduced many exciting new features');

-- Text vectorization result
[0.001018,0.002565,-0.024353,0.004829, ...]

Image Vectorization

Image vectorization uses the same function with proper file handling:

-- Image vectorization
SELECT AI_EMBED('voyage-multimodal-3', TO_FILE('@image_stage', 'dog.jpeg'));

-- Image vectorization result
[-0.015381,0.008240,-0.012634,-0.024048, ...]

Vector Similarity Calculations

AI_EMBED generated vectors work seamlessly with Snowflake's vector similarity functions like cosine similarity. Here are three fundamental patterns:

1. Text-to-Text Similarity

-- Text similarity calculation
SELECT VECTOR_COSINE_SIMILARITY(
    AI_EMBED('snowflake-arctic-embed-l-v2.0', 'Beautiful sunny weather today'),
    AI_EMBED('snowflake-arctic-embed-l-v2.0', 'Today is blessed with great climate')
) as text_similarity;

-- Text similarity result
0.8324767643

2. Image-to-Image Similarity

-- Image similarity calculation
SELECT VECTOR_COSINE_SIMILARITY(
    AI_EMBED('voyage-multimodal-3', TO_FILE('@image_stage', 'cat.jpeg')),
    AI_EMBED('voyage-multimodal-3', TO_FILE('@image_stage', 'dog.jpeg'))
) as image_similarity;

-- Image similarity result
0.5069280956

3. Cross-Modal Text-to-Image Similarity

-- Cross-modal similarity calculation
SELECT VECTOR_COSINE_SIMILARITY(
    AI_EMBED('voyage-multimodal-3', 'Close-up of a dog face with white fur and large eyes'),
    AI_EMBED('voyage-multimodal-3', TO_FILE('@image_stage', 'dog.jpeg'))
) as cross_modal_similarity;

-- Cross-modal similarity result
0.6030817788

Cosine similarity ranges from -1 to 1, with values closer to 1 indicating higher similarity.

Summary

AI_EMBED represents a significant advancement in Snowflake's vectorization capabilities. The unified interface for processing both text and images makes developing multimodal AI applications significantly more accessible and efficient.

Migration from existing EMBED_TEXT_1024 functions is straightforward, enabling gradual application upgrades. As data workloads increasingly involve mixed text and image content, AI_EMBED provides the foundation for building next-generation data utilization platforms efficiently.

The future of search and AI applications is multimodal, and AI_EMBED positions Snowflake users to capitalize on these emerging opportunities. I encourage you to explore AI_EMBED and discover new possibilities for your business applications!

What multimodal use cases are you most excited to build with AI_EMBED? Share your thoughts in the comments below!

Promotion

Snowflake What's New Updates on X

I share Snowflake What's New updates on X. Follow for the latest insights:

English Version

Snowflake What's New Bot (English Version)

Japanese Version

Snowflake's What's New Bot (Japanese Version)

Change Log

(20250726) Initial post

Original Japanese Article

https://zenn.dev/tsubasa_tech/articles/e7683605e7d7aa

Game-Changing UI Updates Make Snowflake Cortex Search Management Effortless

Tsubasa Kanno — Mon, 07 Jul 2025 11:26:07 +0000

Introduction

As we progress through 2025, Snowflake's AI capabilities (Cortex AI) continue to expand dramatically. Snowflake AI & ML Studio has undergone frequent updates, making numerous AI/ML features accessible through intuitive UI interfaces. This evolution truly embodies Snowflake's commitment to usability and simplicity.

Today I'm excited to share major improvements to Cortex Search management UI within Snowflake AI & ML Studio! While Cortex Search service management was traditionally centered around SQL commands, we can now perform comprehensive management through GUI interfaces. Everything from service overviews and configuration changes to data previews and playground functionality can now be completed entirely within Snowsight.

This transformation enables everyone from data engineers to AI application developers to leverage Cortex Search more efficiently. I'll walk through these new management UI capabilities with actual screenshots, demonstrating their value and practical usage.

Understanding Cortex Search

Let me briefly explain what Cortex Search is for those new to the technology. Cortex Search is a fully-managed enterprise search service provided by Snowflake.

Key Features

Hybrid Search: Combines vector search (semantic similarity) with keyword search (lexical similarity) for high-precision results
Automatic Embedding Generation: Automatically and regularly vectorizes text data to enable semantic search capabilities
Fully Managed: No infrastructure management or tuning required - ready to use immediately
Snowflake Native: Complete integration with Snowflake's data governance and security features

For detailed usage and implementation examples, check out my previous articles: "Snowflake Cortex Search for RAG Chat Applications" and "Enhancing RAG Applications with Cortex Search Boosts & Decays".

Note (2025/7/7): Snowflake AI & ML Studio is currently in public preview, so features may undergo significant updates. However, Cortex Search itself is already Generally Available!

Note: This article represents my personal views and not those of Snowflake.

Cortex Search Management in Snowflake AI & ML Studio

Snowflake AI & ML Studio serves as Snowflake's GUI-based AI/ML environment, and Cortex Search creation capabilities have been available for some time. Recent updates have significantly enhanced Cortex Search management functionality, allowing nearly all tasks necessary for Cortex Search creation and operation to be completed entirely within Snowflake AI & ML Studio.

Accessing AI & ML Studio

First, log into Snowsight and click AI & ML → Studio from the left navigation pane.

Within Studio, you can manage various AI/ML features including Cortex Search, Cortex Analyst, LLM Playground, and ML function creation through web-based UI.

Revolutionary Cortex Search Management UI

Note: Since Cortex Search creation screens remain unchanged from previous versions, I'll focus on the management improvements here.

1. Cortex Search Service Overview

When you select Cortex Search from AI & ML Studio, all existing Cortex Search services are displayed in a comprehensive list view.

Information visible at a glance:

Service names and status indicators
Database and schema information
Index creation status
Index refresh frequency

Executable operations:

Create new services (Create button)
View detailed service information
Test searches in playground environment
Manually trigger index updates
Modify index refresh frequency and warehouse settings
Pause/resume index creation
Pause/resume services
Delete services

Previously, information like this was only accessible through SQL commands such as SHOW CORTEX SEARCH SERVICES;. Now it's presented in a visually intuitive format. This is particularly valuable since Cortex Search consumes computing resources during index creation - helping avoid situations like "Oops, I've been updating an unused Cortex Search service forever!"

2. Service Details and Data Preview

Selecting a specific Cortex Search service reveals detailed configuration information, actual data previews, and Cortex Search cost information.

Detailed information displayed:

Search target column specifications
Attribute column details
Last update timestamps
Warehouse utilization
Embedding model configurations
Service query URLs and sample code for Python/API calls
Actual data preview displays
Cortex Search cost analytics

What's particularly noteworthy is the ability to examine actual vector data. While most managed services typically hide this information, being able to inspect the actual embedded vector data provides incredibly valuable debugging information for AI engineers.

3. Playground Functionality

One of the most exciting features is the playground functionality, which allows you to test searches in real-time.

Playground capabilities:

Execute natural language search queries
Display search result chunks
Apply attribute-based filtering
Verify Boosts & Decays effects

This empowers developers to validate search quality before implementation.

Business Value and Impact

Dramatic Development and Operations Efficiency Gains

Traditional Challenge	New Management UI Solution
Required memorizing and executing SQL commands	Intuitive GUI operations
Difficult to understand service status	Real-time status displays and dashboards
Time-consuming search quality verification	Instant testing via playground
Challenging to obtain debugging information	Vector data visualization
Risk of configuration errors	GUI-guided setup

Enhanced ROI

Development Time Reduction:

Decreased service management time
Reduced search quality testing and validation time

Operational Cost Optimization:

Real-time monitoring through GUI enables appropriate resource management
Pre-testing in playground reduces trial-and-error in production environments
Eliminated costs from configuration error-induced recreations

Democratizing AI Application Development

Cortex Search management, which previously required SQL expertise, has become more accessible through GUI interfaces. This enables:

Business users to verify search quality and make basic configuration changes
Application developers to more easily integrate enterprise search and RAG chat applications

Conclusion

The Cortex Search management UI revolution in Snowflake AI & ML Studio has dramatically lowered barriers for enterprise search utilization and RAG chat application development. Operations that previously required SQL expertise can now be performed through GUI, and the playground functionality makes search quality verification simple and straightforward.

Key value propositions include:

Massive development efficiency gains: Significant time savings through intuitive GUI operations
Quality improvements: Enhanced production search quality through playground pre-testing
Reduced learning costs: New engineers can leverage Cortex Search capabilities in minimal time
Strengthened governance: Unified management within Snowflake's integrated environment maintains security and governance
Enhanced visibility: Comprehensive information visualization including vector data

For anyone considering RAG application development or enterprise search system implementation, I highly recommend exploring these new management UI capabilities. Snowflake's AI functionality continues evolving as the "AI platform for enterprise data" - advancing both usability and functionality.

Promotion

Snowflake What's New Updates on X

I share Snowflake What's New updates on X. Follow for the latest insights:

English Version

Snowflake What's New Bot (English Version)

Japanese Version

Snowflake's What's New Bot (Japanese Version)

Change Log

(20250707) Initial post

Original Japanese Article

https://zenn.dev/tsubasa_tech/articles/5f6bd4c3b4d03b

How Snowflake Copilot Inline Transformed My SQL Analysis Experience

Tsubasa Kanno — Wed, 11 Jun 2025 12:20:16 +0000

Introduction

I recently attended Snowflake Summit 2025 in San Francisco for the first time! The Summit featured many notable updates including the Crunchy Data acquisition, the powerful Snowflake Openflow for flexible data ingestion, and significant AI platform advancements. I had meaningful discussions with many customers and partners throughout the event.

Among the developer experience improvements announced, one particularly exciting update is Snowflake Copilot Inline - a new feature in Snowflake Workspaces! This feature makes SQL analysis more intuitive and efficient, delivering what truly feels like having an AI pair programming buddy right in your workspace.

Unlike traditional Snowflake Copilot, which required switching to a dedicated chat interface, Copilot Inline lets you interact with an AI assistant directly within your SQL code. This feels like pair programming with a veteran analyst, where AI supports your code creation - a truly revolutionary feature for SQL analysis.

In this article, I'll share my hands-on experience with Snowflake Copilot Inline, covering its practical value, specific usage patterns, and optimization tips. If you're interested in boosting SQL analysis productivity, this is for you!

Note (2025/6/10): Snowflake Copilot Inline is currently in public preview, so features may undergo significant updates in the future.

Note: This article represents my personal views and not those of Snowflake.

What is Snowflake Copilot Inline?

Snowflake Copilot Inline is an AI assistant feature that integrates directly into your SQL code within Snowflake Workspaces. As an enhanced version of traditional Snowflake Copilot, it offers these key capabilities:

Key Features

Feature	Description
Inline Operations	Call AI assistant with `CMD+I` (Mac) or `Ctrl+I` (Windows) shortcut directly in SQL files
Context Understanding	Automatically grasps current file content and database/schema information
Real-time Suggestions	Provides instant SQL query improvements and fixes based on code context
Diff Display	Shows proposed changes in easy-to-read diff format
One-click Application	Apply suggestions instantly with the Accept button

Supported Regions

Snowflake Copilot Inline is natively supported in:

AWS US West 2 (Oregon)
AWS US East 1 (N. Virginia)

For other regions, cross-region inference functionality can be enabled by setting the CORTEX_ENABLED_CROSS_REGION parameter.

Understanding Snowflake Workspaces

Before diving into Copilot Inline, let's briefly explore Snowflake Workspaces - the foundation that makes this AI integration possible.

Snowflake Workspaces is an integrated development environment for creating, organizing, and managing code across multiple file types, accessible immediately upon logging into Snowsight. Unlike traditional Worksheets, it offers:

Workspaces vs. Traditional Worksheets

Feature	Traditional Worksheets	Workspaces
File Management	Individual worksheet management	File/folder-based hierarchical organization
Development Environment	Single query execution focus	IDE-like integrated development environment
Git Integration	Not supported	Git repository synchronization
Parallel Execution	One query at a time	Two simultaneous queries from same SQL file
Version Control	Basic history only	Full Git-based version control

Note (2025/6/10): Snowflake Workspaces is currently in public preview, so features may undergo significant updates in the future.

Access Control and Permissions

To use Snowflake Copilot Inline, you need these permissions:

Required Permissions

COPILOT_USER database role
- Role within SNOWFLAKE database
- Granted to PUBLIC role by default
CORTEX_USER database role
- Role within SNOWFLAKE database
- Required for Snowflake AISQL functions
- Granted to PUBLIC role by default
claude-3.5-sonnet model access
- Must be included in model allowlist
- No RBAC restrictions applied

Permission Verification

Most users can access the feature with default settings, but if you encounter issues:

-- Check current permissions
SHOW GRANTS TO ROLE PUBLIC;

-- Grant permissions if needed (requires ACCOUNTADMIN)
USE ROLE ACCOUNTADMIN;
GRANT DATABASE ROLE SNOWFLAKE.COPILOT_USER TO ROLE PUBLIC;
GRANT DATABASE ROLE SNOWFLAKE.CORTEX_USER TO ROLE PUBLIC;

Supported Use Cases

Snowflake Copilot Inline excels in these scenarios:

1. Data Exploration

Query AI about unfamiliar datasets to understand structure and characteristics:

"What tables are in this schema?"
"Tell me about the structure of the customer table"

2. SQL Query Generation

Convert natural language requests into SQL code:

"Get monthly sales trends for the past year"
"Show customer purchase frequency ranked by activity"
"Create sales analysis query excluding outliers"

3. Query Optimization

Get improvement suggestions for existing queries:

"Optimize this query for better performance"
"Rewrite this query for better readability"
"Suggest efficiency improvements for this SQL"

4. Syntax Error Fixes

Quickly resolve SQL syntax issues:

"Fix the syntax error in this query"
"Why isn't this query working?"
"Correct the JOIN syntax"

How to Use Copilot Inline

Operating Snowflake Copilot Inline is refreshingly simple:

Basic Workflow

Open Workspaces
- Navigate to Workspaces in Snowsight
- Create new file or open existing SQL file

Call Copilot Inline
- Position cursor anywhere in your code
- Press CMD+I (Mac) or Ctrl+I (Windows)

Submit Request
- Enter natural language request in message dialog
- Click send icon to submit to AI

Review Suggestions
- View AI-generated changes in diff format
- Red: deleted lines, Green: added lines
Apply Changes
- Accept: Apply suggestions to code
- Reject: Decline suggestions
- Close: End session

Execute Suggested Query
- Run the suggested query to see results

Limitations and Considerations

Snowflake Copilot Inline has these current limitations:

Technical Limitations

Limitation	Details
Data Access	Cannot access table data values (metadata only)
Response Time	Complex requests may require several seconds
New Object Recognition	3-4 hours needed to recognize newly created tables/schemas
Search Scope	Considers only top 10 most relevant tables and 10 columns each

Language Support

Supported languages include:

Supported Languages

Business Value and ROI

Snowflake Copilot Inline delivers significant business impact:

Analysis Efficiency Gains

SQL creation time reduction: Significant time savings in analysis and development through natural language generation
Debugging time reduction: AI-powered syntax error detection and fixes
Learning cost reduction: High-quality query creation even for junior developers

Enhanced Data Utilization

Accelerated exploratory analysis: Faster understanding of new datasets
Best practice adoption: AI suggests optimized query patterns
Reduced skill dependency: Less reliance on individual SQL expertise

Cost Reduction Benefits

Optimized development resources: Freedom from routine query creation tasks
Reduced training costs: Shorter onboarding and training time
Quality improvement: Reduced errors and rework through AI assistance

Conclusion

Snowflake Copilot Inline is a game-changing feature that fundamentally transforms SQL analysis experience. It delivers exceptional value through:

Enhanced developer experience: Pair programming-like experience with AI assistance
Accelerated learning: Natural acquisition of best practices through AI suggestions
Massive productivity gains: Focus on creative analysis instead of routine coding tasks

Personally, I often find myself thinking "How do I write this query again?" and this feature has been invaluable for quickly fixing syntax without switching screens.

I highly recommend this feature to everyone involved in SQL analysis and development. Give it a try!

Promotion

Snowflake What's New Updates on X

I share Snowflake What's New updates on X. Follow for the latest:

English Version

Snowflake What's New Bot (English Version)

Japanese Version

Snowflake's What's New Bot (Japanese Version)

Change Log

(20250611) Initial post

Original Japanese Article

https://zenn.dev/tsubasa_tech/articles/eafab909ce2386

From Data Silos to Data Paradise - Organization Listing Approval Workflows in Snowflake

Tsubasa Kanno — Sat, 31 May 2025 10:28:50 +0000

Introduction

With the upcoming Snowflake Summit 2025 starting June 2nd, I'm excited to be heading to San Francisco! If you're attending, I'd love to connect. Unlike my usual focus on generative AI and Streamlit, today I'm diving into an exciting data collaboration update from Snowflake.

Snowflake provides a platform that supports every data architecture pattern, including the ability to realize the Data Mesh vision – where each organization takes ownership of their data while enabling others to discover and utilize it. However, implementing Data Mesh hasn't been straightforward. Beyond technical hurdles, operational challenges around cross-organizational coordination and access management have made it difficult for many enterprises to achieve this ideal.

That's where Snowflake's new Organization Listing approval workflow comes in! This feature makes enterprise data sharing more accessible and secure, enabling organizations to easily implement Data Mesh and enterprise data catalogs on the Snowflake platform.

In this article, I'll explore the value of Organization Listing approval workflows, their role as enterprise data catalogs, and how simple they are to operate.

Note: This article represents my personal views and not those of Snowflake.

Understanding Organization Listing and Internal Marketplace

Let's first clarify the relationship between Organization Listing and Internal Marketplace, as understanding this connection is crucial to grasping the value of the approval workflow feature.

What is Organization Listing?

Organization Listing is a mechanism for securely sharing data products within a Snowflake organization. It refers to listings (data sharing units) created and managed by data providers.

What is Internal Marketplace?

Internal Marketplace is a curated, secure space for collaborative data sharing within your organization, serving as the platform where Organization Listings are centrally displayed. Key features include:

Organization-only: Similar to the public Snowflake Marketplace, but exclusively for your organization
Data catalog functionality: Aggregates and organizes data products available within the organization
Secure access management: Managed through account targeting and Role-Based Access Control (RBAC)
Self-service discovery: Enables discovery and utilization of internal resources without navigating external marketplaces

Two Sides of the Same Coin

Component	Description	Role
Organization Listing	Data products shared within the organization (content)	Data sharing units created and managed by providers
Internal Marketplace	Platform where Organization Listings are displayed (location)	Where data consumers discover and access listings

In essence, Organization Listing is the "content" and Internal Marketplace is the "platform" that displays and manages it – they work together as two sides of the same coin.

Approval Workflow Overview

The newly added approval workflow feature significantly simplifies access management for Organization Listings. Previously, access permissions had to be configured manually, but this feature enables the following workflow:

1. Request-Based Access Management

Data consumers can send access requests with one click from Snowsight
Data providers receive requests and decide whether to approve or deny them
Upon approval, access permissions are automatically granted

2. Two Approval Methods

Approval Method	Features	Use Cases
Manage within Snowflake	Complete approval flow within Snowsight	When rapid approval is needed
External management	Email or URL-based approval flow	When integrating with existing approval processes

3. Flexible Access Control Settings

Organization-wide access: Anyone in the organization can access
Selected accounts and roles only: Only specified accounts and roles can access
Approval required: No one can access without prior approval (default)

Realizing the Data Mesh Vision

The true value of this approval workflow feature lies in its ability to realistically implement Data Mesh principles.

1. Promoting Distributed Data Ownership

Traditional data warehouse approaches often had IT departments centrally managing all data. However, with Organization Listing:

Each department can take responsibility for their own data
Data domain experts function as data providers
People who best understand data quality and meaning manage the data

2. Self-Service Data Discovery

The approval workflow feature enables:

Data consumers to proactively discover data
Direct interaction with data providers without IT department intermediation
Data catalog functionality that visualizes organizational data assets

3. Balancing Governance and Agility

While "strengthening governance" and "accelerating data utilization" have often been seen as opposing forces:

Approval flows maintain governance while
Simple Snowsight operations enable access requests and
Dramatically reduce time to data utilization

Simplicity of Operations

One of the major attractions of the approval workflow feature is its operational simplicity. The Snowsight-based UI allows intuitive operation even for non-technical users.

Data Provider Operations

Create Organization Listing in Provider Studio
Configure approval workflow in Access control section
Select approval method (within Snowflake or external)
Specify approvers (email addresses or roles)
Publish to complete listing

Configure access control settings in Provider Studio

Click "Set up request approval flow" in the "Allow discovery" section

Select "Manage requests in Snowflake" to set up managed approval workflow

Complete necessary settings and click "Publish" in the top right to publish the Organization Listing

Data Consumer Operations

Search and discover data in Internal Marketplace
Click Request access button
Enter access reason and submit
Receive approval notification and immediately start accessing

Search for internally published lists in Internal Marketplace and make access requests

Submit request with reason for access

Approver Operations

Receive email notification or check in Snowsight
Review request details on Internal Requests page
Make approval/denial decision with one click
Access permissions are automatically granted

Requests are notified to administrators via email

View current requests in list format in Provider Studio

Add approval reason and approve to make the listing available to consumers

All these operations are GUI-based and require no SQL knowledge. This enables data sharing and utilization even for non-data engineers.

Real-World Business Scenarios

Scenario 1: Marketing and Sales Department Collaboration

Background: Sales department wants to utilize lead information from Marketing department

Marketing department publishes lead data via Organization Listing
Sales department discovers data in Internal Marketplace
Submit access request and Marketing department approves
Begin real-time utilization for sales activities

Scenario 2: Finance and Business Department Reporting

Background: Various business departments want to perform custom analysis using financial data

Finance department publishes financial data with approval required on Organization Listing
Business departments request access as needed
Finance department judges appropriateness and approves/denies
Data utilization while maintaining compliance

Scenario 3: Data Science and Business Team Collaboration

Background: Business teams want to utilize analysis results from Data Science teams

Data Science team shares analysis results via Organization Listing
Business teams discover relevant datasets
Rapid approval process enables immediate access
Accelerated data-driven decision making

Traditional Challenges and Solutions

Traditional Challenge	Organization Listing Solution
Unaware of data existence	Centralized data catalog in Internal Marketplace
Complex access application process	One-click application in Snowsight
Time-consuming approval	Automated approval workflow
Security concerns	Approval-based and role-based access control
Unknown data quality	Provider descriptions and metadata

Conclusion

Snowflake's Organization Listing approval workflow feature is a game-changer that enables realistic implementation of Data Mesh principles.

It fundamentally solves traditional enterprise data sharing challenges in these key areas:

Significantly reduced technical barriers: GUI-based intuitive operations
Balance of governance and agility: Appropriate control through approval flows
Promoted cross-organizational data utilization: Easy data sharing across account boundaries
Data catalog functionality: Visualization of organization-wide data assets

The Data Mesh vision, often considered "idealistic," can now be realistically and easily implemented on Snowflake. For enterprises looking to accelerate data utilization organization-wide, this is undoubtedly a high-value feature.

I encourage you to leverage this functionality to build a data-driven organizational culture in your own organizations!

Promotion

Snowflake What's New Updates on X

I'm sharing updates on Snowflake's What's New on X. I'd be happy if you could follow:

English Version

Snowflake What's New Bot (English Version)

Japanese Version

Snowflake's What's New Bot (Japanese Version)

Change Log

(20250531) Initial post

Original Japanese Article

https://zenn.dev/tsubasa_tech/articles/15ee58bb9b1bd4