Overview
Snowflake Gen AI Functions is 38% of GES-C02, the largest domain, so expect around 21 questions. It has five objectives. Objective 2.1 is the function catalog: AI_COMPLETE with structured outputs; task-specific functions such as AI_CLASSIFY, AI_EXTRACT, AI_SENTIMENT, AI_SUMMARIZE_AGG, AI_TRANSLATE, AI_EMBED, AI_FILTER, AI_AGG, AI_SIMILARITY, AI_TRANSCRIBE and AI_REDACT; vector similarity and distance functions; and helpers like AI_COUNT_TOKENS, TRY_COMPLETE, text splitters, TO_FILE and PROMPT.
Objective 2.2 applies them to use cases over unstructured and structured data, including chunking, embeddings, reranking, audio and image input, and trade-offs between model size, latency, accuracy and provisioned throughput. Objective 2.3 covers chat interfaces such as Streamlit in Snowflake with multi-turn messages. Objective 2.4 puts Cortex functions into SQL pipelines, and 2.5 runs third-party models on Snowpark Container Services through the Model Registry.
How it's tested
Domain 2 questions are practical. They describe a data task, show part of a query, or state a performance problem, and ask which function, parameter or architecture is correct. Read closely for whether the work is per row or aggregated, whether output must follow a schema, and whether the model is hosted by Cortex or by you.
-
Function selection
A row-level or aggregate task is described and you pick the matching AI function, such as AI_CLASSIFY, AI_FILTER, AI_AGG or AI_EMBED.
-
RAG design
A retrieval scenario is given and you order the steps: parse, chunk, embed or index, retrieve, then generate with context.
-
Model hosting
A model or latency requirement is stated and you choose a Cortex model, provisioned throughput, or the Model Registry with Snowpark Container Services.
An analyst must keep only product reviews that mention shipping damage from ten million rows, then summarize the complaints. AI_FILTER returns true or false per row, so it fits the filtering step in a WHERE clause. AI_AGG or AI_SUMMARIZE_AGG then condenses the remaining rows into one summary. Calling AI_COMPLETE on every row with a free-form prompt would be harder to parse and costlier.
Objectives 5
Official objectives from the Snowflake outline, in outline order.
2.1 Apply AI functions in Snowflake.General, task-specific, vector and helper functions.
- What it means
- This objective covers the full function catalog: AI_COMPLETE for general prompting, including structured outputs; task-specific functions such as AI_CLASSIFY, AI_EXTRACT, AI_PARSE_DOCUMENT, AI_SENTIMENT, SUMMARIZE, AI_SUMMARIZE_AGG, AI_TRANSLATE, AI_EMBED, AI_FILTER, AI_AGG, AI_SIMILARITY, AI_TRANSCRIBE and AI_REDACT; vector functions; and helpers like AI_COUNT_TOKENS, TRY_COMPLETE, text splitters, TO_FILE and PROMPT.
- What to understand
- Match each function to its output. AI_CLASSIFY returns labels from categories you supply, AI_FILTER returns a boolean, AI_SENTIMENT scores sentiment, and AI_AGG and AI_SUMMARIZE_AGG reduce many rows to one result. Structured outputs on AI_COMPLETE use a JSON schema so responses are machine-readable. Vector functions such as VECTOR_COSINE_SIMILARITY and VECTOR_L2_DISTANCE compare embeddings stored in the VECTOR type. TRY_COMPLETE returns NULL rather than raising an error, and AI_COUNT_TOKENS helps check prompt size against context windows.
- How it shows up
- A query or business task is shown and you choose the function, argument or helper that produces the required output.
- Common confusion
- Using AI_COMPLETE with a free-text prompt where a task-specific function gives a cheaper, more consistent result.
2.2 Perform data analysis given a use case.Analysis with managed LLMs, RAG and text-to-SQL over unstructured and structured data.
- What it means
- This objective applies the functions to real use cases with managed LLMs, retrieval-augmented generation and text-to-SQL. For unstructured data it covers parsing, extraction, chunking, embeddings, semantic reranking and audio or image processing. For structured data it covers AI_COMPLETE, Cortex Analyst with verified queries and Search integration, and suggested questions, plus performance trade-offs.
- What to understand
- A sound RAG flow parses documents, splits text into chunks that fit the context window, indexes them with Cortex Search or embeds them with AI_EMBED, retrieves the most relevant chunks, and passes them to AI_COMPLETE as context. Reranking improves the order of retrieved results. For performance, larger models are usually more accurate but slower and costlier; smaller models suit high-volume simple tasks; provisioned throughput reserves capacity for predictable latency.
- How it shows up
- A use case with accuracy, latency or cost constraints is given and you choose the pipeline steps or model trade-off.
- Common confusion
- Embedding whole documents without chunking, which weakens retrieval and can exceed context limits.
2.3 Build or interact with interfaces to chat with data in Snowflake.Chat apps, privileges and Snowflake Intelligence.
- What it means
- This objective covers building chat experiences over Snowflake data: setting up the environment and privileges, invoking Cortex functions from application code such as Streamlit in Snowflake, handling multi-turn conversations with a messages array, and using Snowflake Intelligence as a ready-made chat interface.
- What to understand
- LLM calls are stateless, so a multi-turn chat must resend the conversation history as an array of role and content objects with each call, trimmed to stay within the context window. A Streamlit in Snowflake app runs with its owner's privileges, so that role needs the Cortex database role and access to any Search services or semantic views. Snowflake Intelligence gives business users a chat interface over configured agents without custom code.
- How it shows up
- A chatbot forgets earlier turns or fails with a privilege error, and you identify the fix.
- Common confusion
- Expecting the model to remember previous turns without passing the message history.
2.4 Apply Snowflake Cortex functions in data pipelines.Cortex in SQL pipelines for extraction, enrichment, augmentation and transformation.
- What it means
- This objective covers using the Cortex SQL interface inside pipelines to extract fields from text, enrich records with labels or sentiment, augment data with summaries or translations, and transform content as part of scheduled or incremental processing.
- What to understand
- Because AI functions are SQL functions, they fit inside INSERT, CREATE TABLE AS SELECT, dynamic tables, streams and tasks. Process only new or changed rows to control token spend, store results in columns rather than recomputing, and prefer task-specific functions or structured outputs so downstream steps get predictable types. TRY_COMPLETE helps a batch continue when a few rows fail.
- How it shows up
- A batch enrichment or incremental pipeline is described and you choose where and how to apply the function.
- Common confusion
- Re-running AI functions over the full table on every refresh instead of processing only new rows.
2.5 Run third-party models in Snowflake.Snowpark Container Services and the Model Registry.
- What it means
- This objective covers hosting models that Cortex does not provide. With Snowpark Container Services you set up the environment, build Docker images, push them to an image repository, write a specification file and run services on compute pools. With the Model Registry you log models, manage versions and call them for inference.
- What to understand
- The usual sequence is: create an image repository, push the container image, create a compute pool (GPU for large models), then create a service from a YAML specification. The Snowflake ML Model Registry stores models with versions and metadata; logged models can be called from Python or SQL and deployed to SPCS for inference. Compute pools bill while running, so suspend them when idle.
- How it shows up
- A custom or open-source model must run inside Snowflake and you order the setup steps or choose the component.
- Common confusion
- Confusing the image repository, which stores container images, with the Model Registry, which stores versioned models.
High-yield concepts
The terms, rules and formulas this domain turns into questions most often.
-
AI_COMPLETE
General-purpose prompt to a chosen LLM.
- Remember
- Supports structured outputs with a JSON schema.
- Tested as
- Core function questions.
- Trap
- Using it where a task function fits.
-
AI_FILTER
Natural-language condition returning a boolean.
- Remember
- Use it in WHERE or JOIN clauses.
- Tested as
- Filtering scenarios.
- Trap
- Expecting text output.
-
AI_AGG / AI_SUMMARIZE_AGG
Aggregate insight across many rows.
- Remember
- Not limited by a single context window.
- Tested as
- Summary-over-rows scenarios.
- Trap
- Concatenating rows into one prompt.
-
AI_CLASSIFY
Assigns labels from categories you provide.
- Remember
- Can return one or several labels.
- Tested as
- Categorization scenarios.
- Trap
- Writing a free-form prompt instead.
-
AI_EMBED and VECTOR
Creates embeddings stored as VECTOR.
- Remember
- Compare with cosine similarity or L2 distance.
- Tested as
- Similarity and RAG questions.
- Trap
- Comparing embeddings from different models.
-
TRY_COMPLETE
AI_COMPLETE variant that returns NULL on failure.
- Remember
- Keeps batch jobs running.
- Tested as
- Pipeline resilience questions.
- Trap
- Assuming it retries automatically.
-
AI_COUNT_TOKENS
Counts tokens for a model and input.
- Remember
- Checks fit against context windows and cost.
- Tested as
- Sizing questions.
- Trap
- Estimating from characters instead.
-
Chunking
Splitting text before indexing or embedding.
- Remember
- Text splitter helper functions exist.
- Tested as
- RAG design questions.
- Trap
- Embedding whole documents.
-
Messages array
Role and content history for chat.
- Remember
- Models are stateless between calls.
- Tested as
- Multi-turn chat questions.
- Trap
- Expecting the model to remember.
-
Provisioned throughput
Reserved Cortex model capacity.
- Remember
- Gives predictable throughput and latency.
- Tested as
- Performance questions.
- Trap
- Confusing it with warehouse size.
-
Compute pool
Nodes that run SPCS services.
- Remember
- Choose GPU families for large models.
- Tested as
- Custom model hosting questions.
- Trap
- Leaving pools running when idle.
-
Model Registry
Versioned store for ML models.
- Remember
- Log, version and call models.
- Tested as
- Bring-your-own-model questions.
- Trap
- Confusing it with an image repository.
Side by side
Concepts candidates mix up, compared on the point that decides the answer.
Row-level vs. aggregate AI functions
| Concept | Meaning | Key difference | Common trap |
|---|---|---|---|
| AI_CLASSIFY | Labels each row | Returns categories per row | Using it to summarize a group |
| AI_FILTER | Yes or no per row | Boolean for WHERE clauses | Expecting explanations |
| AI_AGG | Insight across rows | Reduces many rows to one answer | Packing rows into one prompt |
| AI_SUMMARIZE_AGG | Summary across rows | Aggregate summary without instructions | Confusing it with per-row SUMMARIZE |
Cortex Search vs. DIY vector search
| Concept | Meaning | Key difference | Common trap |
|---|---|---|---|
| Cortex Search | Managed hybrid search service | Handles embedding, indexing, refresh and reranking | Rebuilding what it already does |
| AI_EMBED + vector functions | Embeddings in VECTOR columns | You control storage and similarity queries | Mixing embedding models |
Model hosting options
| Concept | Meaning | Key difference | Common trap |
|---|---|---|---|
| Cortex-hosted model | Serverless LLM by name | Pay per token, nothing to deploy | Deploying containers for catalog models |
| Provisioned throughput | Reserved capacity for a Cortex model | Predictable performance for steady load | Using it for occasional use |
| Model Registry + SPCS | Your own model in containers | You size compute pools | Skipping image repository or spec steps |
Exam traps
Each trap is an answer that looks right. Learn the clue that should change your mind.
-
Prompt everything
- What candidates pick
- Use AI_COMPLETE with a prompt to tag sentiment on each row.
- Why it looks right
- AI_COMPLETE can do anything.
- Why it's wrong
- AI_SENTIMENT or AI_CLASSIFY returns consistent typed output at lower cost and with no parsing of free text.
Clue to watch for Output must be a fixed label or score.
-
Stateful chat
- What candidates pick
- Call AI_COMPLETE with only the latest user message.
- Why it looks right
- Chat apps feel stateful.
- Why it's wrong
- The model keeps no memory between calls, so the app must send prior turns in the messages array.
Clue to watch for The bot loses context after one turn.
-
Concatenate for summary
- What candidates pick
- Join all rows into one string and summarize it.
- Why it looks right
- One call seems efficient.
- Why it's wrong
- This can exceed the context window; AI_AGG and AI_SUMMARIZE_AGG are designed to aggregate across many rows.
Clue to watch for Thousands of rows need one combined insight.
-
Mismatched embeddings
- What candidates pick
- Compare query embeddings from one model with stored embeddings from another.
- Why it looks right
- Both are vectors.
- Why it's wrong
- Vectors from different models live in different spaces and often differ in dimension, so similarity scores are meaningless.
Clue to watch for The embedding model name differs between steps.
-
Biggest model wins
- What candidates pick
- Choose the largest model for a high-volume classification job.
- Why it looks right
- Larger models score higher on benchmarks.
- Why it's wrong
- For simple high-volume tasks, a smaller model or task function meets accuracy at far lower latency and cost.
Clue to watch for Volume and latency targets are stated.
-
Registry stores images
- What candidates pick
- Push the Docker image to the Model Registry.
- Why it looks right
- Both store deployable artifacts.
- Why it's wrong
- Container images go to an image repository; the Model Registry holds versioned models that can be deployed to services.
Clue to watch for The step involves docker push.
Answer framework
For any Domain 2 scenario, work through these steps to reach the function or design the exam expects.
- Decide whether the task is per row, across rows, retrieval, text-to-SQL or chat, and whether the output must be a label, boolean, vector, JSON or free text.
- Pick the most specific AI function that produces that output, falling back to AI_COMPLETE with structured outputs only when no task function fits.
- For retrieval, plan the pipeline: parse, chunk to fit the context window, index with Cortex Search or embed with AI_EMBED, retrieve, then generate.
- Weigh model size, latency, accuracy and cost, and consider provisioned throughput when steady volume needs predictable performance.
- If the model is not offered by Cortex, log it in the Model Registry and serve it on Snowpark Container Services with an image repository, compute pool and spec file.
Practice question
Want more like this? The GES-C02 practice test has questions for every domain.
Checklist
0 of 13
Tick each one you can do without notes. Your ticks stay in this browser.
Study strategy
Give this domain the largest block of study time because it carries 38% of the exam. Start with the function catalog in objective 2.1: make a table with each AI function, its inputs, what it returns and a typical use. Then write and run at least one query per function in a trial account, including AI_COMPLETE with a JSON schema, AI_FILTER in a WHERE clause, AI_AGG over a group and a vector similarity search on AI_EMBED output.
Next, build a small RAG flow end to end: split text with a splitter helper, index it with Cortex Search, retrieve chunks and pass them to AI_COMPLETE. Add a Streamlit in Snowflake chat that keeps message history so you see why stateless calls need it. Then turn one enrichment into a task that processes only new rows.
For objective 2.5, follow a Snowpark Container Services tutorial to push an image, create a compute pool and start a service, and log one model in the Model Registry. Finish by reviewing performance trade-offs and provisioned throughput, then practice timed questions that show query fragments.
FAQ
How much of the SnowPro Gen AI exam is Snowflake Gen AI Functions?
Snowflake Gen AI Functions is 38% of GES-C02, the largest domain, or about 21 of 55 questions. It has five objectives covering AI functions, use-case analysis, chat interfaces, pipelines and third-party models.
Which AI functions should I know best?
Know AI_COMPLETE with structured outputs, AI_CLASSIFY, AI_FILTER, AI_SENTIMENT, AI_AGG, AI_SUMMARIZE_AGG, AI_EMBED, AI_EXTRACT, AI_TRANSLATE, AI_TRANSCRIBE and AI_REDACT, plus helpers such as TRY_COMPLETE and AI_COUNT_TOKENS.
Do I need to know vector functions?
Yes. The objectives list inner product, L1 and L2 distance, cosine similarity and vector aggregate and normalization functions over the VECTOR data type, used with embeddings from AI_EMBED.
How does multi-turn chat work with Cortex?
The application passes an array of messages with roles such as system, user and assistant on every call. The model does not store history, so the app keeps and trims it.
When should I use Cortex Search instead of building vector search myself?
Use Cortex Search when you want managed hybrid retrieval with automatic embedding, indexing, refresh and reranking. Build your own with AI_EMBED and vector functions only when you need custom control.
What Snowpark Container Services details are tested?
Expect environment setup, Docker images, image repositories, specification files and compute pools, plus how the Model Registry logs and calls models that you then serve on SPCS.
What is provisioned throughput?
Reserved inference capacity for Cortex models that gives predictable throughput for steady workloads, as opposed to shared on-demand capacity.
Other Artificial Intelligence & Machine Learning certifications
Where the same subject shows up in other exams. Cards marked "Same subject" open the matching domain.
Test your Domain 2 knowledge
You have covered AI functions, RAG, chat interfaces, Cortex pipelines and custom models on SPCS. Test whether you can choose the right function and design under exam timing.
Keep going
- Training Training Built on your Weak areas
- Practice test Questions by domain, with explanations
- Mock exam Full length, timed like the real exam
- Readiness test Find your weakest domain in minutes
- Cheat sheet Key terms and formulas on one page
- Ask the GES-C02 AI tutor Get any concept explained your way