mlrun 1.8.0rc9__py3-none-any.whl → 1.8.0rc12__py3-none-any.whl

mlrun/artifacts/__init__.py

@@ -13,7 +13,7 @@
 # limitations under the License.
 
 # Don't remove this, used by sphinx documentation
-__all__ = ["get_model", "update_model"]
+__all__ = ["get_model", "update_model", "DocumentLoaderSpec", "MLRunLoader"]
 
 from .base import (
     Artifact,

mlrun/artifacts/document.py

@@ -39,8 +39,6 @@ class DocumentLoaderSpec(ModelObj):
         src_name (str): The name of the source attribute to pass to the loader class.
         kwargs (Optional[dict]): Additional keyword arguments to pass to the loader class.
 
-    Methods:
-        make_loader(src_path): Creates an instance of the loader class with the specified source path.
     """
 
     _dict_fields = ["loader_class_name", "src_name", "kwargs"]
@@ -58,6 +56,19 @@ class DocumentLoaderSpec(ModelObj):
             loader_class_name (str): The name of the loader class to use.
             src_name (str): The source name for the document.
             kwargs (Optional[dict]): Additional keyword arguments to pass to the loader class.
+
+        Example:
+            >>> # Create a loader specification for PDF documents
+            >>> loader_spec = DocumentLoaderSpec(
+            ...     loader_class_name="langchain_community.document_loaders.PDFLoader",
+            ...     src_name="file_path",
+            ...     kwargs={"extract_images": True},
+            ... )
+            >>> # Create a loader instance for a specific PDF file
+            >>> pdf_loader = loader_spec.make_loader("/path/to/document.pdf")
+            >>> # Load the documents
+            >>> documents = pdf_loader.load()
+
         """
         self.loader_class_name = loader_class_name
         self.src_name = src_name
@@ -87,6 +98,45 @@ class MLRunLoader:
 
     Returns:
         DynamicDocumentLoader: An instance of a dynamically defined subclass of BaseLoader.
+
+    Example:
+        >>> # Create a document loader specification
+        >>> loader_spec = DocumentLoaderSpec(
+        ...     loader_class_name="langchain_community.document_loaders.TextLoader",
+        ...     src_name="file_path",
+        ... )
+        >>> # Create a basic loader for a single file
+        >>> loader = MLRunLoader(
+        ...     source_path="/path/to/document.txt",
+        ...     loader_spec=loader_spec,
+        ...     artifact_key="my_doc",
+        ...     producer=project,
+        ...     upload=True,
+        ... )
+        >>> documents = loader.load()
+        >>> # Create a loader with auto-generated keys
+        >>> loader = MLRunLoader(
+        ...     source_path="/path/to/document.txt",
+        ...     loader_spec=loader_spec,
+        ...     artifact_key="doc%%",  # %% will be replaced with encoded path
+        ...     producer=project,
+        ... )
+        >>> documents = loader.load()
+        >>> # Use with DirectoryLoader
+        >>> from langchain_community.document_loaders import DirectoryLoader
+        >>> dir_loader = DirectoryLoader(
+        ...     "/path/to/directory",
+        ...     glob="**/*.txt",
+        ...     loader_cls=MLRunLoader,
+        ...     loader_kwargs={
+        ...         "loader_spec": loader_spec,
+        ...         "artifact_key": "doc%%",
+        ...         "producer": project,
+        ...         "upload": True,
+        ...     },
+        ... )
+        >>> documents = dir_loader.load()
+
     """
 
     def __new__(
@@ -178,11 +228,6 @@ class MLRunLoader:
 class DocumentArtifact(Artifact):
     """
     A specific artifact class inheriting from generic artifact, used to maintain Document meta-data.
-
-    Methods:
-        to_langchain_documents(splitter): Create LC documents from the artifact.
-        collection_add(collection_id): Add a collection ID to the artifact.
-        collection_remove(collection_id): Remove a collection ID from the artifact.
     """
 
     class DocumentArtifactSpec(ArtifactSpec):
@@ -205,10 +250,6 @@ class DocumentArtifact(Artifact):
             self.collections = collections if collections is not None else {}
             self.original_source = original_source
 
-    """
-    A specific artifact class inheriting from generic artifact, used to maintain Document meta-data.
-    """
-
     kind = "document"
 
     METADATA_SOURCE_KEY = "source"
@@ -242,6 +283,7 @@ class DocumentArtifact(Artifact):
         )
 
     def get_source(self):
+        """Get the source URI for this artifact."""
         return generate_artifact_uri(self.metadata.project, self.spec.db_key)
 
     def to_langchain_documents(

mlrun/common/constants.py

@@ -25,6 +25,7 @@ MYSQL_MEDIUMBLOB_SIZE_BYTES = 16 * 1024 * 1024
 MLRUN_LABEL_PREFIX = "mlrun/"
 DASK_LABEL_PREFIX = "dask.org/"
 NUCLIO_LABEL_PREFIX = "nuclio.io/"
+RESERVED_TAG_NAME_LATEST = "latest"
 
 
 class MLRunInternalLabels:

mlrun/common/schemas/__init__.py

@@ -146,8 +146,10 @@ from .model_monitoring import (
     GrafanaTable,
     GrafanaTimeSeriesTarget,
     ModelEndpoint,
+    ModelEndpointCreationStrategy,
     ModelEndpointList,
     ModelEndpointMetadata,
+    ModelEndpointSchema,
     ModelEndpointSpec,
     ModelEndpointStatus,
     ModelMonitoringMode,

mlrun/common/schemas/model_monitoring/__init__.py

@@ -26,6 +26,7 @@ from .constants import (
     FileTargetKind,
     FunctionURI,
     MetricData,
+    ModelEndpointCreationStrategy,
     ModelEndpointMonitoringMetricType,
     ModelEndpointSchema,
     ModelEndpointTarget,

mlrun/common/schemas/model_monitoring/constants.py

@@ -44,6 +44,7 @@ class ModelEndpointSchema(MonitoringStrEnum):
     FUNCTION_TAG = "function_tag"
     FUNCTION_UID = "function_uid"
     MODEL_NAME = "model_name"
+    MODEL_DB_KEY = "model_db_key"
     MODEL_TAG = "model_tag"
     MODEL_CLASS = "model_class"
     MODEL_UID = "model_uid"
@@ -70,6 +71,12 @@ class ModelEndpointSchema(MonitoringStrEnum):
     DRIFT_MEASURES = "drift_measures"
 
 
+class ModelEndpointCreationStrategy(MonitoringStrEnum):
+    INPLACE = "inplace"
+    ARCHIVE = "archive"
+    OVERWRITE = "overwrite"
+
+
 class EventFieldType:
     FUNCTION_URI = "function_uri"
     FUNCTION = "function"

mlrun/common/schemas/model_monitoring/model_endpoints.py

@@ -117,10 +117,15 @@ class ModelEndpointMetadata(ObjectMetadata, ModelEndpointParser):
     endpoint_type: EndpointType = EndpointType.NODE_EP
     uid: Optional[constr(regex=MODEL_ENDPOINT_ID_PATTERN)]
 
+    @classmethod
+    def mutable_fields(cls):
+        return ["labels"]
+
 
 class ModelEndpointSpec(ObjectSpec, ModelEndpointParser):
     model_uid: Optional[str] = ""
     model_name: Optional[str] = ""
+    model_db_key: Optional[str] = ""
     model_tag: Optional[str] = ""
     model_class: Optional[str] = ""
     function_name: Optional[str] = ""
@@ -135,6 +140,21 @@ class ModelEndpointSpec(ObjectSpec, ModelEndpointParser):
     children_uids: Optional[list[str]] = []
     monitoring_feature_set_uri: Optional[str] = ""
 
+    @classmethod
+    def mutable_fields(cls):
+        return [
+            "model_uid",
+            "model_name",
+            "model_db_key",
+            "model_tag",
+            "model_class",
+            "function_uid",
+            "feature_names",
+            "label_names",
+            "children",
+            "children_uids",
+        ]
+
 
 class ModelEndpointStatus(ObjectStatus, ModelEndpointParser):
     state: Optional[str] = "unknown"  # will be updated according to the function state
@@ -151,6 +171,14 @@ class ModelEndpointStatus(ObjectStatus, ModelEndpointParser):
     drift_measures: Optional[dict] = {}
     drift_measures_timestamp: Optional[datetime] = None
 
+    @classmethod
+    def mutable_fields(cls):
+        return [
+            "monitoring_mode",
+            "first_request",
+            "last_request",
+        ]
+
 
 class ModelEndpoint(BaseModel):
     kind: ObjectKind = Field(ObjectKind.model_endpoint, const=True)
@@ -158,6 +186,14 @@ class ModelEndpoint(BaseModel):
     spec: ModelEndpointSpec
     status: ModelEndpointStatus
 
+    @classmethod
+    def mutable_fields(cls):
+        return (
+            ModelEndpointMetadata.mutable_fields()
+            + ModelEndpointSpec.mutable_fields()
+            + ModelEndpointStatus.mutable_fields()
+        )
+
     def flat_dict(self) -> dict[str, Any]:
         """Generate a flattened `ModelEndpoint` dictionary. The flattened dictionary result is important for storing
         the model endpoint object in the database.

mlrun/config.py

@@ -160,6 +160,7 @@ default_config = {
         # migration from artifacts to artifacts_v2 is done in batches, and requires a state file to keep track of the
         # migration progress.
         "artifact_migration_batch_size": 200,
+        "artifact_migration_v9_batch_size": 30000,
         "artifact_migration_state_file_path": "./db/_artifact_migration_state.json",
         "datasets": {
             "max_preview_columns": 100,

mlrun/data_types/data_types.py

@@ -124,6 +124,7 @@ def spark_to_value_type(data_type):
         "double": ValueType.DOUBLE,
         "boolean": ValueType.BOOL,
         "timestamp": ValueType.DATETIME,
+        "timestamp_ntz": ValueType.DATETIME,
         "string": ValueType.STRING,
         "array": "list",
         "map": "dict",

mlrun/data_types/spark.py

@@ -19,7 +19,7 @@ from typing import Optional
 import numpy as np
 import pytz
 from pyspark.sql.functions import to_utc_timestamp
-from pyspark.sql.types import BooleanType, DoubleType, TimestampType
+from pyspark.sql.types import BooleanType, DoubleType
 
 from mlrun.feature_store.retrieval.spark_merger import spark_df_to_pandas
 from mlrun.utils import logger
@@ -144,7 +144,8 @@ def get_df_stats_spark(df, options, num_bins=20, sample_size=None):
     timestamp_columns = set()
     boolean_columns = set()
     for field in df_after_type_casts.schema.fields:
-        is_timestamp = isinstance(field.dataType, TimestampType)
+        # covers TimestampType and TimestampNTZType, which was added in PySpark 3.4.0
+        is_timestamp = field.dataType.typeName().startswith("timestamp")
         is_boolean = isinstance(field.dataType, BooleanType)
         if is_timestamp:
             df_after_type_casts = df_after_type_casts.withColumn(

mlrun/data_types/to_pandas.py

@@ -244,6 +244,15 @@ def _to_corrected_pandas_type(dt):
 
 
 def spark_df_to_pandas(spark_df):
+    import pyspark
+
+    if semver.parse(pyspark.__version__) >= semver.Version(3, 5, 0):
+
+        def to_pandas(spark_df_inner):
+            return spark_df_inner.toPandas()
+    else:
+        to_pandas = _to_pandas
+
     # as of pyspark 3.2.3, toPandas fails to convert timestamps unless we work around the issue
     # when we upgrade pyspark, we should check whether this workaround is still necessary
     # see https://stackoverflow.com/questions/76389694/transforming-pyspark-to-pandas-dataframe
@@ -262,9 +271,9 @@ def spark_df_to_pandas(spark_df):
                 )
                 type_conversion_dict[field.name] = "datetime64[ns]"
 
-        df = _to_pandas(spark_df)
+        df = to_pandas(spark_df)
         if type_conversion_dict:
             df = df.astype(type_conversion_dict)
         return df
     else:
-        return _to_pandas(spark_df)
+        return to_pandas(spark_df)

mlrun/datastore/__init__.py

@@ -30,6 +30,8 @@ __all__ = [
     "DatabricksFileSystemDisableCache",
     "DatabricksFileBugFixed",
     "get_stream_pusher",
+    "ConfigProfile",
+    "VectorStoreCollection",
 ]
 
 import fsspec

mlrun/datastore/targets.py

@@ -1136,7 +1136,8 @@ class CSVTarget(BaseStoreTarget):
         import pyspark.sql.functions as funcs
 
         for col_name, col_type in df.dtypes:
-            if col_type == "timestamp":
+            # covers TimestampType and TimestampNTZType, which was added in PySpark 3.4.0
+            if col_type.startswith("timestamp"):
                 # df.write.csv saves timestamps with millisecond precision, but we want microsecond precision
                 # for compatibility with storey.
                 df = df.withColumn(

mlrun/datastore/vectorstore.py

@@ -123,23 +123,29 @@ class VectorStoreCollection:
         Converts artifacts to LangChain documents, adds them to the vector store, and
         updates the MLRun context. If documents are split, the IDs are handled appropriately.
 
-        Args:
-            artifacts (list[DocumentArtifact]): List of DocumentArtifact objects to add
-            splitter (optional): Document splitter to break artifacts into smaller chunks.
-                If None, each artifact becomes a single document.
-            **kwargs: Additional arguments passed to the underlying add_documents method.
-                Special handling for 'ids' kwarg:
-                - If provided and document is split, IDs are generated as "{original_id}_{i}"
-                    where i starts from 1 (e.g., "doc1_1", "doc1_2", etc.)
-                - If provided and document isn't split, original IDs are used as-is
+        :param artifacts: List of DocumentArtifact objects to add
+        :type artifacts: list[DocumentArtifact]
+        :param splitter: Document splitter to break artifacts into smaller chunks.
+                        If None, each artifact becomes a single document.
+        :type splitter: TextSplitter, optional
+        :param kwargs: Additional arguments passed to the underlying add_documents method.
+                    Special handling for 'ids' kwarg:
+
+                    * If provided and document is split, IDs are generated as "{original_id}_{i}"
+                        where i starts from 1 (e.g., "doc1_1", "doc1_2", etc.)
+                    * If provided and document isn't split, original IDs are used as-is
+
+        :return: List of IDs for all added documents. When no custom IDs are provided:
+
+                * Without splitting: Vector store generates IDs automatically
+                * With splitting: Vector store generates separate IDs for each chunk
 
-        Returns:
-            list: List of IDs for all added documents. When no custom IDs are provided:
-                - Without splitting: Vector store generates IDs automatically
-                - With splitting: Vector store generates separate IDs for each chunk
                 When custom IDs are provided:
-                - Without splitting: Uses provided IDs directly
-                - With splitting: Generates sequential IDs as "{original_id}_{i}" for each chunk
+
+                * Without splitting: Uses provided IDs directly
+                * With splitting: Generates sequential IDs as "{original_id}_{i}" for each chunk
+        :rtype: list
+
         """
         all_ids = []
         user_ids = kwargs.pop("ids", None)

mlrun/db/base.py

@@ -666,6 +666,7 @@ class RunDBInterface(ABC):
     def create_model_endpoint(
         self,
         model_endpoint: mlrun.common.schemas.ModelEndpoint,
+        creation_strategy: mlrun.common.schemas.ModelEndpointCreationStrategy = "inplace",
     ) -> mlrun.common.schemas.ModelEndpoint:
         pass
 
@@ -688,6 +689,7 @@ class RunDBInterface(ABC):
         function_name: Optional[str] = None,
         function_tag: Optional[str] = None,
         model_name: Optional[str] = None,
+        model_tag: Optional[str] = None,
         labels: Optional[Union[str, dict[str, Optional[str]], list[str]]] = None,
         start: Optional[datetime.datetime] = None,
         end: Optional[datetime.datetime] = None,

mlrun/db/httpdb.py

@@ -3582,11 +3582,17 @@ class HTTPRunDB(RunDBInterface):
     def create_model_endpoint(
         self,
         model_endpoint: mlrun.common.schemas.ModelEndpoint,
+        creation_strategy: mlrun.common.schemas.ModelEndpointCreationStrategy = "inplace",
     ) -> mlrun.common.schemas.ModelEndpoint:
         """
         Creates a DB record with the given model_endpoint record.
 
         :param model_endpoint: An object representing the model endpoint.
+        :param creation_strategy: model endpoint creation strategy :
+                            * overwrite - Create a new model endpoint and delete the last old one if it exists.
+                            * inplace - Use the existing model endpoint if it already exists (default).
+                            * archive - Preserve the old model endpoint and create a new one,
+                            tagging it as the latest.
 
         :return: The created model endpoint object.
         """
@@ -3596,6 +3602,9 @@ class HTTPRunDB(RunDBInterface):
             method=mlrun.common.types.HTTPMethod.POST,
             path=path,
             body=model_endpoint.json(),
+            params={
+                "creation_strategy": creation_strategy,
+            },
         )
         return mlrun.common.schemas.ModelEndpoint(**response.json())
 
@@ -3637,6 +3646,7 @@ class HTTPRunDB(RunDBInterface):
         function_name: Optional[str] = None,
         function_tag: Optional[str] = None,
         model_name: Optional[str] = None,
+        model_tag: Optional[str] = None,
         labels: Optional[Union[str, dict[str, Optional[str]], list[str]]] = None,
         start: Optional[datetime] = None,
         end: Optional[datetime] = None,
@@ -3653,6 +3663,7 @@ class HTTPRunDB(RunDBInterface):
         :param function_name:   The name of the function
         :param function_tag:    The tag of the function
         :param model_name:      The name of the model
+        :param model_tag:       The tag of the model
         :param labels:          A list of labels to filter by. (see mlrun.common.schemas.LabelsModel)
         :param start:           The start time to filter by.Corresponding to the `created` field.
         :param end:             The end time to filter by. Corresponding to the `created` field.
@@ -3671,6 +3682,7 @@ class HTTPRunDB(RunDBInterface):
             params={
                 "name": name,
                 "model_name": model_name,
+                "model_tag": model_tag,
                 "function_name": function_name,
                 "function_tag": function_tag,
                 "label": labels,

mlrun/db/nopdb.py

@@ -575,6 +575,7 @@ class NopDB(RunDBInterface):
     def create_model_endpoint(
         self,
         model_endpoint: mlrun.common.schemas.ModelEndpoint,
+        creation_strategy: mlrun.common.schemas.ModelEndpointCreationStrategy = "inplace",
     ) -> mlrun.common.schemas.ModelEndpoint:
         pass
 
@@ -595,6 +596,7 @@ class NopDB(RunDBInterface):
         function_name: Optional[str] = None,
         function_tag: Optional[str] = None,
         model_name: Optional[str] = None,
+        model_tag: Optional[str] = None,
         labels: Optional[Union[str, dict[str, Optional[str]], list[str]]] = None,
         start: Optional[datetime.datetime] = None,
         end: Optional[datetime.datetime] = None,

mlrun/feature_store/steps.py

@@ -671,7 +671,7 @@ class SetEventMetadata(MapClass):
 
         self._tagging_funcs = []
 
-    def post_init(self, mode="sync"):
+    def post_init(self, mode="sync", **kwargs):
         def add_metadata(name, path, operator=str):
             def _add_meta(event):
                 value = get_in(event.body, path)

mlrun/model_monitoring/api.py

@@ -54,9 +54,10 @@ def get_or_create_model_endpoint(
     model_endpoint_name: str = "",
     endpoint_id: str = "",
     function_name: str = "",
+    function_tag: str = "latest",
     context: typing.Optional["mlrun.MLClientCtx"] = None,
     sample_set_statistics: typing.Optional[dict[str, typing.Any]] = None,
-    monitoring_mode: mm_constants.ModelMonitoringMode = mm_constants.ModelMonitoringMode.disabled,
+    monitoring_mode: mm_constants.ModelMonitoringMode = mm_constants.ModelMonitoringMode.enabled,
     db_session=None,
 ) -> ModelEndpoint:
     """
@@ -70,8 +71,8 @@ def get_or_create_model_endpoint(
                                      under this endpoint (applicable only to new endpoint_id).
     :param endpoint_id:              Model endpoint unique ID. If not exist in DB, will generate a new record based
                                      on the provided `endpoint_id`.
-    :param function_name:            If a new model endpoint is created, use this function name for generating the
-                                     function URI (applicable only to new endpoint_id).
+    :param function_name:            If a new model endpoint is created, use this function name.
+    :param function_tag:             If a new model endpoint is created, use this function tag.
     :param context:                  MLRun context. If `function_name` not provided, use the context to generate the
                                      full function hash.
     :param sample_set_statistics:    Dictionary of sample set statistics that will be used as a reference data for
@@ -86,28 +87,32 @@ def get_or_create_model_endpoint(
     if not db_session:
         # Generate a runtime database
         db_session = mlrun.get_run_db()
+    model_endpoint = None
     try:
-        model_endpoint = db_session.get_model_endpoint(
-            project=project,
-            name=model_endpoint_name,
-            endpoint_id=endpoint_id,
-            function_name=function_name,
-        )
-        # If other fields provided, validate that they are correspond to the existing model endpoint data
-        _model_endpoint_validations(
-            model_endpoint=model_endpoint,
-            model_path=model_path,
-            sample_set_statistics=sample_set_statistics,
-        )
+        if endpoint_id:
+            model_endpoint = db_session.get_model_endpoint(
+                project=project,
+                name=model_endpoint_name,
+                endpoint_id=endpoint_id,
+            )
+            # If other fields provided, validate that they are correspond to the existing model endpoint data
+            _model_endpoint_validations(
+                model_endpoint=model_endpoint,
+                model_path=model_path,
+                sample_set_statistics=sample_set_statistics,
+            )
 
     except mlrun.errors.MLRunNotFoundError:
         # Create a new model endpoint with the provided details
+        pass
+    if not model_endpoint:
         model_endpoint = _generate_model_endpoint(
             project=project,
             db_session=db_session,
             model_path=model_path,
             model_endpoint_name=model_endpoint_name,
             function_name=function_name,
+            function_tag=function_tag,
             context=context,
             sample_set_statistics=sample_set_statistics,
             monitoring_mode=monitoring_mode,
@@ -333,9 +338,10 @@ def _generate_model_endpoint(
     model_path: str,
     model_endpoint_name: str,
     function_name: str,
+    function_tag: str,
     context: "mlrun.MLClientCtx",
     sample_set_statistics: dict[str, typing.Any],
-    monitoring_mode: mm_constants.ModelMonitoringMode = mm_constants.ModelMonitoringMode.disabled,
+    monitoring_mode: mm_constants.ModelMonitoringMode = mm_constants.ModelMonitoringMode.enabled,
 ) -> ModelEndpoint:
     """
     Write a new model endpoint record.
@@ -345,8 +351,8 @@ def _generate_model_endpoint(
     :param db_session:               A session that manages the current dialog with the database.
     :param model_path:               The model Store path.
     :param model_endpoint_name:      Model endpoint name will be presented under the new model endpoint.
-    :param function_name:            If a new model endpoint is created, use this function name for generating the
-                                     function URI.
+    :param function_name:            If a new model endpoint is created, use this function name.
+    :param function_tag:             If a new model endpoint is created, use this function tag.
     :param context:                  MLRun context. If function_name not provided, use the context to generate the
                                      full function hash.
     :param sample_set_statistics:    Dictionary of sample set statistics that will be used as a reference data for
@@ -374,9 +380,12 @@ def _generate_model_endpoint(
             endpoint_type=mlrun.common.schemas.model_monitoring.EndpointType.BATCH_EP,
         ),
         spec=mlrun.common.schemas.ModelEndpointSpec(
-            function_name=function_name,
-            model_name=model_obj.metadata.key if model_path else None,
-            model_uid=model_obj.metadata.uid if model_path else None,
+            function_name=function_name or "function",
+            function_tag=function_tag or "latest",
+            model_name=model_obj.metadata.key if model_obj else None,
+            model_uid=model_obj.metadata.uid if model_obj else None,
+            model_tag=model_obj.metadata.tag if model_obj else None,
+            model_db_key=model_obj.spec.db_key if model_obj else None,
             model_class="drift-analysis",
         ),
         status=mlrun.common.schemas.ModelEndpointStatus(

mlrun/model_monitoring/applications/base.py

@@ -148,6 +148,44 @@ class ModelMonitoringApplicationBase(MonitoringApplicationToDict, ABC):
             )
         return start, end
 
+    @classmethod
+    def deploy(
+        cls,
+        func_name: str,
+        func_path: Optional[str] = None,
+        image: Optional[str] = None,
+        handler: Optional[str] = None,
+        with_repo: Optional[bool] = False,
+        tag: Optional[str] = None,
+        requirements: Optional[Union[str, list[str]]] = None,
+        requirements_file: str = "",
+        **application_kwargs,
+    ) -> None:
+        """
+        Set the application to the current project and deploy it as a Nuclio serving function.
+        Required for your model monitoring application to work as a part of the model monitoring framework.
+
+        :param func_name: The name of the function.
+        :param func_path: The path of the function, :code:`None` refers to the current Jupyter notebook.
+
+        For the other arguments, refer to
+        :py:meth:`~mlrun.projects.MlrunProject.set_model_monitoring_function`.
+        """
+        project = cast("mlrun.MlrunProject", mlrun.get_current_project())
+        function = project.set_model_monitoring_function(
+            name=func_name,
+            func=func_path,
+            application_class=cls.__name__,
+            handler=handler,
+            image=image,
+            with_repo=with_repo,
+            requirements=requirements,
+            requirements_file=requirements_file,
+            tag=tag,
+            **application_kwargs,
+        )
+        function.deploy()
+
     @classmethod
     def evaluate(
         cls,
@@ -175,10 +213,10 @@ class ModelMonitoringApplicationBase(MonitoringApplicationToDict, ABC):
         :param func_name: The name of the function. If not passed, the class name is used.
         :param tag:       An optional tag for the function.
         :param run_local: Whether to run the function locally or remotely.
-        :param sample_df: Optional - pandas data-frame as the current dataset.
-                          When set, it replaces the data read from the model endpoint's offline source.
-        :param feature_stats: Optional - statistics dictionary of the reference data.
-                              When set, it overrides the model endpoint's feature stats.
+        :param sample_data:       Optional - pandas data-frame as the current dataset.
+                                  When set, it replaces the data read from the model endpoint's offline source.
+        :param reference_data:    Optional - pandas data-frame of the reference dataset.
+                                  When set, its statistics override the model endpoint's feature statistics.
         :param image:             Docker image to run the job on.
         :param with_repo:         Whether to clone the current repo to the build source.
         :param requirements:      List of Python requirements to be installed in the image.