Snowflake Gen AI

Snowflake lets you call language models from SQL. You complete, summarize, translate and classify text across whole tables, choose models by task and size, and estimate what a run over millions of rows will cost.

• Calling a language model from SQL
• Summarization and translation
• Sentiment and classification
• Extracting structured values from text
• Choosing a model by task, size and cost
• Estimating the cost of a run over a table

You build A SQL workflow that classifies and summarizes thousands of rows, with a cost estimate.

A prompt that works once is a draft. You write instructions with roles and examples, request JSON and validate it, test against labeled data, and guard against instructions hidden inside the text you process.

• Roles, instructions and examples
• Parameters that shape output
• Requesting JSON and validating it
• Chaining calls over rows
• Testing prompts against labeled data
• Guarding against injected text in data

You build A prompt that returns validated JSON, tested on labeled examples.

Models answer better when they read the right text first. You turn text into embeddings, chunk documents, build and refresh a Cortex Search service, combine keyword and vector retrieval, and judge the quality of what comes back.

• Embeddings and vector similarity
• Chunking text for retrieval
• Creating and refreshing a search service
• Hybrid retrieval and filters
• Grounding answers in retrieved text
• Evaluating retrieval quality

You build A question-answering flow over a document set, built on a search service.

Business users want answers from tables without writing SQL. You describe tables, measures and relationships in a semantic model, add verified queries, handle ambiguous questions, and measure how accurate the answers are.

• What Cortex Analyst does
• Semantic models: tables, dimensions and measures
• Verified queries and synonyms
• Handling ambiguous questions
• Measuring answer accuracy
• Controlling access to the data it queries

You build A semantic model that answers a set of business questions accurately.

Some models do not run in a warehouse. You use container services to run your own code and models, with compute pools including GPUs, image repositories, service specifications, endpoints and the access they need.

• What container services are for
• Compute pools and GPU choices
• Building and storing images
• Service specifications and endpoints
• Networking, secrets and access
• Cost and lifecycle of a service

You build A containerized service running on a compute pool with a working endpoint.

Owning a model gives control and creates work. You choose an open-source model, log it to the Model Registry, serve it from container compute, fine-tune it on your data, and test whether tuning beat the base model.

• Selecting an open-source model
• Logging a model to the Model Registry
• Serving it from a container service
• Fine-tuning on your own data
• Evaluating a tuned model against its base
• GPU sizing and cost

You build A fine-tuned open-source model, registered and served, with a comparison to its base.

Most company knowledge sits in PDFs and scans. You use Snowflake’s document processing functions to pull text, layout, tables and fields out of files, and check extraction accuracy before anything depends on it.

• Document types and what parsing returns
• Layout, text and table extraction
• Extracting fields into structured columns
• Handling scanned and low-quality files
• Checking extraction accuracy

You build A parser that turns a folder of mixed documents into structured rows.

A parser run by hand is not a pipeline. You bring files in through stages and directory tables, process new arrivals with streams and tasks, batch for cost, handle failures, and tune a pipeline that falls behind.

• Stages and directory tables for file intake
• Streams and tasks for new files
• Batching and cost control
• Error handling and reprocessing
• Monitoring throughput and quality
• Optimizing a slow document pipeline

You build An automated document pipeline that processes new files and reports failures.

An application that cannot be measured cannot be trusted. You build evaluation sets for generated output, apply access control and safety filtering, watch usage and spend, and write down the limits of what an application should be used for.

• Evaluation sets and metrics for generated output
• Access control and data governance
• Guardrails and safety filtering
• Monitoring usage and spend
• Cost levers: model size, caching and batching
• Documenting an application’s limits

You build An evaluation and governance pack for one generative AI application.

You build one application that parses documents, indexes them, answers questions with Cortex models and checks its own accuracy. Then you explain the choices on models, compute, governance and cost.

• Scoping documents, users and questions
• Parsing and indexing the corpus
• Building the question-answering flow
• Evaluating accuracy, safety and cost
• Presenting the design and its trade-offs

You build A working document question-answering application with an evaluation report.