When you’re building tutorial content, good data is hard to come by. You need something real enough to tell a story, rich enough to be interesting, and relevant enough that developers actually care.

So when Joe Reis had just published his 2026 State of Data Engineering report (i.e. 1,136 survey responses from data engineering practitioners across the globe) I knew I had something worth building on. Columns on everything from orchestration tools to AI adoption to the bottlenecks keeping teams up at night.

I also had an idea: turn this static CSV into an interactive data exploration app where anyone could slice the data by role, industry, region, and org size. Not a single dashboard page, but a full multipage Streamlit app with distinct analysis angles spanning personas, tech stacks, AI adoption, organizational dynamics, pain points, education gaps, and practitioner voices.

A project like this would normally take a few months to build out. Back in 2023, I built the State of LLM Apps 2023 in about 3 months.

With agentic engineering in Cortex Code, using custom agent skills, an AGENTS.md file with app design patterns, and an app.md planning doc for ideation, I built a similar app over the course of about a week, working in focused sessions between other tasks. That's 12 weeks compressed into a week! Here's how that played out.

From vibe coding to agentic engineering

But before we dive into the specifics, let’s take a moment to explore the shift from vibe coding to agentic engineering.

“AI-assisted coding” is the catch-all term for any coding activity that uses AI. It spans everything from vibe coding to agentic engineering and whatever comes next. Within that spectrum, the approaches differ sharply in how much control you hand over and how much structure you bring.

In early 2025, Andrej Karpathy coined “vibe coding” to describe the free-form, prompt-driven way people were generating software with AI: type a prompt, accept the output, “forget that the code even exists.” It captured the excitement of the moment. But for anything beyond a quick prototype, vibes alone produce fragile apps that need heavy rework. You end up spending more time debugging AI-generated code than you saved writing it.

A year later, Karpathy introduced a new term: agentic engineering. The distinction matters. “Agentic,” he writes, “because the new default is that you are not writing the code directly 99% of the time, you are orchestrating agents who do and acting as oversight. Engineering to emphasize that there is an art & science and expertise to it. It’s something you can learn and become better at, with its own depth of a different kind.”

Simon Willison builds on this in his Agentic Engineering Patterns guide: you define a goal, the coding agent generates and executes code in a loop until that goal is met, and your job is figuring out what to build, navigating tradeoffs, verifying results, and updating instructions so the agent learns from past mistakes. Vibe coding, Willison argues, is more useful in its original definition as a term for “unreviewed, prototype-quality LLM-generated code” rather than a catch-all for AI-assisted development.

This project was agentic engineering, not vibe coding.

Here’s how:

• The app.md planning doc defined the goals.
• The AGENTS.md file and a custom streamlit-design-patterns skill provided the constraints and patterns.
• I reviewed every page the agent produced, caught edge cases it missed, and refined the instructions for the next session.
• The agent wrote the code.
• I drove the architecture, the editorial decisions, and the quality bar.

Start with the story, not the code

The instinct with vibe coding is to jump straight into prompting: “build me a dashboard.” I’ve learned the hard way that this produces generic apps that need heavy rework through several iterations.

Instead, I started by writing a planning document. Not code. A markdown file called app.md that laid out every page I wanted, what data each page needed, and the story each page should tell. I used the AI to help brainstorm page ideas and analysis angles, then curated and refined the best ones into the plan. The AI Paradox page, for example, needed to answer one question: "82% of practitioners use AI daily, but only 10% have it embedded organizationally. What explains the gap?"

I spent nearly a day on planning alone. But every session after that was faster because of it.

Excerpt from app.md (plan before code)

The planning file lived in an app.md file and was written as a full build specification file (purpose, audience, repo layout, and navigation) before any implementation of the app. It opened like this:

# State of Data Engineering 2026 - Interactive Explorer App

An app building plan for creating an interactive Streamlit application to explore the 2026 State of Data Engineering survey data, following BioCurator design patterns.

---

## 1. App Overview

### Purpose
Transform static survey findings into an interactive exploration tool where users can discover insights relevant to their specific role, industry, and technology stack.

### Target Users
- Data Engineers benchmarking their organization
- Data Leaders making strategic decisions
- Recruiters understanding the talent landscape
- Vendors understanding market adoption

---

## 2. App Structure

state-of-engineering-app/
├── app.py                          # Main entry point (navigation + session state)
├── data_utils.py                   # Shared data loading, filtering, caching
├── chart_utils.py                  # Reusable chart components
├── pages/
│   ├── home.py                     # Overview dashboard with key stats
│   │
│   │   # Persona & Benchmarking
│   ├── persona_matcher.py          # Find Your Tribe Persona Matcher
│   ├── regional_benchmark.py       # Regional Benchmark Tool
│   ├── solo_practitioner.py        # Solo Practitioner Experience
│   │
│   │   # Technology Stack & Architecture  
│   ├── stack_explorer.py           # Technology Stack Explorer
│   ...                             # (additional page modules in the full doc)

The full app.md went on to spell out navigation (st.navigation groupings), session state, sidebar filters, per-page specs, phased implementation order, and widget–chart pairings—so every later prompt could point at a single source of truth.

Architecture: shared utilities, independent pages

With the plan in hand, I asked Cortex Code to build the foundation first: a data_utils.py for loading and filtering survey data, and a chart_utils.py with reusable chart functions including donut charts, lollipop charts, diverging bars, Sankey diagrams, radar charts, and heatmaps.

This was a deliberate choice. Every page imports from the same two utility files, which means consistent styling, consistent data handling, and zero copy-paste drift across 17 pages. When I later tweaked the color palette from defaults to a custom rainbow scheme (#8B5CF6, #3B82F6, #10B981, #FACC15, #F59E0B, #EF4444), every chart across every page updated at once.

The main app.py handles navigation using st.navigation() with grouped sections (Persona, Tech Stack, AI Adoption, Organization, Pain Points, Skills) and a sidebar with global filters. Every page reads from get_filtered_df(), so when you filter to "Finance, 1000+ employees" in the sidebar, all 17 pages reflect that slice.

Building pages with agent skills

Once the foundation was solid, I started requesting pages in focused sessions, typically knocking out two or three pages per sitting. This is where the agentic engineering approach really paid off. I had a custom streamlit-design-patterns skill loaded into Cortex Code and an AGENTS.md file encoding app design patterns (layout conventions, charting preferences, Streamlit idioms). The agent didn't start from scratch each time; it worked from established patterns.

Each prompt followed a pattern:

Build the AI Paradox page. It should show personal AI usage vs organizational adoption as side-by-side donut charts, then filter to the “gap cohort” (daily AI users with low org adoption) and show their bottlenecks and industries. Add a select slider that lets users explore characteristics at each adoption level. End with a segment comparison that shows the personal-vs-org gap by industry, role, or region.

Cortex Code would generate the page, I’d review the output, and we’d iterate. The typical cycle was: generate, run, spot an issue, fix, move on. Most pages took a few rounds of iterations.

Some patterns I noticed working well:

Giving the AI the data schema up front. The survey had columns like ai_usage_frequency, ai_adoption, biggest_bottleneck, and modeling_pain_points (comma-separated multi-select). When I included these column names and their possible values in my prompts, the generated code was far more accurate.

Requesting specific chart types. “Use a lollipop chart for bottlenecks” produced better results than “visualize the bottlenecks.” The AI knew exactly which chart_utils function to call.

Adding insight captions programmatically. Each chart section ends with a dynamically generated st.caption() that highlights the top findings. For example: "Legacy/Tech Debt leads at 24%, followed by Lack of leadership direction at 21%." These aren't hardcoded strings. They're dynamically computed from the filtered data, so they update as users apply filters.

Tricky parts

Not everything was smooth. Here’s a few lessons from the rough edges:

Multi-select columns need preprocessing. The modeling_pain_points column contained comma-separated values like "Pressure to move fast, Lack of ownership." I needed an explode_multiselect() utility to properly count and cross-tabulate these values. The AI initially tried to treat them as single categories.

Global filter state management was fiddly. I wanted an “All Roles” option that auto-deselects when you pick specific roles, and auto-reselects when you clear everything. This required a custom init_multiselect_state() function that tracks previous selections via a shadow key in st.session_state. Getting this right took the most back-and-forth.

Altair’s labelLimit defaults truncate long labels. Survey responses like "Lack of leadership direction / unclear business strategy" would get cut off. Setting axis=alt.Axis(labelLimit=0) on every Y axis became a global pattern I enforced across all pages.

What I’d do differently

If I were starting over, I’d add the about.py page first instead of last. It provides context that helps users understand the data source, methodology, and limitations. Building it last meant I had to go back and verify all my assumptions about column meanings.

I’d also create a FILTERS.md or constants file defining all the ordered category lists (org sizes from "< 50 employees" to "10,000+", AI adoption from "No meaningful adoption" to "AI embedded") in one place. I ended up defining these in data_utils.py, but having them as a separate reference would have made prompts cleaner.

Result

The final app has 17 interactive pages, 20 Python files, a shared color system, global sidebar filters, and dynamically generated insight text. Every chart responds to the global filters. The persona matcher computes similarity scores across four dimensions. The firefighting predictor cross-tabulates modeling approach, orchestration, and org size against firefighting rates.

Here’s what the completed app looked like:

All from one CSV file, one planning document, and about a week of iterative prompting sessions using the agentic engineering workflow. Essentially, the provided prompts provided the intent that the agent skills used to guide it during the coding phase. This took us to a reasonably good starting point that required a few more iterations to fine-tune the app.

You can see the LinkedIn video walkthrough showing the app in action.

2026 State of Data Engineering Survey Interactive Explorer | Chanin Nantasenamat posted on the topic | LinkedIn

Takeaway

Agentic engineering isn’t vibe coding. As Karpathy puts it, you’re orchestrating agents and acting as oversight, not hoping a single prompt produces something usable. As Willison describes, you define goals, verify results, and update your instructions so the agent improves over time. In practice, that meant giving the AI structured context to work from.

An app.md for ideation, an AGENTS.md for design patterns, custom skills for domain knowledge, and reusable utility modules for consistency. I handled the editorial decisions, including what story each page tells, what data supports it, and what the user should take away. The agent handled the execution, grounded in patterns I'd defined.

The planning document was worth more than any individual prompt. If you’re building something beyond a single-page prototype, invest in the context layer first. Your agent will build better software because of it.

Conclusion

The week-long build only worked because the unglamorous decisions (i.e. what to call each page, how files fit together, which chart library to standardize on) were settled in app.md before the first serious line of app code is written.

The product was not something the agent dreamed up, it was the implementation of a plan that I had already thought through on paper. Early on, a workflow like this can feel sluggish: you spend time on markdown, skills, and guardrails instead of visible UI. Treat that as front-loaded cost, not waste. What you buy is alignment: page seventeen still feels like the same app as page one, and a structure you can navigate and debug on your own, long after the session ends.

This is how I build Streamlit apps in the age of agentic AI. How do you build Streamlit apps?

Happy Streamlit-ing! 🎈

How Agentic Engineering Changed the Way I Build Streamlit Apps was originally published in Streamlit on Medium, where people are continuing the conversation by highlighting and responding to this story.

Introduction

If you’ve ever worked with AI coding assistants like Cursor, GitHub Copilot, or Claude Code, you know they can be incredibly powerful, but also inconsistent. Sometimes it nails your code style, sometimes it forgets everything you’ve established.

This is where AGENTS.md comes in. It’s an open standard for guiding AI coding agents. Think of it as a README for AI, a dedicated file that provides context, conventions, and instructions that help AI assistants work effectively on your coding projects.

In this article, I’ll show you how to use this AGENTS.md file to build Streamlit apps across all deployment targets: local development, Streamlit Community Cloud, and Streamlit in Snowflake (SiS).

What is AGENTS.md?

AGENTS.md is a simple, open format adopted by over 60,000 open-source projects, including repositories from OpenAI, Apache, and Google. It emerged from collaborative efforts across the AI software development ecosystem.

The key insight is that README.md files are for humans, while AGENTS.md is for AI agents. It contains the detailed context that AI coding assistants need: build commands, code conventions, testing patterns, and domain-specific knowledge.

Where These Patterns Come From

The Streamlit AGENTS.md isn’t theoretical. It’s built from real-world experience:

• 30 Days of AI: A 30-day learning series teaching AI app development with Streamlit and Snowflake Cortex (GitHub). Each day’s lesson contributed battle-tested patterns for chatbots, RAG systems, streaming responses, and agent orchestration.
• Experience in Streamlit Development: Patterns refined from building dozens of Streamlit applications over 2024–2025, including data dashboards, cheminformatics tools, ML apps, and enterprise applications deployed to Streamlit in Snowflake.

Every pattern in this AGENTS.md has been validated in production. The AI_COMPLETE function, the universal connection pattern, the streaming chat interface: all emerged from solving real-world problems across different deployment environments.

Why This Works

The AGENTS.md approach works because:

1. Minimal friction: One file reference, a few questions, complete app
2. Smart defaults: Caching, error handling, and UI components are inferred
3. Environment-aware: Automatically handles SiS vs Community Cloud differences
4. Complete output: Every app includes app.py, requirements.txt, README.md
5. Consistent patterns: Same proven code patterns every time

Download AGENTS.md

To proceed further, download the Streamlit AGENTS.md file from this GitHub repo:

streamlit/AGENTS.md at main · dataprofessor/streamlit

Getting Started in Using Streamlit AGENTS.md

The Streamlit AGENTS.md supports two modes of operation, making it effortless to get started.

To start, download and copy the Streamlit AGENTS.md to your project.

Mode 1: Quick Start with Instructions

If you know what you want, just tell the AI:

@AGENTS.md build me a chatbot using Snowflake Cortex

Here’s how it looks like in Cursor:

In a nutshell, the AI will:

• Use your instruction as the starting point
• Infer reasonable defaults
• Ask only 1–2 clarifying questions if critical info is missing
• Build the complete app with all files

Here’s the first question and our corresponding answer:

After a few moments, the AI is getting to work:

After about a minute or so, completed app is completed and the app structure and its core features are summarized:

This is followed by instructions on how to run the app:

And it doesn’t stop there, you can ask follow-up questions to assist you in understanding the created app:

Or you can also continue to vibe code and make incremental improvements to the app.

Mode 2: Guided Sequential Questions

If you’re not sure what you need, just reference the file:

@AGENTS.md

Here’s what it looks like in Cursor:

The AI will guide you through questions one at a time:

1. “What would you like to build?” → chatbot, dashboard, data tool
2. “Where will it run?” → local, Community Cloud, Snowflake
3. “What’s your data source?” → CSV, Snowflake, APIs
4. “Which LLM?” (only if you mentioned AI) → Cortex or OpenAI

Then it builds, inferring UI components from app type and adding caching automatically.

Here’s our first question:

The second question:

The third question:

And that’s all, it’ll proceed to building the app:

Once it’s completed, we get a summary of what’s been built:

Along with instructions on deployment:

What Gets Created

When you build an app with the AGENTS.md, you get a complete, deployment-ready project:

my_app/
├── app.py                      # Main application
├── requirements.txt            # Dependencies with versions
├── README.md                   # GitHub-ready documentation
└── .streamlit/
    └── secrets.toml.example    # Credentials template (if needed)

The README.md

Every app includes a README with:

• TLDR: One sentence describing the app
• Features: Bullet list of capabilities
• Run Locally: Step-by-step commands
• Deploy to Community Cloud: 5-step guide
• Deploy to SiS: 3-step guide

No more creating documentation manually!

Example Apps

Two complete example apps were built using the AGENTS.md guided flow. Both are available in the examples/ folder.

Example 1: Chatbot

A conversational AI chatbot powered by Snowflake Cortex.

The Q&A Flow:

Here’s the questions and answers:

• What would you like to build? Simple chatbot
• Where will it run? Community Cloud
• Which LLM? Cortex

What Got Created:

examples/chatbot_app/
├── app.py              # Chat interface with streaming
├── requirements.txt    # streamlit, snowflake-snowpark-python
└── README.md           # Deployment instructions

Features: Chat interface, model selector (Claude/Llama/Mistral), conversation history, response caching.

A few questions. Complete app. Ready to deploy.

Example 2: Stock Dashboard

A real-time stock dashboard using the Yahoo Finance data.

The Q&A Flow:

Here’s the questions and answers:

• What would you like to build? Dashboard
• Where will it run? Snowflake
• What’s your data source? yfinance

What Got Created:

examples/stock_dashboard/
├── app.py              # Dashboard with Plotly charts
├── requirements.txt    # streamlit, yfinance, plotly
└── README.md           # Deployment instructions

Features: Candlestick charts, volume analysis, key metrics, time period selector.

Three questions. The AI knew not to ask about LLMs (dashboards don’t need them) and automatically omitted st.set_page_config() for SiS compatibility as it is an unsupported feature on SiS.

Key Patterns that AGENTS.md Teaches AI

1. Universal Database Connection

Works across all three deployment environments:

@st.cache_resource
def get_session():
    try:
        from snowflake.snowpark.context import get_active_session
        return get_active_session()
    except:
        from snowflake.snowpark import Session
        return Session.builder.configs(
            st.secrets["connections"]["snowflake"]
        ).create()

2. Snowflake Cortex LLM with AI_COMPLETE

The recommended pattern for universal compatibility:

import json
from snowflake.snowpark.functions import ai_complete

@st.cache_data(show_spinner=False)
def call_llm(prompt: str, model: str = "claude-3-5-sonnet") -> str:
    df = session.range(1).select(
        ai_complete(model=model, prompt=prompt).alias("response")
    )
    response_raw = df.collect()[0][0]
    response_json = json.loads(response_raw)
    
    if isinstance(response_json, dict) and "choices" in response_json:
        return response_json["choices"][0]["messages"]
    return str(response_json)

3. Chat Interface with Streaming

st.session_state.setdefault("messages", [])

for msg in st.session_state.messages:
    with st.chat_message(msg["role"]):
        st.markdown(msg["content"])

if prompt := st.chat_input("Your message"):
    st.session_state.messages.append({"role": "user", "content": prompt})
    with st.chat_message("user"):
        st.markdown(prompt)
    
    with st.chat_message("assistant"):
        response = st.write_stream(stream_response(prompt))
    
    st.session_state.messages.append({"role": "assistant", "content": response})

4. SiS-Aware Code

The AI automatically knows:

• SiS deployment → No st.set_page_config()
• Community Cloud → Include st.set_page_config()
• Both → Use the universal connection pattern

Pattern Selection Guide

Based on what you ask for, the AI selects the right patterns:

+-------------------------+---------------------------------------------+
| You Say                 | AI Uses                                     |
+-------------------------+---------------------------------------------+
| chatbot, AI assistant   | Chat Interface + Streaming + AI_COMPLETE    |
+-------------------------+---------------------------------------------+
| dashboard,              | Basic App + Plotly/Altair Charts            |
| visualization           |                                             |
+-------------------------+---------------------------------------------+
| data analysis           | File Upload + DataFrame Styling             |
+-------------------------+---------------------------------------------+
| RAG, search documents   | Chat + Cortex Search + AI_COMPLETE          |
+-------------------------+---------------------------------------------+
| multipage               | st.navigation + Session State               |
+-------------------------+---------------------------------------------+
| Snowflake, SiS          | Omit st.set_page_config + Cortex patterns   |
+-------------------------+---------------------------------------------+

Caching is added automatically wherever beneficial.

Common Pitfalls Prevented

The AGENTS.md teaches the AI to avoid common mistakes:

1. Duplicate Widget Keys

# AI learns to always add unique keys
st.text_input("Name:", key="first_name")
st.text_input("Name:", key="last_name")

2. Page Config in SiS

# AI omits st.set_page_config() when targeting SiS
# (it's not supported)

3. Session State in Multipage Apps

# AI initializes in main app.py, not individual pages
st.session_state.setdefault("df", None)
pg = st.navigation(...)
pg.run()

Conclusion

Building a Streamlit app couldn’t be easier. With the AGENTS.md file, you can truly vibe code. Just describe what you want, answer a few questions, and watch your app come to life.

Instead of explaining patterns in detail, going through several rounds of promptings and hoping that AI gets it right.

Here’s what you get from using AGENTS.md:

• Two modes: Quick instructions or guided questions
• Sequential flow: One question at a time, not overwhelming
• Smart inference: UI components and caching handled automatically
• Complete projects: App, requirements, and README ready to deploy
• Environment-aware: SiS compatibility built in

Check out the examples/ folder in the repo to see the chatbot and dashboard apps created using this exact flow.

Resources

• AGENTS.md Official Website
• Streamlit Documentation
• Snowflake Cortex AI
• Streamlit in Snowflake
• Example Apps: Example apps built with AGENTS.md

Vibe code Streamlit apps with AI using AGENTS.md was originally published in Streamlit on Medium, where people are continuing the conversation by highlighting and responding to this story.

Vibe coding has changed how we build apps. You describe what you want, and after a few seconds, AI generates the code. After a few rounds of iteration and you have a working Streamlit dashboard app. It’s genuinely magical.

But here’s the catch, without understanding how Streamlit actually works under the hood, that rapid progress can hit a wall. Your app suddenly behaves strangely. Data disappears. Buttons don’t seem to work. Performance grinds to a halt.

After spending considerable time on the Streamlit Community Forum and reviewing countless questions from beginners (some of whom were vibe coding their first apps), I started noticing patterns. The same confusions kept surfacing. The same “why isn’t this working?!” moments.

The good news? Most of these issues stem from a handful of core misunderstandings about how Streamlit actually works under the hood. Once you internalize these concepts, the framework clicks into place and you can vibe code with confidence instead of crossing your fingers every time you hit save.

Rather than cataloging every possible mistake (that list would be quite extensive), I’ve distilled these into 10 core principles. Master these, and you’re on your way to building Streamlit apps with confidence.

Let’s dive in!

1. Understand that your script reruns completely on every interaction

This is the concept. The one that explains 80% of the unexpected behavior that you’ll encounter. If you only internalize one thing from this entire post, make it this:

Every button click, slider move, or text input triggers a complete rerun of your script from top to bottom. Not a partial update. Not a diff. The whole thing, starting from import streamlit as st and all the way down.

# ❌ This resets to 0 on every interaction
counter = 0
if st.button("Add"):
    counter += 1
st.write(counter)  # Always shows 0 or 1

# ✅ Use session state for persistence
if "counter" not in st.session_state:
    st.session_state.counter = 0
if st.button("Add"):
    st.session_state.counter += 1
st.write(st.session_state.counter)  # Accumulates correctly

Here are some common symptoms that we may see if not understanding this concept:

• Variables “reset” unexpectedly
• Buttons seem to “not work”
• Data disappears after clicking something else
• Chat history vanishes

The fix: st.session_state

Session state is a dictionary that persists across reruns for each user session. The key pattern to memorize:

# Always initialize before using
if "counter" not in st.session_state:
    st.session_state.counter = 0

This check ensures you only set the default once (on the first run), and subsequent reruns use the existing value. Skip this check, and you’ll reset your variable on every interaction.

When to use session state:

• Counters, toggles, and flags
• User inputs you need to preserve
• Chat message history
• Multi-step form data
• Any value that should survive a rerun

Once this pattern becomes second nature, most “mysterious” Streamlit behavior suddenly makes perfect sense.

2. Cache expensive operations, always

Remember that rerun behavior from Principle 1? Here’s where it becomes a performance nightmare if you’re not careful.

If your code takes time to run (loading files, API calls, ML models), it will run on every single interaction unless you cache it. Your users don’t want to wait 10 seconds every time they adjust a slider.

# ❌ Loads 500MB file on every click
data = pd.read_csv("large_file.csv")

# ✅ Cache it - runs once, reuses result
@st.cache_data
def load_data():
    return pd.read_csv("large_file.csv")

data = load_data()

The two decorators:

• @st.cache_data: For data (DataFrames, lists, API responses). Returns a copy.
• @st.cache_resource: For resources (DB connections, ML models). Returns the same object.

Add TTL for data that updates frequently:

@st.cache_data(ttl=300)  # Refresh every 5 minutes
def get_live_data():
    return api.fetch()

Why does this work? The decorator stores the function’s return value in memory, keyed by the function’s input arguments. On subsequent calls with the same arguments, Streamlit returns the cached result instead of re-executing the function. This means your 10-second data load happens only once, on that initial run, and not on every interaction.

3. Never hardcode secrets: use st.secrets

This one isn’t about convenience. It’s about not accidentally publishing your API keys to GitHub for the world to see.

Yes, bots can actively scan for this. And yes, your keys will get compromised within minutes.

This principle has no exceptions. “Just for testing” is how secrets can end up in the commit history forever.

# ❌ NEVER do this
api_key = "sk-1234567890"

# ✅ Use .streamlit/secrets.toml (with gitignored!)
api_key = st.secrets["openai"]["api_key"]

Here’s what to do instead:

• Create .streamlit/secrets.toml for local development
• Add .streamlit/secrets.toml to .gitignore before your first commit
• Add secrets via the UI in the secrets management when deploying to Community Cloud

4. Handle empty and error states gracefully

Your app will encounter None values. It will receive empty lists. APIs will fail. Files won’t upload.

The difference between a frustrating app and a delightful one is often just how gracefully it handles these situations. Never assume that data exists; always check before processing.

# ❌ Crashes if no file was uploaded
uploaded = st.file_uploader("Upload")
df = pd.read_csv(uploaded)

# ✅ Check first, guide the user
uploaded = st.file_uploader("Upload")
if uploaded is not None:
    df = pd.read_csv(uploaded)
    st.dataframe(df)
else:
    st.info("👆 Upload a CSV to get started")

Apply this pattern everywhere:

• File uploads → check with is not None
• API calls → wrap in try / except
• Filtered data → check if result is empty
• Selectbox options → verify that list isn’t empty

Here’s an example for select boxes:

# Empty options can crash selectbox
options = [x for x in items if x.startswith("A")]
if options:
    selected = st.selectbox("Choose", options)
else:
    st.warning("No matching items found")

Why does this matters? Streamlit apps often start in an “empty” state before the user provides input. Your code needs to handle this gracefully. Think of it as defensive coding: assume nothing exists until you’ve verified that it does.

5. Use forms when you need to batch inputs

Here’s a scenario: you have a form with name, email, and phone fields. Without Streamlit forms, your app might start processing (triggering a rerun of the app) after the user starts typing their name, before they’ve even gotten to their email. As a result, the app may rerun multiple times by the time that you’re finished with filling in the input fields.

Forms let users fill out multiple fields and submit them together as a batch, thereby giving you control over when the processing actually happens.

# ❌ Processing might trigger on partial input
name = st.text_input("Name")
email = st.text_input("Email")

if name:
    process1(name)
if email:
    process2(email)

# ✅ Forms batch until explicit submit
with st.form("user_form"):
    name = st.text_input("Name")
    email = st.text_input("Email")
    submitted = st.form_submit_button("Submit")

if submitted:
    if name and email:  # Only process if both are filled
        process1(name)
        process2(email)
    else:
        st.error("Please fill out all fields")

Use forms when:

• You have multiple related inputs
• You want to prevent premature processing
• You’re building data entry interfaces

Forms create a boundary that prevents reruns until the user explicitly clicks submit. All widgets inside the form collect input without triggering the script, then submit sends everything at once. This gives you a clean “before” and “after” moment instead of continuous partial updates.

6. Add unique keys to widgets in loops

DuplicateWidgetID is one of those error messages that makes perfect sense once you understand it, and is completely baffling before that moment.

When creating widgets dynamically (in loops or conditionally), Streamlit needs unique identifiers to tell them apart. No key? Streamlit guesses. Multiple widgets with the same guess? Chaos.

# ❌ DuplicateWidgetID error
for item in items:
    st.checkbox(item)

# ✅ Add unique keys
for i, item in enumerate(items):
    st.checkbox(item, key=f"checkbox_{i}")

Also remember:

• Capture widget return values: value=st.slider("...")
• Widgets with keys automatically sync to st.session_state

Let’s take a look at an example:

# ✅ Captures the return value from a stored variable
temperature = st.slider("Temperature", 0, 100, 72)
st.write(f"Current: {temperature}°F")

# ✅ A key is automatically stored in session_state
st.slider("Humidity", 0, 100, 50, key="humidity")
st.write(f"Humidity: {st.session_state.humidity}%")

Direct capture: The slider returns its current value, which we store in the temperature variable. This is the simplest approach when you just need to use the value immediately.

Using a key: When you add a key parameter, Streamlit automatically stores the widget’s value in st.session_state under that key name. You can access it as st.session_state.humidity anywhere in your app. This is useful when you need to access the value in multiple places or modify it programmatically.

Streamlit identifies widgets by generating an ID from their type, label, and position in the code. In a loop, multiple widgets can end up with identical IDs and thus give rise to an error! The key parameter overrides this auto-generated ID with your own unique identifier, letting Streamlit distinguish between them. As a bonus, any widget with a key automatically syncs its value to st.session_state, making it accessible throughout your app.

7. Show progress for long operations

A frozen screen is a source of anxiety for users. “Did it crash? Should I refresh? Is my data lost?” These are not the questions you want people asking.

The fix is simple: show them something is happening. Streamlit makes this almost very easy.

# ❌ User sees frozen screen, thinks app crashed
result = slow_api_call()
st.write(result)

# ✅ Show a spinner for single operations
with st.spinner("Generating response..."):
    result = slow_api_call()
st.write(result)

# ✅ Use st.status for multi-step operations
with st.status("Processing...", expanded=True) as status:
    st.write("Step 1: Loading data...")
    data = load_data()
    
    st.write("Step 2: Analyzing...")
    analysis = analyze(data)
    
    st.write("Step 3: Generating report...")
    report = generate_report(analysis)
    
    status.update(label="Complete!", state="complete")

For LLM apps, streaming responses can provide users with real-time feedback.

Here’s how we could implement streaming using OpenAI:

from openai import OpenAI
import streamlit as st

client = OpenAI(api_key=st.secrets["openai"]["api_key"])

stream = client.chat.completions.create(
    model="gpt-4o",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Write a poem about snowflakes."}],
    stream=True
)

st.write_stream(stream)  # Shows tokens as they arrive

And here’s how with Anthropic:

from anthropic import Anthropic
import streamlit as st

client = Anthropic(api_key=st.secrets["anthropic"]["api_key"])

# Stream responses for real-time feedback
with client.messages.stream(
    model="claude-sonnet-4-5",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Write a poem about snowflakes."}]
) as stream:
    st.write_stream(stream.text_stream)  # Shows tokens as they arrive

Why does this matter? Users are surprisingly patient when they can see progress. A 10-second wait with a spinner feels faster than a 5-second frozen screen. It’s not about speed, it’s about communication.

8. Use @st.fragment for partial reruns

This is the “I wish I’d known this sooner” feature for anyone building apps with both expensive visualizations and interactive elements.

By default, the entire script reruns on every interaction. Got a chart that takes 5 seconds to render? Every widget interaction would cause the user to wait for another 5 more seconds as the app reruns. Fragments let you break this cycle by isolating sections that should rerun independently from the rest.

# ❌ Expensive operation reruns on every interaction
st.title("Dashboard")

# This takes 5 seconds
plot_expensive_chart(data)

# Every button click reruns the expensive chart!
if st.button("Increment Counter"):
    st.session_state.count = st.session_state.get("count", 0) + 1
st.write(f"Count: {st.session_state.get('count', 0)}")

# ✅ Fragment isolates the counter from the expensive chart
st.title("Dashboard")

plot_expensive_chart(data)  # Only runs on full page rerun

@st.fragment
def counter_section():
    if st.button("Increment Counter"):
        st.session_state.count = st.session_state.get("count", 0) + 1
    st.write(f"Count: {st.session_state.get('count', 0)}")

counter_section()  # This section reruns independently

Use fragments when:

• Mixing expensive calculations with lightweight interactions
• Any section that updates frequently while others stay static

Why this works: The @st.fragment decorator creates an isolated execution scope that allows only a specific function to re-execute, not the entire script. Everything outside the fragment stays untouched, thereby preserving your expensive computations.

9. Structure your project for deployment from the start

“I’ll organize it later” is the lie we tell ourselves right before our app.py hits 2,000 lines and we can’t find anything.

Future you will thank present you for taking 5 minutes to set up a proper project structure. Don’t wait until deployment to organize your code.

my_app/
├── app.py                 # Entry point
├── requirements.txt       # Pin versions!
├── .gitignore            # Include secrets.toml
├── .streamlit/
│   ├── config.toml       # Theme settings
│   └── secrets.toml      # Local secrets (gitignored)
├── pages/                # Multipage app
│   └── 1_📊_Dashboard.py
└── utils/                # Shared code
    └── data.py

Why pin versions? An unpinned requirements.txt is a ticking time bomb. Your app works perfectly today, but six months from now when you redeploy or reinstall dependencies, a new library version might introduce breaking changes. Pinning versions (pandas==2.1.0 instead of just pandas) ensures your app behaves the same way every time (like putting your app in a time capsule).

Deployment checklist:

• requirements.txt with pinned versions (pandas==2.1.0)
• Relative file paths only (use assets/ as oppossed to /Users/chanin/dashboard_app/assets)
• Secrets in secrets.toml, not hard-coded in the code
• Test your deployment early and often

10. Use Streamlit’s built-in features before custom solutions

Before you spend an hour crafting custom CSS for a metrics display, check if Streamlit already has a widget for that.

It probably does and LLMs may be trained on an older version of Streamlit

The framework has grown significantly, and many common UI patterns now have first-class support. Using built-ins means less code to maintain, better performance, and a more consistent look.

+----------------------+------------------------------------------+
| Need                 | Use This                                 |
+----------------------+------------------------------------------+
| Show loading state   | with st.spinner("Loading...")            |
| Display KPIs         | st.metric(label, value, delta)           |
| Organize content     | st.columns(), st.tabs(), st.expander()   |
| Database connections | st.connection()                          |
| Long operations      | st.status() for multi-step progress      |
| Chat interfaces      | st.chat_message(), st.chat_input()       |
| Stream LLM responses | st.write_stream()                        |
| Partial reruns       | @st.fragment                             |
+----------------------+------------------------------------------+

Let’s say that you want to display metrics in your dashboard app, instead of manually using st.write() you could instead leverage st.metric(), which comes with the metric name and values as well as any recent positive/negative changes.

# ❌ Manual KPI formatting
st.write(f"Revenue: ${revenue:,}")
st.write(f"Change: {change:+.1%}")

# ✅ Use st.metric
st.metric("Revenue", f"${revenue:,}", f"{change:+.1%}")

If Streamlit doesn’t have it built-in, check these before building custom solutions:

1. Streamlit Extras: A curated collection of additional components including card layouts, annotated text, clickable images, and more. Maintained by members of the Streamlit data science team.
2. Streamlit Components Gallery: Third-party extensions for bringing in additional functionality to your Streamlit app!

The hierarchy: Built-in → Streamlit Extras → Third-party → Custom code. Each step down means more maintenance burden, so only go custom when you truly need something unique.

Wrapping Up

There you have it, 10 principles that address the root causes of most Streamlit beginner struggles. The beautiful thing about these principles is that once they click, they become second nature. You’ll start writing Streamlit code that “just works” because you understand why it works.

Vibe coding isn’t about blindly accepting AI suggestions. It’s about knowing enough to guide the conversation productively. The AI handles the syntax; you bring the architectural intuition.

If you’re looking to put these principles into practice, check out the upcoming 30 Days of AI in January 2026. This challenge focuses on teaching learners to build LLM-powered apps, taking you from connecting to an LLM, building basic chat interfaces to features for production-ready AI apps. It’s a free learning challenge, one day at a time.

Happy Streamlit-ing! 🎈

Resources

If you’re ready to dive deeper into the specifics, here are additional resources to help you.

1. Reruns & Session State: Adding Statefulness to Apps
2. Caching: Caching Overview
3. Secrets: Secrets Management
4. Error Handling: Basic Concepts of Streamlit
5. Forms: Using forms
6. Widget Keys: Widget Behavior
7. Progress Indicators: st.spinner, st.status, st.progress
8. Fragments: Working with Fragments
9. Project Structure: App Dependencies, Multipage Apps
10. Built-in Features: API Reference, Streamlit Extras

10 Principles for Keeping the Vibe while Coding Streamlit Apps was originally published in Streamlit on Medium, where people are continuing the conversation by highlighting and responding to this story.

A course to help you learn to build and ship GenAI apps fast

Fast Prototyping of GenAI Apps with Streamlit is created as part of a Snowflake × DeepLearning.AI collaboration.

The course tackles a costly problem: app ideas lose momentum when they linger in discussions, drawn-out specifications, and intangibles that slow down the decision-making process. In a field where new GenAI capabilities surface every week, the teams that can show working demos first are the ones that influence roadmaps and win resources.

What you’ll learn

This course gives you that speed advantage.

We’ll first kick off with an insightful conversation between Chanin Nantasenamat, PhD (the course instructor) and Professor Andrew Ng. We discussed how GenAI has fundamentally changed app development by enabling developers to build and test ideas faster than ever before.

You’ll explore how GenAI streamlines the prototyping workflow, facilitates rapid iteration and validation of product-market fit, and allows anyone, regardless of coding experience, to participate in the application development process.

You’ll learn how to turn a few lines of Python into a shareable Streamlit web app, cut down iteration time from weeks to hours using Snowflake’s secure data and coding copilot, and improve the performance of your application easily using Snowflake’s Cortex AI, a fully managed suite of LLMs, RAG, and text-to-SQL services (free 120-day trial included).

You’ll start with a basic chatbot, layer on prompt engineering and RAG, and publish the result to Snowflake or Streamlit Community Cloud for real-time feedback.

By the end of the course, you’ll leave with a working GenAI app, a repeatable MVP-first framework, and the skills to validate any new idea as soon as it strikes.

How to enroll

Enroll here to start building!

Fast Prototyping of GenAI Apps with Streamlit was originally published in Streamlit on Medium, where people are continuing the conversation by highlighting and responding to this story.

Are you still jumping between multiple tools to manage your data? What if there was one unified platform to ingest, query, analyze and even build apps directly from your browser?

Whether you’re a data analyst, an engineer, or a business user, understanding Snowsight is crucial for maximizing your productivity and managing your data like a pro.

Briefly, we’ll explore Snowflake’s Snowsight web interface, covering everything from basic navigation to advanced data management features. While our primary focus is on mastering Snowsight, we’ll also explore how it fits within the broader Snowflake ecosystem, including how it compares to and integrates with command-line tools, code editors, and third-party applications.

By the end of this article, you’ll have a complete understanding of how Snowsight fits into the broader Snowflake ecosystem and how to leverage it for your specific data needs.

Applications and tools for connecting to Snowflake

Snowflake provides several different applications and tools that you can use to access databases stored on the Snowflake platform.

User Interfaces

Snowsight is Snowflake’s web interface. It distills Snowflake’s powerful SQL support into a unified, easy-to-use experience. Use Snowsight to perform your critical Snowflake operations all with SQL as well as Python, Java and Scala.

Command-line Clients

While Snowsight provides an intuitive web-based experience, many users also prefer working directly from the command line for automation and scripting purposes.

Snowflake CLI: Use the command line to create, manage, update, and view apps running on Snowflake across workloads.

SnowSQL: Provides detailed instructions for installing, configuring, and using the Snowflake command-line client.

Extensions for Code Editors

Beyond standalone interfaces, developers often need to integrate Snowflake capabilities directly into their development workflows and favorite code editors.

Snowflake Extension for Visual Studio Code can be used to connect to Snowflake within Visual Studio Code and perform SQL operations.

Third-party Database Systems

Snowflake Connectors provide native integration of third-party applications and database systems in Snowflake. The connectors provide instant access to current data without the need to manually integrate against API endpoints. Data automatically refreshes, based on your desired frequency, in your Snowflake account. The connectors support both the initial load of historical data as well as incremental changes.

Snowflake Connectors for:

• Google Analytics Raw & Aggregate Data
• Google Looker Studio
• ServiceNow

Snowflake Database Connectors for:

• MySQL
• PostgreSQL
• SharePoint

These connectors represent just a fraction of the broader ecosystem of tools and platforms that integrate seamlessly with Snowflake.

Third-party Softwares | Snowflake Ecosystem

And on to, the Snowflake ecosystem is designed to be highly interoperable, offering a wide array of possibilities for connecting to various third-party tools as well as Snowflake-provided clients.

• Data Integration
• Business Intelligence
• Machine Learning & Data Science
• Security, Governance & Observability
• SQL Development & Management
• Native Programmatic Interfaces

Here’s a diagram categorizing all the interoperable tools into the above mentioned topics.

Understanding these resources is crucial for maximizing your efficiency and leveraging the full potential of Snowflake for diverse data-related tasks. For instance, users can effectively manage their data lifecycle, from ingestion and transformation to analysis and app development, all within the robust and scalable Snowflake ecosystem.

When third-party tools don’t meet your specific requirements, or when you need to build custom applications, Snowflake’s comprehensive suite of drivers and APIs provides the foundation for direct programmatic access.

Drivers and Libraries

Snowflake provides various drivers and APIs for connecting applications to its data cloud.

These include JDBC, ODBC, Python, Go, and Node.js drivers for direct database interaction. Additionally, specialized APIs like Snowflake SQL API, Snowpipe API, and External Functions API enable serverless integration, continuous data loading, and custom logic execution. Snowflake also supports stored procedures for in-database logic.

Additionally, there are Snowflake connectors for Kafka, Python and Spark as well as Snowflake APIs for Python, REST and SQL.

Getting Started

To try out Snowsight, sign up for a free trial account by going to https://signup.snowflake.com/

After a successful signup, you should receive a confirmation email that provide details on logging in. Most likely this will point you to https://app.snowflake.com/

Watch this great getting started video by Gilberto Hernandez to get up to speed with the basics of Snowflake:

Accessing Snowsight

You can access Snowsight from an internet browser in one of 2 ways:

1. Public internet with an internet browser of your choice (e.g. Chrome, Safari, Opera, etc.)
2. Private Link — establishes a secure, private connection between your organization’s network (or cloud environment) and your Snowflake account, bypassing the public internet entirely. The primary benefit of Private Link is significantly enhanced security and compliance, as all data traffic remains on the cloud provider’s private network (e.g. AWS, Azure, or GCP backbone). This reduces the risk of data exposure to external threats and often provides lower latency and more stable connections compared to public internet routes.

Anatomy of the Snowsight UI

Snowsight serves as the central hub for interacting with your Snowflake data, offering a comprehensive and intuitive web interface. It provides a unified experience, whether you prefer working with SQL or Python, and empowers users to perform a wide array of data-related tasks.

After signing in, you should see something like the following:

Let’s dissect each highlighted segment:

• Navigation menu — this is where you’ll be able to ingest, query, and work with your data. It’s here that you’ll be able to access Workspaces, Worksheets, Snowflake Notebooks, Streamlit in Snowflake apps, Snowpark Container Services, Databases, Marketplace, etc.
• Profile settings — enables configuration of your interface to be light/dark mode, configure multifactor authentication, access settings, etc.
• Search bar — enter a few keywords and you’ll have access to relevant resource pages
• Shortcuts — provide quick access to common tasks like file uploads,data query, user invite, etc.
• Recent files — list of recent files that you have been working on, so you can resume work in an instant!

Core Functionalities

Snowsight is designed to cater to various aspects of data analysis, development, and collaboration.

Here’s a detailed look at its core functionalities:

• Data ingestion: Getting data into Snowflake can be done through many ways. There’s the traditional migration through Snowflake’s SnowConvert AI that guides you through the process of migrating data from an external platform to Snowflake. Then there’s the smaller batch approach by reading data from a CSV file, from the cloud (e.g. AWS S3 bucket, Google Cloud, etc.).
• Worksheets: Need to quickly test a query or perform ad-hoc analysis? Worksheets are your go-to. They provide a flexible environment for writing, executing, and refining your SQL queries. This allows users to directly interact with their data, perform ad-hoc analysis, and develop complex data transformations.
• Snowflake Notebooks: Building a complete ML pipeline from data prep to deployment? Notebooks let you do it all in one place. Write SQL and Python, train models, and deploy them without ever leaving Snowflake’s scalable environment. And once you’re done, you can share what you’ve learned with your colleagues.
• Snowflake Copilot: Stuck on a tricky SQL query or need quick insights? Copilot acts as your intelligent assistant, helping you generate queries, uncover patterns, and navigate your data analysis with ease.
• Snowpark Python: Want to use your favorite Python libraries without moving data around? Snowpark brings pandas, scikit-learn, and other familiar frameworks directly into Snowflake, so you can build advanced applications right where your data lives.
• Monitoring Query Performance and History: Need to figure out why that query is running slow? Track performance metrics and dive into your execution history to spot bottlenecks, optimize efficiency, and keep your queries running smoothly.
• Worksheet Management with Sharing and Folders: To facilitate collaboration and organization, Snowsight allows users to manage their worksheets through sharing options and folder structures. This ensures that teams can easily collaborate on projects, share insights, and maintain a tidy workspace. This is made possible with the recent rollout of Workspaces which is available for preview.
• Visualizing Worksheet Results with Charts: Beyond raw data, Snowsight enables users to visualize worksheet results through various chart types. This transformation of data into visual representations makes it easier to understand trends, patterns, and anomalies, aiding in data-driven decision-making.
• Creating Dashboards with Built-in Visualizations: For a consolidated view of key metrics and data insights, Snowsight offers the ability to create interactive dashboards using its built-in visualization tools. These dashboards serve as powerful tools for monitoring business performance and communicating data stories.
• Creating and Running Streamlit Apps: Snowsight integrates with Streamlit, allowing users to build and deploy interactive data applications directly within the Snowflake environment. This empowers users to create engaging data experiences and share them with a broader audience.
• Developing and Sharing Snowflake Native Apps: Snowsight provides the tools necessary to develop and share Snowflake Native Apps. These applications are built and run entirely within Snowflake, offering a secure and efficient way to deliver data-driven solutions to other Snowflake accounts.
• Sharing Data and Apps via Snowflake Marketplace: The platform facilitates seamless data and application sharing with other Snowflake accounts and publicly on the Snowflake Marketplace. This enables data providers to monetize their data assets and applications, fostering a vibrant data economy.

Managing Your Snowflake Deployment and Operations

Beyond data analysis and development, Snowsight is an indispensable tool for performing critical Snowflake operations and managing your entire deployment.

• Cost Management Views: Users can effectively manage and monitor their Snowflake costs through dedicated cost management views. This provides transparency into credit usage, storage costs, and other expenditures, allowing for optimized resource allocation and budget control.
• Trust Center for Security Monitoring: Snowsight allows users to monitor and evaluate their account for security risks. This proactive approach to security helps identify vulnerabilities, ensure compliance, and protect sensitive data.
• Budget Monitoring for Credit Usage: To help control expenditures, Snowsight allows users to monitor their credit usage against predefined budgets. This feature provides alerts and insights, enabling users to stay within their allocated resources.
• Monitoring Data Loading Activity: Tracking data loading activity is crucial for data pipeline management. Snowsight provides comprehensive monitoring tools to observe the progress and status of data ingestion processes.
• Monitoring Data Transformation Tasks and Debugging Task Graphs: For complex data transformations, Snowsight offers robust monitoring of tasks and the ability to debug task graphs. This helps identify and resolve issues in data pipelines, ensuring data accuracy and timely processing.
• User Management: Administrators can easily create and manage users within their Snowflake account through Snowsight. This includes setting up new user accounts, managing user profiles, and defining authentication methods.
• Role Management and Privilege Control: Snowsight provides comprehensive tools for creating and managing roles, as well as granting and revoking privileges. This granular access control ensures that users only have access to the data and functionalities they need, enhancing security and compliance.
• User Profile Management: Each user can manage their personal profile within Snowsight, including preferences and account settings, for a personalized experience.

In essence, Snowsight is more than just a web interface; it’s a powerful and integrated platform that empowers users to unlock the full potential of their Snowflake data, from advanced analytics and application development to comprehensive account management and operational oversight.

Highlights

As there are so many features to consider, let’s highlight a few important ones that you can use from Snowsight.

Workspaces

The predecessor of Workspaces is Worksheets, which acts as only the code editor. Spinning up a Worksheet is very much like creating a new file in VS Code.

Let’s take a look at the anatomy of a typical Worksheet (sometimes called a SQL Worksheet).

Recently Workspaces has been introduced as a Public Preview as of May 2025. And is expected to be Generally Available soon. This feature transforms this experience into more of an IDE where there are additional bells and whistles.

What is Workspaces?

At its core, workspaces is comprised of worksheets but with several additional upgrades.

As a result, it now works very much like an IDE (aka integrated development environment or code editor). Briefly, it is a file-based modern development environment for authoring, organizing, and running Snowflake code artifacts and data, using familiar IDE and source control conventions.

Why Workspaces?

There are several benefits to this upgrade from Worksheets to Workspaces

• Stability and reliability issues with worksheets, and a long tail of feature requests
• No source control for SQL and Python worksheets
• Limited support for more complex development workloads
• Inflexible organization and management of code artifacts
• Limited private development and collaboration controls

It’s also noteworthy that you can import your dbt projects into Snowflake. Check out this video for details:

Snowflake Notebooks

Snowflake Notebooks offer a powerful and interactive environment for data scientists and analysts to perform complex data analysis and machine learning workflows directly within Snowsight. These notebooks combine the flexibility of a traditional notebook interface with the scalability and performance of Snowflake’s data cloud. Users can write and execute SQL and Python code, visualize results, and manage their data projects collaboratively, all within a single, integrated platform.

Streamlit in Snowflake

Streamlit is an open-source Python library that makes it incredibly easy to build and share interactive data apps.

In the diagram below, you can see that a data app can be easily built with Python. This example app can read in CSV data followed by the creation of a line chart.

Streamlit in Snowflake allows users to build, deploy, and share interactive data apps using Snowflake data via the Snowsight interface. This integration provides a seamless experience for data scientists and developers to transform data insights into shareable apps, fostering collaboration and empowering business users with interactive data exploration.

Snowflake Cortex

On the AI front, we have Snowflake Cortex, a comprehensive suite of artificial intelligence features designed to empower users with advanced analytical capabilities and intelligent assistance. Snowflake Cortex leverages the power of large language models (LLMs) to unlock insights from unstructured data, enabling users to ask freeform questions and receive accurate, contextually relevant answers.

Here’s a diagram summarizing the capabilties of Cortex AI:

Particularly, Snowflake Cortex comprises several powerful components:

• Snowflake Cortex AISQL (including LLM functions): This feature allows users to interact with their data using natural language queries, transforming complex questions into actionable SQL commands. It integrates advanced LLM functions to perform sophisticated data analysis and manipulation.
• Snowflake Copilot: Acting as an intelligent assistant, Snowflake Copilot helps users navigate the Snowflake environment, providing guidance, automating tasks, and suggesting optimal approaches for data management and analysis.
• Document AI: This specialized component enables the extraction, analysis, and understanding of information from diverse unstructured documents, such as PDFs, scanned images, and text files. It automates data entry, identifies key entities, and facilitates intelligent document processing.
• Cortex Fine-tuning: This feature provides the capability to customize and optimize pre-trained LLMs with domain-specific data, ensuring higher accuracy and relevance for particular business needs and use cases.
• Cortex Search: This powerful search engine allows users to efficiently discover and retrieve relevant information from vast datasets, leveraging semantic understanding and contextual relevance to deliver precise results.
• Cortex Analyst: Designed to augment human analysts, Cortex Analyst automates repetitive analytical tasks, identifies patterns, and generates insights from data, allowing human experts to focus on higher-level strategic analysis.

Snowflake ML

On the ML front, we have Snowflake ML, which is an integrated set of capabilities for end-to-end machine learning in a single platform on top of your governed data. This is a unified environment for ML development and productionization that is optimized for large-scale distributed feature engineering, model training and inference on CPU and GPU compute without manual tuning or configuration.

Scaling end-to-end ML workflows in Snowflake is seamless. You can do the following:

• Prepare data and use Snowflake Datasets provide an immutable, versioned snapshot of your data suitable for ingestion by your machine learning models
• Create and use features with the Snowflake Feature Store
• Train models with CPUs or GPUs using any open-source package from Snowflake Notebooks on Container Runtime. Use ML Functions for common scenarios such as forecasting and anomaly detection
• Operationalize your pipelines using Snowflake ML Jobs
• Deploy your model for inference at scale with the Snowflake Model Registry
• Monitor your production models with ML Observability and Explainability
• Use ML Lineage provides to track the source data to features, datasets, and models throughout the ML pipeline

Snowflake ML is also flexible and modular. You can deploy the models that you’ve developed in Snowflake outside of Snowflake and externally-trained models can easily be brought into Snowflake for inference.

Conclusion

Snowsight is Snowflake’s primary web interface that integrates data operations from ingestion and transformation to analysis and app development. It also provide essential features for cost management, security, and user administration. Supported by a rich ecosystem of tools and APIs as well as advanced AI/ML capabilities, Snowsight enable users to efficiently and securely manage and leverage data within a unified platform.

Overview of Snowsight: Snowflake’s Web Interface was originally published in Snowflake Builders Blog: Data Engineers, App Developers, AI, & Data Science on Medium, where people are continuing the conversation by highlighting and responding to this story.

Build an AI-Powered Data Processing Pipeline

Have you ever wanted to supercharge your data processing with AI while working in a familiar pandas environment? Many data teams struggle with integrating advanced AI capabilities into their existing data workflows without compromising performance or requiring complex infrastructure changes.

Snowflake Cortex provides a solution by enabling seamless integration of powerful AI capabilities directly into Modin DataFrames within the unified Snowflake ecosystem.

In this blog, we’ll build an end-to-end data processing pipeline that loads product catalog data, applies various AI transformations using Cortex, and visualizes the results with Streamlit.

Readers will learn how to:

• Load and process data using Modin DataFrames for improved performance
• Apply Cortex AI functions for text classification, translation, and sentiment analysis
• Create interactive visualizations with Streamlit
• Write and read data within the Snowflake ecosystem

1. Overview of Snowflake Cortex AI

Before we dive deeper into specific AI functions, let’s take a moment to appreciate the comprehensive power of Snowflake Cortex AI. It’s not just a collection of functions; it’s a fully integrated ecosystem designed to bring advanced AI capabilities directly to your data, without the complexity of moving it.

This diagram illustrates the key components that make up Snowflake Cortex AI, showing how it supports everything from data ingestion and processing to model deployment and governance.

2. Getting Started

Before beginning, ensure you have:

• Access to a Snowflake account
• Basic familiarity with Python and pandas

3. Setup

Retrieve the Notebook

Ready to dive in? To follow along with every step of this quickstart, you can click on Process-DataFrame-with-Modin-and-Cortex.ipynb to download the companion Notebook from GitHub.

Required Packages

Snowflake Notebooks comes pre-loaded with a fantastic array of common Python libraries for data science and machine learning, including numpy, pandas, and matplotlib. However, for this particular journey into AI-powered data processing, we'll need to bring in a few specialized tools:

• modin: Your secret weapon for scaling those familiar pandas operations to handle larger datasets with ease.
• snowflake-ml-python: This is your gateway to unlocking the powerful Cortex LLM functions directly within your Python environment.
• snowflake-snowpark-python: Essential for seamless interaction with Snowpark functionality, bridging your Python code with Snowflake's robust capabilities.

Adding these packages is a breeze! Just head over to the Packages dropdown, located in the top right corner of your Snowflake Notebook interface, and add them there.

Import Prerequisite Libraries

Let’s start by importing the necessary libraries and establishing a connection to Snowflake:

# Import Python packages
import modin.pandas as pd
import snowflake.snowpark.modin.plugin

# Connecting to Snowflake
from snowflake.snowpark.context import get_active_session
session = get_active_session()

This code imports Modin’s pandas implementation and connects to your active Snowflake session.

4. Load Data

Store Data into a Snowflake Stage

Before we can unleash the power of AI on our data, we need a place for it to live within Snowflake. Think of a stage as a secure, internal landing zone for your external data.

We’ll create one to seamlessly bring in our product catalog data from an S3 bucket:

CREATE OR REPLACE STAGE AVALANCHE
    URL = 's3://sfquickstarts/misc/avalanche/csv/';

You should see the following status message the stage is created successfully:

List Stage Contents

Just to be sure our data has landed safely and is ready for action, let’s quickly list the contents of our newly created stage. This helps us verify that everything is accessible before we proceed:

ls @avalanche/

This command should display the files available in the stage, including our target file product-catalog.csv.

Read CSV Data

Now for the exciting part! We’ll read that CSV data directly into a Modin DataFrame. This is where your familiar pandas operations get a significant performance boost, thanks to Modin’s scalability.

df = pd.read_csv("@avalanche/product-catalog.csv")
df

Once loaded, your DataFrame will feature three key columns, ready for the forthcoming AI magic:

• name: Product name
• description: Product description
• price: Product price

5. Classify Text

Classify Text with Cortex

This is where Snowflake Cortex truly shines! It offers powerful AI capabilities that you can apply directly to your data, transforming raw text into structured insights.

Let’s use the ClassifyText function to categorize our products:

from snowflake.cortex import ClassifyText

df["label"] = df["name"].apply(ClassifyText, categories=["Apparel","Accessories"])
df["label2"] = df["description"].apply(ClassifyText, categories=["Apparel","Accessories"])

df

Did you notice something interesting? We’re classifying products in two distinct ways: once based on the concise product name, and again using the more detailed product description.

This is a fantastic way to see how different inputs can lead to nuanced classification results, giving you a richer understanding of your data.

Extract Classification Labels

Cortex’s ClassifyText function returns its results as dictionaries, which is great for comprehensive output. But for our analysis, we just need the clean category values without the label keys. Let's quickly extract those values and then tidy up our DataFrame by dropping the intermediate columns:

df["category"] = df["label"].apply(lambda x: x.get('label'))
df["category2"] = df["label2"].apply(lambda x: x.get('label'))

df.drop(["label", "label2"], axis=1, inplace=True)

df

And just like that, we have beautifully clean category columns, perfectly ready for deeper analysis and visualization. No more manual sorting or tagging!

6. Translate Text

Snowflake Cortex makes language translation incredibly simple. Let’s leverage Cortex’s powerful Translate function to instantly localize our product information from English into German:

from snowflake.cortex import Translate

df["name_de"] = df["name"].apply(Translate, from_language="en", to_language="de")
df["description_de"] = df["description"].apply(Translate, from_language="en", to_language="de")
df["category_de"] = df["category"].apply(Translate, from_language="en", to_language="de")
df["category2_de"] = df["category2"].apply(Translate, from_language="en", to_language="de")

df

With just a few lines of code, you can localize your entire product catalog, opening doors to new markets and ensuring your data speaks every language your business needs.

7. Process Text

Analyze Sentiment

Beyond classification and translation, Cortex offers even more sophisticated text capabilities. Let’s unlock deeper insights from our product descriptions, starting with understanding the emotions they convey.

Ever wondered how your product descriptions are perceived? Are they overwhelmingly positive, or do they carry a hint of negativity? Let’s use Cortex’s Sentiment function to assign a numerical score to each description, instantly revealing its emotional tone:

from snowflake.cortex import Sentiment

df["sentiment_score"] = df["description"].apply(Sentiment)

df

This sentiment score provides a powerful numerical value, giving you an immediate indication of the positivity or negativity embedded within each description. Imagine using this to quickly identify descriptions that might need a rewrite!

Summarize Text

Long descriptions can be overwhelming. What if you could get the gist of a product description in a single, concise sentence? Cortex’s Summarize function makes this a reality, helping you distill lengthy text into digestible summaries:

from snowflake.cortex import Summarize

df["description_summary"] = df["description"].apply(Summarize)

df

This is incredibly useful for quick reviews or for generating short snippets for other applications.

Extract Specific Information

Sometimes, you need to pull out very specific pieces of information from unstructured text. Cortex’s ExtractAnswer function acts like a smart assistant, answering questions directly from your text. Let's use it to identify the exact product mentioned in each name:

from snowflake.cortex import ExtractAnswer

df["product"] = df["name"].apply(ExtractAnswer, question="What product is being mentioned?")
df["product"] = [x[0]["answer"] for x in df['product']]

df

This demonstrates how you can use Cortex to extract structured information from unstructured text.

8. Post-Process Data

Our data has been enriched with powerful AI insights, but before we finalize it, a little post-processing goes a long way to ensure accurate and reliable subsequent data analysis and visualization.

Clean Price Data

Our price column currently contains dollar signs, which isn't ideal for numerical calculations. Let's quickly clean this up by removing the ‘$' symbol and then converting the column to a proper numeric type. This ensures our financial data is ready for any mathematical operations or aggregations.

# For the price column, remove $ symbol and convert to numeric
df["price"] = df["price"].str.replace("$", "", regex=False)
df["price"] = pd.to_numeric(df["price"])

df

Convert Column Types

To maintain data integrity and ensure compatibility with various tools (especially when writing back to Snowflake), it’s good practice to standardize our column types. Let’s make sure all our text-based columns are explicitly set as string types, while leaving our numerical columns (like price and sentiment_score) as they are.

# Convert all other columns to the string type
for col_name in df.columns:
    if col_name != "price" and col_name != "sentiment_score":
        df[col_name] = df[col_name].astype(str)

df

With these quick clean-up steps, our DataFrame is now perfectly structured and ready for its final destination!

9. Data Operations

Now that our data is transformed, enriched, and polished, it’s time to persist these valuable insights. The beauty of working within the Snowflake ecosystem is the seamless ability to write your processed data directly back into a Snowflake table, making it available for countless other applications and analyses.

Write to a Snowflake Table

Let’s write our processed DataFrame to a Snowflake table:

df.to_snowflake("avalanche_products", if_exists="replace", index=False)

Read Data with SQL

Let’s quickly confirm your data is there and looks as expected. We can query our new table using the following SQL query:

SELECT * FROM CHANINN_DEMO_DATA.PUBLIC.AVALANCHE_PRODUCTS

Read Data with Python

And of course, if you ever need to pull this data back into a DataFrame for further Python-based analysis or application development, it’s just as straightforward:

pd.read_snowflake("avalanche_products")

9. Build a Streamlit Dashboard

What’s the point of all this incredible AI-powered data processing if you can’t easily share and interact with the insights? This is where Streamlit steps in, allowing you to transform your data into a beautiful, interactive web application with just a few lines of Python code. Let’s build a simple yet powerful dashboard to visualize our newly enriched product data!

import streamlit as st

df = pd.read_snowflake("avalanche_products")

st.header("Product Category Distribution")

# Selectbox for choosing the category column
selected_category_column = st.selectbox(
    "Select Category Type:",
    ("category", "category2")
)

# Count the occurrences of each category based on the selected column
category_counts = df[selected_category_column].value_counts().reset_index()
category_counts.columns = ['Category', 'Count']

st.bar_chart(category_counts, x='Category', y='Count', color='Category')

st.header("Product Sentiment Analysis")

# Calculate metrics
st.write("Overall Sentiment Scores:")

cols = st.columns(4)

with cols[0]:
    st.metric("Mean Sentiment", df['sentiment_score'].mean() )
with cols[1]:
    st.metric("Min Sentiment", df['sentiment_score'].min() )
with cols[2]:
    st.metric("Max Sentiment", df['sentiment_score'].max() )
with cols[3]:
    st.metric("Standard Deviation", df['sentiment_score'].std() )

# Create a bar chart showing sentiment scores for all products
st.write("Individual Product Sentiment Scores:")
option = st.selectbox("Color bar by", ("name", "sentiment_score"))
st.bar_chart(df[['name', 'sentiment_score']], x='name', y='sentiment_score', color=option)

And there you have it! This intuitive Streamlit app instantly provides:

1. Dynamic Category Insights: A clear bar chart showcasing the distribution of product categories, with the flexibility to switch between classification methods.

2. At-a-Glance Sentiment Metrics: Key statistical metrics that summarize the overall sentiment across your product descriptions.

3. Granular Sentiment Visualization: A bar chart that lets you explore the sentiment score for each individual product, helping you pinpoint outliers or trends.

This isn’t just a visualization; it’s an interactive AI-powered data app that empower users to perform self-serve analytics!

Conclusion And Resources

Congratulations!

You’ve not just followed a tutorial; you’ve successfully engineered a powerful, end-to-end data processing pipeline. You’ve harnessed the scalability of Modin DataFrames and the cutting-edge AI capabilities of Snowflake Cortex to transform raw data into actionable intelligence. From loading external data to applying sophisticated AI transformations like classification, translation, sentiment analysis, and text summarization, you’ve done it all. And to top it off, you’ve brought your insights to life with a dynamic, interactive Streamlit dashboard!

This quickstart truly showcases the immense power and seamless integration of the Snowflake ecosystem. You’ve seen firsthand how you can perform sophisticated data processing and advanced AI operations without ever needing to move your data outside the platform. This isn’t just about convenience; it’s about unlocking unparalleled performance, robust security, and a streamlined workflow for your data projects.

What You Learned

• Loaded data from an S3 bucket into a Snowflake stage
• Processed data using Modin DataFrames for improved performance
• Applied Cortex AI functions for text classification, translation, and sentiment analysis
• Extracted structured information from unstructured text
• Created an interactive dashboard with Streamlit
• Wrote and read data within the Snowflake ecosystem

Related Resources

Want to dive deeper or explore related topics? Check out these valuable resources:

Articles:

• pandas on Snowflake
• Using Snowflake Cortex LLM functions with Snowpark pandas
• Snowflake Cortex AI

Documentation:

• Snowflake Documentation
• Streamlit Documentation
• Modin Documentation

Developer’s Guide to Modin and Snowflake Cortex was originally published in Snowflake Builders Blog: Data Engineers, App Developers, AI, & Data Science on Medium, where people are continuing the conversation by highlighting and responding to this story.

Ever wondered how to make your enterprise data work smarter, not just harder? Snowflake is stepping up its game in enterprise AI with Snowflake Intelligence. You can think of it as a powerful platform that empowers developers to build clever data agents that can analyze, summarize, and even take action on your company’s valuable data.

It’s all built on Snowflake’s robust data foundation and AI services powered by Cortex AI. This fully managed AI engine provides enterprise-grade data agents that not only streamline your workflows but also rigorously protect your data integrity and intellectual property. Inside Cortex AI, you’ll find tools like Cortex Search for diving into unstructured data and Cortex Analyst for querying your structured datasets.

At its heart, a Snowflake Cortex Agent is your personal AI data assistant. It’s engineered to automate those complex data workflows and unlock hidden business insights through natural, conversational interactions.

The really cool part? It uses an agentic AI paradigm. This means that it can plan and execute multi-step processes, intelligently pulling from diverse data sources and wielding various AI tools to fulfill your requests. Just to be clear, agentic AI refers to an AI system’s ability to make decisions, perform tasks, and adapt to its environment without constant human intervention, thereby leading to automation of a wider range of tasks with minimal supervision. So, whether you’re dealing with structured Snowflake tables or unstructured PDFs in object storage, the agent brings it all together to give you unified and comprehensive answers.

Overview of Cortex AI

Here’s a visual representation of the Snowflake Cortex AI ecosystem, illustrating its architectural components and capabilities. The diagram systematically organizes the platform’s features into key functional areas: Agents & Insights, core Processing & Retrieval mechanisms, diverse Data sources, integrated AI Models, and comprehensive Governance frameworks. This overview highlights how Snowflake Cortex AI provides a unified environment for developing and managing AI-powered data solutions.

What an AI Agent Brings to Your Business Intelligence

Ready to see how an AI Agent can transform your BI? Here are some core advantages:

• Self-serve data exploration: Imagine generating charts and getting instant answers just by asking natural language questions. No more waiting for custom dashboards or deep technical expertise. This capability is all about cutting down on data request bottlenecks and maximizing how you utilize your data across the organization.
• Democratized intelligence: This agent grants you access to and analysis of thousands of data sources simultaneously. It’s a game-changer for transforming scattered information into clear, actionable business insights for everyone.
• Contextual deep analytical research: This isn’t just surface-level stuff. The agent uses advanced reasoning and analytical methods across both structured and unstructured data. It tackles complex queries head-on, delivering truly comprehensive insights crucial for strategic decision-making.

Breaking Down Data Silos

One of the biggest headaches in business? Data silos.

A Snowflake Cortex Agent is here to help consolidate your enterprise knowledge:

• Comprehensive integration: It seamlessly analyzes structured and unstructured data together. Think about connecting insights from spreadsheets, documents, images, and databases all at once. This helps you build a holistic, 360-degree view of your entire business ecosystem.
• Enterprise-wide knowledge sharing: The agent makes it easier for everyone to access and utilize company knowledge across all departments. This means transforming isolated information into actionable intelligence that benefits the whole organization.

Under the hood, a Cortex Agent integrates several technical capabilities to power its intelligent functionalities:

• Tool Utilization: It’s smart enough to pick the right tool for the job. This includes specialized tools like Cortex Analyst for generating SQL queries and Cortex Search for semantic searches within text data.
• Large Language Models (LLMs): These are the brains behind its reasoning. LLMs help the agent understand and process your complex natural language requests.
• Multi-step Reasoning: Got a tricky request? The agent can break it down into smaller, manageable sub-tasks. It even handles clarifications, showing a sophisticated, step-by-step problem-solving approach.

Security by Design: Trusted Agent Framework

Security is non-negotiable, right? The Snowflake Cortex Agent operates within a robust framework where security is a fundamental principle, ensuring compliant and reliable operations:

• Automatic security: Good news here! Your existing Snowflake security controls, including role-based access and data masking, automatically apply to all AI interactions and conversations. This means users only ever see answers based on their defined access permissions.
• Complete transparency: Ever wonder how an AI got to an answer? With a Cortex Agent, you can trace data sources, validate insights, and understand the derivation process, bringing full explainability to the forefront.
• Centralized control: All permissions are managed centrally through Snowflake. Plus, you get integrated usage monitoring and relevance tracking functionalities for continuous operational oversight.

Real-World Scenarios: Use Cases for a Cortex Agent

The Snowflake Cortex Agent is super versatile and can be applied across a wide range of business scenarios. Here are a few examples:

• Executive Decision Support: Need quick summaries from sales, finance, or audit reports? The agent can compile them to support executive decision-making processes.
• Financial Services: Imagine getting comprehensive client insights by pulling and analyzing data from claims databases, customer correspondence logs, and more.
• Healthcare and Life Sciences: Researchers can get a huge boost by having the agent aggregate data on adverse reactions and scan extensive medical literature.
• Operational Automation: It’s not just for insights! The agent can automate routine operational tasks, like detecting anomalies and sending automated notifications to the right teams.

So, in a nutshell, a Snowflake Cortex Agent is designed to supercharge your data-driven operations. It provides intelligent, automated assistance for data analysis and information retrieval across industries, all while prioritizing security and transparency.

The Cortex Agent Workflow: Four Core Components

Understanding how a Cortex Agent operates internally helps appreciate its sophisticated approach to handling complex data requests. The workflow consists of four essential components that work together to deliver intelligent responses:

1. Planning forms the foundation of every interaction. When you ask a question, the agent doesn’t just jump to an answer — it first analyzes your request to understand what type of data sources are needed. Whether you’re asking about top distributors by revenue (structured data) or inquiring about contract details (unstructured documents), the agent orchestrates a comprehensive plan to tackle your query systematically.
2. Tool Use is where the real work happens. Armed with a clear plan, the agent selects and deploys the right tools for the job. Cortex Search dives into unstructured sources like documents and PDFs, while Cortex Analyst generates precise SQL queries for your structured datasets. This dual capability ensures no data source is left untapped in finding your answer.
3. Reflection ensures accuracy and completeness. After each tool execution, the agent evaluates the results to determine next steps. It might ask for clarification, iterate on the approach, or synthesize information from multiple sources before generating the final response. This self-assessment capability prevents incomplete or inaccurate answers from reaching you.
4. Monitor and Iterate extends beyond individual queries to continuous improvement. Once deployed, the system tracks performance metrics and refines behavior based on real-world usage patterns. This ongoing optimization means your agent becomes more effective over time, learning from interactions while maintaining strict security and compliance standards.

Utilizing the Snowflake Cortex Agent API

Developers, listen up! The Cortex Agent REST API simplifies building interactive chat applications by giving you a direct interface for agent interaction. Here’s a quick look at how it works:

Request Structure: To interact with a Cortex Agent via its API, developers construct a POST request containing specific parameters that define the conversation and desired actions.

• Endpoint: You’ll send POST requests to <account_url>/api/v2/cortex/agent:run.
• Headers: Don’t forget your authorization token for authentication and setting application/json as your Content-Type.
• Request Body: This is where you tell the agent what you need. Include parameters like the model name, specific response instructions, experimental flags, a list of available tools, tool-specific resources, tool selection configuration, and your conversational message history.

Supported Tool Types: The API allows the agent to call various tools to get things done, covering a wide range of functionalities:

• cortex_search: Great for semantic search operations.
• cortex_analyst_text_to_sql: Perfect for turning natural language questions into SQL queries.
• sql_exec: For executing SQL commands directly.
• data_to_chart: If you need to generate data visualizations. Each tool type comes with its own configuration options.

Response Handling: The agent’s response can be anything from plain text to charts or tables. Plus, the API supports streaming via Server-Sent Events (SSE). This means you get incremental message chunks or error events in real-time, making your applications feel snappier and more dynamic.

This API is your gateway to seamlessly integrating Snowflake Cortex Agent capabilities into your custom applications, letting you build truly powerful conversational AI experiences.

Building a Cortex Agent App

Check out this demo app created by Anna Filippova showing how to integrate the Cortex Agent API into a Streamlit app. This app features a chat interface where business users can ask natural language questions about sales information.

What makes this implementation particularly elegant is how the agent automatically determines whether to query structured sales databases or search through unstructured conversation transcripts, removing the complexity of data source selection from the user.

Here’s the entire Python in 170 lines of code:

import json
import requests
import streamlit as st
import snowflake.connector
import sseclient 


# replace these values in your .streamlit.toml file, not here!
HOST = st.secrets["snowflake"]["host"]
ACCOUNT = st.secrets["snowflake"]["account"]
USER =st.secrets["snowflake"]["user"]
PASSWORD = st.secrets["snowflake"]["password"]
ROLE = st.secrets["snowflake"]["role"]
WAREHOUSE= "SALES_INTELLIGENCE_WH"

# variables shared across pages

AGENT_API_ENDPOINT = "/api/v2/cortex/agent:run"
API_TIMEOUT = 50000  # in milliseconds

CORTEX_SEARCH_SERVICES = "sales_intelligence.data.sales_conversation_search"
SEMANTIC_MODELS = "@sales_intelligence.data.models/sales_metrics_model.yaml" 

def run_snowflake_query(query):
    try:
        df = session.sql(query.replace(';',''))
        
        return df

    except Exception as e:
        st.error(f"Error executing SQL: {str(e)}")
        return None, None

def agent_api_call(query: str, limit: int = 10):

    text = ""
    sql = ""
    citations = []
    
    payload = {
        "model": "llama3.1-70b",
        "messages": [
            {
                "role": "user",
                "content": [
                    {
                        "type": "text",
                        "text": query
                    }
                ]
            }
        ],
        "tools": [
            {
                "tool_spec": {
                    "type": "cortex_analyst_text_to_sql",
                    "name": "analyst1"
                }
            },
            {
                "tool_spec": {
                    "type": "cortex_search",
                    "name": "search1"
                }
            }
        ],
        "tool_resources": {
            "analyst1": {"semantic_model_file": SEMANTIC_MODELS},
            "search1": {
                "name": CORTEX_SEARCH_SERVICES,
                "max_results": limit
            }
        }
    }
    
    resp = requests.post(
            url=f"https://{HOST}"+AGENT_API_ENDPOINT,
            json=payload,
            headers={
                "Authorization": f'Snowflake Token="{st.session_state.CONN.rest.token}"',
                "Content-Type": "application/json",
            }
        )


    if resp.status_code < 400: 
        client = sseclient.SSEClient(resp)

        for event in client.events():
            try: 
                parsed = json.loads(event.data)

                try: 
                    if parsed['delta']['content'][0]['type'] == 'text': 
                        text = parsed['delta']['content'][0]['text']
                        yield text
     
                    elif parsed['delta']['content'][0]['type'] == 'tool_use': 
                        text = parsed['delta']['content'][1]['tool_results']['content'][0]['json']['text']
                        sql = parsed['delta']['content'][1]['tool_results']['content'][0]['json']['sql']
                        yield text
                        yield "\n\n `" + sql + "`" 

                    else: 
                        text = parsed
                        yield text


                except:
                    continue
            except:
                continue

def main():

    with st.sidebar:
        if st.button("Reset Conversation", key="new_chat"):
            st.session_state.messages = []
            st.rerun()

    st.title("Intelligent Sales Assistant")

    # connection
    if 'CONN' not in st.session_state or st.session_state.CONN is None:

        try: 
            st.session_state.CONN = snowflake.connector.connect(
                user=USER,
                password=PASSWORD,
                account=ACCOUNT,
                host=HOST,
                port=443,
                role=ROLE,
                warehouse=WAREHOUSE
            )  
            st.info('Snowflake Connection established!', icon="💡")    
        except:
            st.error('Connection not established. Check that you have correctly entered your Snowflake credentials!', icon="🚨")    



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

    for message in st.session_state.messages:
        with st.chat_message(message['role']):
            st.markdown(message['content'].replace("•", "\n\n-"))

    if user_input := st.chat_input("What is your question?"):

            # Add user message to chat       
            with st.chat_message("user"):
                st.markdown(user_input)
                st.session_state.messages.append({"role": "user", "content": user_input})

            # Get response from API
            with st.spinner("Processing your request..."):
                
                response = agent_api_call(user_input, 1)
                text = st.write(response)

                # Add assistant response to chat
                if text:
                    st.session_state.messages.append({"role": "assistant", "content": text})

      
if __name__ == "__main__":
    main()

If you’d like to try it out for yourself, here’s the GitHub repo:

GitHub - annafil/cortex-agent-api-demo

Conclusion

Snowflake Cortex Agents represent a fundamental shift in how enterprises interact with their data, transforming complex analytics from a technical barrier into natural conversations that any business user can navigate. By combining powerful AI capabilities with enterprise-grade security, these agents don’t just democratize data access — they turn your entire organization’s knowledge into a competitive advantage.

Dive Deeper with these Essential Resources

Ready to get your hands dirty and explore more? These resources are your next stop for understanding and implementing Snowflake Cortex Agents:

YouTube video:

• Getting started with Cortex Agents

Docs and Articles:

• Snowflake Cortex Agents Documentation
• Snowflake Cortex Agents REST API Documentation
• The Future of Data Science: How AI Agents are Revolutionizing ML Development (Medium)

GitHub Repos and Quickstarts Tutorials:

• Cortex Agent API Demo (GitHub)
• Getting Started with Cortex Agents (Snowflake Quickstart)
• Getting Started with Snowflake Agents API and React (Snowflake Quickstart)
• Integrate Snowflake Cortex Agents with Slack (Snowflake Quickstart)
• Integrate Snowflake Cortex Agents with Microsoft Teams (Snowflake Quickstart)

Developer’s Guide to Snowflake Cortex Agent was originally published in Snowflake Builders Blog: Data Engineers, App Developers, AI, & Data Science on Medium, where people are continuing the conversation by highlighting and responding to this story.

Overview

AI-powered Business Intelligence (BI) and conversational analytics hold immense promise for data-driven decision-making. However, directly applying these technologies to complex enterprise schemas often leads to inaccurate or inconsistent results, commonly referred to as “hallucinations.” This challenge arises because AI and BI systems may struggle to interpret raw data without a clear understanding of the organizational context and definitions.

Snowflake addresses these challenges by introducing Semantic Views, a new schema-level object that stores all semantic model information natively within the database. Semantic views capture and store semantic model information directly within the database, including business-relevant concepts such as metrics (e.g., total sales), dimensions (e.g., product category), and facts.

What You’ll Learn

• How to setup a database and schema in Snowflake
• How to create views from existing sample data
• The process of defining a Snowflake semantic view with tables, relationships, dimensions, and metrics
• How to query a semantic view
• How semantic views enhance AI-powered analytics and consistency across BI tools

What You’ll Build

You will build a foundational understanding and practical setup of a Snowflake semantic view, complete with data views and a defined semantic model, enabling simplified and consistent data querying for BI and AI applications using TPC-DS sample data.

What You’ll Need

• Access to a Snowflake account
• Basic knowledge of SQL and Python
• Familiarity with data analysis concepts
• Access to ACCOUNTADMIN role is required for creating semantic views)
• Access to the SNOWFLAKE_SAMPLE_DATA database

Understand Semantic Views

What is a Semantic View?

A semantic view acts as a translator between your raw data and how humans or AI interpret it. It defines key business concepts like “metrics” (e.g., total sales) and “dimensions” (e.g., customer location) by referencing your underlying tables and their relationships.

Why Semantic Views Matter

Semantic views are crucial for several reasons:

• Ensures AI and BI consistency: By embedding organizational context and definitions directly into the data layer, semantic views ensure that both AI and BI systems interpret information uniformly, leading to trustworthy answers.
• Enables AI-powered analytics: They make data “AI-ready,” unlocking advanced use cases such as conversational analytics and significantly reducing the risk of AI hallucinations.
• Maintains consistency across BI Tools: Semantic models are shifted from individual BI tool layers to the core data platform, guaranteeing that all tools utilize the same semantic concepts.
• Unlocks rich analytical capabilities: Semantic views power diverse user interfaces, including AI-powered analytics, traditional BI clients, Streamlit applications, and custom applications.

Basic Elements of a Semantic View Definition

Every semantic view definition requires essential elements:

• Physical model objects: These refer to your existing tables, views, or (in future releases) SQL queries that contain the raw data.
• Relationships: These define how your physical objects connect to each other (e.g., a CUSTOMER table linked to an ORDERS table).
• Dimensions: These are business-friendly attributes used to group or filter your data (e.g., customer’s birth year, product category).
• Metrics: These are business-friendly calculations or aggregations, often representing Key Performance Indicators (KPIs) (e.g., total sales price, total sales quantity).

Setup Environment

Download the Notebook

Firstly, to follow along with this quickstart, you can click on getting-started-with-snowflake-semantic-view.ipynb to download the Notebook from GitHub.

Snowflake Notebooks come pre-installed with common Python libraries for data science and machine learning, such as numpy, pandas, matplotlib, and more! If you are looking to use other packages, click on the Packages dropdown on the top right to add additional packages to your notebook.

Setup your Database and Schema

First, we’ll create a new database named SAMPLE_DATA and a schema named TPCDS_SF10TCL to organize our data. We will then set the context to use this new schema.

-- Create a new test database named SAMPLE_DATA
CREATE DATABASE SAMPLE_DATA;

-- Use the newly created database
USE DATABASE SAMPLE_DATA;

-- Create a new schema named TPCDS_SF10TCL within SAMPLE_DATA
CREATE SCHEMA TPCDS_SF10TCL;

-- Set the context to use the new schema
USE SCHEMA TPCDS_SF10TCL;

Create Views from Sample Data

Next, we’ll create views for the tables we want to analyze. These views will be based on the SNOWFLAKE_SAMPLE_DATA.TPCDS_SF10TCL dataset, allowing us to work with a subset of the data without modifying the original tables.

-- Create or replace views for the tables from SNOWFLAKE_SAMPLE_DATA.TPCDS_SF10TCL
CREATE OR REPLACE VIEW CUSTOMER AS
SELECT * FROM SNOWFLAKE_SAMPLE_DATA.TPCDS_SF10TCL.CUSTOMER;

CREATE OR REPLACE VIEW CUSTOMER_DEMOGRAPHICS AS
SELECT * FROM SNOWFLAKE_SAMPLE_DATA.TPCDS_SF10TCL.CUSTOMER_DEMOGRAPHICS;

CREATE OR REPLACE VIEW DATE_DIM AS
SELECT * FROM SNOWFLAKE_SAMPLE_DATA.TPCDS_SF10TCL.DATE_DIM;

CREATE OR REPLACE VIEW ITEM AS
SELECT * FROM SNOWFLAKE_SAMPLE_DATA.TPCDS_SF10TCL.ITEM;

CREATE OR REPLACE VIEW STORE AS
SELECT * FROM SNOWFLAKE_SAMPLE_DATA.TPCDS_SF10TCL.STORE;

CREATE OR REPLACE VIEW STORE_SALES AS
SELECT * FROM SNOWFLAKE_SAMPLE_DATA.TPCDS_SF10TCL.STORE_SALES;

Verify your Environment Setup

Before proceeding, let’s ensure our warehouse, database, and schema are correctly set, and then list the views we just created.

-- Select the warehouse, database, and schema
USE WAREHOUSE COMPUTE_WH;
USE DATABASE SAMPLE_DATA;
USE SCHEMA TPCDS_SF10TCL;

-- Show all views in the current schema to verify creation
SHOW VIEWS;

Note:

• Ensure you have the ACCOUNTADMIN role to create semantic views
• Verify that all views are created successfully before proceeding to the next step

Create the Semantic View

Define the Semantic View

We’ll start by switching to the ACCOUNTADMIN role:

-- Switch to ACCOUNTADMIN role to create the semantic view
USE ROLE ACCOUNTADMIN;

Now, we’ll define our TPCDS_SEMANTIC_VIEW_SM semantic view. This view will establish relationships between our tables, define facts (measures), and dimensions (attributes), making it easier to query and analyze our data without complex joins.

-- Create or replace the semantic view named TPCDS_SEMANTIC_VIEW_SM
CREATE OR REPLACE SEMANTIC VIEW TPCDS_SEMANTIC_VIEW_SM
 tables (
  CUSTOMER primary key (C_CUSTOMER_SK),
  DATE as DATE_DIM primary key (D_DATE_SK),
  DEMO as CUSTOMER_DEMOGRAPHICS primary key (CD_DEMO_SK),
  ITEM primary key (I_ITEM_SK),
  STORE primary key (S_STORE_SK),
  STORESALES as STORE_SALES
        primary key (SS_SOLD_DATE_SK,SS_CDEMO_SK,SS_ITEM_SK,SS_STORE_SK,SS_CUSTOMER_SK)
 )
 relationships (
  SALESTOCUSTOMER as STORESALES(SS_CUSTOMER_SK) references CUSTOMER(C_CUSTOMER_SK),
  SALESTODATE as STORESALES(SS_SOLD_DATE_SK) references DATE(D_DATE_SK),
  SALESTODEMO as STORESALES(SS_CDEMO_SK) references DEMO(CD_DEMO_SK),
  SALESTOITEM as STORESALES(SS_ITEM_SK) references ITEM(I_ITEM_SK),
  SALETOSTORE as STORESALES(SS_STORE_SK) references STORE(S_STORE_SK)
 )
 facts (
  ITEM.COST as i_wholesale_cost,
  ITEM.PRICE as i_current_price,
  STORE.TAX_RATE as S_TAX_PRECENTAGE
 )
 dimensions (
  CUSTOMER.BIRTHYEAR as C_BIRTH_YEAR,
  CUSTOMER.COUNTRY as C_BIRTH_COUNTRY,
  CUSTOMER.C_CUSTOMER_SK as c_customer_sk,
  DATE.DATE as D_DATE,
  DATE.D_DATE_SK as d_date_sk,
  DATE.MONTH as D_MOY,
  DATE.WEEK as D_WEEK_SEQ,
  DATE.YEAR as D_YEAR,
  DEMO.CD_DEMO_SK as cd_demo_sk,
  DEMO.CREDIT_RATING as CD_CREDIT_RATING,
  DEMO.MARITAL_STATUS as CD_MARITAL_STATUS,
  ITEM.BRAND as I_BRAND,
  ITEM.CATEGORY as I_CATEGORY,
  ITEM.CLASS as I_CLASS,
  ITEM.I_ITEM_SK as i_item_sk,
  STORE.MARKET as S_MARKET_ID,
  STORE.SQUAREFOOTAGE as S_FLOOR_SPACE,
  STORE.STATE as S_STATE,
  STORE.STORECOUNTRY as S_COUNTRY,
  STORE.S_STORE_SK as s_store_sk,
  STORESALES.SS_CDEMO_SK as ss_cdemo_sk,
  STORESALES.SS_CUSTOMER_SK as ss_customer_sk,
  STORESALES.SS_ITEM_SK as ss_item_sk,
  STORESALES.SS_SOLD_DATE_SK as ss_sold_date_sk,
  STORESALES.SS_STORE_SK as ss_store_sk
 )
 metrics (
  STORESALES.TOTALCOST as SUM(item.cost),
  STORESALES.TOTALSALESPRICE as SUM(SS_SALES_PRICE),
  STORESALES.TOTALSALESQUANTITY as SUM(SS_QUANTITY)
            WITH SYNONYMS = ( 'total sales quantity', 'total sales amount')
 )
;

Verify the Semantic View Creation

Let’s confirm that our semantic view has been successfully created by listing all semantic views in the current database.

-- Lists semantic views in the database that is currently in use
SHOW SEMANTIC VIEWS;

Describe the Semantic View

To understand the structure and components of our newly created semantic view, we can use the DESC SEMANTIC VIEW command. This will provide details about its tables, relationships, facts, and dimensions.

-- Describes the semantic view named TPCDS_SEMANTIC_VIEW_SM, and as a special bonus uses our new flow operator to filter and project only the metric and dimension names
DESC SEMANTIC VIEW TPCDS_SEMANTIC_VIEW_SM
    ->> SELECT "object_kind","property_value" as "parent_object","object_name" FROM $1
        WHERE "object_kind" IN ('METRIC','DIMENSION') AND "property" IN ('TABLE')
;

“Talk To” the Semantic View with Cortex Analyst

Natural Language Querying

Snowflake’s Cortex Analyst allows you to interact with your semantic views using natural language. This powerful feature transforms how users can explore data without needing to know SQL syntax.

Access Cortex Analyst

You can access Cortex Analyst through the Snowflake interface.

Let’s dynamically generate a link to Cortex Analyst so that you can access the semantic view.

First, we’ll create a SQL cell named sql_step7:

SELECT 'https://app.snowflake.com/' || CURRENT_ORGANIZATION_NAME() || '/' || CURRENT_ACCOUNT_NAME() || '/#/studio/analyst/databases/SAMPLE_DATA/schemas/TPCDS_SF10TCL/semanticView/TPCDS_SEMANTIC_VIEW_SM/edit' AS RESULT;

Next, we’ll call it from the following Python code cell that we called py_link:

import streamlit as st

link = sql_step7.to_pandas()['RESULT'].iloc[0]
st.link_button("Go to Cortex Analyst", link)

Example Natural Language Query

Once in Cortex Analyst, you can ask questions like:

Show me the top selling brands in by total sales quantity in the state ‘TX’ in the ‘Books’ category in the year 2003

Cortex Analyst will automatically translate this natural language question into the appropriate Semantic SQL query and return the results.

Query Semantic Views

Basic Query Structure

To query a semantic view, you’ll use this special query structure:

SELECT * FROM SEMANTIC_VIEW (view_name
    METRICS metric1, metric2, ...
    DIMENSIONS dimension1, dimension2, ...
);

Let’s break down each part:

• SELECT * FROM SEMANTIC_VIEW (view_name ...): This initiates your query, indicating that you want to retrieve data from a semantic view
• METRICS metric1, metric2, ...: Within the parentheses, specify the metrics (calculated values or totals) you wish to retrieve
• DIMENSIONS dimension1, dimension2, ...: Next, specify the dimensions (categories or attributes) you want to group or filter your data by

Add Filters and Sorting

You can enhance your queries with standard SQL clauses:

• Filtering: Use WHERE clauses to filter your results
• Sorting: Use ORDER BY to sort your results
• Limiting: Use LIMIT to restrict the number of results

Example Query: Top Selling Brands

Now that our semantic view is defined, we can easily query it to retrieve aggregated data. The following query demonstrates how to find the top-selling brands in a specific state and category for a given year and month:

-- Query the semantic view to find top selling brands
SELECT * FROM SEMANTIC_VIEW
(
 TPCDS_SEMANTIC_VIEW_SM
    DIMENSIONS
            Item.Brand,
            Item.Category,
            Date.Year,
            Date.Month,
            Store.State
    METRICS
        StoreSales.TotalSalesQuantity
)
WHERE Year = '2002' AND Month = '12' AND State ='TX' AND Category = 'Books'
ORDER BY TotalSalesQuantity DESC LIMIT 10;

Build an Interactive Data App

In this step, we’ll build 2 simple interactive data apps:

1. Interactive data visualization app
2. Simple interactive dashboard

Query data

Firstly, we’ll modify the SQL query to show data for month 12.

-- Query the semantic view for month 12
SELECT * FROM SEMANTIC_VIEW
( 
 TPCDS_SEMANTIC_VIEW_SM
    DIMENSIONS 
            Item.Brand,
            Item.Category,            
            Date.Year,
            Date.Month,
            Store.State
    METRICS 
        StoreSales.TotalSalesQuantity
    WHERE
        Date.Year = '2002' AND Date.Month = '12' AND Item.Category = 'Books'
) 
ORDER BY TotalSalesQuantity DESC;

Next, in a Python cell named df, we'll convert the SQL table to a Pandas DataFrame:

cell1.to_pandas()

App 1: Interactive data visualization app

Here the user can interactively explore the sales data:

import streamlit as st
import pandas as pd

st.title("📊 Sales Data Interactive Visualization")

# Create selectbox for grouping option
group_by = st.selectbox(
    "Select grouping option:",
    options=['BRAND', 'STATE'],
    index=0
)

# Group the data based on selection
if group_by == 'BRAND':
    grouped_data = df.groupby('BRAND')['TOTALSALESQUANTITY'].sum().reset_index()
    grouped_data = grouped_data.set_index('BRAND')
    chart_title = "Total Sales Quantity by Brand"
else:  # group_by == 'STATE'
    grouped_data = df.groupby('STATE')['TOTALSALESQUANTITY'].sum().reset_index()
    grouped_data = grouped_data.set_index('STATE')
    chart_title = "Total Sales Quantity by State"

# Display the chart
st.subheader(chart_title)
st.bar_chart(grouped_data['TOTALSALESQUANTITY'])

# Optional: Display the data table
if st.checkbox("Show data table"):
    st.subheader("Grouped Data")
    st.dataframe(grouped_data)

App 2: Simple interactive dashboard

Here’s a simple dashboard we’re we’ve included a row of metrics:

import streamlit as st
import pandas as pd

st.title("📊 Sales Data Dashboard")

# Create selectbox for grouping option
group_by = st.selectbox(
    "Select grouping option:",
    options=['BRAND', 'STATE'],
    index=0
)

# Group the data based on selection
if group_by == 'BRAND':
    grouped_data = df.groupby('BRAND')['TOTALSALESQUANTITY'].sum().reset_index()
    grouped_data = grouped_data.set_index('BRAND')
    chart_title = "Total Sales Quantity by Brand"
else:  # group_by == 'STATE'
    grouped_data = df.groupby('STATE')['TOTALSALESQUANTITY'].sum().reset_index()
    grouped_data = grouped_data.set_index('STATE')
    chart_title = "Total Sales Quantity by State"

# Calculate KPIs based on current grouping
total_sales = df['TOTALSALESQUANTITY'].sum()
avg_sales = df['TOTALSALESQUANTITY'].mean()
top_performer = grouped_data['TOTALSALESQUANTITY'].max()
top_performer_name = grouped_data['TOTALSALESQUANTITY'].idxmax()

# Display KPI metrics in 3 columns
col1, col2, col3 = st.columns(3)

with col1:
    st.metric(
        label="Total Sales Quantity", 
        value=f"{total_sales:,.0f}",
        delta=None
    )

with col2:
    if group_by == 'BRAND':
        st.metric(
            label="Average Sales per Brand", 
            value=f"{avg_sales:,.0f}",
            delta=f"{((avg_sales/total_sales)*100):.3f}% of total"
        )
    else:
        st.metric(
            label="Average Sales per State", 
            value=f"{avg_sales:,.0f}",
            delta=f"{len(df['STATE'].unique())} state(s)"
        )

with col3:
    st.metric(
        label=f"Top {group_by.title()}", 
        value=f"{top_performer:,.0f}",
        delta=f"{top_performer_name}"
    )

# Display the chart
st.subheader(chart_title)
st.bar_chart(grouped_data['TOTALSALESQUANTITY'])

# Optional: Display the data table
if st.checkbox("Show data table"):
    st.subheader("Grouped Data")
    st.dataframe(grouped_data)

Conclusion And Resources

Congratulations! You’ve successfully created your first Snowflake semantic view. By implementing this semantic layer directly within Snowflake, you’ve established a foundation for consistent, AI-ready analytics that bridges the gap between raw data and meaningful business insights.

The semantic view you built not only simplifies complex data relationships but also enables natural language querying through Cortex Analyst, democratizing data access across your organization. As you continue to develop your semantic models, remember that this approach scales to support enterprise-wide analytics initiatives, ensuring that all stakeholders — from data analysts to business users — can trust and understand the data that they’re working with.

What You Learned

• How to create and configure Snowflake semantic views using the TPC-DS sample data
• The importance of semantic views for AI-powered analytics and BI consistency
• How to define relationships, dimensions, and metrics in a semantic view
• How to query semantic views
• How to leverage Cortex Analyst for natural language data exploration

Related Resources

Articles:

• Using SQL commands to create and manage semantic views
• Using the Cortex Analyst Semantic View Generator
• Sample Data: TPC-DS
• TPC-DS Benchmark Overview — Understanding the sample dataset used in this guide

Documentation:

• Overview of semantic views
• CREATE SEMANTIC VIEW
• DROP SEMANTIC VIEW
• SHOW SEMANTIC VIEWS
• DESCRIBE SEMANTIC VIEW

Ready to start Snowflake? Start your 30-day free Snowflake trial which includes $400 worth of free usage here.

Getting Started with Snowflake Semantic View was originally published in Snowflake Builders Blog: Data Engineers, App Developers, AI, & Data Science on Medium, where people are continuing the conversation by highlighting and responding to this story.

Have you ever wondered how to transform unstructured customer feedback into actionable business insights? Organizations often struggle to efficiently process and analyze large volumes of customer reviews stored in various document formats.

The solution lies in building an automated analytics pipeline that combines Snowflake’s powerful data processing capabilities with modern visualization tools.

In this blog, I will guide you through creating a complete analytics solution that processes customer review data using Snowflake Cortex and visualizes insights with Streamlit.

While we won’t be building a fully functional dashboard today, the techniques covered can be easily repurposed to create one.

Readers will learn:

• How to extract and process content from DOCX files using Snowflake
• How to perform sentiment analysis using Snowflake Cortex
• How to create interactive visualizations with Streamlit and Altair

Getting Started

Prerequisites

Before proceeding, ensure you have:

• Access to a Snowflake account
• Basic knowledge of SQL and Python
• Familiarity with data analysis concepts

New to data?

Here are some introductory notes on

What is Snowflake? Snowflake is a cloud-based data platform that allows organizations to store, process, and analyze large amounts of data without managing complex infrastructure.

What is Streamlit? Streamlit is an open-source Python library that makes it easy to create and share custom web apps for machine learning and data science projects without requiring front-end development experience.

What is Snowflake Cortex? Snowflake Cortex is a built-in AI and machine learning feature in Snowflake that provides ready-to-use functions for tasks like sentiment analysis, translation, and document parsing without requiring expertise in AI/ML.

Setting Up the Database Environment

Let’s break down the solution into manageable steps.

Create the database and schema

First, we’ll set up our environment and create the necessary database objects.

CREATE DATABASE IF NOT EXISTS avalanche_db;
CREATE SCHEMA IF NOT EXISTS avalanche_schema;

Here, we’re creating a database called avalanche_db and a schema called avalanche_schema within it. In Snowflake, a database is a container for data, and a schema is a way to organize objects within a database. The IF NOT EXISTS clause prevents errors if these objects already exist.

Create the stage

A stage in Snowflake is a location where data files are stored before being loaded into database tables.

Here, we’re creating a stage called customer_reviews with Snowflake-managed encryption and enabling directory listing functionality, which allows us to browse files in the stage.

CREATE STAGE IF NOT EXISTS avalanche_db.avalanche_schema.customer_reviews
  ENCRYPTION = (TYPE = 'SNOWFLAKE_SSE')
  DIRECTORY = (ENABLE = true);

You should see a confirmation message after a stage has been created succesfully:

List contents of a stage

Finally, we can verify that the files have been uploaded successfully to the stage by opening up a SQL worksheet, from the left menu sidebar go to Projects > Worksheets > + (Create SQL Worksheet)

Next, enter the following in a SQL worksheet:

ls @avalanche_db.avalanche_schema.customer_reviews

This should yield the following results output:

Data Extraction Process

Now we’ll extract content from the DOCX files stored in our Snowflake stage.

WITH files AS (
  SELECT 
    REPLACE(REGEXP_SUBSTR(file_url, '[^/]+$'), '%2e', '.') as filename
  FROM DIRECTORY('@avalanche_db.avalanche_schema.customer_reviews')
  WHERE filename LIKE '%.docx'
)
SELECT 
  filename,
  SNOWFLAKE.CORTEX.PARSE_DOCUMENT(
    @avalanche_db.avalanche_schema.customer_reviews,
    filename,
    {'mode': 'layout'}
  ):content AS layout
FROM files;

Here’s a breakdown of the code:

• The WITH clause creates a temporary result set called files that contains the names of all DOCX files in our stage.
• DIRECTORY() lists all files in the specified stage.
• REGEXP_SUBSTR(file_url, '[^/]+$') extracts just the filename from the full path.
• REPLACE(..., '%2e', '.') converts URL-encoded periods back to actual periods.
• SNOWFLAKE.CORTEX.PARSE_DOCUMENT() is a Cortex function that extracts text content from the DOCX files.
• The :content part uses Snowflake's semi-structured data access notation to get just the content field from the returned JSON object.
• {'mode': 'layout'} tells the parser to preserve the document's original layout.

Running the above query should yield the following table output:

Data Reshaping

Let’s transform the extracted content into a structured format and we’ll do this with regular expressions, which are patterns used to match character combinations in strings.

SELECT 
  filename,
  REGEXP_SUBSTR(layout, 'Product: (.*?) Date:', 1, 1, 'e') as product,
  REGEXP_SUBSTR(layout, 'Date: (202[0-9]-[0-9]{2}-[0-9]{2})', 1, 1, 'e') as date,
  REGEXP_SUBSTR(layout, '## Customer Review\n([\\s\\S]*?)$', 1, 1, 'es') as customer_review
FROM previous_query_result;

Here’s what the above query is doing:

• We’re using REGEXP_SUBSTR() to extract specific pieces of information from the document text.
• The first expression extracts the product name from between "Product:" and "Date:".
• The second expression extracts a date in YYYY-MM-DD format.
• The third expression extracts all content after the "## Customer Review" heading.
• The parameters 1, 1, 'e' mean: start at position 1, get the first occurrence, and extract the captured group.

The resulting table output should look like the following:

Analytics Processing

We’ll apply Snowflake Cortex functions to translate and summarize text as well as computing the sentiment score.

SELECT 
    product,
    date,
    SNOWFLAKE.CORTEX.TRANSLATE(customer_review, '', 'en') as translated_review,
    SNOWFLAKE.CORTEX.SUMMARIZE(translated_review) as summary,
    SNOWFLAKE.CORTEX.SENTIMENT(translated_review) as sentiment_score
FROM previous_query_result
ORDER BY date;

Let’s see what the above query is doing:

• TRANSLATE(customer_review, '', 'en') translates the review text to English if it's in another language. The empty string '' means to auto-detect the source language.
• SUMMARIZE(translated_review) creates a concise summary of the review text.
• SENTIMENT(translated_review) analyzes the emotional tone of the review and returns a score (typically between -1 and 1, where negative values indicate negative sentiment and positive values indicate positive sentiment).
• ORDER BY date sorts the results chronologically.

Results from the query is shown below:

Converting SQL Results to a Pandas DataFrame

To prepare for visualization, we’ll convert the SQL results to a Pandas DataFrame:

df = sql_result.to_pandas()

This conversion allows us to use Python’s data visualization libraries to create interactive charts and graphs.

Data Visualization

Finally, we’ll create interactive visualizations using Streamlit and Altair.

Calculate Daily Sentiment Scores

First, let’s create a bar chart showing sentiment scores by date:

import streamlit as st
import altair as alt
import pandas as pd

# Ensure SENTIMENT_SCORE is numeric
df['SENTIMENT_SCORE'] = pd.to_numeric(df['SENTIMENT_SCORE'])

# Create the base chart with bars
chart = alt.Chart(df).mark_bar(size=15).encode(
    x=alt.X('DATE:T',
            axis=alt.Axis(
                format='%Y-%m-%d',  # YYYY-MM-DD format
                labelAngle=90)  # Rotate labels 90 degrees
            ),
    y=alt.Y('SENTIMENT_SCORE:Q'),
    color=alt.condition(
        alt.datum.SENTIMENT_SCORE >= 0,
        alt.value('#2ecc71'),  # green for positive
        alt.value('#e74c3c')   # red for negative
    ),
    tooltip=['PRODUCT:N', 'DATE:T'] # Add tooltip
).properties(
    height=500
)

# Display the chart
st.altair_chart(chart, use_container_width=True)

Let’s take a glimpse at what the code is doing:

1. We first import the necessary Python libraries: streamlitfor the web app, pandas for data visualization, and pandasfor data manipulation.
2. pd.to_numeric() converts the sentiment scores to numbers (they might be strings in the original data).
3. alt.Chart(df) creates a new chart using our data.
4. mark_bar(size=15) specifies we want a bar chart with bars 15 pixels wide.
5. The encode() function maps data fields to visual properties:

• x=alt.X('DATE:T') puts dates on the x-axis ('T'means temporal/date data)
• y=alt.Y('SENTIMENT_SCORE:Q') puts sentiment scores on the y-axis ('Q' means quantitative/numeric data)
• color=alt.condition(...) colors positive scores green and negative scores red
• tooltip=[...] shows product and date when hovering over a bar

6. st.altair_chart() displays the chart in the Streamlit app.

This produces the following bar chart that conditionally colors the bars as green or red for positive and negative scores, respectively.

Calculate Product Sentiment Scores

Next, let’s create a bar chart showing average sentiment scores by product:

import streamlit as st
import altair as alt
import pandas as pd

# Create the base chart with aggregation by PRODUCT
bars = alt.Chart(df).mark_bar(size=15).encode(
    y=alt.Y('PRODUCT:N', 
            axis=alt.Axis(
                labelAngle=0,  # Horizontal labels
                labelOverlap=False,  # Prevent label overlap
                labelPadding=10  # Add some padding
            )
    ),
    x=alt.X('mean(SENTIMENT_SCORE):Q',  # Aggregate mean sentiment score
            title='MEAN SENTIMENT_SCORE'),
    color=alt.condition(
        alt.datum.mean_SENTIMENT_SCORE >= 0,
        alt.value('#2ecc71'),  # green for positive
        alt.value('#e74c3c')   # red for negative
    ),
    tooltip=['PRODUCT:N', 'mean(SENTIMENT_SCORE):Q']
).properties(
    height=400
)

# Display the chart
st.altair_chart(bars, use_container_width=True)

This chart:

• Shows average sentiment scores for each product
• Uses the same color scheme as the previous chart
• Includes tooltips that show the product name and average sentiment score

Add Download Button

Finally, let’s add a download button so users can export the processed data:

# Download button for the CSV file
st.subheader('Processed Customer Reviews Data')
st.download_button(
    label="Download CSV",
    data=df[['PRODUCT', 'DATE', 'SUMMARY', 'SENTIMENT_SCORE']].to_csv(index=False).encode('utf-8'),
    mime="text/csv"
)

This button allows users to download a CSV file containing the product name, date, summary, and sentiment score for each review.

Conclusion

In this blog, we built a comprehensive customer review analytics solution that transforms unstructured DOCX files into actionable insights. The solution combines Snowflake’s data processing capabilities with Cortex’s AI functions and Streamlit’s visualization tools to create an end-to-end analytics pipeline. You can adapt this framework for your own use cases by modifying the data source, analysis parameters, or visualization components to meet your specific business needs.

What You’ve Learned

• How to use Snowflake stages to store document files
• How to extract text from DOCX files using Snowflake Cortex
• How to structure unstructured data using regular expressions
• How to apply AI functions for sentiment analysis and summarization
• How to create interactive visualizations with Streamlit and Altair

While we didn’t build a complete dashboard in this tutorial, the components we’ve developed can be easily combined into a comprehensive analytics dashboard. The Streamlit app we created serves as the foundation for more complex visualizations and interactive features.

Resources

Videos:

• YouTube playlist on Snowflake Notebooks

Documentation:

• PARSE_DOCUMENT
• Snowflake Cortex
• Snowflake Documentation
• Streamlit Documentation
• Altair Documentation

Towards Building a Customer Review Analytics Dashboard with Snowflake Cortex and Streamlit was originally published in Snowflake Builders Blog: Data Engineers, App Developers, AI, & Data Science on Medium, where people are continuing the conversation by highlighting and responding to this story.

The pace of advancements in the AI space is indeed proceeding at an unprecedented speed. In just over a week, the release of the DeepSeek-R1 LLM model has shaken the AI world with its impressive accuracy that is on par with established models and yet created at a steep fraction of the typical cost.

The DeepSeek team managed to distill the reasoning capabilities of their massive 671B parameter model as 6 small models based on Qwen (DeepSeek-R1-Distill-Qwen-1.5B, 7B, 14B and 32B) and Llama (DeepSeek-R1-Distill-Llama-8B and 70B). This essentially means that you can work with your own copy of the model — customizing it, making changes, running it locally, or hosting it on cloud platforms.

In this blog, we’re building a DeepSeek-R1 chatbot in Python. Briefly, Streamlit is used for the frontend, while on the backend the LLM model that is powering the app’s response is made possible through API calls to the DeepSeek-R1 model hosted in Snowflake.

By the end of this article, you’ll learn how to:

1. Set up the development environment
2. Build the app
3. Deploy the app

🐳 Want to jump right in? Here's the GitHub repo.

What is DeepSeek-R1?

In a nutshell, DeepSeek-R1 is a reasoning model that leverages reinforcement learning to teach a base language model namely DeepSeek-V3 to reason without the need for human supervision.

Here are 5 key features of DeepSeek-R1:

1. State-of-the-Art Reasoning: DeepSeek-R1 could achieve 97.3% accuracy on advanced math tasks, outperforming earlier benchmarks. Similarly, it afforded scores of 79.8% on AIME 2024 and 49.2% on SWE-bench Verified, which also outperformed other models.
2. Cost Efficiency: DeepSeek models were trained at significantly reduced costs compared to industry standards
3. Versatile Applications: Demonstrates robust performance in creative writing, long-context comprehension, and factual question-answering.
4. Scalability: Models are available in several distilled versions (1.5B to 70B parameters) thereby optimizing the balance between capability and resource usage.
5. Accessibility: Open-source availability empowers developers and researchers to experiment with the model in efforts to implement advanced AI tools to real-world projects.

In spite of its performance, there may still be concerns on security issues in relations to its usage. In light of this, since models were open-sourced the underlying code can be examined while the models itself could be self-deployed on the user’s own compute resources.

In this tutorial, we’ll use the DeepSeek-R1 model that is hosted in the Snowflake platform.

App overview

Here is a high-level overview of the DeepSeek-R1 chatbot app:

1. The user provides a prompt input (i.e. ask a question).
2. An LLM call is made via the use of SNOWFLAKE.CORTEX.COMPLETE(), where the prompt input is submitted and the resulting LLM-generated response is obtained and displayed in the app.

Chatbot in action

Let’s see the chatbot in action, fire up the chatbot and enter a question into the chat input:

As a reasoning model, the LLM first proceeds to the thinking phase:

After the thought process is complete, the final answer is revealed underneath:

It should be noted that the depth of thought and answer is directly affected by the max tokens parameter. Here, we limit the max tokens to 800 for testing purposes, but you may increase this to 20,480.

Build DeepSeek-R1 chatbot

Let’s now proceed to build the DeepSeek-R1 chatbot on the Snowflake platform.

Setup your development environment

To have access to the necessary tools, ensure you have access to a Snowflake account.

Next, navigate to Streamlit in Snowflake by heading over to Projects→ Streamlit and then click on + Streamlit App to create the app (you’ll then specify the app location and warehouse):

Next, you’ll see an example starter app to get you started:

This Streamlit in Snowflake interface resembles an online code editor where you can edit code on the left and see the rendered app on the right.

Go ahead and replace this with the app that we’ll be building today.

Retrieve the code

The DeepSeek-R1 chatbot app that we’ll build today is comprised of:

• environment.yml — environment dependencies of the app
• streamlit_app.py — Streamlit app file

Firstly, the content of the environment.yml file is displayed below:

name: app_environment
channels:
  - snowflake
dependencies:
  - python=3.11.*
  - snowflake-ml-python
  - snowflake-snowpark-python
  - streamlit

Secondly, the content for the sis_app.py file is shown below:

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

# App configuration
st.set_page_config(page_title="🐳💬 DeepSeek R1 Chatbot", initial_sidebar_state="expanded")
session = get_active_session()

# Helper functions
def clear_chat_history():
    st.session_state.messages = [{"role": "assistant", "content": "How may I assist you today?"}]

def escape_sql_string(s):
    return s.replace("'", "''")

def extract_think_content(response):
    think_pattern = r'<think>(.*?)</think>'
    think_match = re.search(think_pattern, response, re.DOTALL)
    
    if think_match:
        think_content = think_match.group(1).strip()
        main_response = re.sub(think_pattern, '', response, flags=re.DOTALL).strip()
        return think_content, main_response
    return None, response

def generate_deepseek_response(prompt, **params):
    string_dialogue = "".join(
        f"{msg['content']}\n\n" 
        for msg in st.session_state.messages
    )
    
    cortex_prompt = f"'[INST] {string_dialogue}{prompt} [/INST]'"
    prompt_data = [{'role': 'user', 'content': cortex_prompt}], params
    prompt_json = escape_sql_string(json.dumps(prompt_data))
    response = session.sql(
        "select snowflake.cortex.complete(?, ?)", 
        params=['deepseek-r1', prompt_json]
    ).collect()[0][0]
    
    return response

# Model parameters configuration
MODEL_PARAMS = {
    'temperature': {'min': 0.01, 'max': 1.0, 'default': 0.7, 'step': 0.01},
    'top_p': {'min': 0.01, 'max': 1.0, 'default': 1.0, 'step': 0.01},
    'max_tokens': {'min': 10, 'max': 100, 'default': 20, 'step': 10},
    'presence_penalty': {'min': -1.0, 'max': 1.0, 'default': 0.0, 'step': 0.1},
    'frequency_penalty': {'min': -1.0, 'max': 1.0, 'default': 0.0, 'step': 0.1}
}

# Sidebar UI
with st.sidebar:
    st.title('🐳💬 DeepSeek R1 Chatbot')
    st.write('This chatbot is created using the DeepSeek R1 LLM model via Snowflake Cortex.')
    
    st.subheader('⚙️ Model parameters')
    params = {
        param: st.sidebar.slider(
            param.replace('_', ' ').title(),
            min_value=settings['min'],
            max_value=settings['max'],
            value=settings['default'],
            step=settings['step']
        )
        for param, settings in MODEL_PARAMS.items()
    }
    
    st.button('Clear Chat History', on_click=clear_chat_history)

# Initialize chat history
if "messages" not in st.session_state:
    st.session_state.messages = [{"role": "assistant", "content": "How may I assist you today?"}]

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

# Handle user input
if prompt := st.chat_input():
    with st.chat_message("user"):
        st.write(prompt)
    st.session_state.messages.append({"role": "user", "content": prompt})
    
    if st.session_state.messages[-1]["role"] != "assistant":
        with st.chat_message("assistant"):
            status_container = st.status("Thinking ...", expanded=True)
            
            with status_container:
                response = generate_deepseek_response(prompt, **params)
                think_content, main_response = extract_think_content(response)
                if think_content:
                    st.write(think_content)
            
            status_container.update(label="Thoughts", state="complete", expanded=False)
            st.markdown(main_response)
            st.session_state.messages.append({"role": "assistant", "content": main_response})

You can also download the necessary app files from this DeepSeek-R1 chatbot Github repository.

Run the app

To run the app, copy-paste the aforementioned code and click on the Run button.

You can position your mouse cursor on the divider of the code/app panels, then shift it to the left until the code panel disappears (see below). This will expand the app panel to full screen.

Go ahead and enter a prompt to begin your chatting session:

Also, see the Chatbot in action section above for an account of the LLM-generated thought process and answers.

Code explanation

Let’s explore what each code blocks are doing …

Import libraries

We’ll first start by importing the prerequisite libraries.

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

App configuration

Next, we’re defining the app page and setup of their initial page parameter using st.set_page_config() and we’ll set the initial_sidebar_state="expanded" so that they’ll do exactly as that, expanding the sidebar. Here, we also set the session variable, which we’ll use momentarily.

# App configuration
st.set_page_config(page_title="🐳💬 DeepSeek R1 Chatbot", initial_sidebar_state="expanded")
session = get_active_session()

Helper functions

In this segment, we’re defining several of the helper functions that we’ll use in latter parts of the app:

• clear_chat_history() — this allows us to clear the chat history to the initial state
• escape_sql_string() — replaces the SQL strings as we perform some text formatting
• extract_think_content() — parse and separate content that’s wrapped in XML-style “think” tags (<think> and </think>) from the final response.

# Helper functions
def clear_chat_history():
    st.session_state.messages = [{"role": "assistant", "content": "How may I assist you today?"}]

def escape_sql_string(s):
    return s.replace("'", "''")

def extract_think_content(response):
    think_pattern = r'<think>(.*?)</think>'
    think_match = re.search(think_pattern, response, re.DOTALL)
    
    if think_match:
        think_content = think_match.group(1).strip()
        main_response = re.sub(think_pattern, '', response, flags=re.DOTALL).strip()
        return think_content, main_response
    return None, response

For example, say we have the following generated response:

<think>Let me analyze this problem step by step...</think>
Here's the solution you're looking for...

It would parse and separate into:

• think_content: “Let me analyze this problem step by step…”
• main_response: “Here’s the solution you’re looking for…”

Let’s continue with our last helper function:

• generate_deepseek_response() — generate LLM responses using Snowflake’s Cortex service with the DeepSeek R1 model

def generate_deepseek_response(prompt, **params):
    string_dialogue = "".join(
        f"{msg['content']}\n\n" 
        for msg in st.session_state.messages
    )
    
    cortex_prompt = f"'[INST] {string_dialogue}{prompt} [/INST]'"
    prompt_data = [{'role': 'user', 'content': cortex_prompt}], params
    prompt_json = escape_sql_string(json.dumps(prompt_data))
    response = session.sql(
        "select snowflake.cortex.complete(?, ?)", 
        params=['deepseek-r1', prompt_json]
    ).collect()[0][0]
    
    return response

Sidebar UI

We’ll start by defining the MODEL_PARAMS variable as a dictionary format with their model parameters and associated min, max, default and step size values.

Next, we’ll define the sidebar that starts with the title of the app along with the app description. Here, we also include several slider widgets that is iteratively created via the for loop. Finally, we have a Clear Chat History button that calls the clear_chat_history callback function to reset the history to its initial state.

# Model parameters configuration
MODEL_PARAMS = {
    'temperature': {'min': 0.01, 'max': 1.0, 'default': 0.7, 'step': 0.01},
    'top_p': {'min': 0.01, 'max': 1.0, 'default': 1.0, 'step': 0.01},
    'max_tokens': {'min': 10, 'max': 100, 'default': 20, 'step': 10},
    'presence_penalty': {'min': -1.0, 'max': 1.0, 'default': 0.0, 'step': 0.1},
    'frequency_penalty': {'min': -1.0, 'max': 1.0, 'default': 0.0, 'step': 0.1}
}

# Sidebar UI
with st.sidebar:
    st.title('🐳💬 DeepSeek R1 Chatbot')
    st.write('This chatbot is created using the DeepSeek R1 LLM model via Snowflake Cortex.')
    
    st.subheader('⚙️ Model parameters')
    params = {
        param: st.sidebar.slider(
            param.replace('_', ' ').title(),
            min_value=settings['min'],
            max_value=settings['max'],
            value=settings['default'],
            step=settings['step']
        )
        for param, settings in MODEL_PARAMS.items()
    }
    
    st.button('Clear Chat History', on_click=clear_chat_history)

Chat elements

In this final segment of the app, we’re initializing the session state variable for the chat history, iteratively display chat messages as they come in and finally define the conditional flow for handling the user/app chat logic. The latter part makes use of previously defined helper functions to process the LLM generated responses.

# Initialize chat history
if "messages" not in st.session_state:
    st.session_state.messages = [{"role": "assistant", "content": "How may I assist you today?"}]

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

# Handle user input
if prompt := st.chat_input():
    with st.chat_message("user"):
        st.write(prompt)
    st.session_state.messages.append({"role": "user", "content": prompt})
    
    if st.session_state.messages[-1]["role"] != "assistant":
        with st.chat_message("assistant"):
            status_container = st.status("Thinking ...", expanded=True)
            
            with status_container:
                response = generate_deepseek_response(prompt, **params)
                think_content, main_response = extract_think_content(response)
                if think_content:
                    st.write(think_content)
            
            status_container.update(label="Thoughts", state="complete", expanded=False)
            st.markdown(main_response)
            st.session_state.messages.append({"role": "assistant", "content": main_response})

Piecing these code blocks together gives us the DeepSeek-R1 chatbot!

Conclusion

Congratulations on building your very own chatbot powered by the powerful DeepSeek-R1 model. This is impressively achieved in less than 100 lines of code. You’ll probably notice that big portion of the code pertains to the processing of the “think” tags and extensive in-line comments, which if removed could make the app significantly smaller. You can further adapt this chatbot to your own use case, and do share with us in the comment section, the amazing projects you’re building with this!

Resources

Here are some additional further reading:

• DeepSeek-R1 chatbot code
• Announcing DeepSeek-R1 in Preview on Snowflake Cortex AI
• DeepSeek-R1’s GitHub repo
• Snowflake Cortex LLM functions
• Streamlit Documentation

How to build a DeepSeek-R1 chatbot was originally published in Snowflake Builders Blog: Data Engineers, App Developers, AI, & Data Science on Medium, where people are continuing the conversation by highlighting and responding to this story.