mlrun 1.8.0rc8__py3-none-any.whl → 1.8.0rc11__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/base.py

@@ -379,6 +379,7 @@ class Artifact(ModelObj):
             iter=self.metadata.iter,
             tree=tree,
             tag=tag,
+            uid=self.uid,
         )
         return mlrun.datastore.get_store_uri(self._store_prefix, uri)
 
@@ -653,6 +654,14 @@ class Artifact(ModelObj):
     def hash(self, hash):
         self.metadata.hash = hash
 
+    @property
+    def uid(self):
+        return self.metadata.uid
+
+    @uid.setter
+    def uid(self, uid):
+        self.metadata.uid = uid
+
     def generate_target_path(self, artifact_path, producer):
         return generate_target_path(self, artifact_path, producer)
 

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(
@@ -277,6 +319,7 @@ class DocumentArtifact(Artifact):
             )
 
         results = []
+        idx = 0
         for document in documents:
             if splitter:
                 texts = splitter.split_text(document.page_content)
@@ -293,13 +336,14 @@ class DocumentArtifact(Artifact):
                     self.get_target_path()
                 )
 
-            for idx, text in enumerate(texts):
+            for text in texts:
                 metadata[self.METADATA_CHUNK_KEY] = str(idx)
                 doc = Document(
                     page_content=text,
                     metadata=metadata.copy(),
                 )
                 results.append(doc)
+                idx = idx + 1
         return results
 
     def collection_add(self, collection_id: str) -> None:

mlrun/artifacts/manager.py

@@ -306,7 +306,6 @@ class ArtifactManager:
         item.target_path = target_path
 
         item.before_log()
-        self.artifact_uris[key] = item.uri
 
         if ((upload is None and item.kind != "dir") or upload) and not item.is_inline():
             # before uploading the item, we want to ensure that its tags are valid,
@@ -315,7 +314,12 @@ class ArtifactManager:
             item.upload(artifact_path=artifact_path)
 
         if db_key:
-            self._log_to_db(db_key, project, producer.inputs, item)
+            artifact_uid = self._log_to_db(db_key, project, producer.inputs, item)
+            if artifact_uid is not None:
+                item.uid = artifact_uid
+        # Generate the artifact URI after logging to the database and retrieving the artifact UID, if available.
+        self.artifact_uris[key] = item.uri
+
         size = str(item.size) or "?"
         db_str = "Y" if (self.artifact_db and db_key) else "N"
         logger.debug(
@@ -327,20 +331,21 @@ class ArtifactManager:
         self.artifact_uris[item.key] = item.uri
         self._log_to_db(item.db_key, producer.project, producer.inputs, item)
 
-    def _log_to_db(self, key, project, sources, item, tag=None):
+    def _log_to_db(self, key, project, sources, item, tag=None) -> typing.Optional[str]:
         """
         log artifact to db
         :param key: Identifying key of the artifact.
         :param project: Project that the artifact belongs to.
-        :param sources: List of artifact sources ( Mainly passed from the producer.items ).
+        :param sources: List of artifact sources ( Mainly passed from the `producer.items` ).
         :param item: The actual artifact to store.
         :param tag: The name of the Tag of the artifact.
+        :return: The logged artifact uid.
         """
         if self.artifact_db:
             item.updated = None
             if sources:
                 item.sources = [{"name": k, "path": str(v)} for k, v in sources.items()]
-            self.artifact_db.store_artifact(
+            artifact_item = self.artifact_db.store_artifact(
                 key,
                 item.to_dict(),
                 iter=item.iter,
@@ -348,6 +353,8 @@ class ArtifactManager:
                 project=project,
                 tree=item.tree,
             )
+            if artifact_item:
+                return artifact_item.get("metadata", {}).get("uid")
 
     def link_artifact(
         self,

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/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"

mlrun/common/schemas/model_monitoring/model_endpoints.py

@@ -121,6 +121,7 @@ class ModelEndpointMetadata(ObjectMetadata, ModelEndpointParser):
 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] = ""

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/store_resources.py

@@ -163,11 +163,16 @@ def get_store_resource(
         return db.get_feature_vector(name, project, tag, uid)
 
     elif StorePrefix.is_artifact(kind):
-        project, key, iteration, tag, tree = parse_artifact_uri(
+        project, key, iteration, tag, tree, uid = parse_artifact_uri(
             uri, project or config.default_project
         )
         resource = db.read_artifact(
-            key, project=project, tag=tag, iter=iteration, tree=tree
+            key,
+            project=project,
+            tag=tag,
+            iter=iteration,
+            tree=tree,
+            uid=uid,
         )
         if resource.get("kind", "") == "link":
             # todo: support other link types (not just iter, move this to the db/api layer

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

@@ -14,11 +14,32 @@
 
 import inspect
 from collections.abc import Iterable
-from typing import Union
+from typing import Optional, Union
 
 from mlrun.artifacts import DocumentArtifact
 
 
+def _extract_collection_name(vectorstore: "VectorStore") -> str:  # noqa: F821
+    # List of possible attribute names for collection name
+    possible_attributes = ["collection_name", "_collection_name"]
+
+    for attr in possible_attributes:
+        if hasattr(vectorstore, attr):
+            collection_name = getattr(vectorstore, attr)
+            if collection_name:
+                return collection_name
+
+    store_class = vectorstore.__class__.__name__.lower()
+    if store_class == "mongodbatlasvectorsearch":
+        return vectorstore.collection.name
+
+    # If we get here, we couldn't find a valid collection name
+    raise ValueError(
+        "Failed to extract collection name from the vector store. "
+        "Please provide the collection name explicitly. "
+    )
+
+
 class VectorStoreCollection:
     """
     A wrapper class for vector store collections with MLRun integration.
@@ -36,12 +57,17 @@ class VectorStoreCollection:
     def __init__(
         self,
         mlrun_context: Union["MlrunProject", "MLClientCtx"],  # noqa: F821
-        collection_name: str,
         vector_store: "VectorStore",  # noqa: F821
+        collection_name: Optional[str] = None,
     ):
         self._collection_impl = vector_store
         self._mlrun_context = mlrun_context
-        self.collection_name = collection_name
+        self.collection_name = collection_name or _extract_collection_name(vector_store)
+
+    @property
+    def __class__(self):
+        # Make isinstance() check the wrapped object's class
+        return self._collection_impl.__class__
 
     def __getattr__(self, name):
         # This method is called when an attribute is not found in the usual places
@@ -56,6 +82,9 @@ class VectorStoreCollection:
             # Forward the attribute setting to _collection_impl
             setattr(self._collection_impl, name, value)
 
+    def delete(self, *args, **kwargs):
+        self._collection_impl.delete(*args, **kwargs)
+
     def add_documents(
         self,
         documents: list["Document"],  # noqa: F821
@@ -94,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

@@ -674,8 +674,9 @@ class RunDBInterface(ABC):
         self,
         name: str,
         project: str,
-        function_name: str,
-        endpoint_id: str,
+        function_name: Optional[str] = None,
+        function_tag: Optional[str] = None,
+        endpoint_id: Optional[str] = None,
     ):
         pass
 
@@ -685,6 +686,7 @@ class RunDBInterface(ABC):
         project: str,
         name: Optional[str] = None,
         function_name: Optional[str] = None,
+        function_tag: Optional[str] = None,
         model_name: Optional[str] = None,
         labels: Optional[Union[str, dict[str, Optional[str]], list[str]]] = None,
         start: Optional[datetime.datetime] = None,
@@ -702,6 +704,7 @@ class RunDBInterface(ABC):
         name: str,
         project: str,
         function_name: Optional[str] = None,
+        function_tag: Optional[str] = None,
         endpoint_id: Optional[str] = None,
         tsdb_metrics: bool = True,
         feature_analysis: bool = False,
@@ -715,6 +718,7 @@ class RunDBInterface(ABC):
         project: str,
         attributes: dict,
         function_name: Optional[str] = None,
+        function_tag: Optional[str] = None,
         endpoint_id: Optional[str] = None,
     ) -> mlrun.common.schemas.ModelEndpoint:
         pass

mlrun/db/httpdb.py

@@ -996,7 +996,7 @@ class HTTPRunDB(RunDBInterface):
         tag=None,
         project="",
         tree=None,
-    ):
+    ) -> dict[str, str]:
         """Store an artifact in the DB.
 
         :param key: Identifying key of the artifact.
@@ -1008,6 +1008,7 @@ class HTTPRunDB(RunDBInterface):
         :param tag: Tag of the artifact.
         :param project: Project that the artifact belongs to.
         :param tree: The tree (producer id) which generated this artifact.
+        :returns: The stored artifact dictionary.
         """
         if uid:
             warnings.warn(
@@ -1032,9 +1033,10 @@ class HTTPRunDB(RunDBInterface):
             params["tree"] = tree
 
         body = _as_json(artifact)
-        self.api_call(
+        response = self.api_call(
             "PUT", endpoint_path, error, body=body, params=params, version="v2"
         )
+        return response.json()
 
     def read_artifact(
         self,
@@ -3601,8 +3603,9 @@ class HTTPRunDB(RunDBInterface):
         self,
         name: str,
         project: str,
-        function_name: str,
-        endpoint_id: str,
+        function_name: Optional[str] = None,
+        function_tag: Optional[str] = None,
+        endpoint_id: Optional[str] = None,
     ):
         """
         Deletes the DB record of a given model endpoint, project and endpoint_id are used for lookup
@@ -3610,15 +3613,19 @@ class HTTPRunDB(RunDBInterface):
         :param name: The name of the model endpoint
         :param project: The name of the project
         :param function_name: The name of the function
+        :param function_tag: The tag of the function
         :param endpoint_id: The id of the endpoint
         """
-
+        self._check_model_endpoint_representation(
+            function_name, function_tag, endpoint_id
+        )
         path = f"projects/{project}/model-endpoints/{name}"
         self.api_call(
             method=mlrun.common.types.HTTPMethod.DELETE,
             path=path,
             params={
                 "function_name": function_name,
+                "function_tag": function_tag,
                 "endpoint_id": endpoint_id,
             },
         )
@@ -3628,6 +3635,7 @@ class HTTPRunDB(RunDBInterface):
         project: str,
         name: Optional[str] = None,
         function_name: Optional[str] = None,
+        function_tag: Optional[str] = None,
         model_name: Optional[str] = None,
         labels: Optional[Union[str, dict[str, Optional[str]], list[str]]] = None,
         start: Optional[datetime] = None,
@@ -3643,6 +3651,7 @@ class HTTPRunDB(RunDBInterface):
         :param project:         The name of the project
         :param name:            The name of the model endpoint
         :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 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.
@@ -3663,6 +3672,7 @@ class HTTPRunDB(RunDBInterface):
                 "name": name,
                 "model_name": model_name,
                 "function_name": function_name,
+                "function_tag": function_tag,
                 "label": labels,
                 "start": datetime_to_iso(start),
                 "end": datetime_to_iso(end),
@@ -3680,7 +3690,7 @@ class HTTPRunDB(RunDBInterface):
         name: str,
         project: str,
         function_name: Optional[str] = None,
-        # TODO: function_tag
+        function_tag: Optional[str] = None,
         endpoint_id: Optional[str] = None,
         tsdb_metrics: bool = True,
         feature_analysis: bool = False,
@@ -3691,6 +3701,7 @@ class HTTPRunDB(RunDBInterface):
         :param name:                       The name of the model endpoint
         :param project:                    The name of the project
         :param function_name:              The name of the function
+        :param function_tag:               The tag of the function
         :param endpoint_id:                The id of the endpoint
         :param tsdb_metrics:               Whether to include metrics from the time series DB.
         :param feature_analysis:           Whether to include feature analysis data (feature_stats,
@@ -3698,13 +3709,16 @@ class HTTPRunDB(RunDBInterface):
 
         :return:                          A `ModelEndpoint` object.
         """
-
+        self._check_model_endpoint_representation(
+            function_name, function_tag, endpoint_id
+        )
         path = f"projects/{project}/model-endpoints/{name}"
         response = self.api_call(
             method=mlrun.common.types.HTTPMethod.GET,
             path=path,
             params={
                 "function_name": function_name,
+                "function_tag": function_tag,
                 "endpoint_id": endpoint_id,
                 "tsdb_metrics": tsdb_metrics,
                 "feature_analysis": feature_analysis,
@@ -3719,6 +3733,7 @@ class HTTPRunDB(RunDBInterface):
         project: str,
         attributes: dict,
         function_name: Optional[str] = None,
+        function_tag: Optional[str] = None,
         endpoint_id: Optional[str] = None,
     ) -> mlrun.common.schemas.ModelEndpoint:
         """
@@ -3728,13 +3743,16 @@ class HTTPRunDB(RunDBInterface):
         :param project:                    The name of the project
         :param attributes:                 The attributes to update
         :param function_name:              The name of the function
+        :param function_tag:               The tag of the function
         :param endpoint_id:                The id of the endpoint
         :return:                          The updated `ModelEndpoint` object.
         """
         attributes_keys = list(attributes.keys())
         attributes["name"] = name
         attributes["project"] = project
-        attributes["uid"] = endpoint_id or ""
+        attributes["function_name"] = function_name or None
+        attributes["function_tag"] = function_tag or None
+        attributes["uid"] = endpoint_id or None
         model_endpoint = mlrun.common.schemas.ModelEndpoint.from_flat_dict(attributes)
         path = f"projects/{project}/model-endpoints"
         logger.info(
@@ -3753,6 +3771,15 @@ class HTTPRunDB(RunDBInterface):
 
         return mlrun.common.schemas.ModelEndpoint(**response.json())
 
+    @staticmethod
+    def _check_model_endpoint_representation(
+        function_name: str, function_tag: str, uid: str
+    ):
+        if not uid and not (function_name and function_tag):
+            raise MLRunInvalidArgumentError(
+                "Either endpoint_uid or function_name and function_tag must be provided"
+            )
+
     def update_model_monitoring_controller(
         self,
         project: str,