orca-sdk 0.1.10__py3-none-any.whl → 0.1.12__py3-none-any.whl

orca_sdk/memoryset.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import logging
 from abc import ABC
 from datetime import datetime, timedelta
 from os import PathLike
@@ -16,13 +15,7 @@ from typing import (
     overload,
 )
 
-import pandas as pd
-import pyarrow as pa
-from datasets import Dataset
-from torch.utils.data import DataLoader as TorchDataLoader
-from torch.utils.data import Dataset as TorchDataset
-
-from ._utils.common import UNSET, CreateMode, DropMode
+from ._utils.common import UNSET, CreateMode, DropMode, logger
 from .async_client import OrcaAsyncClient
 from .client import (
     CascadingEditSuggestion,
@@ -30,6 +23,7 @@ from .client import (
     CreateMemorysetFromDatasourceRequest,
     CreateMemorysetRequest,
     FilterItem,
+    LabeledBatchMemoryUpdatePatch,
 )
 from .client import LabeledMemory as LabeledMemoryResponse
 from .client import (
@@ -49,6 +43,7 @@ from .client import (
     MemorysetUpdate,
     MemoryType,
     OrcaClient,
+    ScoredBatchMemoryUpdatePatch,
 )
 from .client import ScoredMemory as ScoredMemoryResponse
 from .client import (
@@ -74,6 +69,13 @@ from .job import Job, Status
 from .telemetry import ClassificationPrediction, RegressionPrediction
 
 if TYPE_CHECKING:
+    # peer dependencies that are used for types only
+    from datasets import Dataset as HFDataset  # type: ignore
+    from pandas import DataFrame as PandasDataFrame  # type: ignore
+    from pyarrow import Table as PyArrowTable  # type: ignore
+    from torch.utils.data import DataLoader as TorchDataLoader  # type: ignore
+    from torch.utils.data import Dataset as TorchDataset  # type: ignore
+
     from .classification_model import ClassificationModel
     from .regression_model import RegressionModel
 
@@ -94,7 +96,31 @@ FilterOperation = Literal["==", "!=", ">", ">=", "<", "<=", "in", "not in", "lik
 Operations that can be used in a filter expression.
 """
 
-FilterValue = str | int | float | bool | datetime | None | list[str | None] | list[int] | list[float] | list[bool]
+ConsistencyLevel = Literal["Strong", "Session", "Bounded", "Eventual"]
+"""
+Consistency level for memoryset reads.
+
+* **`Strong`**: Reads include all committed writes; may wait for full freshness.
+* **`Session`**: Reads include all writes that happened in the same server process.
+* **`Bounded`**: Reads may miss newest writes within a small staleness window.
+* **`Eventual`**: No freshness guarantee; reads can miss recent writes.
+"""
+
+FilterValue = (
+    str
+    | int
+    | float
+    | bool
+    | datetime
+    | list[None]
+    | list[str]
+    | list[str | None]
+    | list[int]
+    | list[int | None]
+    | list[float]
+    | list[bool]
+    | None
+)
 """
 Values that can be used in a filter expression.
 """
@@ -134,7 +160,21 @@ def _is_metric_column(column: str):
     return column in ["feedback_metrics", "lookup"]
 
 
-def _parse_filter_item_from_tuple(input: FilterItemTuple) -> FilterItem | TelemetryFilterItem:
+@overload
+def _parse_filter_item_from_tuple(input: FilterItemTuple, allow_metric_fields: Literal[False]) -> FilterItem:
+    pass
+
+
+@overload
+def _parse_filter_item_from_tuple(
+    input: FilterItemTuple, allow_metric_fields: Literal[True] = True
+) -> FilterItem | TelemetryFilterItem:
+    pass
+
+
+def _parse_filter_item_from_tuple(
+    input: FilterItemTuple, allow_metric_fields: bool = True
+) -> FilterItem | TelemetryFilterItem:
     field = input[0].split(".")
     if (
         len(field) == 1
@@ -146,6 +186,8 @@ def _parse_filter_item_from_tuple(input: FilterItemTuple) -> FilterItem | Teleme
     if isinstance(value, datetime):
         value = value.isoformat()
     if _is_metric_column(field[0]):
+        if not allow_metric_fields:
+            raise ValueError(f"Cannot filter on {field[0]} - metric fields are not supported")
         if not (
             (isinstance(value, list) and all(isinstance(v, float) or isinstance(v, int) for v in value))
             or isinstance(value, float)
@@ -165,7 +207,7 @@ def _parse_filter_item_from_tuple(input: FilterItemTuple) -> FilterItem | Teleme
         return TelemetryFilterItem(field=cast(TelemetryField, tuple(field)), op=op, value=value)
 
     # Convert list to tuple for FilterItem field type
-    return FilterItem(field=tuple(field), op=op, value=value)  # type: ignore[assignment]
+    return FilterItem(field=tuple[Any, ...](field), op=op, value=value)
 
 
 def _parse_sort_item_from_tuple(
@@ -238,17 +280,29 @@ def _parse_memory_insert(memory: dict[str, Any], type: MemoryType) -> LabeledMem
             }
 
 
-def _parse_memory_update(update: dict[str, Any], type: MemoryType) -> LabeledMemoryUpdate | ScoredMemoryUpdate:
-    if "memory_id" not in update:
-        raise ValueError("memory_id must be specified in the update dictionary")
-    memory_id = update["memory_id"]
-    if not isinstance(memory_id, str):
-        raise ValueError("memory_id must be a string")
-    payload: LabeledMemoryUpdate | ScoredMemoryUpdate = {"memory_id": memory_id}
-    if "value" in update:
-        if not isinstance(update["value"], str):
-            raise ValueError("value must be a string or unset")
-        payload["value"] = update["value"]
+def _extract_metadata_for_patch(update: dict[str, Any], exclude_keys: set[str]) -> dict[str, Any] | None:
+    """Extract metadata from update dict for patch operations.
+
+    Returns the metadata dict to include in the payload, or None if metadata should be omitted
+    (to preserve existing metadata on the server).
+    """
+    if "metadata" in update and update["metadata"] is not None:
+        # User explicitly provided metadata dict (could be {} to clear all metadata)
+        metadata = update["metadata"]
+        if not isinstance(metadata, dict):
+            raise ValueError("metadata must be a dict")
+        return metadata
+    # Extract metadata from top-level keys, only include if non-empty
+    metadata = {k: v for k, v in update.items() if k not in DEFAULT_COLUMN_NAMES | exclude_keys}
+    if any(k in metadata for k in FORBIDDEN_METADATA_COLUMN_NAMES):
+        raise ValueError(f"Cannot update the following metadata keys: {', '.join(FORBIDDEN_METADATA_COLUMN_NAMES)}")
+    return metadata if metadata else None
+
+
+def _parse_memory_update_patch(
+    update: dict[str, Any], type: MemoryType
+) -> LabeledBatchMemoryUpdatePatch | ScoredBatchMemoryUpdatePatch:
+    payload: LabeledBatchMemoryUpdatePatch | ScoredBatchMemoryUpdatePatch = {}
     if "source_id" in update:
         source_id = update["source_id"]
         if source_id is not None and not isinstance(source_id, str):
@@ -261,31 +315,41 @@ def _parse_memory_update(update: dict[str, Any], type: MemoryType) -> LabeledMem
         payload["partition_id"] = partition_id
     match type:
         case "LABELED":
-            payload = cast(LabeledMemoryUpdate, payload)
+            payload = cast(LabeledBatchMemoryUpdatePatch, payload)
             if "label" in update:
                 if not isinstance(update["label"], int):
                     raise ValueError("label must be an integer or unset")
                 payload["label"] = update["label"]
-            metadata = {k: v for k, v in update.items() if k not in DEFAULT_COLUMN_NAMES | {"memory_id", "label"}}
-            if any(k in metadata for k in FORBIDDEN_METADATA_COLUMN_NAMES):
-                raise ValueError(
-                    f"Cannot update the following metadata keys: {', '.join(FORBIDDEN_METADATA_COLUMN_NAMES)}"
-                )
-            payload["metadata"] = metadata
+            metadata = _extract_metadata_for_patch(update, {"memory_id", "label", "metadata"})
+            if metadata is not None:
+                payload["metadata"] = metadata
             return payload
         case "SCORED":
-            payload = cast(ScoredMemoryUpdate, payload)
+            payload = cast(ScoredBatchMemoryUpdatePatch, payload)
             if "score" in update:
                 if not isinstance(update["score"], (int, float)):
                     raise ValueError("score must be a number or unset")
                 payload["score"] = update["score"]
-            metadata = {k: v for k, v in update.items() if k not in DEFAULT_COLUMN_NAMES | {"memory_id", "score"}}
-            if any(k in metadata for k in FORBIDDEN_METADATA_COLUMN_NAMES):
-                raise ValueError(
-                    f"Cannot update the following metadata keys: {', '.join(FORBIDDEN_METADATA_COLUMN_NAMES)}"
-                )
-            payload["metadata"] = metadata
-            return cast(ScoredMemoryUpdate, payload)
+            metadata = _extract_metadata_for_patch(update, {"memory_id", "score", "metadata"})
+            if metadata is not None:
+                payload["metadata"] = metadata
+            return payload
+
+
+def _parse_memory_update(update: dict[str, Any], type: MemoryType) -> LabeledMemoryUpdate | ScoredMemoryUpdate:
+    if "memory_id" not in update:
+        raise ValueError("memory_id must be specified in the update dictionary")
+    memory_id = update["memory_id"]
+    if not isinstance(memory_id, str):
+        raise ValueError("memory_id must be a string")
+    payload: LabeledMemoryUpdate | ScoredMemoryUpdate = {"memory_id": memory_id}
+    if "value" in update:
+        if not isinstance(update["value"], str):
+            raise ValueError("value must be a string or unset")
+        payload["value"] = update["value"]
+    for key, value in _parse_memory_update_patch(update, type).items():
+        payload[key] = value
+    return payload
 
 
 class MemoryBase(ABC):
@@ -933,6 +997,7 @@ class MemorysetBase(Generic[MemoryT, MemoryLookupT], ABC):
         description: Description of the memoryset
         length: Number of memories in the memoryset
         embedding_model: Embedding model used to embed the memory values for semantic search
+        partitioned: Whether the memoryset is partitioned
         created_at: When the memoryset was created, automatically generated on create
         updated_at: When the memoryset was last updated, automatically updated on updates
     """
@@ -947,6 +1012,7 @@ class MemorysetBase(Generic[MemoryT, MemoryLookupT], ABC):
     updated_at: datetime
     insertion_status: Status | None
     embedding_model: EmbeddingModelBase
+    partitioned: bool
     index_type: IndexType
     index_params: dict[str, Any]
     hidden: bool
@@ -968,6 +1034,7 @@ class MemorysetBase(Generic[MemoryT, MemoryLookupT], ABC):
         self.insertion_status = (
             Status(metadata["insertion_status"]) if metadata["insertion_status"] is not None else None
         )
+        self.partitioned = metadata["is_partitioned"]
         self._last_refresh = datetime.now()
         self.index_type = metadata["index_type"]
         self.index_params = metadata["index_params"]
@@ -1029,6 +1096,60 @@ class MemorysetBase(Generic[MemoryT, MemoryLookupT], ABC):
 
         return existing
 
+    @classmethod
+    def _create_empty(
+        cls,
+        name: str,
+        *,
+        embedding_model: FinetunedEmbeddingModel | PretrainedEmbeddingModel | None = None,
+        partitioned: bool = False,
+        description: str | None = None,
+        label_names: list[str] | None = None,
+        max_seq_length_override: int | None = None,
+        prompt: str | None = None,
+        index_type: IndexType = "FLAT",
+        index_params: dict[str, Any] = {},
+        if_exists: CreateMode = "error",
+        hidden: bool = False,
+        memory_type: MemoryType | None = None,
+    ) -> Self:
+        if embedding_model is None:
+            embedding_model = PretrainedEmbeddingModel.GTE_BASE
+
+        existing = cls._handle_if_exists(
+            name,
+            if_exists=if_exists,
+            label_names=label_names,
+            embedding_model=embedding_model,
+        )
+        if existing is not None:
+            return existing
+
+        payload: CreateMemorysetRequest = {
+            "name": name,
+            "description": description,
+            "label_names": label_names,
+            "max_seq_length_override": max_seq_length_override,
+            "index_type": index_type,
+            "index_params": index_params,
+            "hidden": hidden,
+            "is_partitioned": partitioned,
+        }
+        if memory_type is not None:
+            payload["memory_type"] = memory_type
+        if prompt is not None:
+            payload["prompt"] = prompt
+        if isinstance(embedding_model, PretrainedEmbeddingModel):
+            payload["pretrained_embedding_model_name"] = embedding_model.name
+        elif isinstance(embedding_model, FinetunedEmbeddingModel):
+            payload["finetuned_embedding_model_name_or_id"] = embedding_model.id
+        else:
+            raise ValueError("Invalid embedding model")
+
+        client = OrcaClient._resolve_client()
+        response = client.POST("/memoryset/empty", json=payload)
+        return cls.open(response["id"])
+
     @classmethod
     def _create_from_datasource(
         cls,
@@ -1054,11 +1175,10 @@ class MemorysetBase(Generic[MemoryT, MemoryLookupT], ABC):
         subsample: int | float | None = None,
         memory_type: MemoryType | None = None,
     ) -> Self | Job[Self]:
-        """
-        Create a memoryset from a datasource by calling the API.
-
-        This is a private method that performs the actual API call to create a memoryset from a datasource.
-        """
+        # Private method for the actual API call to create a memoryset from a datasource.
+        # This exists because subclass from_datasource() methods have narrower signatures
+        # (e.g., ScoredMemoryset only has score_column, not label_column), so they can't
+        # be called polymorphically. Both create() and from_datasource() delegate here.
         if embedding_model is None:
             embedding_model = PretrainedEmbeddingModel.GTE_BASE
 
@@ -1116,6 +1236,7 @@ class MemorysetBase(Generic[MemoryT, MemoryLookupT], ABC):
         *,
         datasource: None = None,
         embedding_model: FinetunedEmbeddingModel | PretrainedEmbeddingModel | None = None,
+        partitioned: bool = False,
         description: str | None = None,
         label_names: list[str] | None = None,
         max_seq_length_override: int | None = None,
@@ -1184,6 +1305,35 @@ class MemorysetBase(Generic[MemoryT, MemoryLookupT], ABC):
     ) -> Self:
         pass
 
+    @overload
+    @classmethod
+    def create(
+        cls,
+        name: str,
+        *,
+        datasource: Datasource | None = None,
+        embedding_model: FinetunedEmbeddingModel | PretrainedEmbeddingModel | None = None,
+        value_column: str = "value",
+        label_column: str | None = None,
+        score_column: str | None = None,
+        source_id_column: str | None = None,
+        partition_id_column: str | None = None,
+        partitioned: bool = False,
+        description: str | None = None,
+        label_names: list[str] | None = None,
+        max_seq_length_override: int | None = None,
+        prompt: str | None = None,
+        remove_duplicates: bool = True,
+        index_type: IndexType = "FLAT",
+        index_params: dict[str, Any] = {},
+        if_exists: CreateMode = "error",
+        background: bool = False,
+        hidden: bool = False,
+        subsample: int | float | None = None,
+        memory_type: MemoryType | None = None,
+    ) -> Self | Job[Self]:
+        pass
+
     @classmethod
     def create(
         cls,
@@ -1196,6 +1346,7 @@ class MemorysetBase(Generic[MemoryT, MemoryLookupT], ABC):
         score_column: str | None = None,
         source_id_column: str | None = None,
         partition_id_column: str | None = None,
+        partitioned: bool = False,
         description: str | None = None,
         label_names: list[str] | None = None,
         max_seq_length_override: int | None = None,
@@ -1233,6 +1384,8 @@ class MemorysetBase(Generic[MemoryT, MemoryLookupT], ABC):
             source_id_column: Optional name of the column in the datasource that contains the ids in
                 the system of reference
             partition_id_column: Optional name of the column in the datasource that contains the partition ids
+            partitioned: Whether the memoryset should be partitioned. Only valid when creating an
+                empty memoryset (datasource is None). Use partition_id_column when creating from a datasource.
             description: Optional description for the memoryset, this will be used in agentic flows,
                 so make sure it is concise and describes the contents of your memoryset not the
                 datasource or the embedding model.
@@ -1277,9 +1430,12 @@ class MemorysetBase(Generic[MemoryT, MemoryLookupT], ABC):
                 index_params=index_params,
                 if_exists=if_exists,
                 hidden=hidden,
+                partitioned=partitioned,
                 memory_type=memory_type,
             )
         else:
+            if partitioned:
+                raise ValueError("Use 'partition_id_column' instead of 'partitioned' when creating from a datasource")
             return cls._create_from_datasource(
                 name,
                 datasource=datasource,
@@ -1459,105 +1615,21 @@ class MemorysetBase(Generic[MemoryT, MemoryLookupT], ABC):
             memory_type=memory_type,
         )
 
-    @classmethod
-    def _create_empty(
-        cls,
-        name: str,
-        *,
-        embedding_model: FinetunedEmbeddingModel | PretrainedEmbeddingModel | None = None,
-        description: str | None = None,
-        label_names: list[str] | None = None,
-        max_seq_length_override: int | None = None,
-        prompt: str | None = None,
-        index_type: IndexType = "FLAT",
-        index_params: dict[str, Any] = {},
-        if_exists: CreateMode = "error",
-        hidden: bool = False,
-        memory_type: MemoryType | None = None,
-    ) -> Self:
-        """
-        Create an empty memoryset in the OrcaCloud
-
-        This creates a memoryset with no initial memories. You can add memories later using
-        the `insert` method.
-
-        Params:
-            name: Name for the new memoryset (must be unique)
-            embedding_model: Embedding model to use for embedding memory values for semantic search.
-                If not provided, a default embedding model for the memoryset will be used.
-            description: Optional description for the memoryset, this will be used in agentic flows,
-                so make sure it is concise and describes the contents of your memoryset not the
-                datasource or the embedding model.
-            label_names: List of human-readable names for the labels in the memoryset
-            max_seq_length_override: Maximum sequence length of values in the memoryset, if the
-                value is longer than this it will be truncated, will default to the model's max
-                sequence length if not provided
-            prompt: Optional prompt to use when embedding documents/memories for storage
-            index_type: Type of vector index to use for the memoryset, defaults to `"FLAT"`. Valid
-                values are `"FLAT"`, `"IVF_FLAT"`, `"IVF_SQ8"`, `"IVF_PQ"`, `"HNSW"`, and `"DISKANN"`.
-            index_params: Parameters for the vector index, defaults to `{}`
-            if_exists: What to do if a memoryset with the same name already exists, defaults to
-                `"error"`. Other option is `"open"` to open the existing memoryset.
-            hidden: Whether the memoryset should be hidden
-            memory_type: Type of memoryset to create, defaults to `"LABELED"` if called from
-                `LabeledMemoryset` and `"SCORED"` if called from `ScoredMemoryset`.
-
-        Returns:
-            Handle to the new memoryset in the OrcaCloud
-
-        Raises:
-            ValueError: If the memoryset already exists and if_exists is `"error"` or if it is
-                `"open"` and the params do not match those of the existing memoryset.
-        """
-        if embedding_model is None:
-            embedding_model = PretrainedEmbeddingModel.GTE_BASE
-
-        existing = cls._handle_if_exists(
-            name,
-            if_exists=if_exists,
-            label_names=label_names,
-            embedding_model=embedding_model,
-        )
-        if existing is not None:
-            return existing
-
-        payload: CreateMemorysetRequest = {
-            "name": name,
-            "description": description,
-            "label_names": label_names,
-            "max_seq_length_override": max_seq_length_override,
-            "index_type": index_type,
-            "index_params": index_params,
-            "hidden": hidden,
-        }
-        if memory_type is not None:
-            payload["memory_type"] = memory_type
-        if prompt is not None:
-            payload["prompt"] = prompt
-        if isinstance(embedding_model, PretrainedEmbeddingModel):
-            payload["pretrained_embedding_model_name"] = embedding_model.name
-        elif isinstance(embedding_model, FinetunedEmbeddingModel):
-            payload["finetuned_embedding_model_name_or_id"] = embedding_model.id
-        else:
-            raise ValueError("Invalid embedding model")
-
-        client = OrcaClient._resolve_client()
-        response = client.POST("/memoryset/empty", json=payload)
-        return cls.open(response["id"])
-
     @overload
     @classmethod
-    def from_hf_dataset(cls, name: str, hf_dataset: Dataset, background: Literal[True], **kwargs: Any) -> Self:
+    def from_hf_dataset(cls, name: str, hf_dataset: HFDataset, background: Literal[True], **kwargs: Any) -> Self:
         pass
 
     @overload
     @classmethod
-    def from_hf_dataset(cls, name: str, hf_dataset: Dataset, background: Literal[False] = False, **kwargs: Any) -> Self:
+    def from_hf_dataset(
+        cls, name: str, hf_dataset: HFDataset, background: Literal[False] = False, **kwargs: Any
+    ) -> Self:
         pass
 
     @classmethod
     def from_hf_dataset(
-        cls, name: str, hf_dataset: Dataset, background: bool = False, **kwargs: Any
+        cls, name: str, hf_dataset: HFDataset, background: bool = False, **kwargs: Any
     ) -> Self | Job[Self]:
         """
         Create a new memoryset from a Hugging Face [`Dataset`][datasets.Dataset] in the OrcaCloud
@@ -1817,7 +1889,7 @@ class MemorysetBase(Generic[MemoryT, MemoryLookupT], ABC):
     def from_pandas(
         cls,
         name: str,
-        dataframe: pd.DataFrame,
+        dataframe: PandasDataFrame,
         *,
         background: Literal[True],
         **kwargs: Any,
@@ -1829,7 +1901,7 @@ class MemorysetBase(Generic[MemoryT, MemoryLookupT], ABC):
     def from_pandas(
         cls,
         name: str,
-        dataframe: pd.DataFrame,
+        dataframe: PandasDataFrame,
         *,
         background: Literal[False] = False,
         **kwargs: Any,
@@ -1840,7 +1912,7 @@ class MemorysetBase(Generic[MemoryT, MemoryLookupT], ABC):
     def from_pandas(
         cls,
         name: str,
-        dataframe: pd.DataFrame,
+        dataframe: PandasDataFrame,
         *,
         background: bool = False,
         **kwargs: Any,
@@ -1883,7 +1955,7 @@ class MemorysetBase(Generic[MemoryT, MemoryLookupT], ABC):
     def from_arrow(
         cls,
         name: str,
-        pyarrow_table: pa.Table,
+        pyarrow_table: PyArrowTable,
         *,
         background: Literal[True],
         **kwargs: Any,
@@ -1895,7 +1967,7 @@ class MemorysetBase(Generic[MemoryT, MemoryLookupT], ABC):
     def from_arrow(
         cls,
         name: str,
-        pyarrow_table: pa.Table,
+        pyarrow_table: PyArrowTable,
         *,
         background: Literal[False] = False,
         **kwargs: Any,
@@ -1906,7 +1978,7 @@ class MemorysetBase(Generic[MemoryT, MemoryLookupT], ABC):
     def from_arrow(
         cls,
         name: str,
-        pyarrow_table: pa.Table,
+        pyarrow_table: PyArrowTable,
         *,
         background: bool = False,
         **kwargs: Any,
@@ -2090,7 +2162,7 @@ class MemorysetBase(Generic[MemoryT, MemoryLookupT], ABC):
         ]
 
     @classmethod
-    def drop(cls, name_or_id: str, if_not_exists: DropMode = "error"):
+    def drop(cls, name_or_id: str, if_not_exists: DropMode = "error", cascade: bool = False):
         """
         Delete a memoryset from the OrcaCloud
 
@@ -2098,14 +2170,17 @@ class MemorysetBase(Generic[MemoryT, MemoryLookupT], ABC):
             name_or_id: Name or id of the memoryset
             if_not_exists: What to do if the memoryset does not exist, defaults to `"error"`.
                 Other options are `"ignore"` to do nothing if the memoryset does not exist.
+            cascade: If True, also delete all associated predictive models and predictions.
+                Defaults to False.
 
         Raises:
             LookupError: If the memoryset does not exist and if_not_exists is `"error"`
+            RuntimeError: If the memoryset has associated models and cascade is False
         """
         try:
             client = OrcaClient._resolve_client()
-            client.DELETE("/memoryset/{name_or_id}", params={"name_or_id": name_or_id})
-            logging.info(f"Deleted memoryset {name_or_id}")
+            client.DELETE("/memoryset/{name_or_id}", params={"name_or_id": name_or_id, "cascade": cascade})
+            logger.info(f"Deleted memoryset {name_or_id}")
         except LookupError:
             if if_not_exists == "error":
                 raise
@@ -2151,6 +2226,7 @@ class MemorysetBase(Generic[MemoryT, MemoryLookupT], ABC):
         embedding_model: PretrainedEmbeddingModel | FinetunedEmbeddingModel | None = None,
         max_seq_length_override: int | None = None,
         prompt: str | None = None,
+        partitioned: bool | None = None,
         if_exists: CreateMode = "error",
         background: Literal[True],
     ) -> Job[Self]:
@@ -2164,6 +2240,7 @@ class MemorysetBase(Generic[MemoryT, MemoryLookupT], ABC):
         embedding_model: PretrainedEmbeddingModel | FinetunedEmbeddingModel | None = None,
         max_seq_length_override: int | None = None,
         prompt: str | None = None,
+        partitioned: bool | None = None,
         if_exists: CreateMode = "error",
         background: Literal[False] = False,
     ) -> Self:
@@ -2176,6 +2253,7 @@ class MemorysetBase(Generic[MemoryT, MemoryLookupT], ABC):
         embedding_model: PretrainedEmbeddingModel | FinetunedEmbeddingModel | None = None,
         max_seq_length_override: int | None = UNSET,
         prompt: str | None = None,
+        partitioned: bool | None = None,
         if_exists: CreateMode = "error",
         background: bool = False,
     ) -> Self | Job[Self]:
@@ -2191,6 +2269,8 @@ class MemorysetBase(Generic[MemoryT, MemoryLookupT], ABC):
                 If not provided, will use the source memoryset's max sequence length.
             prompt: Optional custom prompt to use for the cloned memoryset.
                 If not provided, will use the source memoryset's prompt.
+            partitioned: Whether the cloned memoryset should be partitioned.
+                If not provided, will inherit the source memoryset's partitioning.
             if_exists: What to do if a memoryset with the same name already exists, defaults to
                 `"error"`. Other option is `"open"` to open the existing memoryset.
 
@@ -2231,6 +2311,8 @@ class MemorysetBase(Generic[MemoryT, MemoryLookupT], ABC):
             payload["pretrained_embedding_model_name"] = embedding_model.name
         elif isinstance(embedding_model, FinetunedEmbeddingModel):
             payload["finetuned_embedding_model_name_or_id"] = embedding_model.id
+        if partitioned is not None:
+            payload["is_partitioned"] = partitioned
 
         client = OrcaClient._resolve_client()
         metadata = client.POST("/memoryset/{name_or_id}/clone", params={"name_or_id": self.id}, json=payload)
@@ -2328,6 +2410,7 @@ class MemorysetBase(Generic[MemoryT, MemoryLookupT], ABC):
         partition_filter_mode: Literal[
             "ignore_partitions", "include_global", "exclude_global", "only_global"
         ] = "include_global",
+        consistency_level: ConsistencyLevel = "Bounded",
     ) -> list[MemoryLookupT]:
         pass
 
@@ -2342,6 +2425,7 @@ class MemorysetBase(Generic[MemoryT, MemoryLookupT], ABC):
         partition_filter_mode: Literal[
             "ignore_partitions", "include_global", "exclude_global", "only_global"
         ] = "include_global",
+        consistency_level: ConsistencyLevel = "Bounded",
     ) -> list[list[MemoryLookupT]]:
         pass
 
@@ -2355,6 +2439,7 @@ class MemorysetBase(Generic[MemoryT, MemoryLookupT], ABC):
         partition_filter_mode: Literal[
             "ignore_partitions", "include_global", "exclude_global", "only_global"
         ] = "include_global",
+        consistency_level: ConsistencyLevel = "Bounded",
     ) -> list[MemoryLookupT] | list[list[MemoryLookupT]]:
         """
         Search for memories that are semantically similar to the query
@@ -2370,6 +2455,7 @@ class MemorysetBase(Generic[MemoryT, MemoryLookupT], ABC):
                 - "include_global": Include global memories
                 - "exclude_global": Exclude global memories
                 - "only_global": Only include global memories
+            consistency_level: Consistency level to use for the search
         Returns:
             List of memories from the memoryset that match the query. If a single query is provided,
                 the return value is a list containing a single list of memories. If a list of
@@ -2411,6 +2497,7 @@ class MemorysetBase(Generic[MemoryT, MemoryLookupT], ABC):
                 "prompt": prompt,
                 "partition_id": partition_id,
                 "partition_filter_mode": partition_filter_mode,
+                "consistency_level": consistency_level,
             },
         )
         lookups = [
@@ -2436,10 +2523,7 @@ class MemorysetBase(Generic[MemoryT, MemoryLookupT], ABC):
         filters: list[FilterItemTuple] = [],
         with_feedback_metrics: bool = False,
         sort: list[TelemetrySortItem] | None = None,
-        partition_id: str | None = None,
-        partition_filter_mode: Literal[
-            "ignore_partitions", "include_global", "exclude_global", "only_global"
-        ] = "include_global",
+        consistency_level: ConsistencyLevel = "Bounded",
     ) -> list[MemoryT]:
         """
         Query the memoryset for memories that match the filters
@@ -2447,8 +2531,10 @@ class MemorysetBase(Generic[MemoryT, MemoryLookupT], ABC):
         Params:
             offset: The offset of the first memory to return
             limit: The maximum number of memories to return
-            filters: List of filters to apply to the query.
+            filters: List of filters to apply to the query
             with_feedback_metrics: Whether to include feedback metrics in the response
+            sort: Optional sort order to apply
+            consistency_level: Consistency level to use for the query
 
         Returns:
             List of memories from the memoryset that match the filters
@@ -2460,27 +2546,18 @@ class MemorysetBase(Generic[MemoryT, MemoryLookupT], ABC):
                 LabeledMemory({ label: <negative: 0>, value: "I am sad" }),
             ]
         """
-        parsed_filters = [
-            _parse_filter_item_from_tuple(filter) if isinstance(filter, tuple) else filter for filter in filters
-        ]
 
+        client = OrcaClient._resolve_client()
         if with_feedback_metrics:
-            if partition_id:
-                raise ValueError("Partition ID is not supported when with_feedback_metrics is True")
-            if partition_filter_mode != "include_global":
-                raise ValueError(
-                    f"Partition filter mode {partition_filter_mode} is not supported when with_feedback_metrics is True. Only 'include_global' is supported."
-                )
-
-            client = OrcaClient._resolve_client()
             response = client.POST(
                 "/telemetry/memories",
                 json={
                     "memoryset_id": self.id,
                     "offset": offset,
                     "limit": limit,
-                    "filters": parsed_filters,
+                    "filters": [_parse_filter_item_from_tuple(filter) for filter in filters],
                     "sort": [_parse_sort_item_from_tuple(item) for item in sort] if sort else None,
+                    "consistency_level": consistency_level,
                 },
             )
             return [
@@ -2495,18 +2572,16 @@ class MemorysetBase(Generic[MemoryT, MemoryLookupT], ABC):
             raise ValueError("Feedback metrics are only supported when the with_feedback_metrics flag is set to True")
 
         if sort:
-            logging.warning("Sorting is not supported when with_feedback_metrics is False. Sort value will be ignored.")
+            logger.warning("Sorting is not supported when with_feedback_metrics is False. Sort value will be ignored.")
 
-        client = OrcaClient._resolve_client()
         response = client.POST(
             "/memoryset/{name_or_id}/memories",
             params={"name_or_id": self.id},
             json={
                 "offset": offset,
                 "limit": limit,
-                "filters": cast(list[FilterItem], parsed_filters),
-                "partition_id": partition_id,
-                "partition_filter_mode": partition_filter_mode,
+                "filters": [_parse_filter_item_from_tuple(filter, allow_metric_fields=False) for filter in filters],
+                "consistency_level": consistency_level,
             },
         )
         return [
@@ -2524,11 +2599,16 @@ class MemorysetBase(Generic[MemoryT, MemoryLookupT], ABC):
         filters: list[FilterItemTuple] = [],
         with_feedback_metrics: bool = False,
         sort: list[TelemetrySortItem] | None = None,
-    ) -> pd.DataFrame:
+    ) -> PandasDataFrame:
         """
         Convert the memoryset to a pandas DataFrame
         """
-        return pd.DataFrame(
+        try:
+            from pandas import DataFrame as PandasDataFrame  # type: ignore
+        except ImportError:
+            raise ImportError("Install pandas to use this method")
+
+        return PandasDataFrame(
             [
                 memory.to_dict()
                 for memory in self.query(
@@ -2639,19 +2719,22 @@ class MemorysetBase(Generic[MemoryT, MemoryLookupT], ABC):
         self._last_refresh = current_time
 
     @overload
-    def get(self, memory_id: str) -> MemoryT:  # type: ignore -- this takes precedence
+    def get(self, memory_id: str, consistency_level: ConsistencyLevel = "Bounded") -> MemoryT:  # type: ignore -- this takes precedence
         pass
 
     @overload
-    def get(self, memory_id: Iterable[str]) -> list[MemoryT]:
+    def get(self, memory_id: Iterable[str], consistency_level: ConsistencyLevel = "Bounded") -> list[MemoryT]:
         pass
 
-    def get(self, memory_id: str | Iterable[str]) -> MemoryT | list[MemoryT]:
+    def get(
+        self, memory_id: str | Iterable[str], consistency_level: ConsistencyLevel = "Bounded"
+    ) -> MemoryT | list[MemoryT]:
         """
         Fetch a memory or memories from the memoryset
 
         Params:
             memory_id: Unique identifier of the memory or memories to fetch
+            consistency_level: Consistency level to use for the get operation
 
         Returns:
             Memory or list of memories from the memoryset
@@ -2677,7 +2760,8 @@ class MemorysetBase(Generic[MemoryT, MemoryLookupT], ABC):
         if isinstance(memory_id, str):
             client = OrcaClient._resolve_client()
             response = client.GET(
-                "/memoryset/{name_or_id}/memory/{memory_id}", params={"name_or_id": self.id, "memory_id": memory_id}
+                "/memoryset/{name_or_id}/memory/{memory_id}",
+                params={"name_or_id": self.id, "memory_id": memory_id, "consistency_level": consistency_level},
             )
             return cast(
                 MemoryT,
@@ -2688,7 +2772,7 @@ class MemorysetBase(Generic[MemoryT, MemoryLookupT], ABC):
             response = client.POST(
                 "/memoryset/{name_or_id}/memories/get",
                 params={"name_or_id": self.id},
-                json={"memory_ids": list(memory_id)},
+                json={"memory_ids": list(memory_id), "consistency_level": consistency_level},
             )
             return [
                 cast(
@@ -2699,18 +2783,28 @@ class MemorysetBase(Generic[MemoryT, MemoryLookupT], ABC):
             ]
 
     @overload
-    def update(self, updates: dict[str, Any], *, batch_size: int = 32) -> MemoryT:
+    def update(self, updates: dict[str, Any] | Iterable[dict[str, Any]], *, batch_size: int = 32) -> int:
         pass
 
     @overload
-    def update(self, updates: Iterable[dict[str, Any]], *, batch_size: int = 32) -> list[MemoryT]:
+    def update(
+        self,
+        *,
+        filters: list[FilterItemTuple],
+        patch: dict[str, Any],
+    ) -> int:
         pass
 
     def update(
-        self, updates: dict[str, Any] | Iterable[dict[str, Any]], *, batch_size: int = 32
-    ) -> MemoryT | list[MemoryT]:
+        self,
+        updates: dict[str, Any] | Iterable[dict[str, Any]] | None = None,
+        *,
+        batch_size: int = 32,
+        filters: list[FilterItemTuple] | None = None,
+        patch: dict[str, Any] | None = None,
+    ) -> int:
         """
-        Update one or multiple memories in the memoryset
+        Update one or multiple memories in the memoryset.
 
         Params:
             updates: List of updates to apply to the memories. Each update should be a dictionary
@@ -2723,10 +2817,12 @@ class MemorysetBase(Generic[MemoryT, MemoryLookupT], ABC):
                 - `partition_id`: Optional new partition ID of the memory
                 - `...`: Optional new values for metadata properties
 
-            batch_size: Number of memories to update in a single API call
+            filters: Filters to match memories against. Each filter is a tuple of (field, operation, value).
+            patch: Patch to apply to matching memories (only used with filters).
+            batch_size: Number of memories to update in a single API call (only used with updates)
 
         Returns:
-            Updated memory or list of updated memories
+            The number of memories updated.
 
         Examples:
             Update a single memory:
@@ -2742,32 +2838,57 @@ class MemorysetBase(Generic[MemoryT, MemoryLookupT], ABC):
             ...     {"memory_id": m.memory_id, "label": 2}
             ...     for m in memoryset.query(filters=[("tag", "==", "happy")])
             ... )
+
+            Update all memories matching a filter:
+            >>> memoryset.update(filters=[("label", "==", 0)], patch={"label": 1})
         """
         if batch_size <= 0 or batch_size > 500:
             raise ValueError("batch_size must be between 1 and 500")
+
         client = OrcaClient._resolve_client()
-        updates_list = cast(list[dict[str, Any]], [updates]) if isinstance(updates, dict) else list(updates)
-        # update memories in batches to avoid API timeouts
-        updated_memories: list[MemoryT] = []
-        for i in range(0, len(updates_list), batch_size):
-            batch = updates_list[i : i + batch_size]
-            response = client.PATCH(
-                "/gpu/memoryset/{name_or_id}/memories",
-                params={"name_or_id": self.id},
-                json=cast(
-                    list[LabeledMemoryUpdate] | list[ScoredMemoryUpdate],
-                    [_parse_memory_update(update, type=self.memory_type) for update in batch],
-                ),
-            )
-            updated_memories.extend(
-                cast(
-                    MemoryT,
-                    (LabeledMemory(self.id, memory) if "label" in memory else ScoredMemory(self.id, memory)),
+
+        # Convert updates to list
+        single_update = isinstance(updates, dict)
+        updates_list: list[dict[str, Any]] | None
+        if single_update:
+            updates_list = [updates]  # type: ignore[list-item]
+        elif updates is not None:
+            updates_list = [u for u in updates]  # type: ignore[misc]
+        else:
+            updates_list = None
+
+        # Batch updates to avoid API timeouts
+        if updates_list and len(updates_list) > batch_size:
+            updated_count: int = 0
+            for i in range(0, len(updates_list), batch_size):
+                batch = updates_list[i : i + batch_size]
+                response = client.PATCH(
+                    "/gpu/memoryset/{name_or_id}/memories",
+                    params={"name_or_id": self.id},
+                    json={"updates": [_parse_memory_update(update, type=self.memory_type) for update in batch]},
                 )
-                for memory in response
-            )
+                updated_count += response["updated_count"]
+            return updated_count
 
-        return updated_memories[0] if isinstance(updates, dict) else updated_memories
+        # Single request for all other cases
+        response = client.PATCH(
+            "/gpu/memoryset/{name_or_id}/memories",
+            params={"name_or_id": self.id},
+            json={
+                "updates": (
+                    [_parse_memory_update(update, type=self.memory_type) for update in updates_list]
+                    if updates_list is not None
+                    else None
+                ),
+                "filters": (
+                    [_parse_filter_item_from_tuple(filter, allow_metric_fields=False) for filter in filters]
+                    if filters is not None
+                    else None
+                ),
+                "patch": _parse_memory_update_patch(patch, type=self.memory_type) if patch is not None else None,
+            },
+        )
+        return response["updated_count"]
 
     def get_cascading_edits_suggestions(
         self,
@@ -2826,37 +2947,128 @@ class MemorysetBase(Generic[MemoryT, MemoryLookupT], ABC):
             },
         )
 
-    def delete(self, memory_id: str | Iterable[str], *, batch_size: int = 32) -> None:
+    @overload
+    def delete(self, memory_id: str | Iterable[str], *, batch_size: int = 32) -> int:
+        pass
+
+    @overload
+    def delete(
+        self,
+        *,
+        filters: list[FilterItemTuple],
+    ) -> int:
+        pass
+
+    def delete(
+        self,
+        memory_id: str | Iterable[str] | None = None,
+        *,
+        batch_size: int = 32,
+        filters: list[FilterItemTuple] | None = None,
+    ) -> int:
         """
-        Delete memories from the memoryset
+        Delete memories from the memoryset.
+
 
         Params:
             memory_id: unique identifiers of the memories to delete
-            batch_size: Number of memories to delete in a single API call
+            filters: Filters to match memories against. Each filter is a tuple of (field, operation, value).
+            batch_size: Number of memories to delete in a single API call (only used with memory_id)
+
+        Returns:
+            The number of memories deleted.
 
         Examples:
-            Delete a single memory:
+            Delete a single memory by ID:
             >>> memoryset.delete("0195019a-5bc7-7afb-b902-5945ee1fb766")
 
-            Delete multiple memories:
+            Delete multiple memories by ID:
             >>> memoryset.delete([
             ...     "0195019a-5bc7-7afb-b902-5945ee1fb766",
             ...     "019501a1-ea08-76b2-9f62-95e4800b4841",
-            ... )
+            ... ])
+
+            Delete all memories matching a filter:
+            >>> deleted_count = memoryset.delete(filters=[("label", "==", 0)])
 
         """
         if batch_size <= 0 or batch_size > 500:
             raise ValueError("batch_size must be between 1 and 500")
+        if memory_id is not None and filters is not None:
+            raise ValueError("Cannot specify memory_ids together with filters")
+
         client = OrcaClient._resolve_client()
-        memory_ids = [memory_id] if isinstance(memory_id, str) else list(memory_id)
-        # delete memories in batches to avoid API timeouts
-        for i in range(0, len(memory_ids), batch_size):
-            batch = memory_ids[i : i + batch_size]
-            client.POST(
-                "/memoryset/{name_or_id}/memories/delete", params={"name_or_id": self.id}, json={"memory_ids": batch}
-            )
-        logging.info(f"Deleted {len(memory_ids)} memories from memoryset.")
-        self.refresh()
+
+        # Convert memory_id to list
+        if isinstance(memory_id, str):
+            memory_ids = [memory_id]
+        elif memory_id is not None:
+            memory_ids = list(memory_id)
+        else:
+            memory_ids = None
+
+        # Batch memory_id deletions to avoid API timeouts
+        if memory_ids and len(memory_ids) > batch_size:
+            total_deleted = 0
+            for i in range(0, len(memory_ids), batch_size):
+                batch = memory_ids[i : i + batch_size]
+                response = client.POST(
+                    "/memoryset/{name_or_id}/memories/delete",
+                    params={"name_or_id": self.id},
+                    json={"memory_ids": batch},
+                )
+                total_deleted += response.get("deleted_count", 0)
+            if total_deleted > 0:
+                logger.info(f"Deleted {total_deleted} memories from memoryset.")
+                self.refresh()
+            return total_deleted
+
+        # Single request for all other cases
+        response = client.POST(
+            "/memoryset/{name_or_id}/memories/delete",
+            params={"name_or_id": self.id},
+            json={
+                "memory_ids": memory_ids,
+                "filters": (
+                    [_parse_filter_item_from_tuple(filter, allow_metric_fields=False) for filter in filters]
+                    if filters is not None
+                    else None
+                ),
+            },
+        )
+        deleted_count = response["deleted_count"]
+        logger.info(f"Deleted {deleted_count} memories from memoryset.")
+        if deleted_count > 0:
+            self.refresh()
+        return deleted_count
+
+    def truncate(self, *, partition_id: str | None = UNSET) -> int:
+        """
+        Delete all memories from the memoryset or a specified partition.
+
+        Params:
+            partition_id: Optional partition ID to truncate, `None` refers to the global partition.
+
+        Returns:
+            The number of deleted memories.
+        """
+        client = OrcaClient._resolve_client()
+        response = client.POST(
+            "/memoryset/{name_or_id}/memories/delete",
+            params={"name_or_id": self.id},
+            json={
+                "filters": (
+                    [FilterItem(field=("partition_id",), op="==", value=partition_id)]
+                    if partition_id is not UNSET
+                    else [FilterItem(field=("memory_id",), op="!=", value=None)]  # match all
+                ),
+            },
+        )
+        deleted_count = response["deleted_count"]
+        logger.info(f"Deleted {deleted_count} memories from memoryset.")
+        if deleted_count > 0:
+            self.refresh()
+        return deleted_count
 
     @overload
     def analyze(
@@ -3003,10 +3215,21 @@ class MemorysetBase(Generic[MemoryT, MemoryLookupT], ABC):
         job = Job(analysis["job_id"], get_analysis_result)
         return job if background else job.result()
 
-    def get_potential_duplicate_groups(self) -> list[list[MemoryT]]:
-        """Group potential duplicates in the memoryset"""
+    def get_potential_duplicate_groups(self) -> list[list[MemoryT]] | None:
+        """
+        Group potential duplicates in the memoryset.
+
+        Returns:
+            List of groups of potentially duplicate memories, where each group is a list of memories.
+            Returns None if duplicate analysis has not been run on this memoryset yet.
+
+        Raises:
+            LookupError: If the memoryset does not exist.
+        """
         client = OrcaClient._resolve_client()
         response = client.GET("/memoryset/{name_or_id}/potential_duplicate_groups", params={"name_or_id": self.id})
+        if response is None:
+            return None
         return [
             [cast(MemoryT, LabeledMemory(self.id, m) if "label" in m else ScoredMemory(self.id, m)) for m in ms]
             for ms in response
@@ -3047,6 +3270,7 @@ class LabeledMemoryset(MemorysetBase[LabeledMemory, LabeledMemoryLookup]):
         *,
         datasource: None = None,
         embedding_model: FinetunedEmbeddingModel | PretrainedEmbeddingModel | None = None,
+        partitioned: bool = False,
         description: str | None = None,
         label_names: list[str],
         max_seq_length_override: int | None = None,
@@ -3121,6 +3345,7 @@ class LabeledMemoryset(MemorysetBase[LabeledMemory, LabeledMemoryLookup]):
         label_column: str | None = "label",
         source_id_column: str | None = None,
         partition_id_column: str | None = None,
+        partitioned: bool = False,
         description: str | None = None,
         label_names: list[str] | None = None,
         max_seq_length_override: int | None = None,
@@ -3185,70 +3410,29 @@ class LabeledMemoryset(MemorysetBase[LabeledMemory, LabeledMemoryLookup]):
             ValueError: If the memoryset already exists and if_exists is `"error"` or if it is
                 `"open"` and the params do not match those of the existing memoryset.
         """
-        if datasource is None:
-            return super().create(
-                name,
-                datasource=None,
-                embedding_model=embedding_model,
-                description=description,
-                label_names=label_names,
-                max_seq_length_override=max_seq_length_override,
-                prompt=prompt,
-                index_type=index_type,
-                index_params=index_params,
-                if_exists=if_exists,
-                hidden=hidden,
-                memory_type="LABELED",
-            )
-        else:
-            # Type narrowing: datasource is definitely Datasource here
-            assert datasource is not None
-            if background:
-                return super().create(
-                    name,
-                    datasource=datasource,
-                    label_column=label_column,
-                    score_column=None,
-                    embedding_model=embedding_model,
-                    value_column=value_column,
-                    source_id_column=source_id_column,
-                    partition_id_column=partition_id_column,
-                    description=description,
-                    label_names=label_names,
-                    max_seq_length_override=max_seq_length_override,
-                    prompt=prompt,
-                    remove_duplicates=remove_duplicates,
-                    index_type=index_type,
-                    index_params=index_params,
-                    if_exists=if_exists,
-                    background=True,
-                    hidden=hidden,
-                    subsample=subsample,
-                    memory_type="LABELED",
-                )
-            else:
-                return super().create(
-                    name,
-                    datasource=datasource,
-                    label_column=label_column,
-                    score_column=None,
-                    embedding_model=embedding_model,
-                    value_column=value_column,
-                    source_id_column=source_id_column,
-                    partition_id_column=partition_id_column,
-                    description=description,
-                    label_names=label_names,
-                    max_seq_length_override=max_seq_length_override,
-                    prompt=prompt,
-                    remove_duplicates=remove_duplicates,
-                    index_type=index_type,
-                    index_params=index_params,
-                    if_exists=if_exists,
-                    background=False,
-                    hidden=hidden,
-                    subsample=subsample,
-                    memory_type="LABELED",
-                )
+        return super().create(
+            name,
+            datasource=datasource,
+            embedding_model=embedding_model,
+            value_column=value_column,
+            label_column=label_column,
+            score_column=None,
+            source_id_column=source_id_column,
+            partition_id_column=partition_id_column,
+            partitioned=partitioned,
+            description=description,
+            label_names=label_names,
+            max_seq_length_override=max_seq_length_override,
+            prompt=prompt,
+            remove_duplicates=remove_duplicates,
+            index_type=index_type,
+            index_params=index_params,
+            if_exists=if_exists,
+            background=background,
+            hidden=hidden,
+            subsample=subsample,
+            memory_type="LABELED",
+        )
 
     @overload
     @classmethod
@@ -3376,52 +3560,27 @@ class LabeledMemoryset(MemorysetBase[LabeledMemory, LabeledMemoryLookup]):
             ValueError: If the memoryset already exists and if_exists is `"error"` or if it is
                 `"open"` and the params do not match those of the existing memoryset.
         """
-        if background:
-            return super().create(
-                name,
-                datasource=datasource,
-                label_column=label_column,
-                score_column=None,
-                embedding_model=embedding_model,
-                value_column=value_column,
-                source_id_column=source_id_column,
-                partition_id_column=partition_id_column,
-                description=description,
-                label_names=label_names,
-                max_seq_length_override=max_seq_length_override,
-                prompt=prompt,
-                remove_duplicates=remove_duplicates,
-                index_type=index_type,
-                index_params=index_params,
-                if_exists=if_exists,
-                background=True,
-                hidden=hidden,
-                subsample=subsample,
-                memory_type="LABELED",
-            )
-        else:
-            return super().create(
-                name,
-                datasource=datasource,
-                label_column=label_column,
-                score_column=None,
-                embedding_model=embedding_model,
-                value_column=value_column,
-                source_id_column=source_id_column,
-                partition_id_column=partition_id_column,
-                description=description,
-                label_names=label_names,
-                max_seq_length_override=max_seq_length_override,
-                prompt=prompt,
-                remove_duplicates=remove_duplicates,
-                index_type=index_type,
-                index_params=index_params,
-                if_exists=if_exists,
-                background=False,
-                hidden=hidden,
-                subsample=subsample,
-                memory_type="LABELED",
-            )
+        return cls._create_from_datasource(
+            name,
+            datasource=datasource,
+            label_column=label_column,
+            embedding_model=embedding_model,
+            value_column=value_column,
+            source_id_column=source_id_column,
+            partition_id_column=partition_id_column,
+            description=description,
+            label_names=label_names,
+            max_seq_length_override=max_seq_length_override,
+            prompt=prompt,
+            remove_duplicates=remove_duplicates,
+            index_type=index_type,
+            index_params=index_params,
+            if_exists=if_exists,
+            background=background,
+            hidden=hidden,
+            subsample=subsample,
+            memory_type="LABELED",
+        )
 
     def display_label_analysis(self):
         """
@@ -3434,6 +3593,22 @@ class LabeledMemoryset(MemorysetBase[LabeledMemory, LabeledMemoryLookup]):
 
         display_suggested_memory_relabels(self)
 
+    @property
+    def classification_models(self) -> list[ClassificationModel]:
+        """
+        List all classification models that use this memoryset
+
+        Returns:
+            List of classification models associated with this memoryset
+        """
+        from .classification_model import ClassificationModel
+
+        client = OrcaClient._resolve_client()
+        return [
+            ClassificationModel(metadata)
+            for metadata in client.GET("/classification_model", params={"memoryset_name_or_id": str(self.id)})
+        ]
+
 
 class ScoredMemoryset(MemorysetBase[ScoredMemory, ScoredMemoryLookup]):
     """
@@ -3462,6 +3637,7 @@ class ScoredMemoryset(MemorysetBase[ScoredMemory, ScoredMemoryLookup]):
         *,
         datasource: None = None,
         embedding_model: FinetunedEmbeddingModel | PretrainedEmbeddingModel | None = None,
+        partitioned: bool = False,
         description: str | None = None,
         max_seq_length_override: int | None = None,
         prompt: str | None = None,
@@ -3505,8 +3681,8 @@ class ScoredMemoryset(MemorysetBase[ScoredMemory, ScoredMemoryLookup]):
         *,
         datasource: Datasource,
         embedding_model: FinetunedEmbeddingModel | PretrainedEmbeddingModel | None = None,
-        score_column: str | None = "score",
         value_column: str = "value",
+        score_column: str | None = "score",
         source_id_column: str | None = None,
         partition_id_column: str | None = None,
         description: str | None = None,
@@ -3533,6 +3709,7 @@ class ScoredMemoryset(MemorysetBase[ScoredMemory, ScoredMemoryLookup]):
         score_column: str | None = "score",
         source_id_column: str | None = None,
         partition_id_column: str | None = None,
+        partitioned: bool = False,
         description: str | None = None,
         max_seq_length_override: int | None = None,
         prompt: str | None = None,
@@ -3590,65 +3767,27 @@ class ScoredMemoryset(MemorysetBase[ScoredMemory, ScoredMemoryLookup]):
             ValueError: If the memoryset already exists and if_exists is `"error"` or if it is
                 `"open"` and the params do not match those of the existing memoryset.
         """
-        if datasource is None:
-            return super().create(
-                name,
-                datasource=None,
-                embedding_model=embedding_model,
-                description=description,
-                max_seq_length_override=max_seq_length_override,
-                prompt=prompt,
-                index_type=index_type,
-                index_params=index_params,
-                if_exists=if_exists,
-                hidden=hidden,
-                memory_type="SCORED",
-            )
-        else:
-            # Type narrowing: datasource is definitely Datasource here
-            assert datasource is not None
-            if background:
-                return super().create(
-                    name,
-                    datasource=datasource,
-                    embedding_model=embedding_model,
-                    value_column=value_column,
-                    score_column=score_column,
-                    source_id_column=source_id_column,
-                    partition_id_column=partition_id_column,
-                    description=description,
-                    max_seq_length_override=max_seq_length_override,
-                    prompt=prompt,
-                    remove_duplicates=remove_duplicates,
-                    index_type=index_type,
-                    index_params=index_params,
-                    if_exists=if_exists,
-                    background=True,
-                    hidden=hidden,
-                    subsample=subsample,
-                    memory_type="SCORED",
-                )
-            else:
-                return super().create(
-                    name,
-                    datasource=datasource,
-                    embedding_model=embedding_model,
-                    value_column=value_column,
-                    score_column=score_column,
-                    source_id_column=source_id_column,
-                    partition_id_column=partition_id_column,
-                    description=description,
-                    max_seq_length_override=max_seq_length_override,
-                    prompt=prompt,
-                    remove_duplicates=remove_duplicates,
-                    index_type=index_type,
-                    index_params=index_params,
-                    if_exists=if_exists,
-                    background=False,
-                    hidden=hidden,
-                    subsample=subsample,
-                    memory_type="SCORED",
-                )
+        return super().create(
+            name,
+            datasource=datasource,
+            embedding_model=embedding_model,
+            value_column=value_column,
+            score_column=score_column,
+            source_id_column=source_id_column,
+            partition_id_column=partition_id_column,
+            partitioned=partitioned,
+            description=description,
+            max_seq_length_override=max_seq_length_override,
+            prompt=prompt,
+            remove_duplicates=remove_duplicates,
+            index_type=index_type,
+            index_params=index_params,
+            if_exists=if_exists,
+            background=background,
+            hidden=hidden,
+            subsample=subsample,
+            memory_type="SCORED",
+        )
 
     @overload
     @classmethod
@@ -3767,45 +3906,39 @@ class ScoredMemoryset(MemorysetBase[ScoredMemory, ScoredMemoryLookup]):
             ValueError: If the memoryset already exists and if_exists is `"error"` or if it is
                 `"open"` and the params do not match those of the existing memoryset.
         """
-        if background:
-            return super().create(
-                name,
-                datasource=datasource,
-                embedding_model=embedding_model,
-                value_column=value_column,
-                score_column=score_column,
-                source_id_column=source_id_column,
-                partition_id_column=partition_id_column,
-                description=description,
-                max_seq_length_override=max_seq_length_override,
-                prompt=prompt,
-                remove_duplicates=remove_duplicates,
-                index_type=index_type,
-                index_params=index_params,
-                if_exists=if_exists,
-                background=True,
-                hidden=hidden,
-                subsample=subsample,
-                memory_type="SCORED",
-            )
-        else:
-            return super().create(
-                name,
-                datasource=datasource,
-                embedding_model=embedding_model,
-                value_column=value_column,
-                score_column=score_column,
-                source_id_column=source_id_column,
-                partition_id_column=partition_id_column,
-                description=description,
-                max_seq_length_override=max_seq_length_override,
-                prompt=prompt,
-                remove_duplicates=remove_duplicates,
-                index_type=index_type,
-                index_params=index_params,
-                if_exists=if_exists,
-                background=False,
-                hidden=hidden,
-                subsample=subsample,
-                memory_type="SCORED",
-            )
+        return cls._create_from_datasource(
+            name,
+            datasource=datasource,
+            embedding_model=embedding_model,
+            value_column=value_column,
+            score_column=score_column,
+            source_id_column=source_id_column,
+            partition_id_column=partition_id_column,
+            description=description,
+            max_seq_length_override=max_seq_length_override,
+            prompt=prompt,
+            remove_duplicates=remove_duplicates,
+            index_type=index_type,
+            index_params=index_params,
+            if_exists=if_exists,
+            background=background,
+            hidden=hidden,
+            subsample=subsample,
+            memory_type="SCORED",
+        )
+
+    @property
+    def regression_models(self) -> list[RegressionModel]:
+        """
+        List all regression models that use this memoryset
+
+        Returns:
+            List of regression models associated with this memoryset
+        """
+        from .regression_model import RegressionModel
+
+        client = OrcaClient._resolve_client()
+        return [
+            RegressionModel(metadata)
+            for metadata in client.GET("/regression_model", params={"memoryset_name_or_id": str(self.id)})
+        ]