mlrun 1.8.0rc19__py3-none-any.whl → 1.8.0rc26__py3-none-any.whl

mlrun/projects/project.py

@@ -29,6 +29,7 @@ import zipfile
 from copy import deepcopy
 from os import environ, makedirs, path
 from typing import Callable, Optional, Union, cast
+from urllib.parse import urlparse
 
 import dotenv
 import git
@@ -83,6 +84,7 @@ from ..artifacts import (
     ModelArtifact,
 )
 from ..artifacts.manager import ArtifactManager, dict_to_artifact, extend_artifact_path
+from ..common.runtimes.constants import RunStates
 from ..datastore import store_manager
 from ..features import Feature
 from ..model import EntrypointParam, ImageBuilder, ModelObj
@@ -851,6 +853,7 @@ class ProjectSpec(ModelObj):
         build=None,
         custom_packagers: Optional[list[tuple[str, bool]]] = None,
         default_function_node_selector=None,
+        notifications=None,
     ):
         self.repo = None
 
@@ -891,6 +894,7 @@ class ProjectSpec(ModelObj):
         # whether it is mandatory for a run (raise exception on collection error) or not.
         self.custom_packagers = custom_packagers or []
         self._default_function_node_selector = default_function_node_selector or None
+        self.notifications = notifications or []
 
     @property
     def source(self) -> str:
@@ -1172,7 +1176,6 @@ class MlrunProject(ModelObj):
         self._artifact_manager = None
         self._notifiers = CustomNotificationPusher(
             [
-                NotificationTypes.slack,
                 NotificationTypes.console,
                 NotificationTypes.ipython,
             ]
@@ -1910,7 +1913,7 @@ class MlrunProject(ModelObj):
 
     def log_document(
         self,
-        key: str,
+        key: str = "",
         tag: str = "",
         local_path: str = "",
         artifact_path: Optional[str] = None,
@@ -1923,7 +1926,8 @@ class MlrunProject(ModelObj):
         """
         Log a document as an artifact.
 
-        :param key: Artifact key
+        :param key: Optional artifact key. If not provided, will be derived from local_path
+                or target_path using DocumentArtifact.key_from_source()
         :param tag: Version tag
         :param local_path:    path to the local file we upload, will also be use
                               as the destination subpath (under "artifact_path")
@@ -1952,7 +1956,6 @@ class MlrunProject(ModelObj):
         Example:
             >>> # Log a PDF document with custom loader
             >>> project.log_document(
-            ...     key="my_doc",
             ...     local_path="path/to/doc.pdf",
             ...     document_loader=DocumentLoaderSpec(
             ...         loader_class_name="langchain_community.document_loaders.PDFLoader",
@@ -1962,17 +1965,24 @@ class MlrunProject(ModelObj):
             ... )
 
         """
+        if not key and not local_path and not target_path:
+            raise ValueError(
+                "Must provide either 'key' parameter or 'local_path'/'target_path' to derive the key from"
+            )
+        if not key:
+            key = DocumentArtifact.key_from_source(local_path or target_path)
+
+        document_loader_spec = document_loader_spec or DocumentLoaderSpec()
         if not document_loader_spec.download_object and upload:
             raise ValueError(
-                "This document loader expects direct links/URLs and does not support file uploads. "
-                "Either set download_object=True or set upload=False"
+                "The document loader is configured to not support downloads but the upload flag is set to True."
+                "Either set loader.download_object=True or set upload=False"
             )
         doc_artifact = DocumentArtifact(
             key=key,
             original_source=local_path or target_path,
-            document_loader_spec=document_loader_spec
-            if document_loader_spec
-            else DocumentLoaderSpec(),
+            document_loader_spec=document_loader_spec,
+            collections=kwargs.pop("collections", None),
             **kwargs,
         )
         return self.log_artifact(
@@ -2116,8 +2126,9 @@ class MlrunProject(ModelObj):
         """
         :param name:                   AlertConfig name.
         :param summary:                Summary of the alert, will be sent in the generated notifications
-        :param endpoints:              The endpoints from which to retrieve the metrics that the
-                                       alerts will be based on.
+        :param endpoints:              The endpoints from which metrics will be retrieved to configure the alerts.
+                                       This `ModelEndpointList` object obtained via the `list_model_endpoints`
+                                       method or created manually using `ModelEndpoint` objects.
         :param events:                 AlertTrigger event types (EventKind).
         :param notifications:          List of notifications to invoke once the alert is triggered
         :param result_names:           Optional. Filters the result names used to create the alert configuration,
@@ -2126,6 +2137,8 @@ class MlrunProject(ModelObj):
                                        For example:
                                        [`app1.result-*`, `*.result1`]
                                        will match "mep1.app1.result.result-1" and "mep1.app2.result.result1".
+                                       A specific result_name (not a wildcard) will always create a new alert
+                                       config, regardless of whether the result name exists.
         :param severity:               Severity of the alert.
         :param criteria:               When the alert will be triggered based on the
                                        specified number of events within the defined time period.
@@ -2136,6 +2149,11 @@ class MlrunProject(ModelObj):
         """
         db = mlrun.db.get_run_db(secrets=self._secrets)
         matching_results = []
+        specific_result_names = [
+            result_name
+            for result_name in result_names
+            if result_name.count(".") == 3 and "*" not in result_name
+        ]
         alerts = []
         endpoint_ids = [endpoint.metadata.uid for endpoint in endpoints.endpoints]
         # using separation to group by endpoint IDs:
@@ -2159,7 +2177,14 @@ class MlrunProject(ModelObj):
                 existing_result_names=results_fqn_by_endpoint,
                 result_name_filters=result_names,
             )
-        for result_fqn in matching_results:
+        for specific_result_name in specific_result_names:
+            if specific_result_name not in matching_results:
+                logger.warning(
+                    f"The specific result name '{specific_result_name}' was"
+                    f" not found in the existing endpoint results. Adding alert configuration anyway."
+                )
+        alert_result_names = list(set(specific_result_names + matching_results))
+        for result_fqn in alert_result_names:
             alerts.append(
                 mlrun.alerts.alert.AlertConfig(
                     project=self.name,
@@ -2670,6 +2695,36 @@ class MlrunProject(ModelObj):
             timeout=timeout,
         )
 
+    def push_pipeline_notification_kfp_runner(
+        self,
+        pipeline_id: str,
+        current_run_state: mlrun_pipelines.common.models.RunStatuses,
+        message: str,
+        notifications: Optional[list] = None,
+    ):
+        """
+        Push notifications for a pipeline run(KFP).
+
+        :param pipeline_id:         Unique ID of the pipeline run.
+        :param current_run_state:   Current run state of the pipeline.
+        :param message:             Message to send in the notification.
+        :param notifications:       List of notifications to send.
+        """
+        current_run_state = RunStates.pipeline_run_status_to_run_state(
+            current_run_state
+        )
+        db = mlrun.get_run_db()
+        notifications = notifications or self.spec.notifications
+        notifications_to_send = []
+        for notification in notifications:
+            if current_run_state in notification.when:
+                notification_copy = notification.copy()
+                notification_copy.message = message
+                notifications_to_send.append(notification_copy)
+        db.push_pipeline_notifications(
+            pipeline_id, self.metadata.name, notifications_to_send
+        )
+
     def _instantiate_function(
         self,
         func: typing.Union[str, mlrun.runtimes.BaseRuntime] = None,
@@ -3576,9 +3631,12 @@ class MlrunProject(ModelObj):
     def set_model_monitoring_credentials(
         self,
         access_key: Optional[str] = None,
-        stream_path: Optional[str] = None,
-        tsdb_connection: Optional[str] = None,
+        stream_path: Optional[str] = None,  # Deprecated
+        tsdb_connection: Optional[str] = None,  # Deprecated
         replace_creds: bool = False,
+        *,
+        stream_profile_name: Optional[str] = None,
+        tsdb_profile_name: Optional[str] = None,
     ):
         """
         Set the credentials that will be used by the project's model monitoring
@@ -3590,50 +3648,109 @@ class MlrunProject(ModelObj):
                                           * None - will be set from the system configuration.
                                           * v3io - for v3io endpoint store, pass `v3io` and the system will generate the
                                             exact path.
-        :param stream_path:               Path to the model monitoring stream. By default, None. Options:
-
-                                          * None - will be set from the system configuration.
-                                          * v3io - for v3io stream, pass `v3io` and the system will generate the exact
-                                            path.
-                                          * Kafka - for Kafka stream, provide the full connection string without custom
-                                            topic, for example kafka://<some_kafka_broker>:<port>.
-        :param tsdb_connection:           Connection string to the time series database. By default, None.
+        :param stream_path:               (Deprecated) This argument is deprecated. Use ``stream_profile_name`` instead.
+                                          Path to the model monitoring stream. By default, None. Options:
+
+                                          * ``"v3io"`` - for v3io stream, pass ``"v3io"`` and the system will generate
+                                            the exact path.
+                                          * Kafka - for Kafka stream, provide the full connection string without acustom
+                                            topic, for example ``"kafka://<some_kafka_broker>:<port>"``.
+        :param tsdb_connection:           (Deprecated) Connection string to the time series database. By default, None.
                                           Options:
 
-                                          * None - will be set from the system configuration.
-                                          * v3io - for v3io stream, pass `v3io` and the system will generate the exact
-                                            path.
+                                          * v3io - for v3io stream, pass ``"v3io"`` and the system will generate the
+                                            exact path.
                                           * TDEngine - for TDEngine tsdb, provide the full websocket connection URL,
-                                            for example taosws://<username>:<password>@<host>:<port>.
+                                            for example ``"taosws://<username>:<password>@<host>:<port>"``.
         :param replace_creds:             If True, will override the existing credentials.
                                           Please keep in mind that if you already enabled model monitoring on
                                           your project this action can cause data loose and will require redeploying
                                           all model monitoring functions & model monitoring infra
                                           & tracked model server.
+        :param stream_profile_name:       The datastore profile name of the stream to be used in model monitoring.
+                                          The supported profiles are:
+
+                                          * :py:class:`~mlrun.datastore.datastore_profile.DatastoreProfileV3io`
+                                          * :py:class:`~mlrun.datastore.datastore_profile.DatastoreProfileKafkaSource`
+
+                                          You need to register one of them, and pass the profile's name.
+        :param tsdb_profile_name:         The datastore profile name of the time-series database to be used in model
+                                          monitoring. The supported profiles are:
+
+                                          * :py:class:`~mlrun.datastore.datastore_profile.DatastoreProfileV3io`
+                                          * :py:class:`~mlrun.datastore.datastore_profile.TDEngineDatastoreProfile`
+
+                                          You need to register one of them, and pass the profile's name.
         """
         db = mlrun.db.get_run_db(secrets=self._secrets)
-        if tsdb_connection == "v3io":
-            tsdb_profile = mlrun.datastore.datastore_profile.DatastoreProfileV3io(
-                name="mm-infra-tsdb"
+
+        if tsdb_connection:
+            warnings.warn(
+                "The `tsdb_connection` argument is deprecated and will be removed in MLRun version 1.8.0. "
+                "Use `tsdb_profile_name` instead.",
+                FutureWarning,
             )
+            if tsdb_profile_name:
+                raise mlrun.errors.MLRunValueError(
+                    "If you set `tsdb_profile_name`, you must not pass `tsdb_connection`."
+                )
+            if tsdb_connection == "v3io":
+                tsdb_profile = mlrun.datastore.datastore_profile.DatastoreProfileV3io(
+                    name=mm_constants.DefaultProfileName.TSDB
+                )
+            else:
+                parsed_url = urlparse(tsdb_connection)
+                if parsed_url.scheme != "taosws":
+                    raise mlrun.errors.MLRunValueError(
+                        f"Unsupported `tsdb_connection`: '{tsdb_connection}'."
+                    )
+                tsdb_profile = (
+                    mlrun.datastore.datastore_profile.TDEngineDatastoreProfile(
+                        name=mm_constants.DefaultProfileName.TSDB,
+                        user=parsed_url.username,
+                        password=parsed_url.password,
+                        host=parsed_url.hostname,
+                        port=parsed_url.port,
+                    )
+                )
+
             self.register_datastore_profile(tsdb_profile)
             tsdb_profile_name = tsdb_profile.name
-        else:
-            tsdb_profile_name = None
-        if stream_path == "v3io":
-            stream_profile = mlrun.datastore.datastore_profile.DatastoreProfileV3io(
-                name="mm-infra-stream"
+
+        if stream_path:
+            warnings.warn(
+                "The `stream_path` argument is deprecated and will be removed in MLRun version 1.8.0. "
+                "Use `stream_profile_name` instead.",
+                FutureWarning,
             )
+            if stream_profile_name:
+                raise mlrun.errors.MLRunValueError(
+                    "If you set `stream_profile_name`, you must not pass `stream_path`."
+                )
+            if stream_path == "v3io":
+                stream_profile = mlrun.datastore.datastore_profile.DatastoreProfileV3io(
+                    name=mm_constants.DefaultProfileName.STREAM
+                )
+            else:
+                parsed_stream = urlparse(stream_path)
+                if parsed_stream.scheme != "kafka":
+                    raise mlrun.errors.MLRunValueError(
+                        f"Unsupported `stream_path`: '{stream_path}'."
+                    )
+                stream_profile = (
+                    mlrun.datastore.datastore_profile.DatastoreProfileKafkaSource(
+                        name=mm_constants.DefaultProfileName.STREAM,
+                        brokers=[parsed_stream.netloc],
+                        topics=[],
+                    )
+                )
             self.register_datastore_profile(stream_profile)
             stream_profile_name = stream_profile.name
-        else:
-            stream_profile_name = None
+
         db.set_model_monitoring_credentials(
             project=self.name,
             credentials={
                 "access_key": access_key,
-                "stream_path": stream_path,
-                "tsdb_connection": tsdb_connection,
                 "tsdb_profile_name": tsdb_profile_name,
                 "stream_profile_name": stream_profile_name,
             },
@@ -3644,7 +3761,7 @@ class MlrunProject(ModelObj):
                 "Model monitoring credentials were set successfully. "
                 "Please keep in mind that if you already had model monitoring functions "
                 "/ model monitoring infra / tracked model server "
-                "deployed on your project, you will need to redeploy them."
+                "deployed on your project, you will need to redeploy them. "
                 "For redeploying the model monitoring infra, please use `enable_model_monitoring` API "
                 "and set `rebuild_images=True`"
             )

mlrun/runtimes/nuclio/serving.py

@@ -309,7 +309,7 @@ class ServingRuntime(RemoteRuntime):
         self,
         stream_path: Optional[str] = None,
         batch: Optional[int] = None,
-        sample: Optional[int] = None,
+        sampling_percentage: float = 100,
         stream_args: Optional[dict] = None,
         tracking_policy: Optional[Union["TrackingPolicy", dict]] = None,
         enable_tracking: bool = True,
@@ -317,13 +317,13 @@ class ServingRuntime(RemoteRuntime):
         """Apply on your serving function to monitor a deployed model, including real-time dashboards to detect drift
         and analyze performance.
 
-        :param stream_path:         Path/url of the tracking stream e.g. v3io:///users/mike/mystream
-                                    you can use the "dummy://" path for test/simulation.
-        :param batch:               Micro batch size (send micro batches of N records at a time).
-        :param sample:              Sample size (send only one of N records).
-        :param stream_args:         Stream initialization parameters, e.g. shards, retention_in_hours, ..
-        :param enable_tracking:     Enabled/Disable model-monitoring tracking.
-                                    Default True (tracking enabled).
+        :param stream_path:                Path/url of the tracking stream e.g. v3io:///users/mike/mystream
+                                           you can use the "dummy://" path for test/simulation.
+        :param batch:                      Deprecated. Micro batch size (send micro batches of N records at a time).
+        :param sampling_percentage:        Down sampling events that will be pushed to the monitoring stream based on
+                                           a specified percentage. e.g. 50 for 50%. By default, all events are pushed.
+        :param stream_args:                Stream initialization parameters, e.g. shards, retention_in_hours, ..
+        :param enable_tracking:            Enabled/Disable model-monitoring tracking. Default True (tracking enabled).
 
         Example::
 
@@ -336,12 +336,21 @@ class ServingRuntime(RemoteRuntime):
         # Applying model monitoring configurations
         self.spec.track_models = enable_tracking
 
+        if not 0 < sampling_percentage <= 100:
+            raise mlrun.errors.MLRunInvalidArgumentError(
+                "`sampling_percentage` must be greater than 0 and less or equal to 100."
+            )
+        self.spec.parameters["sampling_percentage"] = sampling_percentage
+
         if stream_path:
             self.spec.parameters["log_stream"] = stream_path
         if batch:
-            self.spec.parameters["log_stream_batch"] = batch
-        if sample:
-            self.spec.parameters["log_stream_sample"] = sample
+            warnings.warn(
+                "The `batch` size parameter was deprecated in version 1.8.0 and is no longer used. "
+                "It will be removed in 1.10.",
+                # TODO: Remove this in 1.10
+                FutureWarning,
+            )
         if stream_args:
             self.spec.parameters["stream_args"] = stream_args
         if tracking_policy is not None:
@@ -679,7 +688,7 @@ class ServingRuntime(RemoteRuntime):
             "project": self.metadata.project,
             "version": "v2",
             "parameters": self.spec.parameters,
-            "graph": self.spec.graph.to_dict() if self.spec.graph else {},
+            "graph": self.spec.graph.to_dict(strip=True) if self.spec.graph else {},
             "load_mode": self.spec.load_mode,
             "functions": function_name_uri_map,
             "graph_initializer": self.spec.graph_initializer,
@@ -747,7 +756,7 @@ class ServingRuntime(RemoteRuntime):
             namespace=namespace,
             logger=logger,
             is_mock=True,
-            monitoring_mock=track_models,
+            monitoring_mock=self.spec.track_models,
         )
 
         if workdir:

mlrun/runtimes/sparkjob/spark3job.py

@@ -789,7 +789,7 @@ class Spark3Runtime(KubejobRuntime):
         Spark itself uses the spec.[executor|driver].cores parameter to set the parallelism of tasks and cores
         assigned to each task within the pod. This function sets the .cores parameters for the job executed.
 
-        See https://github.com/GoogleCloudPlatform/spark-on-k8s-operator/issues/581 for a discussion about those
+        See https://github.com/kubeflow/spark-operator/issues/581 for a discussion about those
         parameters and their meaning in Spark operator.
 
         :param executor_cores: Number of cores to use for executor (spark.executor.cores)

mlrun/secrets.py

@@ -134,7 +134,7 @@ class SecretsStore:
     def k8s_env_variable_name_for_secret(secret_name):
         from mlrun.config import config
 
-        return config.secret_stores.kubernetes.env_variable_prefix + secret_name.upper()
+        return config.secret_stores.kubernetes.env_variable_prefix + secret_name
 
     def get_k8s_secrets(self):
         for source in self._hidden_sources:

mlrun/serving/server.py

@@ -44,6 +44,8 @@ from ..utils import get_caller_globals
 from .states import RootFlowStep, RouterStep, get_function, graph_root_setter
 from .utils import event_id_key, event_path_key
 
+DUMMY_STREAM = "dummy://"
+
 
 class _StreamContext:
     """Handles the stream context for the events stream process. Includes the configuration for the output stream
@@ -72,14 +74,20 @@ class _StreamContext:
                 function_uri, config.default_project
             )
 
-            self.stream_uri = mlrun.model_monitoring.get_stream_path(project=project)
+            stream_args = parameters.get("stream_args", {})
+
+            if log_stream == DUMMY_STREAM:
+                # Dummy stream used for testing, see tests/serving/test_serving.py
+                self.stream_uri = DUMMY_STREAM
+            elif not stream_args.get("mock"):  # if not a mock: `context.is_mock = True`
+                self.stream_uri = mlrun.model_monitoring.get_stream_path(
+                    project=project
+                )
 
             if log_stream:
                 # Update the stream path to the log stream value
                 self.stream_uri = log_stream.format(project=project)
 
-            stream_args = parameters.get("stream_args", {})
-
             self.output_stream = get_stream_pusher(self.stream_uri, **stream_args)
 
 

mlrun/serving/states.py

@@ -31,6 +31,7 @@ import storey.utils
 
 import mlrun
 import mlrun.common.schemas as schemas
+from mlrun.utils import logger
 
 from ..config import config
 from ..datastore import get_stream_pusher
@@ -49,6 +50,8 @@ path_splitter = "/"
 previous_step = "$prev"
 queue_class_names = [">>", "$queue"]
 
+MAX_MODELS_PER_ROUTER = 5000
+
 
 class GraphError(Exception):
     """error in graph topology or configuration"""
@@ -86,8 +89,10 @@ _task_step_fields = [
     "endpoint_type",
 ]
 
-
-MAX_ALLOWED_STEPS = 4500
+_default_fields_to_strip_from_step = [
+    "model_endpoint_creation_strategy",
+    "endpoint_type",
+]
 
 
 def new_remote_endpoint(
@@ -110,6 +115,7 @@ class BaseStep(ModelObj):
     kind = "BaseStep"
     default_shape = "ellipse"
     _dict_fields = ["kind", "comment", "after", "on_error"]
+    _default_fields_to_strip = _default_fields_to_strip_from_step
 
     def __init__(
         self,
@@ -319,6 +325,9 @@ class BaseStep(ModelObj):
         full_event: Optional[bool] = None,
         input_path: Optional[str] = None,
         result_path: Optional[str] = None,
+        model_endpoint_creation_strategy: Optional[
+            schemas.ModelEndpointCreationStrategy
+        ] = None,
         **class_args,
     ):
         """add a step right after this step and return the new step
@@ -346,6 +355,16 @@ class BaseStep(ModelObj):
                             this require that the event body will behave like a dict, example:
                             event: {"x": 5} , result_path="y" means the output of the step will be written
                             to event["y"] resulting in {"x": 5, "y": <result>}
+        :param model_endpoint_creation_strategy: Strategy for creating or updating the model endpoint:
+            * **overwrite**:
+            1. If model endpoints with the same name exist, delete the `latest` one.
+            2. Create a new model endpoint entry and set it as `latest`.
+            * **inplace** (default):
+            1. If model endpoints with the same name exist, update the `latest` entry.
+            2. Otherwise, create a new entry.
+            * **archive**:
+            1. If model endpoints with the same name exist, preserve them.
+            2. Create a new model endpoint with the same name and set it to `latest`.
         :param class_args:  class init arguments
         """
         if hasattr(self, "steps"):
@@ -367,6 +386,7 @@ class BaseStep(ModelObj):
             input_path=input_path,
             result_path=result_path,
             class_args=class_args,
+            model_endpoint_creation_strategy=model_endpoint_creation_strategy,
         )
         step = parent._steps.update(name, step)
         step.set_parent(parent)
@@ -625,6 +645,19 @@ class TaskStep(BaseStep):
                 raise exc
         return event
 
+    def to_dict(
+        self,
+        fields: Optional[list] = None,
+        exclude: Optional[list] = None,
+        strip: bool = False,
+    ) -> dict:
+        self.endpoint_type = (
+            self.endpoint_type.value
+            if isinstance(self.endpoint_type, schemas.EndpointType)
+            else self.endpoint_type
+        )
+        return super().to_dict(fields, exclude, strip)
+
 
 class MonitoringApplicationStep(TaskStep):
     """monitoring application execution step, runs users class code"""
@@ -755,7 +788,7 @@ class RouterStep(TaskStep):
         creation_strategy: schemas.ModelEndpointCreationStrategy = schemas.ModelEndpointCreationStrategy.INPLACE,
         **class_args,
     ):
-        """add child route step or class to the router
+        """add child route step or class to the router, if key exists it will be updated
 
         :param key:        unique name (and route path) for the child step
         :param route:      child step object (Task, ..)
@@ -775,7 +808,13 @@ class RouterStep(TaskStep):
             2. Create a new model endpoint with the same name and set it to `latest`.
 
         """
-
+        if len(self.routes.keys()) >= MAX_MODELS_PER_ROUTER and key not in self.routes:
+            raise mlrun.errors.MLRunModelLimitExceededError(
+                f"Router cannot support more than {MAX_MODELS_PER_ROUTER} model endpoints. "
+                f"To add a new route, edit an existing one by passing the same key."
+            )
+        if key in self.routes:
+            logger.info(f"Model {key} already exists, updating it.")
         if not route and not class_name and not handler:
             raise MLRunInvalidArgumentError("route or class_name must be specified")
         if not route:
@@ -790,10 +829,6 @@ class RouterStep(TaskStep):
             )
         route.function = function or route.function
 
-        if len(self._routes) >= MAX_ALLOWED_STEPS:
-            raise mlrun.errors.MLRunInvalidArgumentError(
-                f"Cannot create the serving graph: the maximum number of steps is {MAX_ALLOWED_STEPS}"
-            )
         route = self._routes.update(key, route)
         route.set_parent(self)
         return route
@@ -806,6 +841,10 @@ class RouterStep(TaskStep):
             del self._routes[key]
 
     def init_object(self, context, namespace, mode="sync", reset=False, **extra_kwargs):
+        if not self.routes:
+            raise mlrun.errors.MLRunRuntimeError(
+                "You have to add models to the router step before initializing it"
+            )
         if not self._is_local_function(context):
             return
 
@@ -1010,6 +1049,9 @@ class QueueStep(BaseStep):
         full_event: Optional[bool] = None,
         input_path: Optional[str] = None,
         result_path: Optional[str] = None,
+        model_endpoint_creation_strategy: Optional[
+            schemas.ModelEndpointCreationStrategy
+        ] = None,
         **class_args,
     ):
         if not function:
@@ -1026,6 +1068,7 @@ class QueueStep(BaseStep):
             full_event,
             input_path,
             result_path,
+            model_endpoint_creation_strategy,
             **class_args,
         )
 
@@ -1104,6 +1147,9 @@ class FlowStep(BaseStep):
         full_event: Optional[bool] = None,
         input_path: Optional[str] = None,
         result_path: Optional[str] = None,
+        model_endpoint_creation_strategy: Optional[
+            schemas.ModelEndpointCreationStrategy
+        ] = None,
         **class_args,
     ):
         """add task, queue or router step/class to the flow
@@ -1135,6 +1181,16 @@ class FlowStep(BaseStep):
                             this require that the event body will behave like a dict, example:
                             event: {"x": 5} , result_path="y" means the output of the step will be written
                             to event["y"] resulting in {"x": 5, "y": <result>}
+        :param model_endpoint_creation_strategy: Strategy for creating or updating the model endpoint:
+            * **overwrite**:
+            1. If model endpoints with the same name exist, delete the `latest` one.
+            2. Create a new model endpoint entry and set it as `latest`.
+            * **inplace** (default):
+            1. If model endpoints with the same name exist, update the `latest` entry.
+            2. Otherwise, create a new entry.
+            * **archive**:
+            1. If model endpoints with the same name exist, preserve them.
+            2. Create a new model endpoint with the same name and set it to `latest`.
         :param class_args:  class init arguments
         """
 
@@ -1147,6 +1203,7 @@ class FlowStep(BaseStep):
             full_event=full_event,
             input_path=input_path,
             result_path=result_path,
+            model_endpoint_creation_strategy=model_endpoint_creation_strategy,
             class_args=class_args,
         )