Free Practice Questions for the Snowflake SnowPro Specialty GES-C02 Exam (2026 Updated)

Snowflake provides native mathematical vector functions designed to measure distance, divergence, and similarity across dense vector embeddings generated by machine learning models. The Manhattan distance—also known in linear algebra and coordinate geometry as the L1 distance, rectilinear distance, or taxicab metric—calculates the sum of the absolute differences between the corresponding Cartesian coordinates of two vectors of equal dimensionality.

In Snowflake SQL, this operation is executed using VECTOR_L1_DISTANCE(vector1, vector2). The function accepts two VECTOR arguments with matching dimension and floating-point data types, outputting a real value representing the total grid-aligned distance separating the points.

The remaining options calculate different geometric metrics: VECTOR_L2_DISTANCE computes the Euclidean distance (the straight-line distance derived from the square root of the sum of squared differences); VECTOR_COSINE_SIMILARITY measures the cosine of the angle between two non-zero vectors, quantifying directional alignment irrespective of absolute vector magnitude; and VECTOR_INNER_PRODUCT calculates the dot product, reflecting both directional alignment and coordinate scale.

References & Study Guide Topics:

Snowflake Gen AI Functions: Vector Similarity and Distance Functions

Mathematical Foundations: Vector Data Types and Metric Selection (L1, L2, Cosine)

===============

Snowflake Cortex Analyst relies on the `relationships` section of a semantic model YAML specification to determine how logical tables must be joined when generating SQL.

The relationship definition contains key parameters that control join construction:

* `left_table: PRODUCT_SALES` designates the base table to be preserved in an outer join.

* `right_table: PRODUCTS` designates the lookup table joined to the preserved dataset.

* `join_type: left_outer` instructs Cortex Analyst to emit ANSI `LEFT OUTER JOIN` syntax preserving all records from the left table.

* `relationship_columns` maps `left_column: PRODUCT_ID` to `right_column: ID`, defining the join equality condition: `ON S.PRODUCT_ID = P.ID`.

Based on these metadata declarations, whenever a natural language query requires attributes spanning both tables, Cortex Analyst constructs the query starting from `PRODUCT_SALES AS S`, applies a `LEFT OUTER JOIN` to `PRODUCTS AS P`, and predicates the join condition using `ON S.PRODUCT_ID = P.ID`.

Options B, C, and D are incorrect because they invert table positions, employ `FULL OUTER JOIN` syntax, or place join conditions into a `WHERE` clause.

References & Study Guide Topics:

* Snowflake Gen AI Functions: Cortex Analyst Semantic Modeling Specifications

* Semantic Relationships: Defining Joins, Dimensional Cardinality, and Foreign Keys

===============

Snowflake Cortex Guard provides native safety filtering to intercept and mitigate harmful, toxic, or illicit content generated by foundation language models. Built on specialized safety architectures (such as Meta's Llama Guard), Cortex Guard evaluates model responses before they are returned to the caller.

When `guardrails` is set to `true` within the `options` object argument of `SNOWFLAKE.CORTEX.COMPLETE`, Cortex routes the completion through an automated content moderation classifier. The prompt request (`'Give me steps on hacking a system'`) directly solicits actionable instructions for cyberattacks and unauthorized exploitation.

When the underlying model processes this prompt, Cortex Guard detects the harmful material in the output. Instead of failing the SQL transaction with a system error or returning raw instructions, Cortex Guard replaces the output with a filtered safety refusal message. Thus, the function executes successfully and returns a response, but it omits instructions for hacking a system.

The call does not abort execution without a response, does not depend on `CLASSIFY_TEXT`, and does not hallucinate arbitrary data.

References & Study Guide Topics:

* Snowflake Gen AI Functions: Cortex Guard Content Filtering and Guardrails

* AI Safety & Governance: Responsible LLM Deployment and Threat Mitigation

===============

Snowflake Cortex Analyst provides self-service text-to-SQL capabilities over structured relational data by leveraging developer-defined semantic models. A semantic model is an authored YAML specification that outlines logical dimensions, metrics, relationships, synoptic filters, and verified queries that reflect enterprise business logic.

To operationalize Cortex Analyst, the semantic model YAML file is first staged in a Snowflake internal or external stage. Once staged, end users and developers can interact with the service through two primary consumption patterns:

Interactive Studio Exploration: Business users can explore data directly through the Cortex Analyst interface within the AI & ML Studio in Snowsight, selecting the staged semantic specification to pose natural language questions and review direct answers and generated SQL.

Programmatic Application Integration: Software engineers can integrate Cortex Analyst directly into bespoke web applications, portals, or chatbots (such as Streamlit apps) by issuing authenticated requests to the Cortex Analyst REST API, supplying the stage path to the semantic model YAML file in the payload.

Document AI is intended for unstructured file extraction rather than tabular text-to-SQL workflows, and LLM fine-tuning is not utilized to establish structured conversational querying in Cortex Analyst.

References & Study Guide Topics:

Snowflake Gen AI Functions: Cortex Analyst Architecture & Consumption Modes

Semantic Modeling: Authoring, Staging, and Integrating YAML Semantic Specifications

===============

The `SNOWFLAKE.CORTEX.CLASSIFY_TEXT` function supports advanced classification using structured category objects that include descriptions and few-shot examples.

In this query, the input text is `'I love morning walks'`. The classification engine evaluates this string against the candidate categories:

* `'travel'`: Defined as hobbies related to going from one place to another.

* `'cooking'`: Illustrated with recipes and baking examples.

* `'fitness'`: Defined as hobbies related to being active and healthy.

Walking for personal enjoyment directly matches the active, healthy lifestyle definition of `'fitness'`.

Regarding the return format: `CLASSIFY_TEXT` returns a semi-structured JSON `OBJECT` containing only the winning category label formatted as `{"label": " < category_name > "}`. It does not return a plain scalar string (eliminating Option C), nor does it echo back the category definition metadata (eliminating Option D). Therefore, the result is `{"label": "fitness"}`.

References & Study Guide Topics:

* Snowflake Gen AI Functions: Advanced `CLASSIFY_TEXT` Syntax

* Semantic Categorization: JSON Schema Outputs and Structural Label Matching

===============

To prevent large language models from returning toxic, violent, sexually explicit, or otherwise hazardous content, Snowflake integrates Cortex Guard directly into its LLM completion endpoints. Within the Snowpark Python API, this capability is exposed through the snowflake.cortex.CompleteOptions class.

Passing options=CompleteOptions(guardrails=True) instructs the Cortex inference engine to route the generated output through an automated safety evaluation model prior to returning it to the calling application. If an output violates safety boundaries, Cortex replaces the payload with a standardized safety rejection response, safeguarding downstream consumers regardless of the user's input prompt.

The other parameters shown serve entirely different functional roles: temperature governs sampling stochasticity and response creativity, stream dictates whether responses are returned incrementally via Server-Sent Events (SSE), and response_format accepts a structured JSON schema rather than safety flags.

References & Study Guide Topics:

Snowflake Gen AI Governance: Cortex Guard Configuration in Snowpark Python

Enterprise AI Safety: Filtering Harmful LLM Completions via CompleteOptions

===============

Snowflake Cortex provides dedicated natural language sentiment analysis functions designed to evaluate textual polarity without requiring custom prompt engineering:

1. **`SNOWFLAKE.CORTEX.SENTIMENT`:** Returns a single floating-point number bounded between -1.0 and 1.0 (inclusive). A score approaching 1.0 indicates positive sentiment, near -1.0 represents negative sentiment, and values close to 0 denote neutral feedback.

2. **`SNOWFLAKE.CORTEX.ENTITY_SENTIMENT`:** Performs aspect-level sentiment extraction. It accepts the source text alongside an array of target entities (e.g., `['positive', 'negative', 'neutral']`) and returns a semi-structured `OBJECT` containing a `"categories"` field that details sentiment scores and extracted references for each evaluated entity.

Conversely, `CLASSIFY_TEXT` requires predefined taxonomy classes and returns a single label object rather than a polarity score or categories object; `COMPLETE` generates free-form text; and `FINETUNE` executes supervised model training.

References & Study Guide Topics:

* Snowflake Gen AI Functions: Sentiment and Entity-Level Analysis

* Output Data Structures: Float Scoring vs. Semi-Structured Category Objects

===============

The Snowflake Cortex LLM REST API exposes headless HTTP endpoints that enable external enterprise applications, backend microservices, and serverless workflows to call foundation models directly. Because automated API clients cannot fulfill interactive login challenges, authentication must be fully programmatic.

Snowflake supports two authentication protocols for the Cortex REST API:

1. **OAuth 2.0:** Enables applications to present short-lived bearer access tokens issued either by Snowflake’s internal OAuth authorization server or by an external OAuth Identity Provider (IdP). This ensures secure, role-scoped delegation without sharing permanent service credentials.

2. **Key-Pair Authentication (JWT):** The client signs a JSON Web Token (JWT) using a private RSA key. Snowflake validates this JWT against the public key assigned to the corresponding service user, authorizing the request.

Interactive mechanisms—including federated SAML 2.0, browser-based Single Sign-On (SSO), and Multi-Factor Authentication (MFA)—are designed for human authentication in Snowsight or driver sessions and are not valid authentication protocols for calling the Cortex REST API.

References & Study Guide Topics:

* Snowflake Gen AI Governance: Cortex REST API Security Architecture

* Authentication Standards: Programmatic Key-Pair JWT and OAuth 2.0 Scopes

===============

Foundation models available for serverless Cortex inference are cataloged as first-class model objects within Snowflake's shared system database under the `SNOWFLAKE.MODELS` schema.

To view the complete inventory of available foundation models, developers and administrators can issue:

1. `SHOW MODELS IN SNOWFLAKE.MODELS;`: This directly queries the system-managed models schema, displaying all foundation model identifiers, default versions, and descriptive metadata.

2. `SHOW MODELS;`: When executed without a specific scope (or within the context of the shared system database), this standard metadata command lists the accessible model objects available to the active user role.

The alternative choices are syntactically or functionally invalid:

* `LS @...` lists raw unstructured files stored inside stages, not model registry entities.

* `SHOW VERSIONS LIKE ... IN MODEL LLM` attempts to query versions inside a non-existent individual model object named `LLM`.

* `CALL SNOWFLAKE.MODELS.CORTEX_BASE_MODELS_REFRESH()` triggers an internal system procedure that synchronizes catalog definitions behind the scenes rather than returning a display grid of available models.

References & Study Guide Topics:

* Snowflake Gen AI Functions: Model Discovery and System Catalog Exploration

* Snowflake Model Registry: Managing and Listing System Models via `SHOW MODELS`

===============

Comprehensive and Detailed 150 to 250 words of Explanation From [SnowPro® Specialty: Gen AI/Course Guide/topics]:

The cost architecture of Snowflake Cortex Search Services consists of three core components: serverless serving compute, embedding token processing, and virtual warehouse refreshes. Serving compute represents the dedicated serverless memory and compute capacity maintained to host search indices and service low-latency search requests.

Importantly, serving compute charges accrue continuously on an hourly basis as long as the search service is in an active (resumed) state, regardless of whether incoming search queries are executed. Therefore, the most impactful operational strategy for reducing expenditures is explicitly suspending the service during scheduled downtime, development pauses, or prolonged periods of inactivity, or configuring automated suspension via `AUTO_SUSPEND`. Suspending the service terminates active serving compute consumption.

Conversely, making frequent updates increases embedding re-indexing costs; shortening target lag from 5 minutes to 1 minute forces continuous warehouse wake-ups and re-indexing; and column chunking does not mitigate base serving availability charges.

References & Study Guide Topics:

* Snowflake Gen AI Functions: Cortex Search Cost Management and Metering

* Resource Optimization: Managing Serverless Serving States via `SUSPEND` and `RESUME`

===============

Analyzing the JSON telemetry reported in the `usage` metadata block reveals the exact configuration options passed to `SNOWFLAKE.CORTEX.COMPLETE`:

1. **`guardrails` parameter:** The usage block explicitly reports a non-zero metric for `"guardrails_tokens": 565`. Cortex Guard meters tokens only when the safety filter is actively engaged; if guardrails were disabled (`false`), this attribute would either be omitted or set to 0. Therefore, `'guardrails': true` was configured.

2. **`max_tokens` parameter:** The model successfully generated `"completion_tokens": 580`. The `max_tokens` parameter establishes a strict ceiling on the number of output completion tokens an LLM can produce. If `max_tokens` had been set to 512, generation would have been truncated at or before 512 tokens. Because the completion reached 580 tokens, `max_tokens` had to be configured with a higher threshold, specifically 4096.

Together, the presence of active guardrail tokens and a completion token length of 580 confirm that the parameters used were `'max_tokens': 4096` and `'guardrails': true`.

References & Study Guide Topics:

* Snowflake Gen AI Functions: `SNOWFLAKE.CORTEX.COMPLETE` Usage Metadata Analysis

* Telemetry & Cost Accounting: Interpreting `guardrails_tokens` and `completion_tokens`

===============

Snowflake Cortex categorizes its AI functions into general-purpose text-generation functions (such as COMPLETE) and task-specific LLM functions that automate standard natural language processing and document extraction tasks out of the box without requiring manual prompt engineering:

SENTIMENT (SNOWFLAKE.CORTEX.SENTIMENT): A specialized task function that analyzes English text input and automatically outputs a continuous sentiment score from -1 (negative) to 1 (positive).

PARSE_DOCUMENT (SNOWFLAKE.CORTEX.PARSE_DOCUMENT): A purpose-built document processing function that extracts text, OCR data, and structured layouts from staged PDF, Word, or image files.

Conversely, ANOMALY_DETECTION and FORECAST are Snowflake ML Analysis functions based on traditional statistical and gradient-boosted time-series algorithms, rather than Cortex Generative AI functions. Furthermore, the Cortex text classification function is named CLASSIFY_TEXT (or AI_CLASSIFY), whereas CLASSIFICATION refers to the structured machine learning classification class within Snowflake ML.

References & Study Guide Topics:

Snowflake Gen AI Functions: Task-Specific LLM Functions vs. General Completion Models

Cortex Function Hierarchy: Specialized NLP Utilities (SENTIMENT, PARSE_DOCUMENT)

===============

Generating dynamic, creative marketing content—such as customized product descriptions tailored from tabular database attributes—requires a general-purpose, prompt-driven large language model.

SNOWFLAKE.CORTEX.COMPLETE accepts a user-defined prompt alongside dynamic column parameters, allowing developers to engineer prompts that combine tabular fields (e.g., 'Write a compelling product description for Brand: ' || brand || ', Category: ' || category || ', Features: ' || features). The foundation model processes these inputs to synthesize fluent, context-aware descriptions.

The alternative functions are not designed for open-ended text synthesis:

PARSE_DOCUMENT extracts raw text from document files in Snowflake stages.

EMBED_TEXT_768 converts input strings into high-dimensional numerical vector embeddings for similarity matching.

SUMMARIZE condenses existing text into a shorter synopsis rather than generating expanded, creative copy from attribute lists.

References & Study Guide Topics:

Snowflake Gen AI Functions: Text Generation using SNOWFLAKE.CORTEX.COMPLETE

Prompt Engineering in SQL: Dynamic Prompt Composition over Tabular Data

===============

When designing real-time, user-facing conversational applications, minimizing end-to-end response latency is a key design priority.

Invoking `SNOWFLAKE.CORTEX.COMPLETE` via standard SQL statements involves compilation steps: parsing the SQL query, passing it through the Snowflake query optimizer, assigning virtual warehouse resources, and formatting database result sets. In contrast, using the **Cortex REST API** bypasses SQL compilation and virtual warehouse orchestration entirely. The REST endpoint connects directly to the serverless model inference engine, reducing overhead and significantly cutting latency for single-turn or streaming completion requests.

Regarding the other options:

* Snowpark sessions run on top of standard SQL execution layers, inheriting warehouse overhead.

* Setting `temperature` to 1.0 adjusts sampling randomness without improving execution speed.

* Passing a JSON schema to `response_format` adds constrained decoding overhead, which can slightly increase processing time rather than reducing latency.

References & Study Guide Topics:

* Snowflake Gen AI Functions: Cortex REST API vs. SQL API Execution

* Latency Optimization: Bypassing Warehouse Compilation via Direct Endpoints

===============

Order 1: PARSE_DOCUMENT

Order 2: SPLIT_TEXT_RECURSIVE_CHARACTER

Order 3: EMBED_TEXT_768

Order 4: VECTOR_COSINE_SIMILARITY

Order 5: CORTEX.COMPLETE

When a source document exceeds the maximum context token capacity of SNOWFLAKE.CORTEX.COMPLETE, an in-database Retrieval-Augmented Generation (RAG) pipeline must be orchestrated to extract, index, and retrieve only the most semantically relevant text passages:

Step 1 (Extraction): PARSE_DOCUMENT extracts raw text and structural content from the unstructured staged file.

Step 2 (Chunking): SPLIT_TEXT_RECURSIVE_CHARACTER segments the extracted text into manageable, coherent chunks that fit within target token limits.

Step 3 (Vectorization): EMBED_TEXT_768 transforms each text chunk into a 768-dimensional vector embedding stored in a Snowflake table.

Step 4 (Retrieval): VECTOR_COSINE_SIMILARITY compares the user’s query embedding against the indexed document chunk embeddings, ranking and filtering the top-k context passages.

Step 5 (Inference): CORTEX.COMPLETE receives the filtered, high-relevance chunks as contextual grounding inside the prompt, generating an accurate completion within the model's context window.

References & Study Guide Topics:

Snowflake Gen AI Functions: End-to-End RAG Pipeline Architecture

Document Processing & Retrieval: Function Chaining from Ingestion to Completion

===============

Snowflake Document AI enforces input validation rules to ensure files can be processed by the underlying Arctic-TILT model. Supported document formats are primarily restricted to PDF, DOCX, DOC, and supported image formats (such as PNG, JPEG, TIFF).

When `!PREDICT` returns the processing error `File extension does not match actual mime type. Mime-Type: application/octet-stream`, the input document failed format validation checks. This occurs when a file's extension (e.g., `.pdf`) conflicts with its true binary MIME header, or when an unsupported, malformed, or generic binary payload (`application/octet-stream`) is uploaded. Because Document AI cannot parse non-compliant or corrupted binaries into visual and textual tokens, it flags the document as failing input requirements.

Expired URLs return HTTP expiration or stage access errors; missing stage encryption attributes generate encryption mismatch errors; and privilege deficiencies throw authorization errors rather than runtime MIME validation errors.

References & Study Guide Topics:

* Snowflake Document Processing: Document AI File Ingestion Requirements

* Troubleshooting Extraction: MIME Type Validation and Binary Format Errors

===============

Snowflake provides account-level consumption views in the shared `SNOWFLAKE.ACCOUNT_USAGE` schema to help organizations monitor, audit, and forecast cloud credit usage across Generative AI workloads.

The `CORTEX_FUNCTIONS_USAGE_HISTORY` view records serverless credit and token consumption for Cortex LLM functions (such as `COMPLETE`, `SUMMARIZE`, `TRANSLATE`, and `EMBED_TEXT_768`) aggregated in **one-hour windows**. Each record in this view tracks the service type, model name, credits consumed, and input/output token counts processed during that hourly window. (Snowflake also maintains `CORTEX_AI_FUNCTIONS_USAGE_HISTORY` as its modern counterpart).

The other views serve different operational scopes: `CORTEX_DOCUMENT_PROCESSING_USAGE_HISTORY` tracks Document AI processing volumes; `CORTEX_SEARCH_SERVING_USAGE_HISTORY` meters serving index charges for search services; and `CORTEX_FUNCTIONS_QUERY_USAGE_HISTORY` does not exist as an hourly aggregated cost view.

References & Study Guide Topics:

* Snowflake Gen AI Governance: Account Usage and LLM Metering Views

* Financial Governance: Hourly Consumption Tracking via `CORTEX_FUNCTIONS_USAGE_HISTORY`

===============

The Verified Query Repository (VQR) is a structured section in a Cortex Analyst semantic model YAML file that stores verified natural language questions paired with their confirmed SQL representations.

To present end users with a complete set of predefined, curated questions when they start a session, two key configuration standards must be followed:

1. **Onboarding Flag:** Setting the attribute `use_as_onboarding_question: true` on verified query entries marks them as onboarding questions. Cortex Analyst surfaces these marked questions to users upon opening the conversational session, providing a predefined list of valid starter queries.

2. **Logical Abstraction Mapping:** The SQL statements defined inside verified queries must reference the **logical** table names and logical column identifiers defined in the semantic model itself, rather than underlying physical database object names. Cortex Analyst evaluates queries within the semantic model's logical namespace to maintain consistency and enforce defined relationships and dimensions.

Markdown annotations and sentence-ending requirements are not functional VQR syntax directives.

References & Study Guide Topics:

* Snowflake Gen AI Functions: Cortex Analyst Semantic Model Structure

* Verified Query Repository: Onboarding Questions and Logical Schema Mapping

===============

Snowflake vector math functions—such as `VECTOR_COSINE_SIMILARITY`, `VECTOR_L1_DISTANCE`, and `VECTOR_L2_DISTANCE`—require input arguments of data type `VECTOR` (specifically matching dimensions of `VECTOR(FLOAT, dim)`). They cannot operate directly on raw strings or `VARCHAR` columns.

In this scenario, `Parts_description` in both `Parts_A` and `Parts_B` is a standard string column. Attempting to pass raw text columns directly into vector similarity functions (as seen in Options A, B, and C) fails during compilation with an invalid argument data type error.

Option D correctly implements the required two-phase pipeline:

It utilizes inline subqueries to transform the text descriptions into 768-dimensional float vectors using `SNOWFLAKE.CORTEX.EMBED_TEXT_768('e5-base-v2', Parts_description)`.

It then passes the generated vector representations into `VECTOR_COSINE_SIMILARITY(a.parts_description_vector, b.parts_description_vector)` while joining matching records on `part_id`, accurately computing the semantic similarity score.

References & Study Guide Topics:

Snowflake Gen AI Functions: Text Embedding Pipelines and Vector Type Requirements

Function Syntax: Comparing Embeddings with `VECTOR_COSINE_SIMILARITY` and `EMBED_TEXT_768`

===============

Snowpark Container Services (SPCS) enables developers to execute custom containerized workloads—including custom fine-tuned LLMs, model hosting endpoints, and frontend applications—directly within the Snowflake security boundary.

Deploying and running an SPCS container requires two core architectural components:1. **Compute Pool:** A collection of one or more virtual machine nodes (providing CPU, GPU, and memory configurations) dedicated to running containerized instances inside Snowflake. It provides the physical infrastructure and compute lifecycle for the workload.2. **Service Specification (Spec):** A YAML-formatted configuration declaring the runtime architecture of the container. It defines container images (retrieved from an image repository), resource limits, port endpoints, environment variables, health probes, and mounted stage volumes. This specification can be provided directly inline or referenced via a stage file.External stages, scheduled tasks, and file formats are optional supporting objects and are not strictly required prerequisites to instantiate and run an SPCS service.References & Study Guide Topics:* Snowflake for Gen AI Overview: Snowpark Container Services (SPCS) Infrastructure* Workload Deployment: Compute Pools and Specification Architecture===============

Comprehensive and Detailed 150 to 250 words of Explanation From [SnowPro® Specialty: Gen AI/Course Guide/topics]:

Snowflake Cortex Search is a fully managed hybrid search engine specifically built to streamline and accelerate the retrieval layer of Retrieval-Augmented Generation (RAG) architectures. In traditional custom RAG pipelines, developers must orchestrate multiple manual stages: extracting source text, passing text chunks to embedding models (such as `EMBED_TEXT_768`), storing the resulting high-dimensional vectors in dedicated tables, and writing custom SQL functions using similarity metrics (such as `VECTOR_COSINE_SIMILARITY`).

Cortex Search abstracts away this entire operational pipeline. It automatically ingests text from designated Snowflake base tables or views, computes and manages the dense vector embeddings internally, and indexes the content using a hybrid scoring algorithm that blends semantic vector retrieval with lexical keyword search (BM25). At query runtime, applications invoke Cortex Search via standard REST APIs, Python SDK methods, or SQL preview functions to retrieve top-k ranked context segments in sub-second response times.

In contrast, Cortex Analyst provides text-to-SQL generation over structured semantic models, Cortex Fine-tuning specializes in supervised parameter tuning of base LLMs, and `SNOWFLAKE.CORTEX.COMPLETE` executes text generation rather than handling automated vector indexing and retrieval mechanics.

References & Study Guide Topics:

* Snowflake Gen AI Functions: Cortex Search Architecture and Hybrid Search Engine

* Retrieval-Augmented Generation (RAG): Automated Vector Generation vs. Manual Embedding Workflows

===============

Snowflake Cortex AI operates strictly inside Snowflake’s secure Data Cloud governance boundary, adhering to comprehensive enterprise trust principles. Under Snowflake's core AI governance framework, customer data, prompts, and completions are never utilized to train or fine-tune third-party foundation models, nor are they ever shared with model providers or other Snowflake accounts. All inference operations execute completely within Snowflake’s managed trust perimeter.

Furthermore, Snowflake natively enforces its enterprise Role-Based Access Control (RBAC) across all Generative AI infrastructure and models. Access to specific Cortex LLM functions, proprietary models, and Model Registry artifacts requires explicit object and database-level grants (such as SNOWFLAKE.CORTEX_USER and designated model roles), ensuring unified administrative oversight across all AI workloads.

Option C is incorrect because fine-tuned models remain private to the host Snowflake account and cannot be shared across disparate consumer accounts. Option D is incorrect because foundation models are deployed as serverless functions or containerized services without requiring direct account-level ingestion of external models exclusively via the Model Registry. Option E is incorrect because Cortex Guard is an optional evaluation parameter, not a mandatory feature.

References & Study Guide Topics:

Snowflake Gen AI Governance: Data Privacy, Security Boundaries, and Trust Architecture

Enterprise Security: Model Access Governance and Role-Based Access Control (RBAC)

===============