Streamlit in Snowflake Skill

Build and deploy Streamlit apps natively within Snowflake, including Marketplace publishing as Native Apps.

Quick Start

1. Initialize Project

Copy the templates to your project:

# Create project directory
mkdir my-streamlit-app && cd my-streamlit-app

# Copy templates (Claude will provide these)

2. Configure snowflake.yml

Update placeholders in snowflake.yml:

definition_version: 2
entities:
  my_app:
    type: streamlit
    identifier: my_streamlit_app        # ← Your app name
    stage: my_app_stage                 # ← Your stage name
    query_warehouse: my_warehouse       # ← Your warehouse
    main_file: streamlit_app.py
    pages_dir: pages/
    artifacts:
      - common/
      - environment.yml

3. Deploy

# Deploy to Snowflake
snow streamlit deploy --replace

# Open in browser
snow streamlit deploy --replace --open

When to Use This Skill

Use when:

• Building data apps that run natively in Snowflake
• Need Snowpark integration for data access
• Publishing apps to Snowflake Marketplace
• Setting up CI/CD for Streamlit in Snowflake

Don't use when:

• Hosting Streamlit externally (use Streamlit Community Cloud)
• Building general Snowpark pipelines (use a Snowpark-specific skill)
• Need custom Streamlit components (not supported in SiS)

Runtime Environments

Snowflake offers two runtime options for Streamlit apps:

Warehouse Runtime (Default)

• Creates a personal instance for each viewer
• Uses environment.yml with Snowflake Anaconda Channel
• Python 3.9, 3.10, or 3.11
• Streamlit 1.22.0 - 1.35.0
• Best for: Sporadic usage, isolated sessions

Container Runtime (Preview)

• Creates a shared instance for all viewers
• Uses requirements.txt or pyproject.toml with PyPI packages
• Python 3.11 only
• Streamlit 1.49+
• Significantly lower cost (~$2.88/day vs ~$48/day for equivalent compute)
• Best for: Frequent usage, cost optimization

Container Runtime Configuration:

CREATE STREAMLIT my_app
  FROM '@my_stage/app_folder'
  MAIN_FILE = 'streamlit_app.py'
  RUNTIME_NAME = 'SYSTEM$ST_CONTAINER_RUNTIME_PY3_11'
  COMPUTE_POOL = my_compute_pool
  QUERY_WAREHOUSE = my_warehouse;

Key difference: Container runtime allows external PyPI packages - not limited to Snowflake Anaconda Channel.

See: Runtime Environments

Security Model

Streamlit apps support two privilege models:

Owner's Rights (Default)

• Apps execute with the owner's privileges, not the viewer's
• Apps use the warehouse provisioned by the owner
• Viewers can interact with data using all owner role privileges

Security implications:

• Exercise caution when granting write privileges to app roles
• Use dedicated roles for app creation/viewing
• Viewers can access any data the owner role can access
• Best for: Internal tools with trusted users

Caller's Rights (v1.53.0+)

• Apps execute with the viewer's privileges
• Each viewer sees only data they have permission to access
• Provides data isolation in multi-tenant scenarios

Use caller's rights when:

• Building public or external-facing apps
• Need per-user data access control
• Multi-tenant applications requiring data isolation

See Caller's Rights Connection pattern below.

Project Structure

my-streamlit-app/
├── snowflake.yml           # Project definition (required)
├── environment.yml         # Package dependencies (required)
├── streamlit_app.py        # Main entry point
├── pages/                  # Multi-page apps
│   └── data_explorer.py
├── common/                 # Shared utilities
│   └── utils.py
└── .gitignore

Key Patterns

Snowpark Session Connection

import streamlit as st

# Get Snowpark session (native SiS connection)
conn = st.connection("snowflake")
session = conn.session()

# Query data
df = session.sql("SELECT * FROM my_table LIMIT 100").to_pandas()
st.dataframe(df)

Caller's Rights Connection (v1.53.0+)

Execute queries with viewer's privileges instead of owner's privileges:

import streamlit as st

# Use caller's rights for data isolation
conn = st.connection("snowflake", type="callers_rights")

# Each viewer sees only data they have permission to access
df = conn.query("SELECT * FROM sensitive_customer_data")
st.dataframe(df)

Security comparison:

Connection Type	Privilege Model	Use Case
type="snowflake" (default)	Owner's rights	Internal tools, trusted users
type="callers_rights" (v1.53.0+)	Caller's rights	Public apps, data isolation

Source: Streamlit v1.53.0 Release

Caching Expensive Queries

@st.cache_data(ttl=600)  # Cache for 10 minutes
def load_data(query: str):
    conn = st.connection("snowflake")
    return conn.session().sql(query).to_pandas()

# Use cached function
df = load_data("SELECT * FROM large_table")

Warning: In Streamlit v1.22.0-1.53.0, params argument is not included in cache key. Use ttl=0 to disable caching when using parametrized queries, or upgrade to 1.54.0+ when available (Issue #13644).

Optimizing Snowpark DataFrame Performance

When using Snowpark DataFrames with charts or tables, select only required columns to avoid fetching unnecessary data:

# ❌ Fetches all 50 columns even though chart only needs 2
df = session.table("wide_table")  # 50 columns
st.line_chart(df, x="date", y="value")

# ✅ Fetch only needed columns for better performance
df = session.table("wide_table").select("date", "value")
st.line_chart(df, x="date", y="value")
# 5-10x faster for wide tables

Why it matters: st.dataframe() and chart components call df.to_pandas() which evaluates ALL columns, even if the visualization only needs some. Pre-selecting columns reduces data transfer and improves performance (Issue #11701).

Environment Configuration

environment.yml (required format):

name: sf_env
channels:
  - snowflake          # REQUIRED - only supported channel
dependencies:
  - streamlit=1.35.0   # Explicit version (default is old 1.22.0)
  - pandas
  - plotly
  - altair=4.0         # Version 4.0 supported in SiS
  - snowflake-snowpark-python

Error Prevention

This skill prevents 14 documented errors:

Error	Cause	Prevention
PackageNotFoundError	Using conda-forge or external channel	Use channels: - snowflake (or Container Runtime for PyPI)
Missing Streamlit features	Default version 1.22.0	Explicitly set streamlit=1.35.0 (or use Container Runtime for 1.49+)
ROOT_LOCATION deprecated	Old CLI syntax	Use Snowflake CLI 3.14.0+ with FROM source_location
Auth failures (2026+)	Password-only authentication	Use key-pair or OAuth (see references/authentication.md)
File upload fails	File >200MB	Keep uploads under 200MB limit
DataFrame display fails	Data >32MB	Paginate or limit data before display
page_title not supported	SiS limitation	Don't use page_title, page_icon, or menu_items in st.set_page_config()
Custom component error	SiS limitation	Only components without external service calls work
_snowflake module not found	Container Runtime migration	Use from snowflake.snowpark.context import get_active_session instead of from _snowflake import get_active_session (Migration Guide)
Cached query returns wrong data with different params	params not in cache key (v1.22.0-1.53.0)	Use ttl=0 to disable caching for parametrized queries, or upgrade to 1.54.0+ when available (Issue #13644)
Invalid connection_name 'default' with kwargs only	Missing secrets.toml or connections.toml	Create minimal .streamlit/secrets.toml with [connections.snowflake] section (Issue #9016)
Native App upgrades unexpectedly	Implicit default Streamlit version (BCR-1857)	Explicitly set streamlit=1.35.0 in environment.yml to prevent automatic version changes (BCR-1857)
File paths fail in Container Runtime subdirectories	Some commands use entrypoint-relative paths	Use pathlib to resolve absolute paths: Path(__file__).parent / "assets/logo.png" (Runtime Docs)
Slow performance with wide Snowpark DataFrames	st.dataframe() fetches all columns even if unused	Pre-select only needed columns: df.select("col1", "col2") before passing to Streamlit (Issue #11701)

Deployment Commands

Basic Deployment

# Deploy and replace existing
snow streamlit deploy --replace

# Deploy and open in browser
snow streamlit deploy --replace --open

# Deploy specific entity (if multiple in snowflake.yml)
snow streamlit deploy my_app --replace

CI/CD Deployment

See references/ci-cd.md for GitHub Actions workflow template.

Marketplace Publishing (Native App)

To publish your Streamlit app to Snowflake Marketplace:

1. Convert to Native App - Use templates-native-app/ templates
2. Create Provider Profile - Required for Marketplace listings
3. Submit for Approval - Snowflake reviews before publishing

See templates-native-app/README.md for complete workflow.

Native App Structure

my-native-app/
├── manifest.yml            # Native App manifest
├── setup.sql               # Installation script
├── streamlit/
│   ├── environment.yml
│   ├── streamlit_app.py
│   └── pages/
└── README.md

Package Availability

Only packages from the Snowflake Anaconda Channel are available:

-- Query available packages
SELECT * FROM information_schema.packages
how to use streamlit-snowflake
CursorClaude CodeClineCodexWindsurfGooseGitHub CopilotVS CodeGemini CLIKiloOpencodeKimi CLIRoo ClineAiderContinueZedBolt.newLovablev0Replit AgentSweepSmol DeveloperDevinCavemanAmpAntigravity
How to use streamlit-snowflake on Cursor
AI-first code editor with Composer
1
Prerequisites
Before installing skills in Cursor, ensure your development environment meets these requirements:
›Cursor installed and configured on your development machine
›Node.js version 16.0+ with npm package manager (verify with node --version)
›Active project directory or workspace where you want to add streamlit-snowflake
2
Execute installation command
Execute the skills CLI command in your project's root directory to begin installation:
$npx skills add https://github.com/jezweb/claude-skills --skill streamlit-snowflakecopy
The skills CLI fetches streamlit-snowflake from GitHub repository jezweb/claude-skills and configures it for Cursor.
3
Select Cursor when prompted
The CLI will show a list of available agents. Use arrow keys to navigate and space to select Cursor:
◆ Which agents do you want to install to?
│
│ ── Universal (.agents/skills) ── always included ────
│   • Amp
│   • Antigravity
│   • Cline
│   • Codex
│ ●Cursor(selected)
│   • Cursor
│   • Windsurf
4
Verify installation
Confirm successful installation by checking the skill directory location:
.cursor/skills/streamlit-snowflake
Reload or restart Cursor to activate streamlit-snowflake. Access the skill through slash commands (e.g., /streamlit-snowflake) or your agent's skill management interface.
⚠
Security & Verification Notice
We perform automated surface-level scans (Gen AI Scanner, Socket, Snyk) during installation. These checks detect common vulnerabilities but do not guarantee complete security. Always review skill source code and verify the publisher's reputation before production use.
Skills execute code in your development environment. Always verify the publisher's identity, review recent commits, and test in isolated environments before production deployment.
Additional Resources
›View source code on GitHub›Skills CLI documentation›Learn more about Cursor›What are agent skills?