Governed AI for Public Health: Reading Free-Text Records with Snowflake Cortex and Posit

Why does it matter where the AI model runs in public health?

Privacy, security, and oversight teams in public health share a duty to protect personal information. HIPAA and protected health information rules, the FISMA authorization boundary, and agency data residency requirements all expect that you can answer four questions about any workflow that touches protected text:

1. What data went in?
2. What model produced the output?
3. Who saw it, and when?
4. Can the result be reproduced?

Sending text to an external LLM API breaks the first answer the moment the request leaves your network. You no longer fully control where the payload was logged, what cache it touched, or how the provider’s data retention policy maps onto your agreements. Even if the legal team is comfortable, your privacy officer may not be.

Cortex AI removes that exposure because the call never leaves Snowflake. A SELECT SNOWFLAKE.CORTEX.COMPLETE(...) runs on Snowflake-managed infrastructure inside the same region as your account, governed by the same role-based access control (RBAC). Output is materialized as a normal column, which means it is queryable, joinable, and visible to the same audit logs and access controls you already trust.

The Posit Team Native App applies the same logic to the IDE and the deployment platform. Your analysts open Positron, RStudio Pro, JupyterLab, or VS Code from a browser, but the session itself is a container in Snowpark Container Services running under a Snowflake service role. Posit Connect publishes Shiny apps, Plumber and FastAPI endpoints, and Quarto reports on the same foundation. Nothing has to be routed through a corporate virtual private network (VPN) to a separate analytics environment.

What does the Cortex AI and Posit architecture look like?

R and Python sessions reach Cortex through the standard Snowflake drivers and Snowpark, so the model call runs in the warehouse. Posit Connect picks up published content from Workbench and serves it inside the same Native App. The credentials your analysts use are Snowflake credentials, so role-based access on the underlying tables also governs who can call which Cortex function on which data.

Use case 1: How can an epidemiology team summarize case notes?

Case investigation notes are long, inconsistent, and full of detail that matters: exposure settings, symptom onset, suspected pathogens, follow-up actions. An epidemiologist preparing a weekly summary needs a short readable digest of each note and a structured pull of a few key fields. Across hundreds of notes, doing this by hand is slow, and it is the first task that gets dropped when case volume rises.

The plan: store the notes as text in a CASE_NOTES table, summarize them with SNOWFLAKE.CORTEX.SUMMARIZE, and extract structured fields with SNOWFLAKE.CORTEX.COMPLETE against a JSON schema.

library(DBI)
library(odbc)
con <- dbConnect(odbc::snowflake(),
notes <- tbl(con, in_catalog("MARKETING_DEMO","CASES", "CASE_NOTES"))

summaries <- notes |>
  filter(REPORT_WEEK >= "2026-01-01") |>
  mutate(SUMMARY = sql("SNOWFLAKE.CORTEX.SUMMARIZE(NOTE_TEXT)")) |>
  select(CASE_ID, REPORT_WEEK, SUMMARY)

summaries |>
  head(5) |>
  collect()

prompt_base <- "You are reviewing a public health case investigation note. Return a JSON object with the keys exposure_setting, symptom_summary, suspected_pathogen, and follow_up_action. Each value should be a short string. Do not include any prose outside the JSON. NOTE: "

extracted <- notes |>
  filter(report_week >= "2026-01-01") |>
  mutate(
    FIELDS_JSON = sql(paste0(
      "SNOWFLAKE.CORTEX.COMPLETE(",
      "'llama3.1-70b', ",
      "CONCAT('", prompt_base, "', NOTE_TEXT)",
      ")"
    ))
  ) |>
  select(CASE_ID, FIELDS_JSON)

extracted_results <- extracted |>
  collect()

Use case 2: How can program staff query records in plain language?

Program staff who are not R users still need to explore incoming public inquiries and route them to the right team: foodborne reports, respiratory concerns, vaccine questions, environmental complaints. Today that is a manual triage queue.

The plan: classify each inquiry with SNOWFLAKE.CORTEX.CLASSIFY_TEXT, then publish a Shiny application on Posit Connect that lets staff filter the routed records and ask questions in natural language.

CLASSIFY_TEXT takes a string and a list of candidate labels. For a public health intake queue, the labels map to existing program areas:
inquiries <- tbl(con, in_catalog("MARKETING_DEMO","CASES", "PUBLIC_INQUIRIES"))

routed <- inquiries |>
  mutate(
    CATEGORY = sql(
      "SNOWFLAKE.CORTEX.CLASSIFY_TEXT(INQUIRY_TEXT, ['foodborne', 'respiratory', 'vaccine_inquiry', 'environmental', 'other'])"
    )
  ) |>
  select(INQUIRY_ID, RECEIVED_DATE, CATEGORY)

routed |>
  compute(name = in_catalog("MARKETING_DEMO","CASES", "INQUIRIES_ROUTED"), temporary = FALSE)

library(shiny)
library(querychat)
library(DBI)
library(DT)
library(odbc)
library(bslib)

con <- dbConnect(odbc::snowflake())

qc <- QueryChat$new(
  data_source = DBISource$new
  (con,
   DBI::Id(catalog = "MARKETING_DEMO", schema  ="CASES", table = "INQUIRIES_ROUTED")),
  greeting    = "Ask about routed public inquiries by category or date.")

ui <-page_sidebar(
  sidebar = qc$sidebar(),
  DT::DTOutput("table"))

server <- function(input, output, session) {
  chat <- qc$server()
  output$table <- DT::renderDT(chat$df())}

shinyApp(ui, server)

What does this mean for privacy and oversight?

The combination above gives you a code-first analytical environment, an LLM, and a deployment platform that all share one identity model and one audit trail. Your privacy, compliance, and oversight teams can verify the following directly, without a separate evidence-gathering exercise:

• Every Cortex call is associated with a Snowflake user and role, captured in the account’s query history.
• Every Posit Connect deployment is a versioned bundle pinned to the package versions installed by Posit Package Manager, which can mirror an internally curated repository.
• Every Workbench session runs as a container with logged start, stop, and resource usage.
• Every output table from a Cortex pipeline is governed by the same RBAC, masking policies, and row access policies as the source data.

The same governance story your team already tells about SQL workloads in Snowflake now extends to the AI-assisted R and Python work that has historically lived somewhere else.

How can I get started with Cortex AI and Posit Team?

If you want to try this in your own Snowflake account, start with the Posit Team Native App listing on Snowflake Marketplace and the Cortex AI documentation. The links below are good starting points, and the Posit Solutions Engineering team is happy to walk through a proof of concept with your data.

• Posit + Snowflake partnership page for an overview of integration capabilities.
• Curious about Posit Team, but not ready to commit? Start a 30-day free trial of the Posit Team Native App immediately, no sales calls required.
• Learn about Posit’s integration with Snowflake Cortex.
• Snowflake Cortex AI function reference for the full list of available functions and models.
• Posit Team Native App documentation for setup and configuration.

You can also schedule a demo with a Posit expert to see the Native App in action with your specific use cases. If you build something interesting on this stack, we would like to hear about it on the Posit Community forum.

Frequently asked questions

About Posit

Posit (formerly RStudio) is the data science platform for R and Python, used by teams across government, public health, life sciences, financial services, and academia. Posit Team, including Posit Workbench, Posit Connect, and Posit Package Manager, gives organizations in regulated industries the tools to develop, deploy, and govern analytic work, with deep support for the open-source R and Python ecosystems. Learn more at posit.co.

About Snowflake

Snowflake delivers the AI Data Cloud, a global network where thousands of organizations mobilize data with near-unlimited scale, concurrency, and performance. Snowflake’s Native App Framework and Snowpark Container Services allow software partners like Posit to run their applications inside customer Snowflake accounts, giving regulated industries a single governance boundary for both data and the analytical tools that work on it. Learn more at snowflake.com.