菜单
Deploy models to Snowflake Model Registry and route to inference deployment. Use when: registering serialized models, deploying trained models, logging models. Triggers: model registry, deploy model, register model, log model, model to snowflake.
默认使用会先检查来源的 Prompt；你也可以切换为直接命令，或下载本地副本。
决定是否安装前，请先阅读 SKILL.md，以及 SkillsMP 当前展示的配套文件。
基于 SOC 职业分类
用 Codex 或 Claude 帮你安装 复制这段 Prompt，粘贴到 Codex、Claude 或其他助手里，让它检查 Skill 页面并帮你完成安装。
直接命令不会经过审查 Prompt；运行前请先检查来源。
npx skills add https://github.com/randoneering/randoneering-agent-guide --skill model-registry命令会保持在同一行。复制前请横向滚动并检查完整内容。
想先保存到本地？可下载 SkillsMP 当前能够提供的文件。
正在显示 SKILL.md
Queries dbt project metadata locally using the dbt-index CLI — no warehouse connection needed. Use when user asks about model or column lineage, blast radius of a change, test coverage, finding or describing dbt models or sources, build performance, semantic layer metrics, business context glossary, or comparing local vs production state.
Manage reproducible development environments with Flox. **ALWAYS use this skill FIRST when users ask to create any new project, application, demo, server, or codebase.** Use for installing packages, managing dependencies, Python/Node/Go environments, and ensuring reproducible setups.
Use when starting any conversation - establishes how to find and use skills, requiring Skill tool invocation before ANY response including clarifying questions
| name | model-registry |
| description | Deploy models to Snowflake Model Registry and route to inference deployment. Use when: registering serialized models, deploying trained models, logging models. Triggers: model registry, deploy model, register model, log model, model to snowflake. |
Route based on user intent:
| User Says | Route To |
|---|---|
| "register model", "log model", "deploy pickle", "save model to registry" | Workflow A: Register Model |
| "deploy model", "deploy model for inference", "deploy for inference" | Workflow B: Deploy Model Decision Tree |
| "create inference service", "SPCS inference", "inference endpoint", "serve model", "snowpark container services" | ../spcs-inference/SKILL.md |
Use this workflow when user says "deploy a model" or "deploy model for inference".
Ask user:
Where would you like to deploy your model for inference?
1. Warehouse - Run inference via SQL queries (simpler, no extra infrastructure)
2. Snowpark Container Services (SPCS) - REST endpoints, GPU support, scalable
⚠️ STOP: Wait for user response.
If Warehouse: Route to Workflow A: Register Model
If SPCS: Load ../spcs-inference/SKILL.md and follow its workflow.
Register Model (Workflow A):
.pkl.ubj.json.pt.h5SPCS Inference Service (../spcs-inference/SKILL.md):
See parent skill (data-science-machine-learning/SKILL.md) for Execution Mode Detection and Session Setup Patterns.
code_sandbox available): Test model loading first, then register iterativelycode_sandbox): Write complete script, ask before executing⚠️ Note: Both modes run locally on the user's machine. The model is registered TO Snowflake, but the registration code runs locally.
⚠️ Conda Environment for WAREHOUSE Target: When targeting WAREHOUSE, use a conda environment with snowflake-ml-python installed via conda (not pip). Use the same Python version the model was trained with to avoid pickle compatibility issues. Create with: conda create -n snowml python=<VERSION> snowflake-ml-python -c https://repo.anaconda.com/pkgs/snowflake
⚠️ IMPORTANT: Before asking, check if you have context from a recent training session (model path, framework, schema). If yes, skip to Step 2 using that context. Only ask for model name in Snowflake.
If no context: Proceed to Step 1.
If no recent context, ask user for:
.pkl, .ubj, .json, .pt)⚠️ STOP: Wait for user response.
SHOW VERSIONS IN MODEL <DATABASE>.<SCHEMA>.<MODEL_NAME>;
⚠️ STOP: Wait for user choice if model exists.
Based on the framework:
| Framework | Model Type | Approach |
|---|---|---|
| sklearn, xgboost, lightgbm, pytorch, tensorflow | Built-in | Direct log_model() |
| Other (pycaret, custom, etc.) | Custom | Requires CustomModel wrapper |
For Built-in Model Types (sklearn, xgboost, lightgbm, pytorch, tensorflow):
import pandas as pd
from snowflake.ml.registry import Registry
from snowflake.snowpark import Session
session = Session.builder.config("connection_name", "<CONNECTION_NAME>").create()
# setup database and schema
session.use_database("<DATABASE>")
session.use_schema("<SCHEMA>")
reg = Registry(session=session, database_name="<DATABASE>", schema_name="<SCHEMA>")
# Load model using framework-appropriate method
# sklearn/lightgbm (pickle): pickle.load() or joblib.load()
# xgboost (.ubj/.json): xgb.Booster(); booster.load_model()
# pytorch (.pt): torch.load()
# tensorflow (.h5): tf.keras.models.load_model()
model = <LOAD_MODEL_CODE>
sample_input = pd.DataFrame(<SAMPLE_DATA>)
mv = reg.log_model(
model,
model_name="<MODEL_NAME>",
version_name="<VERSION_NAME>", # e.g., "v1", "v2" - determined in Step 2
sample_input_data=sample_input,
conda_dependencies=["<FRAMEWORK>", "<OTHER_DEPS>"], # Snowflake conda channel (warehouse) or conda-forge (SPCS)
target_platforms=["WAREHOUSE", "SNOWPARK_CONTAINER_SERVICES"],
comment="<DESCRIPTION>"
)
print(f"Model registered: {mv.model_name} version {mv.version_name}")
For Custom/Unsupported Model Types:
import pandas as pd
from snowflake.ml.registry import Registry
from snowflake.ml.model import custom_model
from snowflake.snowpark import Session
session = Session.builder.config("connection_name", "<CONNECTION_NAME>").create()
model_context = custom_model.ModelContext(
model_file="<MODEL_FILE_PATH>"
)
class MyCustomModel(custom_model.CustomModel):
def __init__(self, context: custom_model.ModelContext) -> None:
super().__init__(context)
# Load model using framework-appropriate method
self.model = <LOAD_MODEL_CODE>
@custom_model.inference_api
def predict(self, input_df: pd.DataFrame) -> pd.DataFrame:
predictions = self.model.predict(input_df)
return pd.DataFrame({"prediction": predictions})
my_model = MyCustomModel(model_context)
sample_input = pd.DataFrame(<SAMPLE_DATA>)
output = my_model.predict(sample_input)
reg = Registry(session=session, database_name="<DATABASE>", schema_name="<SCHEMA>")
mv = reg.log_model(
my_model,
model_name="<MODEL_NAME>",
version_name="<VERSION_NAME>", # e.g., "v1", "v2" - determined in Step 2
sample_input_data=sample_input,
conda_dependencies=["<DEPS>"], # Snowflake conda channel (warehouse) or conda-forge (SPCS)
target_platforms=["WAREHOUSE", "SNOWPARK_CONTAINER_SERVICES"],
comment="<DESCRIPTION>"
)
print(f"Model registered: {mv.model_name} version {mv.version_name}")
Interactive Mode: Test model loading → test prediction → run registration → verify with reg.show_models()
Write Mode: Write complete script, then ask user confirmation before executing.
⚠️ MANDATORY: Present summary and wait for user approval before executing.
Follow Python Environment Setup from parent skill. If execution fails, read complete error, fix, and ask user again before re-executing.
| Parameter | Description | Required |
|---|---|---|
model | Python model object | Yes |
model_name | Name in registry | Yes |
version_name | Version identifier | Recommended |
sample_input_data | DataFrame for schema inference | Yes* |
conda_dependencies | List of conda packages (for warehouse) | See below |
pip_requirements | List of pip packages (requires artifact_repository_map for warehouse) | See below |
target_platforms | Target deployment platforms | See below |
artifact_repository_map | Map of package indexes for non-conda packages | See below |
*Or provide signatures instead.
For WAREHOUSE target:
conda_dependencies for packages in Snowflake conda channelpip_requirements + artifact_repository_map for PyPI packagesFor SPCS only:
pip_requirements directly without artifact_repository_mapconda_dependencies are loaded from conda-forge (not Snowflake conda channel)Default approach: Try ["WAREHOUSE", "SNOWPARK_CONTAINER_SERVICES"] first to enable both warehouse inference and SPCS deployment.
Fallback: If log_model() fails with warehouse target (e.g., due to unsupported dependencies or model size), retry with ["SNOWPARK_CONTAINER_SERVICES"] only.
# First attempt: try both platforms (use conda_dependencies for warehouse compatibility)
try:
mv = reg.log_model(
model,
model_name="<MODEL_NAME>",
version_name="<VERSION>",
sample_input_data=sample_input,
conda_dependencies=["<DEPS>"], # Snowflake conda channel (warehouse) or conda-forge (SPCS)
target_platforms=["WAREHOUSE", "SNOWPARK_CONTAINER_SERVICES"],
)
except Exception as e:
# Fallback: SPCS only (can use pip_requirements directly)
mv = reg.log_model(
model,
model_name="<MODEL_NAME>",
version_name="<VERSION>",
sample_input_data=sample_input,
pip_requirements=["<DEPS>"],
target_platforms=["SNOWPARK_CONTAINER_SERVICES"],
)
When your model depends on packages not available in the Snowflake conda channel, use artifact_repository_map to specify PyPI as the package source.
Use the shared pypi_shared_repository for public PyPI packages:
mv = reg.log_model(
model,
model_name="<MODEL_NAME>",
version_name="<VERSION>",
sample_input_data=sample_input,
pip_requirements=["scikit-learn", "shap>=0.42.0"],
target_platforms=["WAREHOUSE", "SNOWPARK_CONTAINER_SERVICES"],
artifact_repository_map={
"shap": "pypi_shared_repository" # Map non-conda packages to PyPI
},
)
pip_requirements)pypi_shared_repository for public PyPI packagesSHOW VERSIONS IN MODEL to check, increment version or renamepickle.dump() or joblib.dump()signaturesartifact_repository_map to specify PyPI or custom repository (see Using artifact_repository_map)⚠️ MANDATORY: After registration completes, verify the model was registered correctly before proceeding.
Run verification checks:
-- 1. Verify model exists in registry
SHOW MODELS IN SCHEMA <DATABASE>.<SCHEMA>;
-- 2. Verify version was created
SHOW VERSIONS IN MODEL <DATABASE>.<SCHEMA>.<MODEL_NAME>;
-- 3. Check available functions/methods
SHOW FUNCTIONS IN MODEL <DATABASE>.<SCHEMA>.<MODEL_NAME>;
Verification checklist:
| Check | Expected Result |
|---|---|
SHOW MODELS includes model | Model name listed in results |
SHOW VERSIONS IN MODEL returns version | Version name listed (e.g., "v1") |
SHOW FUNCTIONS IN MODEL returns methods | At least one method (e.g., PREDICT, PREDICT_PROBA) |
If verification fails:
⚠️ STOP: Only proceed to next steps after all verification checks pass.
If target_platforms includes WAREHOUSE:
Ask user what they'd like to do:
../model-monitor/SKILL.md)If target_platforms is SPCS only:
Warehouse inference is not available. Ask user:
../model-monitor/SKILL.md)⚠️ STOP: Wait for user response.
If user chooses to test warehouse inference:
⚠️ Always specify the version explicitly. Use the version from Step 2 (e.g., V1, V2)—do not rely on the default version.
Run a sample prediction using SQL or Python. Use the method name from the model (e.g., PREDICT, PREDICT_PROBA, TRANSFORM).
SQL Syntax:
Use MODEL(model_name, version)!METHOD(...) syntax. Version names are unquoted identifiers.
SELECT MODEL(<DATABASE>.<SCHEMA>.<MODEL_NAME>, <VERSION>)!<METHOD_NAME>(col1, col2, col3) AS result
FROM <INPUT_TABLE>
LIMIT 10;
-- Extract specific output field
SELECT MODEL(<DATABASE>.<SCHEMA>.<MODEL_NAME>, <VERSION>)!<METHOD_NAME>(col1, col2, col3):output_feature_0 AS result
FROM <INPUT_TABLE>;
⚠️ Important: Do NOT quote version names. Use V2 not 'V2'.
Python:
mv = reg.get_model("<MODEL_NAME>").version("<VERSION>")
# Check available methods
print(mv.show_functions())
# Run inference
result = mv.run(test_data, function_name="<method_name>")
print(result)
If user chooses SPCS deployment: Proceed to Workflow B.
When to use Warehouse vs SPCS Inference:
| Use Case | Recommendation |
|---|---|
| Ad-hoc queries, testing | Warehouse inference |
| Batch predictions | Warehouse inference |
| Real-time API endpoint | SPCS inference (Workflow B) |
| High-throughput, low-latency | SPCS inference (Workflow B) |
../spcs-inference/SKILL.md)