dataiku · kevanescence · May 27, 2026 · May 27, 2026 · May 27, 2026
diff --git a/HISTORY.txt b/HISTORY.txt
@@ -2,6 +2,10 @@ Changelog
 ==========
 
 
+14.6.0 (2026-05-27)
+-------------------
+
+* Initial release for DSS 14.6.0
 
 14.5.2 (2026-05-25)
 -------------------

diff --git a/dataikuapi/dss/admin.py b/dataikuapi/dss/admin.py
@@ -2202,6 +2202,7 @@ def add_container_runtime_addition(self, container_runtime_addition):
         * PYTHON36_SUPPORT
         * PYTHON37_SUPPORT
         * PYTHON38_SUPPORT
+        * HUGGING_FACE_LOCAL_GPU
 
         :param dict container_runtime_addition: a dict with the container runtime addition definition
         """

diff --git a/dataikuapi/dss/agent.py b/dataikuapi/dss/agent.py
@@ -226,6 +226,11 @@ def disable(self):
         self.mode = self.MODE_NONE
 
 
+# Neutral aliases for shared LLM interaction logging concepts.
+DSSLLMInteractionLoggingSettings = DSSAgentInteractionLoggingSettings
+DSSLLMInteractionLoggingSelection = DSSAgentInteractionLoggingSelection
+
+
 class DSSAgentListItem(DSSTaggableObjectListItem):
     """
     An item in a list of agents
@@ -521,7 +526,7 @@ def interaction_logging_selection(self):
         .. code-block:: python
 
             project = client.get_project("MYPROJECT")
-            project.create_agent_interaction_logging_dataset(
+            project.create_llm_interaction_logging_dataset(
                 "agent_logs",
                 connection_id="filesystem_managed",
                 time_partitioning="DAY",

diff --git a/dataikuapi/dss/agent_review.py b/dataikuapi/dss/agent_review.py
@@ -214,6 +214,32 @@ def nb_executions(self):
     def nb_executions(self, value):
         self.data["nbExecutions"] = value
 
+    @property
+    def hitl_validation_policy(self):
+        """
+        Review-wide default HITL validation policy used when creating a test.
+        Possible values are ``ACCEPT`` or ``REJECT``.
+        :rtype: str
+        """
+        return self.data.get("hitlValidationPolicy")
+
+    @hitl_validation_policy.setter
+    def hitl_validation_policy(self, value):
+        self.data["hitlValidationPolicy"] = value
+
+    @property
+    def hitl_max_validation_turns(self):
+        """
+        Maximum number of validation turns auto-answered during a test run before stopping.
+        Possible values are integers greater than or equal to ``1``.
+        :rtype: int
+        """
+        return self.data.get("hitlMaxValidationTurns")
+
+    @hitl_max_validation_turns.setter
+    def hitl_max_validation_turns(self, value):
+        self.data["hitlMaxValidationTurns"] = value
+
     def get_trait(self, trait_id):
         """
         Get a specific trait by its ID.
@@ -278,13 +304,14 @@ def get_test(self, test_id):
         )
         return DSSAgentReviewTest(self.dss_client, self.project_key, test)
 
-    def create_test(self, query=None, reference_answer=None, expectations=None):
+    def create_test(self, query=None, reference_answer=None, expectations=None, hitl_validation_policy=None):
         """
         Create a new test for this agent review.
 
         :param str query: Query to test the agent. Optional.
         :param str reference_answer: Reference answer. Optional.
         :param str expectations: Expectations on the agent answer. Optional.
+        :param str hitl_validation_policy: Per-test HITL validation policy. Optional.
         :returns: The created test object.
         :rtype: :class:`DSSAgentReviewTest`
         """
@@ -294,13 +321,14 @@ def create_test(self, query=None, reference_answer=None, expectations=None):
             "query": query,
             "referenceAnswer": reference_answer,
             "expectations": expectations,
+            "hitlValidationPolicy": hitl_validation_policy,
         }
         test = self.dss_client._perform_json(
             "POST", "/projects/%s/agent-reviews/tests" % self.project_key, body=body
         )
         return DSSAgentReviewTest(self.dss_client, self.project_key, test)
 
-    def create_tests_from_dataset(self, full_dataset_name, query_column, reference_answer_column=None, expectations_column=None, top_n=None, partitions=None, latest_partitions_n=None):
+    def create_tests_from_dataset(self, full_dataset_name, query_column, reference_answer_column=None, expectations_column=None, top_n=None, partitions=None, latest_partitions_n=None, hitl_validation_policy_column=None):
         """
         Create new tests for this agent review by importing them from a dataset.
 
@@ -311,6 +339,7 @@ def create_tests_from_dataset(self, full_dataset_name, query_column, reference_a
         :param int top_n: Only take the first n rows of the dataset. Optional.
         :param list[str] partitions: For partitioned datasets, only consider the given partitions. Optional.
         :param int latest_partitions_n: For partitioned datasets and if partitions is not set, only consider the latest n partitions. Optional.
+        :param str hitl_validation_policy_column: Name of the column containing per-test HITL validation policy. Optional.
         :returns: A dictionary with keys:
             - "createdTestIds": list of ids of the created tests
             - "error": The error message if any occurred
@@ -324,6 +353,7 @@ def create_tests_from_dataset(self, full_dataset_name, query_column, reference_a
             "queryColumn": query_column,
             "referenceAnswerColumn": reference_answer_column,
             "expectationsColumn": expectations_column,
+            "hitlValidationPolicyColumn": hitl_validation_policy_column,
         }
         if top_n is not None:
             body["samplingMethod"] = "HEAD_SEQUENTIAL"
@@ -587,6 +617,19 @@ def expectations(self):
     def expectations(self, value):
         self.data["expectations"] = value
 
+    @property
+    def hitl_validation_policy(self):
+        """
+        Per-test HITL validation policy.
+        Possible values are ``ACCEPT`` or ``REJECT``.
+        :rtype: str
+        """
+        return self.data.get("hitlValidationPolicy")
+
+    @hitl_validation_policy.setter
+    def hitl_validation_policy(self, value):
+        self.data["hitlValidationPolicy"] = value
+
     @property
     def creation_timestamp(self):
         """
@@ -735,6 +778,15 @@ def expectations(self):
         """
         return self.get("expectations")
 
+    @property
+    def hitl_validation_policy(self):
+        """
+        Per-test HITL validation policy.
+        Possible values are ``ACCEPT`` or ``REJECT``.
+        :rtype: str
+        """
+        return self.get("hitlValidationPolicy")
+
 
 class DSSAgentReviewRun(object):
     """

diff --git a/dataikuapi/dss/knowledgebank.py b/dataikuapi/dss/knowledgebank.py
@@ -245,7 +245,7 @@ def id(self):
     @property
     def vector_store_type(self):
         """
-        Returns the type of storage backing the vector store (could be CHROMA, PINECONE, ELASTICSEARCH, AZURE_AI_SEARCH, VERTEX_AI_GCS_BASED, FAISS, QDRANT_LOCAL)
+        Returns the type of storage backing the vector store (could be CHROMA, PINECONE, ELASTICSEARCH, AZURE_AI_SEARCH, SNOWFLAKE_CORTEX_SEARCH, VERTEX_AI_GCS_BASED, FAISS, QDRANT_LOCAL)
 
         :rtype: str
         """

diff --git a/dataikuapi/dss/ml.py b/dataikuapi/dss/ml.py
@@ -1493,11 +1493,9 @@ def strategy(self, _):
                              "To update the search strategy, use <HyperparameterSearchSettings object>.strategy = ..., "
                              "obtained with <DSSPredictionMLTaskSettings object>.get_hyperparameter_search_settings()")
 
-
-class RandomForestSettings(PredictionAlgorithmSettings):
-
+class _RandomForestSettingsBase(PredictionAlgorithmSettings):
     def __init__(self, raw_settings, hyperparameter_search_params):
-        super(RandomForestSettings, self).__init__(raw_settings, hyperparameter_search_params)
+        super(_RandomForestSettingsBase, self).__init__(raw_settings, hyperparameter_search_params)
         self.n_estimators = self._register_numerical_hyperparameter("n_estimators")
         self.min_samples_leaf = self._register_numerical_hyperparameter("min_samples_leaf")
         self.max_tree_depth = self._register_numerical_hyperparameter("max_tree_depth")
@@ -1507,10 +1505,19 @@ def __init__(self, raw_settings, hyperparameter_search_params):
         self.selection_mode = self._register_single_category_hyperparameter("selection_mode", accepted_values=["sqrt", "log2", "number", "prop"])
 
 
-class LightGBMSettings(PredictionAlgorithmSettings):
+class TimeseriesRandomForestSettings(_RandomForestSettingsBase):
+    pass
+
 
+class RandomForestSettings(_RandomForestSettingsBase):
     def __init__(self, raw_settings, hyperparameter_search_params):
-        super(LightGBMSettings, self).__init__(raw_settings, hyperparameter_search_params)
+        super(RandomForestSettings, self).__init__(raw_settings, hyperparameter_search_params)
+        self.allow_sparse_matrices = self._register_single_value_hyperparameter("allow_sparse_matrices", accepted_types=[bool])
+
+
+class _LightGBMSettingsBase(PredictionAlgorithmSettings):
+    def __init__(self, raw_settings, hyperparameter_search_params):
+        super(_LightGBMSettingsBase, self).__init__(raw_settings, hyperparameter_search_params)
         self.boosting_type = self._register_categorical_hyperparameter("boosting_type")
         self.num_leaves = self._register_numerical_hyperparameter("num_leaves")
         self.learning_rate = self._register_numerical_hyperparameter("learning_rate")
@@ -1521,9 +1528,6 @@ def __init__(self, raw_settings, hyperparameter_search_params):
         self.colsample_bytree = self._register_numerical_hyperparameter("colsample_bytree")
         self.reg_alpha = self._register_numerical_hyperparameter("reg_alpha")
         self.reg_lambda = self._register_numerical_hyperparameter("reg_lambda")
-
-        self.early_stopping = self._register_single_value_hyperparameter("early_stopping", accepted_types=[bool])
-        self.early_stopping_rounds = self._register_single_value_hyperparameter("early_stopping_rounds", accepted_types=[int])
         self.random_state = self._register_single_value_hyperparameter("random_state", accepted_types=[int])
         self.n_jobs = self._register_single_value_hyperparameter("n_jobs", accepted_types=[int])
         self.max_depth = self._register_single_value_hyperparameter("max_depth", accepted_types=[int])
@@ -1532,6 +1536,18 @@ def __init__(self, raw_settings, hyperparameter_search_params):
         self.use_bagging = self._register_single_value_hyperparameter("use_bagging", accepted_types=[bool])
 
 
+class TimeseriesLightGBMSettings(_LightGBMSettingsBase):
+    pass
+
+
+class LightGBMSettings(_LightGBMSettingsBase):
+    def __init__(self, raw_settings, hyperparameter_search_params):
+        super(LightGBMSettings, self).__init__(raw_settings, hyperparameter_search_params)
+        self.early_stopping = self._register_single_value_hyperparameter("early_stopping", accepted_types=[bool])
+        self.early_stopping_rounds = self._register_single_value_hyperparameter("early_stopping_rounds", accepted_types=[int])
+        self.allow_sparse_matrices = self._register_single_value_hyperparameter("allow_sparse_matrices", accepted_types=[bool])
+
+
 class TabICLSettings(PredictionAlgorithmSettings):
 
     def __init__(self, raw_settings, hyperparameter_search_params):
@@ -1551,10 +1567,10 @@ def __init__(self, raw_settings, hyperparameter_search_params):
         self.outlier_threshold = self._register_single_value_hyperparameter("outlier_threshold")
 
 
-class XGBoostSettings(PredictionAlgorithmSettings):
+class _XGBoostSettingsBase(PredictionAlgorithmSettings):
 
     def __init__(self, raw_settings, hyperparameter_search_params):
-        super(XGBoostSettings, self).__init__(raw_settings, hyperparameter_search_params)
+        super(_XGBoostSettingsBase, self).__init__(raw_settings, hyperparameter_search_params)
         self.max_depth = self._register_numerical_hyperparameter("max_depth")
         self.learning_rate = self._register_numerical_hyperparameter("learning_rate")
         self.gamma = self._register_numerical_hyperparameter("gamma")
@@ -1575,8 +1591,6 @@ def __init__(self, raw_settings, hyperparameter_search_params):
         self.missing = self._register_single_value_hyperparameter("missing", accepted_types=[int, float])
         self.tree_method = self._register_single_category_hyperparameter("tree_method", accepted_values=["auto", "exact", "approx", "hist"])
         self.seed = self._register_single_value_hyperparameter("seed", accepted_types=[int])
-        self.enable_early_stopping = self._register_single_value_hyperparameter("enable_early_stopping", accepted_types=[bool])
-        self.early_stopping_rounds = self._register_single_value_hyperparameter("early_stopping_rounds", accepted_types=[int])
         self.tweedie_variance_power = self._register_single_value_hyperparameter("tweedie_variance_power", accepted_types=[int, float])
 
     @property
@@ -1614,6 +1628,18 @@ def gpu_tree_method(self, value):
             self.tree_method.set_value(value)
 
 
+class TimeseriesXGBoostSettings(_XGBoostSettingsBase):
+    pass
+
+
+class XGBoostSettings(_XGBoostSettingsBase):
+    def __init__(self, raw_settings, hyperparameter_search_params):
+        super(XGBoostSettings, self).__init__(raw_settings, hyperparameter_search_params)
+        self.enable_early_stopping = self._register_single_value_hyperparameter("enable_early_stopping", accepted_types=[bool])
+        self.early_stopping_rounds = self._register_single_value_hyperparameter("early_stopping_rounds", accepted_types=[int])
+        self.allow_sparse_matrices = self._register_single_value_hyperparameter("allow_sparse_matrices", accepted_types=[bool])
+
+
 class GradientBoostedTreesSettings(PredictionAlgorithmSettings):
 
     def __init__(self, raw_settings, hyperparameter_search_params):
@@ -1866,6 +1892,71 @@ def __init__(self, raw_settings, hyperparameter_search_params):
         self.maxiter = self._register_single_value_hyperparameter("maxiter", accepted_types=[int])
 
 
+class ArimaSettings(PredictionAlgorithmSettings):
+    def __init__(self, raw_settings, hyperparameter_search_params):
+        super(ArimaSettings, self).__init__(raw_settings, hyperparameter_search_params)
+        self.p = self._register_single_value_hyperparameter("p", accepted_types=[int])
+        self.d = self._register_single_value_hyperparameter("d", accepted_types=[int])
+        self.q = self._register_single_value_hyperparameter("q", accepted_types=[int])
+        self.P = self._register_single_value_hyperparameter("P", accepted_types=[int])
+        self.D = self._register_single_value_hyperparameter("D", accepted_types=[int])
+        self.Q = self._register_single_value_hyperparameter("Q", accepted_types=[int])
+        self.s = self._register_single_value_hyperparameter("s", accepted_types=[int])
+        self.trend = self._register_single_category_hyperparameter("trend", accepted_values=["n", "c", "t", "ct"])
+        self.trend_offset = self._register_single_value_hyperparameter("trend_offset", accepted_types=[int])
+        self.enforce_stationarity = self._register_single_value_hyperparameter("enforce_stationarity", accepted_types=[bool])
+        self.enforce_invertibility = self._register_single_value_hyperparameter("enforce_invertibility", accepted_types=[bool])
+        self.concentrate_scale = self._register_single_value_hyperparameter("concentrate_scale", accepted_types=[bool])
+
+
+class CrostonSettings(PredictionAlgorithmSettings):
+    def __init__(self, raw_settings, hyperparameter_search_params):
+        super(CrostonSettings, self).__init__(raw_settings, hyperparameter_search_params)
+        self.variant = self._register_categorical_hyperparameter("variant")
+        self.alpha_d = self._register_numerical_hyperparameter("alpha_d")
+        self.alpha_p = self._register_numerical_hyperparameter("alpha_p")
+
+
+class ETSSettings(PredictionAlgorithmSettings):
+
+    def __init__(self, raw_settings, hyperparameter_search_params):
+        super(ETSSettings, self).__init__(raw_settings, hyperparameter_search_params)
+        self.trend = self._register_categorical_hyperparameter("trend")
+        self.damped_trend = self._register_categorical_hyperparameter("damped_trend")
+        self.seasonal = self._register_categorical_hyperparameter("seasonal")
+        self.error = self._register_categorical_hyperparameter("error")
+        self.seasonal_periods = self._register_single_value_hyperparameter("seasonal_periods", accepted_types=[int])
+        self.include_unstable = self._register_single_value_hyperparameter("include_unstable", accepted_types=[bool])
+        self.seed = self._register_single_value_hyperparameter("seed", accepted_types=[int])
+
+
+class NHITSSettings(PredictionAlgorithmSettings):
+    def __init__(self, raw_settings, hyperparameter_search_params):
+        super(NHITSSettings, self).__init__(raw_settings, hyperparameter_search_params)
+        self.context_length = self._register_numerical_hyperparameter("context_length")
+        self.learning_rate = self._register_numerical_hyperparameter("learning_rate")
+        self.batch_size = self._register_single_value_hyperparameter("batch_size", accepted_types=[int])
+        self.max_steps = self._register_single_value_hyperparameter("max_steps", accepted_types=[int])
+        self.patience = self._register_single_value_hyperparameter("patience", accepted_types=[int])
+        self.random_state = self._register_single_value_hyperparameter("random_state", accepted_types=[int])
+
+
+class TFTSettings(PredictionAlgorithmSettings):
+    def __init__(self, raw_settings, hyperparameter_search_params):
+        super(TFTSettings, self).__init__(raw_settings, hyperparameter_search_params)
+        self.context_length = self._register_numerical_hyperparameter("context_length")
+        self.hidden_size_factor = self._register_numerical_hyperparameter("hidden_size_factor")
+        self.learning_rate = self._register_numerical_hyperparameter("learning_rate")
+        self.n_rnn_layers = self._register_numerical_hyperparameter("n_rnn_layers")
+        self.n_head = self._register_numerical_hyperparameter("n_head")
+        self.batch_size = self._register_single_value_hyperparameter("batch_size", accepted_types=[int])
+        self.max_steps = self._register_single_value_hyperparameter("max_steps", accepted_types=[int])
+        self.patience = self._register_single_value_hyperparameter("patience", accepted_types=[int])
+        self.random_state = self._register_single_value_hyperparameter("random_state", accepted_types=[int])
+        self.max_hidden_size = self._register_single_value_hyperparameter("max_hidden_size", accepted_types=[int])
+        self.limit_hidden_size = self._register_single_value_hyperparameter("limit_hidden_size", accepted_types=[bool])
+
+
 class SeasonalLoessSettings(PredictionAlgorithmSettings):
 
     def __init__(self, raw_settings, hyperparameter_search_params):
@@ -2377,6 +2468,15 @@ def get_algorithm_settings(self, algorithm_name):
 class DSSTimeseriesForecastingMLTaskSettings(AbstractTabularPredictionMLTaskSettings):
     __doc__ = []
     _algorithm_remap = {
+        "ARIMA": PredictionAlgorithmMeta("arima_timeseries", ArimaSettings),
+        "CROSTON": PredictionAlgorithmMeta("croston_timeseries", CrostonSettings),
+        "ETS": PredictionAlgorithmMeta("ets_timeseries", ETSSettings),
+        "NHITS": PredictionAlgorithmMeta("nhits_timeseries", NHITSSettings),
+        "TFT": PredictionAlgorithmMeta("tft_timeseries", TFTSettings),
+        "RANDOM_FOREST_REGRESSION": PredictionAlgorithmMeta("random_forest_regression", TimeseriesRandomForestSettings),
+        "XGBOOST_REGRESSION": PredictionAlgorithmMeta("xgboost", TimeseriesXGBoostSettings),
+        "RIDGE_REGRESSION": PredictionAlgorithmMeta("ridge_regression", RidgeRegressionSettings),
+        "LIGHTGBM_REGRESSION": PredictionAlgorithmMeta("lightgbm_regression", TimeseriesLightGBMSettings),
         "TRIVIAL_IDENTITY_TIMESERIES": PredictionAlgorithmMeta("trivial_identity_timeseries"),
         "SEASONAL_NAIVE": PredictionAlgorithmMeta("seasonal_naive_timeseries", SeasonalNaiveSettings),
         "AUTO_ARIMA": PredictionAlgorithmMeta("autoarima_timeseries", AutoArimaSettings),