diff --git a/README.md b/README.md
index 642cd8f2ec..7929adb4b5 100644
--- a/README.md
+++ b/README.md
@@ -22,6 +22,7 @@ models**
 [![PyPI python](https://img.shields.io/pypi/pyversions/fiftyone)](https://pypi.org/project/fiftyone)
 [![PyPI version](https://badge.fury.io/py/fiftyone.svg)](https://pypi.org/project/fiftyone)
 [![Downloads](https://pepy.tech/badge/fiftyone)](https://pepy.tech/project/fiftyone)
+[![Docker Pulls](https://badgen.net/docker/pulls/voxel51/fiftyone?icon=docker&label=pulls)](https://hub.docker.com/r/voxel51/fiftyone/)
 [![Build](https://github.com/voxel51/fiftyone/workflows/Build/badge.svg?branch=develop&event=push)](https://github.com/voxel51/fiftyone/actions?query=workflow%3ABuild)
 [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](LICENSE)
 [![Slack](https://img.shields.io/badge/Slack-4A154B?logo=slack&logoColor=white)](https://slack.voxel51.com)
diff --git a/app/package.json b/app/package.json
index 96018190d4..b87856532f 100644
--- a/app/package.json
+++ b/app/package.json
@@ -16,7 +16,7 @@
         "start": "yarn workspace @fiftyone/app start",
         "start-desktop": "yarn workspace FiftyOne start-desktop",
         "test": "yarn vitest run",
-        "test-ui": "yarn vitest --ui",
+        "test-ui": "yarn vitest --ui --coverage",
         "gen:schema": "strawberry export-schema fiftyone.server.app:schema > schema.graphql"
     },
     "devDependencies": {
diff --git a/app/packages/core/src/components/Filters/BooleanFieldFilter.tsx b/app/packages/core/src/components/Filters/BooleanFieldFilter.tsx
index 3407a01193..12769a7491 100644
--- a/app/packages/core/src/components/Filters/BooleanFieldFilter.tsx
+++ b/app/packages/core/src/components/Filters/BooleanFieldFilter.tsx
@@ -1,12 +1,10 @@
-import React from "react";
-
 import {
+  boolExcludeAtom,
+  boolIsMatchingAtom,
   booleanCountResults,
   booleanSelectedValuesAtom,
-  boolIsMatchingAtom,
-  boolOnlyMatchAtom,
-  boolExcludeAtom,
 } from "@fiftyone/state";
+import React from "react";
 import CategoricalFilter from "./categoricalFilter/CategoricalFilter";
 
 const BooleanFieldFilter = ({
@@ -27,7 +25,6 @@ const BooleanFieldFilter = ({
     <CategoricalFilter<{ value: boolean | null; count: number }>
       selectedValuesAtom={booleanSelectedValuesAtom({ path, modal })}
       isMatchingAtom={boolIsMatchingAtom({ path, modal })}
-      onlyMatchAtom={boolOnlyMatchAtom({ path, modal })}
       excludeAtom={boolExcludeAtom({ path, modal })}
       countsAtom={booleanCountResults({
         path,
diff --git a/app/packages/core/src/components/Filters/LabelFieldFilter.tsx b/app/packages/core/src/components/Filters/LabelFieldFilter.tsx
index ea672b231f..14cfc9b2e9 100644
--- a/app/packages/core/src/components/Filters/LabelFieldFilter.tsx
+++ b/app/packages/core/src/components/Filters/LabelFieldFilter.tsx
@@ -2,12 +2,11 @@ import React from "react";
 
 import {
   isMatchingAtom,
-  onlyMatchAtom,
   stringExcludeAtom,
   stringSelectedValuesAtom,
 } from "@fiftyone/state";
-import CategoricalFilter from "./categoricalFilter/CategoricalFilter";
 import { labelTagsCount } from "../Sidebar/Entries/EntryCounts";
+import CategoricalFilter from "./categoricalFilter/CategoricalFilter";
 
 const LabelTagFieldFilter = ({
   path,
@@ -27,7 +26,6 @@ const LabelTagFieldFilter = ({
     <CategoricalFilter<{ value: string | null; count: number }>
       selectedValuesAtom={stringSelectedValuesAtom({ modal, path })}
       excludeAtom={stringExcludeAtom({ modal, path })}
-      onlyMatchAtom={onlyMatchAtom({ modal, path })}
       isMatchingAtom={isMatchingAtom({ modal, path })}
       countsAtom={labelTagsCount({ modal, extended: false })}
       path={path}
diff --git a/app/packages/core/src/components/Filters/NumericFieldFilter.tsx b/app/packages/core/src/components/Filters/NumericFieldFilter.tsx
index 890fd81764..e33b386204 100644
--- a/app/packages/core/src/components/Filters/NumericFieldFilter.tsx
+++ b/app/packages/core/src/components/Filters/NumericFieldFilter.tsx
@@ -10,14 +10,14 @@ import styled from "styled-components";
 
 import * as fos from "@fiftyone/state";
 
-import RangeSlider from "../Common/RangeSlider";
-import Checkbox from "../Common/Checkbox";
-import { Button } from "../utils";
 import { DATE_FIELD, DATE_TIME_FIELD, FLOAT_FIELD } from "@fiftyone/utilities";
 import { formatDateTime } from "../../utils/generic";
-import withSuspense from "./withSuspense";
+import Checkbox from "../Common/Checkbox";
+import RangeSlider from "../Common/RangeSlider";
 import FieldLabelAndInfo from "../FieldLabelAndInfo";
+import { Button } from "../utils";
 import FilterOption from "./categoricalFilter/filterOption/FilterOption";
+import withSuspense from "./withSuspense";
 
 const NamedRangeSliderContainer = styled.div`
   margin: 3px;
@@ -135,11 +135,6 @@ const NumericFieldFilter = ({
     modal,
     defaultRange,
   });
-  const onlyMatchAtom = fos.numericOnlyMatchAtom({
-    path,
-    modal,
-    defaultRange,
-  });
   const values = useRecoilValue(
     fos.rangeAtom({
       modal,
@@ -149,7 +144,6 @@ const NumericFieldFilter = ({
     })
   );
   const setExcluded = excludeAtom ? useSetRecoilState(excludeAtom) : null;
-  const setOnlyMatch = onlyMatchAtom ? useSetRecoilState(onlyMatchAtom) : null;
   const setIsMatching = isMatchingAtom
     ? useSetRecoilState(isMatchingAtom)
     : null;
@@ -207,7 +201,6 @@ const NumericFieldFilter = ({
   const initializeSettings = () => {
     setFilter([null, null]);
     setExcluded && setExcluded(false);
-    setOnlyMatch && setOnlyMatch(true);
     setIsMatching && setIsMatching(!nestedField);
   };
 
@@ -304,7 +297,6 @@ const NumericFieldFilter = ({
             nestedField={nestedField}
             shouldNotShowExclude={false} // only boolean fields don't use exclude
             excludeAtom={excludeAtom}
-            onlyMatchAtom={onlyMatchAtom}
             isMatchingAtom={isMatchingAtom}
             valueName={field?.name ?? ""}
             path={path}
diff --git a/app/packages/core/src/components/Filters/StringFieldFilter.tsx b/app/packages/core/src/components/Filters/StringFieldFilter.tsx
index aa8f3df7c1..a2697f5598 100644
--- a/app/packages/core/src/components/Filters/StringFieldFilter.tsx
+++ b/app/packages/core/src/components/Filters/StringFieldFilter.tsx
@@ -1,12 +1,10 @@
-import React from "react";
 import * as fos from "@fiftyone/state";
-
 import {
   isMatchingAtom,
-  onlyMatchAtom,
   stringExcludeAtom,
   stringSelectedValuesAtom,
 } from "@fiftyone/state";
+import React from "react";
 import CategoricalFilter from "./categoricalFilter/CategoricalFilter";
 
 const StringFieldFilter = ({
@@ -27,7 +25,6 @@ const StringFieldFilter = ({
     <CategoricalFilter<{ value: string | null; count: number }>
       selectedValuesAtom={stringSelectedValuesAtom({ modal, path })}
       excludeAtom={stringExcludeAtom({ modal, path })}
-      onlyMatchAtom={onlyMatchAtom({ modal, path })}
       isMatchingAtom={isMatchingAtom({ modal, path })}
       countsAtom={fos.stringCountResults({
         modal,
diff --git a/app/packages/core/src/components/Filters/categoricalFilter/CategoricalFilter.tsx b/app/packages/core/src/components/Filters/categoricalFilter/CategoricalFilter.tsx
index efe73f4366..bcb5ceac19 100644
--- a/app/packages/core/src/components/Filters/categoricalFilter/CategoricalFilter.tsx
+++ b/app/packages/core/src/components/Filters/categoricalFilter/CategoricalFilter.tsx
@@ -175,7 +175,6 @@ interface Props<T extends V = V> {
   selectedValuesAtom: RecoilState<T["value"][]>;
   excludeAtom: RecoilState<boolean>; // toggles select or exclude
   isMatchingAtom: RecoilState<boolean>; // toggles match or filter
-  onlyMatchAtom: RecoilState<boolean>; // toggles onlyMatch mode (omit empty samples)
   countsAtom: RecoilValue<{
     count: number;
     results: [T["value"], number][];
@@ -190,7 +189,6 @@ const CategoricalFilter = <T extends V = V>({
   countsAtom,
   selectedValuesAtom,
   excludeAtom,
-  onlyMatchAtom,
   isMatchingAtom,
   path,
   modal,
@@ -203,6 +201,7 @@ const CategoricalFilter = <T extends V = V>({
     : path.startsWith("_label_tags")
     ? "label tag"
     : name;
+
   const selectedCounts = useRef(new Map<V["value"], number>());
   const onSelect = useOnSelect(selectedValuesAtom, selectedCounts);
   const useSearch = getUseSearch({ modal, path });
@@ -213,7 +212,7 @@ const CategoricalFilter = <T extends V = V>({
 
   // id fields should always use filter mode
   const neverShowExpansion = field?.ftype?.includes("ObjectIdField");
-
+  if (countsLoadable.state === "hasError") throw countsLoadable.contents;
   if (countsLoadable.state !== "hasValue") return null;
   const { count, results } = countsLoadable.contents;
 
@@ -267,7 +266,6 @@ const CategoricalFilter = <T extends V = V>({
           selectedValuesAtom={selectedValuesAtom}
           excludeAtom={excludeAtom}
           isMatchingAtom={isMatchingAtom}
-          onlyMatchAtom={onlyMatchAtom}
           modal={modal}
           totalCount={count}
           selectedCounts={selectedCounts}
diff --git a/app/packages/core/src/components/Filters/categoricalFilter/Wrapper.tsx b/app/packages/core/src/components/Filters/categoricalFilter/Wrapper.tsx
index 2853f8b614..381371ca3a 100644
--- a/app/packages/core/src/components/Filters/categoricalFilter/Wrapper.tsx
+++ b/app/packages/core/src/components/Filters/categoricalFilter/Wrapper.tsx
@@ -8,18 +8,17 @@ import {
 
 import * as fos from "@fiftyone/state";
 
-import FilterOption from "./filterOption/FilterOption";
 import Checkbox from "../../Common/Checkbox";
 import { Button } from "../../utils";
 import { CHECKBOX_LIMIT, nullSort } from "../utils";
-import { isKeypointLabel, V } from "./CategoricalFilter";
+import { V, isKeypointLabel } from "./CategoricalFilter";
+import FilterOption from "./filterOption/FilterOption";
 
 interface WrapperProps {
   results: [V["value"], number][];
   selectedValuesAtom: RecoilState<V["value"][]>;
   excludeAtom: RecoilState<boolean>;
   isMatchingAtom: RecoilState<boolean>;
-  onlyMatchAtom: RecoilState<boolean>;
   color: string;
   totalCount: number;
   modal: boolean;
@@ -34,7 +33,6 @@ const Wrapper = ({
   selectedValuesAtom,
   excludeAtom,
   isMatchingAtom,
-  onlyMatchAtom,
   modal,
   path,
   selectedCounts,
@@ -44,7 +42,6 @@ const Wrapper = ({
   const [selected, setSelected] = useRecoilState(selectedValuesAtom);
   const selectedSet = new Set(selected);
   const setExcluded = excludeAtom ? useSetRecoilState(excludeAtom) : null;
-  const setOnlyMatch = onlyMatchAtom ? useSetRecoilState(onlyMatchAtom) : null;
   const setIsMatching = isMatchingAtom
     ? useSetRecoilState(isMatchingAtom)
     : null;
@@ -87,7 +84,6 @@ const Wrapper = ({
 
   const initializeSettings = () => {
     setExcluded && setExcluded(false);
-    setOnlyMatch && setOnlyMatch(true);
     setIsMatching && setIsMatching(!nestedField);
   };
 
@@ -144,7 +140,6 @@ const Wrapper = ({
               nestedField={nestedField}
               shouldNotShowExclude={shouldNotShowExclude}
               excludeAtom={excludeAtom}
-              onlyMatchAtom={onlyMatchAtom}
               isMatchingAtom={isMatchingAtom}
               valueName={name}
               color={color}
diff --git a/app/packages/core/src/components/Filters/categoricalFilter/filterOption/FilterOption.tsx b/app/packages/core/src/components/Filters/categoricalFilter/filterOption/FilterOption.tsx
index 8cb7239ff6..29d5afa561 100644
--- a/app/packages/core/src/components/Filters/categoricalFilter/filterOption/FilterOption.tsx
+++ b/app/packages/core/src/components/Filters/categoricalFilter/filterOption/FilterOption.tsx
@@ -1,27 +1,24 @@
-import React, { PropsWithChildren, useEffect } from "react";
-import styled from "styled-components";
-import { RecoilState, useRecoilState, useSetRecoilState } from "recoil";
 import FilterAltIcon from "@mui/icons-material/FilterAlt";
 import FilterAltOffIcon from "@mui/icons-material/FilterAltOff";
-import ImageIcon from "@mui/icons-material/Image";
 import HideImageIcon from "@mui/icons-material/HideImage";
+import ImageIcon from "@mui/icons-material/Image";
 import { IconButton } from "@mui/material";
-import { useSpring } from "framer-motion";
 import Color from "color";
+import React, { useEffect } from "react";
+import { RecoilState, useRecoilState, useSetRecoilState } from "recoil";
+import styled from "styled-components";
 
-import { useOutsideClick } from "@fiftyone/state";
 import { useTheme } from "@fiftyone/components/src/components/ThemeProvider";
 import Tooltip from "@fiftyone/components/src/components/Tooltip";
+import { useOutsideClick } from "@fiftyone/state";
 
-import { PopoutDiv } from "../../../utils";
-import Item from "./FilterItem";
 import { Popout } from "@fiftyone/components";
+import Item from "./FilterItem";
 
 interface Props {
   nestedField: string | undefined; // nested ListFields only ("detections")
   shouldNotShowExclude: boolean; // for BooleanFields
   excludeAtom: RecoilState<boolean>;
-  onlyMatchAtom: RecoilState<boolean>;
   isMatchingAtom: RecoilState<boolean>;
   valueName: string;
   color: string;
@@ -132,7 +129,6 @@ const FilterOption: React.FC<Props> = ({
   nestedField,
   shouldNotShowExclude,
   excludeAtom,
-  onlyMatchAtom,
   isMatchingAtom,
 }) => {
   const isLabelTag = path?.startsWith("_label_tags");
@@ -140,7 +136,6 @@ const FilterOption: React.FC<Props> = ({
 
   const [open, setOpen] = React.useState(false);
   const [excluded, setExcluded] = useRecoilState(excludeAtom);
-  const setOnlyMatch = onlyMatchAtom ? useSetRecoilState(onlyMatchAtom) : null;
   const setIsMatching = isMatchingAtom
     ? useSetRecoilState(isMatchingAtom)
     : null;
@@ -213,25 +208,21 @@ const FilterOption: React.FC<Props> = ({
   const onSelectFilter = () => {
     setExcluded && setExcluded(false);
     setIsMatching && setIsMatching(false);
-    setOnlyMatch && setOnlyMatch(true);
   };
 
   const onSelectNegativeFilter = () => {
     setExcluded && setExcluded(true);
     setIsMatching && setIsMatching(false);
-    setOnlyMatch && setOnlyMatch(false);
   };
 
   const onSelectMatch = () => {
     setExcluded && setExcluded(false);
     setIsMatching && setIsMatching(true);
-    setOnlyMatch && setOnlyMatch(true);
   };
 
   const onSelectNegativeMatch = () => {
     setExcluded && setExcluded(true);
     setIsMatching && setIsMatching(true);
-    setOnlyMatch && setOnlyMatch(true);
   };
 
   const children = (
diff --git a/app/packages/core/src/plugins/SchemaIO/components/DropdownView.tsx b/app/packages/core/src/plugins/SchemaIO/components/DropdownView.tsx
index 39d580f727..d9ad7d0ce7 100644
--- a/app/packages/core/src/plugins/SchemaIO/components/DropdownView.tsx
+++ b/app/packages/core/src/plugins/SchemaIO/components/DropdownView.tsx
@@ -1,15 +1,46 @@
+import { Box, ListItemText, MenuItem, Select, Typography } from "@mui/material";
 import React from "react";
-import { Box, Typography, Select, MenuItem, ListItemText } from "@mui/material";
-import FieldWrapper from "./FieldWrapper";
-import autoFocus from "../utils/auto-focus";
 import { getComponentProps } from "../utils";
+import autoFocus from "../utils/auto-focus";
+import AlertView from "./AlertView";
+import FieldWrapper from "./FieldWrapper";
+
+const MULTI_SELECT_TYPES = ["string", "array"];
 
 export default function DropdownView(props) {
   const { onChange, schema, path, data } = props;
-  const { view = {}, type } = schema;
-  const { choices, placeholder = "", readOnly } = view;
+  const { default: defaultValue, view = {}, type } = schema;
+  const {
+    choices,
+    multiple: multiSelect,
+    placeholder = "",
+    separator = ",",
+    readOnly,
+  } = view;
+
+  if (multiSelect && !MULTI_SELECT_TYPES.includes(type))
+    return (
+      <AlertView
+        schema={{
+          view: {
+            label: `Unsupported type "${type}" for multi-select`,
+            description:
+              "Multi-select is supported for types " +
+              MULTI_SELECT_TYPES.join(", "),
+            severity: "error",
+          },
+        }}
+      />
+    );
 
-  const multiple = type === "array";
+  const isArrayType = type === "array";
+  const multiple = multiSelect || isArrayType;
+  const fallbackDefaultValue = multiple ? [] : "";
+  const rawDefaultValue = data ?? defaultValue ?? fallbackDefaultValue;
+  const computedDefaultValue =
+    multiple && !Array.isArray(rawDefaultValue)
+      ? rawDefaultValue.toString().split(separator)
+      : rawDefaultValue;
 
   const choiceLabels = choices.reduce((labels, choice) => {
     labels[choice.value] = choice.label;
@@ -21,7 +52,7 @@ export default function DropdownView(props) {
       <Select
         disabled={readOnly}
         autoFocus={autoFocus(props)}
-        defaultValue={data ?? schema.default ?? (multiple ? [] : "")}
+        defaultValue={computedDefaultValue}
         size="small"
         fullWidth
         displayEmpty
@@ -34,7 +65,14 @@ export default function DropdownView(props) {
           }
           return choiceLabels[value] || value;
         }}
-        onChange={(e) => onChange(path, e.target.value)}
+        onChange={(e) => {
+          const value = e.target.value;
+          const computedValue =
+            Array.isArray(value) && type !== "array"
+              ? value.join(separator)
+              : value;
+          onChange(path, computedValue);
+        }}
         multiple={multiple}
         {...getComponentProps(props, "select")}
       >
diff --git a/app/packages/state/src/hooks/useSchemaSettings.test.ts b/app/packages/state/src/hooks/useSchemaSettings.test.ts
index 493c1e761c..a9a381f28b 100644
--- a/app/packages/state/src/hooks/useSchemaSettings.test.ts
+++ b/app/packages/state/src/hooks/useSchemaSettings.test.ts
@@ -1,35 +1,891 @@
 import { afterEach, describe, expect, it, vi } from "vitest";
 import { disabledField } from "./useSchemaSettings.utils";
-import { OBJECT_ID_FIELD } from "@fiftyone/utilities";
+import {
+  ARRAY_FIELD,
+  CLASSIFICATIONS_FIELD,
+  CLASSIFICATION_FIELD,
+  DETECTIONS_FIELD,
+  DETECTION_DISABLED_SUB_PATHS,
+  DETECTION_FIELD,
+  EMBEDDED_DOCUMENT_FIELD,
+  FLOAT_FIELD,
+  FRAME_NUMBER_FIELD,
+  GEO_LOCATIONS_FIELD,
+  GEO_LOCATION_FIELD,
+  HEATMAP_FIELD,
+  INT_FIELD,
+  POLYLINE_DISABLED_SUB_PATHS,
+  KEYPOINT_FIELD,
+  LIST_FIELD,
+  OBJECT_ID_FIELD,
+  POLYLINES_FIELD,
+  POLYLINE_FIELD,
+  REGRESSION_FIELD,
+  SEGMENTATION_FIELD,
+  STRING_FIELD,
+  TEMPORAL_DETECTIONS_FIELD,
+  TEMPORAL_DETECTION_FIELD,
+  CLASSIFICATION_DISABLED_SUB_PATHS,
+  REGRESSION_DISABLED_SUB_PATHS,
+  KEYPOINT_DISABLED_SUB_PATHS,
+  SEGMENTATION_DISABLED_SUB_PATHS,
+  HEATMAP_DISABLED_SUB_PATHS,
+  TEMPORAL_DETECTION_DISABLED_SUB_PATHS,
+  GEOLOCATION_DISABLED_SUB_PATHS,
+  GEOLOCATIONS_DISABLED_SUB_PATHS,
+  KEYPOINTS_FIELD,
+  VECTOR_FIELD,
+  FRAME_SUPPORT_FIELD,
+} from "@fiftyone/utilities";
+
+const BASE_FIELD = {
+  path: null,
+  embeddedDocType: null,
+  ftype: null,
+  description: null,
+  info: null,
+  name: null,
+  fields: null,
+  dbField: null,
+  subfield: null,
+  visible: false,
+};
+
+const GROUP_DATASET = "group";
+const NOT_GROUP_DATASET = "";
 
 const FIELDS = {
   ID_FIELD: {
+    ...BASE_FIELD,
     path: "id",
-    embeddedDocType: null,
     ftype: OBJECT_ID_FIELD,
-    description: null,
-    info: null,
-    name: null,
-    fields: null,
-    dbField: null,
-    subfield: null,
-    visible: false,
+  },
+  FILEPATH_FIELD: {
+    ...BASE_FIELD,
+    path: "filepath",
+    ftype: STRING_FIELD,
+  },
+  TAGS_FIELD: {
+    ...BASE_FIELD,
+    path: "tags",
+    ftype: LIST_FIELD,
+  },
+  CUSTOM_LIST_FIELD: {
+    ...BASE_FIELD,
+    path: "custom_list",
+    ftype: LIST_FIELD,
+  },
+  METADATA_FIELD: {
+    ...BASE_FIELD,
+    path: "metadata",
+    ftype: EMBEDDED_DOCUMENT_FIELD,
+  },
+  OBJECT_ID_TYPE: {
+    ...BASE_FIELD,
+    path: "id",
+    ftype: OBJECT_ID_FIELD,
+  },
+  OBJECT_ID_TYPE_NESTED: {
+    ...BASE_FIELD,
+    path: "Nested.ObjectIdType",
+    ftype: OBJECT_ID_FIELD,
+  },
+  FRAME_NUMBER_TYPE: {
+    ...BASE_FIELD,
+    path: "frame_number",
+    ftype: FRAME_NUMBER_FIELD,
+  },
+  FRAME_NUMBER_CUSTOM_FIELD_TYPE: {
+    ...BASE_FIELD,
+    path: "frame_number_custom_name",
+    ftype: FRAME_NUMBER_FIELD,
+  },
+  FRAME_SUPPORT_TYPE: {
+    ...BASE_FIELD,
+    path: "FrameSupportField",
+    ftype: FRAME_SUPPORT_FIELD,
+  },
+  VECTOR_TYPE: {
+    ...BASE_FIELD,
+    path: "VectorField",
+    ftype: VECTOR_FIELD,
+  },
+  CUSTOM_EMBEDDED_DOCUMENT_FIELD: {
+    ...BASE_FIELD,
+    path: "customEmbeddedDocumentField",
+    ftype: EMBEDDED_DOCUMENT_FIELD,
+  },
+  CUSTOM_EMBEDDED_DOCUMENT_NAME_FIELD: {
+    ...BASE_FIELD,
+    path: "customEmbeddedDocumentField.name",
+    ftype: STRING_FIELD,
+  },
+  GROUP_FIELD: {
+    ...BASE_FIELD,
+    path: GROUP_DATASET,
+    ftype: EMBEDDED_DOCUMENT_FIELD,
+  },
+  GROUP_CHILD_FIELD: {
+    ...BASE_FIELD,
+    path: `${GROUP_DATASET}.name`,
+    ftype: STRING_FIELD,
+  },
+  FRAME_ID_FIELD: {
+    ...BASE_FIELD,
+    path: "frames.id",
+    ftype: OBJECT_ID_FIELD,
+  },
+  FRAMES_NUMBER_FIELD: {
+    ...BASE_FIELD,
+    path: "frames.frame_number",
+    ftype: FRAME_NUMBER_FIELD,
+  },
+  SAMPLE_ID_FIELD: {
+    ...BASE_FIELD,
+    path: "sample_id",
+    ftype: OBJECT_ID_FIELD,
+  },
+  FRAME_SAMPLE_ID_FIELD: {
+    ...BASE_FIELD,
+    path: "frames.sample_id",
+    ftype: OBJECT_ID_FIELD,
+  },
+  FRAME_NUMBER_FIELD: {
+    ...BASE_FIELD,
+    path: "frame_number",
+    ftype: INT_FIELD,
+  },
+  METADATA_WIDTH_FIELD: {
+    ...BASE_FIELD,
+    path: "metadata.width",
+    ftype: FLOAT_FIELD,
+  },
+  DETECTION_FIELD: {
+    ...BASE_FIELD,
+    path: "detection",
+    ftype: DETECTION_FIELD,
+  },
+  DETECTIONS_FIELD: {
+    ...BASE_FIELD,
+    path: "detections",
+    ftype: DETECTIONS_FIELD,
+  },
+  DETECTIONS_LIST_FIELD: {
+    ...BASE_FIELD,
+    path: "detections",
+    ftype: LIST_FIELD,
+    embeddedDocType: DETECTIONS_FIELD,
+  },
+  CLASSIFICATION_FIELD: {
+    ...BASE_FIELD,
+    path: "classification",
+    ftype: CLASSIFICATION_FIELD,
+  },
+  CLASSIFICATIONS_FIELD: {
+    ...BASE_FIELD,
+    path: "classifications",
+    ftype: CLASSIFICATIONS_FIELD,
+  },
+  KEYPOINT_FIELD: {
+    ...BASE_FIELD,
+    path: "keypoint",
+    ftype: KEYPOINT_FIELD,
+  },
+  KEYPOINTS_FIELD: {
+    ...BASE_FIELD,
+    path: "keypoints",
+    ftype: KEYPOINTS_FIELD,
+  },
+  REGRESSION_FIELD: {
+    ...BASE_FIELD,
+    path: "regression",
+    ftype: REGRESSION_FIELD,
+  },
+  HEATMAP_FIELD: {
+    ...BASE_FIELD,
+    path: "heatmap",
+    ftype: HEATMAP_FIELD,
+  },
+  SEGMENTATION_FIELD: {
+    ...BASE_FIELD,
+    path: "segmentation",
+    ftype: SEGMENTATION_FIELD,
+  },
+  GEO_LOCATION_FIELD: {
+    ...BASE_FIELD,
+    path: "geolocation",
+    ftype: GEO_LOCATION_FIELD,
+  },
+  GEO_LOCATIONS_FIELD: {
+    ...BASE_FIELD,
+    path: "geolocations",
+    ftype: GEO_LOCATIONS_FIELD,
+  },
+  POLYLINE_FIELD: {
+    ...BASE_FIELD,
+    path: "polyline",
+    ftype: POLYLINE_FIELD,
+  },
+  POLYLINES_FIELD: {
+    ...BASE_FIELD,
+    path: "polylines",
+    ftype: POLYLINES_FIELD,
+  },
+  TEMPORAL_DETECTION_FIELD: {
+    ...BASE_FIELD,
+    path: "temporal",
+    ftype: TEMPORAL_DETECTION_FIELD,
+  },
+  TEMPORAL_DETECTION_FRAME_SUPPORT: {
+    ...BASE_FIELD,
+    path: "temporal.support",
+    ftype: FRAME_SUPPORT_FIELD,
+  },
+  TEMPORAL_DETECTIONS_FIELD: {
+    ...BASE_FIELD,
+    path: "temporals",
+    ftype: TEMPORAL_DETECTIONS_FIELD,
   },
 };
 
-const GROUP_DATASET = "group";
-const NOT_GROUP_DATASET = "";
+const ORIGINAL_SCHEMA = {};
+Object.values(FIELDS).forEach((f) => {
+  ORIGINAL_SCHEMA[f.path] = f;
+});
+let SCHEMA = { ...ORIGINAL_SCHEMA };
+
+const getDisabledNestedLabelFields = (prefix: string, paths: string[]) => {
+  const res = [];
+  if (paths.includes("id")) {
+    res.push({ ...BASE_FIELD, path: `${prefix}.id`, ftype: OBJECT_ID_FIELD });
+  }
+  if (paths.includes("tags")) {
+    res.push({ ...BASE_FIELD, path: `${prefix}.tags`, ftype: LIST_FIELD });
+  }
+  if (paths.includes("label")) {
+    res.push({ ...BASE_FIELD, path: `${prefix}.label`, ftype: STRING_FIELD });
+  }
+  if (paths.includes("bounding_box")) {
+    res.push({
+      ...BASE_FIELD,
+      path: `${prefix}.bounding_box`,
+      ftype: LIST_FIELD,
+    });
+  }
+  if (paths.includes("mask")) {
+    res.push({ ...BASE_FIELD, path: `${prefix}.mask`, ftype: ARRAY_FIELD });
+  }
+  if (paths.includes("confidence")) {
+    res.push({
+      ...BASE_FIELD,
+      path: `${prefix}.confidence`,
+      ftype: FLOAT_FIELD,
+    });
+  }
+  if (paths.includes("index")) {
+    res.push({ ...BASE_FIELD, path: `${prefix}.index`, ftype: INT_FIELD });
+  }
+  if (paths.includes("support")) {
+    res.push({
+      ...BASE_FIELD,
+      path: `${prefix}.support`,
+      ftype: FRAME_SUPPORT_FIELD,
+    });
+  }
+
+  return res;
+};
 
-describe("Disabled schema fields", () => {
+const getEnabledNestedLabelFields = (prefix: string, paths: string[]) => {
+  const res = [];
+  for (let i = 0; i < paths.length; i++) {
+    res.push({
+      ...BASE_FIELD,
+      path: `${prefix}.${paths[i]}`,
+      ftype: STRING_FIELD,
+    });
+  }
+  return res;
+};
+
+describe("Disabled field paths in schema fields", () => {
   afterEach(() => {
     vi.restoreAllMocks();
   });
 
   it("id path is disabled across all fields", () => {
-    const path = "id";
-    const field_1 = FIELDS.ID_FIELD;
-    const schema = { id: field_1 };
+    expect(disabledField("id", SCHEMA, NOT_GROUP_DATASET)).toBe(true);
+  });
+
+  it("filepath path is disabled across all fields", () => {
+    expect(disabledField(FIELDS.FILEPATH_FIELD.path, SCHEMA)).toBe(true);
+  });
+
+  it("tags path is disabled across all fields", () => {
+    expect(disabledField(FIELDS.TAGS_FIELD.path, SCHEMA)).toBe(true);
+  });
+
+  it("metadata path is disabled across all fields", () => {
+    expect(disabledField(FIELDS.METADATA_FIELD.path, SCHEMA)).toBe(true);
+  });
+});
+
+describe("Disabled field types in schema fields", () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("A field with ObjectIdField type and top-level 'id' path is disabled", () => {
+    expect(disabledField(FIELDS.OBJECT_ID_TYPE.path, SCHEMA)).toBe(true);
+  });
+
+  it("A field with ObjectIdField type and non top-level 'id' path is enabled", () => {
+    expect(disabledField(FIELDS.OBJECT_ID_TYPE_NESTED.path, SCHEMA)).toBe(
+      false
+    );
+  });
+
+  it("top level FrameNumberField type is disabled in a video dataset if path=frame_number", () => {
+    expect(
+      disabledField(
+        FIELDS.FRAME_NUMBER_TYPE.path,
+        SCHEMA,
+        NOT_GROUP_DATASET,
+        false,
+        false,
+        true
+      )
+    ).toBe(true);
+  });
+
+  it("top-level FrameNumberField type is disabled in a frameView if path = frame_number", () => {
+    expect(
+      disabledField(
+        FIELDS.FRAME_NUMBER_TYPE.path,
+        SCHEMA,
+        NOT_GROUP_DATASET,
+        true,
+        false,
+        false
+      )
+    ).toBe(true);
+  });
+
+  it("top-level FrameNumberField type is disabled in a frameView if path != frame_number", () => {
+    expect(
+      disabledField(
+        FIELDS.FRAME_NUMBER_CUSTOM_FIELD_TYPE.path,
+        SCHEMA,
+        NOT_GROUP_DATASET,
+        true,
+        false,
+        false
+      )
+    ).toBe(false);
+  });
+
+  it("A field with type FrameSupportField is enabled if not ClipView and a top level path ", () => {
+    expect(
+      disabledField(
+        FIELDS.FRAME_SUPPORT_TYPE.path,
+        SCHEMA,
+        NOT_GROUP_DATASET,
+        false,
+        false
+      )
+    ).toBe(false);
+  });
+
+  it("A field with VectorField type is enabled", () => {
+    expect(
+      disabledField(FIELDS.VECTOR_TYPE.path, SCHEMA, NOT_GROUP_DATASET)
+    ).toBe(false);
+  });
+});
+
+describe("Disabled group field in schema fields", () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("group field is disabled across all fields", () => {
+    expect(
+      disabledField(
+        FIELDS.CUSTOM_EMBEDDED_DOCUMENT_FIELD.path,
+        SCHEMA,
+        NOT_GROUP_DATASET,
+        false
+      )
+    ).toBe(false);
+    expect(
+      disabledField(FIELDS.GROUP_FIELD.path, SCHEMA, GROUP_DATASET, false)
+    ).toBe(true);
+  });
+
+  it("field with parent group is disabled", () => {
+    const parentPath = FIELDS.GROUP_FIELD.path;
+    const path = FIELDS.GROUP_CHILD_FIELD.path;
+
+    expect(disabledField(parentPath, SCHEMA, GROUP_DATASET)).toBe(true);
+    expect(disabledField(path, SCHEMA, GROUP_DATASET)).toBe(true);
+  });
+});
+
+describe("Video dataset disabled fields", () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("frames.id field is disabled", () => {
+    expect(
+      disabledField(
+        FIELDS.FRAME_ID_FIELD.path,
+        SCHEMA,
+        NOT_GROUP_DATASET,
+        false,
+        false,
+        true
+      )
+    ).toBe(true);
+  });
+
+  it("frames.frame_number field is disabled", () => {
+    expect(
+      disabledField(
+        FIELDS.FRAMES_NUMBER_FIELD.path,
+        SCHEMA,
+        NOT_GROUP_DATASET,
+        false,
+        false,
+        true
+      )
+    ).toBe(true);
+  });
+});
+
+describe("Patches view disabled fields", () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("sample_id field is disabled in patches view", () => {
+    expect(
+      disabledField(
+        FIELDS.SAMPLE_ID_FIELD.path,
+        SCHEMA,
+        NOT_GROUP_DATASET,
+        false,
+        false,
+        false,
+        true
+      )
+    ).toBe(true);
+  });
+
+  it("sample_id field is enabled for non patches view", () => {
+    expect(
+      disabledField(
+        FIELDS.SAMPLE_ID_FIELD.path,
+        SCHEMA,
+        NOT_GROUP_DATASET,
+        false,
+        false,
+        false,
+        false
+      )
+    ).toBe(false);
+  });
+});
+
+describe("Frames view disabled fields", () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("sample_id field is disabled", () => {
+    expect(
+      disabledField(
+        FIELDS.SAMPLE_ID_FIELD.path,
+        SCHEMA,
+        NOT_GROUP_DATASET,
+        true
+      )
+    ).toBe(true);
+  });
+
+  it("frame_number field is disabled", () => {
+    expect(
+      disabledField(
+        FIELDS.FRAME_NUMBER_FIELD.path,
+        SCHEMA,
+        NOT_GROUP_DATASET,
+        true
+      )
+    ).toBe(true);
+  });
+});
+
+describe("Clip view", () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("sample_id field is disabled", () => {
+    expect(
+      disabledField(
+        FIELDS.SAMPLE_ID_FIELD.path,
+        SCHEMA,
+        NOT_GROUP_DATASET,
+        false,
+        true
+      )
+    ).toBe(true);
+  });
+
+  it("support field is disabled", () => {
+    expect(
+      disabledField(
+        FIELDS.FRAME_SUPPORT_TYPE.path,
+        SCHEMA,
+        NOT_GROUP_DATASET,
+        false,
+        true
+      )
+    ).toBe(true);
+  });
+});
+
+describe("metadata and its children are disabled fields", () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("metadata field is disabled", () => {
+    expect(
+      disabledField(FIELDS.METADATA_FIELD.path, SCHEMA, NOT_GROUP_DATASET)
+    ).toBe(true);
+  });
+
+  it("metadata's subpaths are disabled", () => {
+    expect(
+      disabledField(FIELDS.METADATA_WIDTH_FIELD.path, SCHEMA, NOT_GROUP_DATASET)
+    ).toBe(true);
+  });
+});
+
+describe("label types are disabled fields", () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("Disabled label fields", () => {
+    expect(disabledField(FIELDS.DETECTION_FIELD.path, SCHEMA)).toBe(true);
+    expect(disabledField(FIELDS.DETECTIONS_FIELD.path, SCHEMA)).toBe(true);
+    expect(disabledField(FIELDS.CLASSIFICATION_FIELD.path, SCHEMA)).toBe(true);
+    expect(disabledField(FIELDS.CLASSIFICATIONS_FIELD.path, SCHEMA)).toBe(true);
+    expect(disabledField(FIELDS.KEYPOINT_FIELD.path, SCHEMA)).toBe(true);
+    expect(disabledField(FIELDS.KEYPOINTS_FIELD.path, SCHEMA)).toBe(true);
+    expect(disabledField(FIELDS.TEMPORAL_DETECTION_FIELD.path, SCHEMA)).toBe(
+      true
+    );
+    expect(disabledField(FIELDS.TEMPORAL_DETECTIONS_FIELD.path, SCHEMA)).toBe(
+      true
+    );
+    expect(disabledField(FIELDS.REGRESSION_FIELD.path, SCHEMA)).toBe(true);
+    expect(disabledField(FIELDS.HEATMAP_FIELD.path, SCHEMA)).toBe(true);
+    expect(disabledField(FIELDS.SEGMENTATION_FIELD.path, SCHEMA)).toBe(true);
+    expect(disabledField(FIELDS.GEO_LOCATION_FIELD.path, SCHEMA)).toBe(true);
+    expect(disabledField(FIELDS.GEO_LOCATIONS_FIELD.path, SCHEMA)).toBe(true);
+    expect(disabledField(FIELDS.POLYLINE_FIELD.path, SCHEMA)).toBe(true);
+    expect(disabledField(FIELDS.POLYLINES_FIELD.path, SCHEMA)).toBe(true);
+  });
+
+  it("disable a field of TemporalDetection label with FrameSupportField type", () => {
+    expect(
+      disabledField(FIELDS.TEMPORAL_DETECTION_FRAME_SUPPORT.path, SCHEMA)
+    ).toBe(true);
+  });
+});
+
+describe("Label fields that are disabled", () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("Detection nested fields that are disabled", () => {
+    const disabledSubFields = getDisabledNestedLabelFields(
+      "detection",
+      DETECTION_DISABLED_SUB_PATHS
+    );
+    disabledSubFields.forEach((field) => {
+      SCHEMA[field.path] = field;
+    });
+
+    disabledSubFields.forEach((field) => {
+      expect(disabledField(field.path, SCHEMA)).toBe(true);
+    });
+
+    const enabledSubFields = getEnabledNestedLabelFields("detection", [
+      "foo",
+      "bar",
+    ]);
+    enabledSubFields.forEach((field) => {
+      SCHEMA[field.path] = field;
+    });
+    enabledSubFields.forEach((field) => {
+      expect(disabledField(field.path, SCHEMA)).toBe(false);
+    });
+  });
+
+  it("Polyline nested fields that are disabled", () => {
+    const disabledSubFields = getDisabledNestedLabelFields(
+      "polyline",
+      POLYLINE_DISABLED_SUB_PATHS
+    );
+    disabledSubFields.forEach((field) => {
+      SCHEMA[field.path] = field;
+    });
+
+    disabledSubFields.forEach((field) => {
+      expect(disabledField(field.path, SCHEMA)).toBe(true);
+    });
+
+    const enabledSubFields = getEnabledNestedLabelFields("polyline", [
+      "foo",
+      "bar",
+    ]);
+    enabledSubFields.forEach((field) => {
+      SCHEMA[field.path] = field;
+    });
+    enabledSubFields.forEach((field) => {
+      expect(disabledField(field.path, SCHEMA)).toBe(false);
+    });
+  });
+
+  it("Classification nested fields that are disabled", () => {
+    const disabledSubFields = getDisabledNestedLabelFields(
+      "classification",
+      CLASSIFICATION_DISABLED_SUB_PATHS
+    );
+    disabledSubFields.forEach((field) => {
+      SCHEMA[field.path] = field;
+    });
+
+    disabledSubFields.forEach((field) => {
+      expect(disabledField(field.path, SCHEMA)).toBe(true);
+    });
+
+    const enabledSubFields = getEnabledNestedLabelFields("classification", [
+      "foo",
+      "bar",
+    ]);
+    enabledSubFields.forEach((field) => {
+      SCHEMA[field.path] = field;
+    });
+    enabledSubFields.forEach((field) => {
+      expect(disabledField(field.path, SCHEMA)).toBe(false);
+    });
+  });
+
+  it("Regression nested fields that are disabled", () => {
+    const disabledSubFields = getDisabledNestedLabelFields(
+      "regression",
+      REGRESSION_DISABLED_SUB_PATHS
+    );
+    disabledSubFields.forEach((field) => {
+      SCHEMA[field.path] = field;
+    });
+
+    disabledSubFields.forEach((field) => {
+      expect(disabledField(field.path, SCHEMA)).toBe(true);
+    });
+
+    const enabledSubFields = getEnabledNestedLabelFields("regression", [
+      "foo",
+      "bar",
+    ]);
+    enabledSubFields.forEach((field) => {
+      SCHEMA[field.path] = field;
+    });
+    enabledSubFields.forEach((field) => {
+      expect(disabledField(field.path, SCHEMA)).toBe(false);
+    });
+  });
+
+  it("Keypoint nested fields that are disabled", () => {
+    const disabledSubFields = getDisabledNestedLabelFields(
+      "keypoint",
+      KEYPOINT_DISABLED_SUB_PATHS
+    );
+    disabledSubFields.forEach((field) => {
+      SCHEMA[field.path] = field;
+    });
+
+    disabledSubFields.forEach((field) => {
+      expect(disabledField(field.path, SCHEMA)).toBe(true);
+    });
+
+    const enabledSubFields = getEnabledNestedLabelFields("keypoint", [
+      "foo",
+      "bar",
+    ]);
+    enabledSubFields.forEach((field) => {
+      SCHEMA[field.path] = field;
+    });
+    enabledSubFields.forEach((field) => {
+      expect(disabledField(field.path, SCHEMA)).toBe(false);
+    });
+  });
+
+  it("Segmentation nested fields that are disabled", () => {
+    SCHEMA = { ...ORIGINAL_SCHEMA };
+    const disabledSubFields = getDisabledNestedLabelFields(
+      "segmentation",
+      SEGMENTATION_DISABLED_SUB_PATHS
+    );
+    disabledSubFields.forEach((field) => {
+      SCHEMA[field.path] = field;
+    });
+
+    disabledSubFields.forEach((field) => {
+      expect(disabledField(field.path, SCHEMA)).toBe(true);
+    });
+
+    const enabledSubFields = getEnabledNestedLabelFields("segmentation", [
+      "foo",
+      "bar",
+    ]);
+    enabledSubFields.forEach((field) => {
+      SCHEMA[field.path] = field;
+    });
+    enabledSubFields.forEach((field) => {
+      expect(disabledField(field.path, SCHEMA)).toBe(false);
+    });
+  });
+
+  it("Heatmap nested fields that are disabled", () => {
+    SCHEMA = { ...ORIGINAL_SCHEMA };
+    const disabledSubFields = getDisabledNestedLabelFields(
+      "heatmap",
+      HEATMAP_DISABLED_SUB_PATHS
+    );
+    disabledSubFields.forEach((field) => {
+      SCHEMA[field.path] = field;
+    });
+
+    disabledSubFields.forEach((field) => {
+      expect(disabledField(field.path, SCHEMA)).toBe(true);
+    });
+
+    const enabledSubFields = getEnabledNestedLabelFields("heatmap", [
+      "foo",
+      "bar",
+    ]);
+    enabledSubFields.forEach((field) => {
+      SCHEMA[field.path] = field;
+    });
+    enabledSubFields.forEach((field) => {
+      expect(disabledField(field.path, SCHEMA)).toBe(false);
+    });
+  });
+
+  it("TemporalDetection nested fields that are disabled", () => {
+    SCHEMA = { ...ORIGINAL_SCHEMA };
+    const disabledSubFields = getDisabledNestedLabelFields(
+      "temporal",
+      TEMPORAL_DETECTION_DISABLED_SUB_PATHS
+    );
+    disabledSubFields.forEach((field) => {
+      SCHEMA[field.path] = field;
+    });
+
+    disabledSubFields.forEach((field) => {
+      expect(disabledField(field.path, SCHEMA)).toBe(true);
+    });
+
+    const enabledSubFields = getEnabledNestedLabelFields("temporal", [
+      "foo",
+      "bar",
+    ]);
+    enabledSubFields.forEach((field) => {
+      SCHEMA[field.path] = field;
+    });
+    enabledSubFields.forEach((field) => {
+      expect(disabledField(field.path, SCHEMA)).toBe(false);
+    });
+  });
+
+  it("GeoLocation nested fields that are disabled", () => {
+    SCHEMA = { ...ORIGINAL_SCHEMA };
+    const disabledSubFields = getDisabledNestedLabelFields(
+      "geolocation",
+      GEOLOCATION_DISABLED_SUB_PATHS
+    );
+    disabledSubFields.forEach((field) => {
+      SCHEMA[field.path] = field;
+    });
+
+    disabledSubFields.forEach((field) => {
+      expect(disabledField(field.path, SCHEMA)).toBe(true);
+    });
+
+    const enabledSubFields = getEnabledNestedLabelFields("geolocation", [
+      "foo",
+      "bar",
+    ]);
+    enabledSubFields.forEach((field) => {
+      SCHEMA[field.path] = field;
+    });
+    enabledSubFields.forEach((field) => {
+      expect(disabledField(field.path, SCHEMA)).toBe(false);
+    });
+  });
+
+  it("GeoLocations nested fields that are disabled", () => {
+    SCHEMA = { ...ORIGINAL_SCHEMA };
+    const disabledSubFields = getDisabledNestedLabelFields(
+      "geolocations",
+      GEOLOCATIONS_DISABLED_SUB_PATHS
+    );
+    disabledSubFields.forEach((field) => {
+      SCHEMA[field.path] = field;
+    });
+
+    disabledSubFields.forEach((field) => {
+      expect(disabledField(field.path, SCHEMA)).toBe(true);
+    });
+
+    const enabledSubFields = getEnabledNestedLabelFields("geolocations", [
+      "foo",
+      "bar",
+    ]);
+    enabledSubFields.forEach((field) => {
+      SCHEMA[field.path] = field;
+    });
+    enabledSubFields.forEach((field) => {
+      expect(disabledField(field.path, SCHEMA)).toBe(false);
+    });
+  });
+});
+
+describe("List of labels", () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("List of labels are disabled", () => {
+    expect(
+      disabledField(
+        FIELDS.DETECTIONS_LIST_FIELD.path,
+        SCHEMA,
+        NOT_GROUP_DATASET
+      )
+    ).toBe(true);
+  });
 
-    expect(disabledField(path, schema, NOT_GROUP_DATASET)).toBe(true);
+  it("List of non-labels are enabled", () => {
+    expect(
+      disabledField(FIELDS.CUSTOM_LIST_FIELD.path, SCHEMA, NOT_GROUP_DATASET)
+    ).toBe(false);
   });
 });
diff --git a/app/packages/state/src/hooks/useSchemaSettings.ts b/app/packages/state/src/hooks/useSchemaSettings.ts
index b531da288d..f34f45f59f 100644
--- a/app/packages/state/src/hooks/useSchemaSettings.ts
+++ b/app/packages/state/src/hooks/useSchemaSettings.ts
@@ -173,6 +173,9 @@ export const excludedPathsState = atomFamily({
         const dataset = await getPromise(fos.dataset);
         const showNestedField = await getPromise(showNestedFieldsState);
         const searchResults = await getPromise(schemaSearchRestuls);
+        const isFrameView = await getPromise(fos.isFramesView);
+        const isClipsView = await getPromise(fos.isClipsView);
+        const isPatchesView = await getPromise(fos.isPatchesView);
         const isVideo = dataset.mediaType === "video";
         const isImage = dataset.mediaType === "image";
         const isInSearchMode = !!searchResults?.length;
@@ -205,7 +208,15 @@ export const excludedPathsState = atomFamily({
                 combinedSchema?.[rawPath]?.ftype,
                 combinedSchema
               ) &&
-              !disabledField(path, combinedSchema, dataset?.groupField)
+              !disabledField(
+                path,
+                combinedSchema,
+                dataset?.groupField,
+                isFrameView,
+                isClipsView,
+                isVideo,
+                isPatchesView
+              )
             );
           })
           .map((path) => mapping?.[path] || path);
@@ -417,6 +428,10 @@ export default function useSchemaSettings() {
     searchMetaFilterState
   );
 
+  const isPatchesView = useRecoilValue(fos.isPatchesView);
+  const isFrameView = useRecoilValue(fos.isFramesView);
+  const isClipsView = useRecoilValue(fos.isClipsView);
+
   const [expandedPaths, setExpandedPaths] = useRecoilState(expandedPathsState);
 
   const [lastActionToggleSelection, setLastActionToggleSelection] =
@@ -471,14 +486,34 @@ export default function useSchemaSettings() {
     selectedPathState
   );
   // disabled paths are filtered
-  const datasetSelectedPaths = selectedPaths[datasetName] || new Set();
-  const enabledSelectedPaths =
-    datasetSelectedPaths?.size && combinedSchema
+  const enabledSelectedPaths = useMemo(() => {
+    const datasetSelectedPaths = selectedPaths[datasetName] || new Set();
+
+    return datasetSelectedPaths?.size && combinedSchema
       ? [...datasetSelectedPaths]?.filter(
           ({ path }) =>
-            path && !disabledField(path, combinedSchema, isGroupDataset)
+            path &&
+            !disabledField(
+              path,
+              combinedSchema,
+              isGroupDataset,
+              isFrameView,
+              isClipsView,
+              isVideo,
+              isPatchesView
+            )
         )
       : [];
+  }, [
+    combinedSchema,
+    datasetName,
+    isClipsView,
+    isFrameView,
+    isGroupDataset,
+    isPatchesView,
+    isVideo,
+    selectedPaths,
+  ]);
 
   const excludePathsState = excludedPathsState({});
   const [excludedPaths, setExcludedPaths] = useRecoilState<{}>(
@@ -551,8 +586,15 @@ export default function useSchemaSettings() {
         const ftype = finalSchemaKeyByPath[path].ftype;
         const skip = skipField(path, ftype, finalSchemaKeyByPath);
         const disabled =
-          disabledField(path, finalSchemaKeyByPath, isGroupDataset) ||
-          filterRuleTab;
+          disabledField(
+            path,
+            finalSchemaKeyByPath,
+            isGroupDataset,
+            isFrameView,
+            isClipsView,
+            isVideo,
+            isPatchesView
+          ) || filterRuleTab;
 
         const fullPath =
           isVideo && viewSchema?.[path] ? `frames.${path}` : path;
@@ -614,6 +656,9 @@ export default function useSchemaSettings() {
     datasetName,
     fieldSchema,
     includeNestedFields,
+    isPatchesView,
+    isClipsView,
+    isVideo,
   ]);
 
   const [searchSchemaFieldsRaw] = useMutation<foq.searchSelectFieldsMutation>(
@@ -821,7 +866,17 @@ export default function useSchemaSettings() {
           setExcludedPaths({ [datasetName]: new Set(topLevelPaths) });
         }
         const res = Object.values(combinedSchema)
-          .filter((f) => disabledField(f.path, combinedSchema, isGroupDataset))
+          .filter((f) =>
+            disabledField(
+              f.path,
+              combinedSchema,
+              isGroupDataset,
+              isFrameView,
+              isClipsView,
+              isVideo,
+              isPatchesView
+            )
+          )
           .map((f) => f.path);
 
         setSelectedPaths({
@@ -841,6 +896,9 @@ export default function useSchemaSettings() {
     includeNestedFields,
     filterRuleTab,
     combinedSchema,
+    isPatchesView,
+    isClipsView,
+    isVideo,
   ]);
 
   const setAllFieldsCheckedWrapper = useCallback(
diff --git a/app/packages/state/src/hooks/useSchemaSettings.utils.ts b/app/packages/state/src/hooks/useSchemaSettings.utils.ts
index 4776514054..c6e15e14b8 100644
--- a/app/packages/state/src/hooks/useSchemaSettings.utils.ts
+++ b/app/packages/state/src/hooks/useSchemaSettings.utils.ts
@@ -1,118 +1,193 @@
 import {
-  CLASSIFICATIONS_FIELD,
+  CLASSIFICATION_DISABLED_SUB_PATHS,
   CLASSIFICATION_FIELD,
-  DETECTIONS_FIELD,
+  DETECTION_DISABLED_SUB_PATHS,
   DETECTION_FIELD,
-  DYNAMIC_EMBEDDED_DOCUMENT_FIELD,
-  DYNAMIC_EMBEDDED_DOCUMENT_PATH,
+  DISABLED_LABEL_FIELDS_VISIBILITY,
+  DISABLED_PATHS,
   FRAME_NUMBER_FIELD,
   FRAME_SUPPORT_FIELD,
   Field,
+  GEOLOCATIONS_DISABLED_SUB_PATHS,
+  GEOLOCATION_DISABLED_SUB_PATHS,
   GEO_LOCATIONS_FIELD,
   GEO_LOCATION_FIELD,
+  HEATMAP_DISABLED_SUB_PATHS,
   HEATMAP_FIELD,
-  KEYPOINT_FILED,
+  KEYPOINT_DISABLED_SUB_PATHS,
+  KEYPOINT_FIELD,
   LIST_FIELD,
   OBJECT_ID_FIELD,
-  POLYLINES_FIELD,
+  POLYLINE_DISABLED_SUB_PATHS,
   POLYLINE_FIELD,
-  REGRESSION_FILED,
-  RESERVED_FIELD_KEYS,
+  REGRESSION_DISABLED_SUB_PATHS,
+  REGRESSION_FIELD,
+  SEGMENTATION_DISABLED_SUB_PATHS,
   SEGMENTATION_FIELD,
+  TEMPORAL_DETECTION_DISABLED_SUB_PATHS,
   TEMPORAL_DETECTION_FIELD,
   VALID_LABEL_TYPES,
-  VECTOR_FIELD,
 } from "@fiftyone/utilities";
 
+export const isMetadataField = (path: string) => {
+  return path === "metadata" || path.startsWith("metadata.");
+};
+
 export const disabledField = (
   path: string,
   combinedSchema: Record<string, Field>,
-  groupField?: string
+  groupField?: string,
+  isFrameView?: boolean,
+  isClipsView?: boolean,
+  isVideo?: boolean,
+  isPatchesView?: boolean
 ): boolean => {
-  const currField = combinedSchema?.[path] || ({} as Field);
+  const currField = combinedSchema[path] || ({} as Field);
   const { ftype, embeddedDocType } = currField;
   const parentPath = path.substring(0, path.lastIndexOf("."));
-  const parentField = combinedSchema?.[parentPath];
-  const parentEmbeddedDocType = parentField?.embeddedDocType;
+  const parentField = combinedSchema[parentPath];
+  const parentFType = parentField?.ftype;
   const pathSplit = path.split(".");
-  const embeddedDocTypeSplit = embeddedDocType?.split(".");
-  const hasDynamicEmbeddedDocument = [
-    DYNAMIC_EMBEDDED_DOCUMENT_FIELD,
-    DYNAMIC_EMBEDDED_DOCUMENT_PATH,
-  ].includes(embeddedDocType);
-
-  return (
-    [
-      OBJECT_ID_FIELD,
-      FRAME_NUMBER_FIELD,
-      FRAME_SUPPORT_FIELD,
-      VECTOR_FIELD,
-    ].includes(ftype) ||
-    [path, parentPath].includes(groupField) ||
-    RESERVED_FIELD_KEYS.includes(path) ||
-    path.startsWith("metadata") ||
-    ([
-      TEMPORAL_DETECTION_FIELD,
-      DETECTION_FIELD,
-      DETECTIONS_FIELD,
-      CLASSIFICATION_FIELD,
-      CLASSIFICATIONS_FIELD,
-      KEYPOINT_FILED,
-      REGRESSION_FILED,
-      HEATMAP_FIELD,
-      SEGMENTATION_FIELD,
-      GEO_LOCATIONS_FIELD,
-      GEO_LOCATION_FIELD,
-      POLYLINE_FIELD,
-      POLYLINES_FIELD,
-    ].includes(parentEmbeddedDocType) &&
-      [
-        "id",
-        "tags",
-        "label",
-        "bounding_box",
-        "mask",
-        "confidence",
-        "index",
-        "points",
-        "closed",
-        "filled",
-        "logits",
-        "mask_path",
-        "map",
-        "map_path",
-        "Range",
-        "Confidence",
-        "support",
-        "point",
-        "line",
-        "Polygon",
-        "points",
-        "polygons",
-      ].includes(pathSplit[pathSplit.length - 1])) ||
-    [
-      TEMPORAL_DETECTION_FIELD,
-      DETECTION_FIELD,
-      DETECTIONS_FIELD,
-      CLASSIFICATION_FIELD,
-      CLASSIFICATIONS_FIELD,
-      KEYPOINT_FILED,
-      REGRESSION_FILED,
-      HEATMAP_FIELD,
-      SEGMENTATION_FIELD,
-      GEO_LOCATIONS_FIELD,
-      GEO_LOCATION_FIELD,
-      POLYLINE_FIELD,
-      POLYLINES_FIELD,
-    ].includes(ftype) ||
-    (parentPath &&
-      parentPath !== path &&
-      ftype === LIST_FIELD &&
-      (hasDynamicEmbeddedDocument ||
-        VALID_LABEL_TYPES.includes(
-          embeddedDocType?.includes(".")
-            ? embeddedDocTypeSplit[embeddedDocTypeSplit.length - 1]
-            : embeddedDocType
-        )))
-  );
+  const shortPath = pathSplit[pathSplit.length - 1];
+  const isTopLevelField =
+    pathSplit.length === 1 ||
+    (pathSplit.length === 1 && pathSplit[0] === "frames");
+
+  // ex: 'id' and 'filepath' are always disabled
+  if (DISABLED_PATHS.includes(path)) {
+    return true;
+  }
+
+  if (
+    (isPatchesView || isFrameView || isClipsView) &&
+    ["sample_id", "frames.sample_id"].includes(path)
+  ) {
+    return true;
+  }
+
+  if ("frames.id" === path && ftype === OBJECT_ID_FIELD) {
+    return true;
+  }
+
+  if ("frames.frame_number" === path && ftype === FRAME_NUMBER_FIELD) {
+    return true;
+  }
+
+  // Clip view's top level field(s) with frameSupport type is disabled
+  if (isClipsView && ftype === FRAME_SUPPORT_FIELD && isTopLevelField) {
+    return true;
+  }
+
+  // ex: in a dataset with 'dataset.group_field="group"'
+  //  field 'group' (and children) will be disabled.
+  if ([path, parentPath || path].includes(groupField)) {
+    return true;
+  }
+
+  if ((isFrameView || isVideo) && path === "frame_number") {
+    return true;
+  }
+
+  // metadata and all its children are disabled
+  if (isMetadataField(path)) {
+    return true;
+  }
+
+  // All label
+  if (DISABLED_LABEL_FIELDS_VISIBILITY.includes(ftype)) {
+    return true;
+  }
+
+  // field Detection has reserved subpaths. ex: tags, id, mask
+  if (
+    parentFType === DETECTION_FIELD &&
+    DETECTION_DISABLED_SUB_PATHS.includes(pathSplit[pathSplit.length - 1])
+  ) {
+    return true;
+  }
+
+  // field Polyline has reserved subpaths. ex: "points", "closed", "filled",
+  if (
+    parentFType === POLYLINE_FIELD &&
+    POLYLINE_DISABLED_SUB_PATHS.includes(shortPath)
+  ) {
+    return true;
+  }
+
+  // field Classification has reserved subpaths. ex: "logits"
+  if (
+    parentFType === CLASSIFICATION_FIELD &&
+    CLASSIFICATION_DISABLED_SUB_PATHS.includes(shortPath)
+  ) {
+    return true;
+  }
+
+  // field Regression has reserved subpaths. ex: "value", "id"
+  if (
+    parentFType === REGRESSION_FIELD &&
+    REGRESSION_DISABLED_SUB_PATHS.includes(shortPath)
+  ) {
+    return true;
+  }
+
+  // field Keypoint has reserved subpaths. ex: "point", "index"
+  if (
+    parentFType === KEYPOINT_FIELD &&
+    KEYPOINT_DISABLED_SUB_PATHS.includes(shortPath)
+  ) {
+    return true;
+  }
+
+  // field Segmentation has reserved subpaths. ex: "mask", "mask_path"
+  if (
+    parentFType === SEGMENTATION_FIELD &&
+    SEGMENTATION_DISABLED_SUB_PATHS.includes(shortPath)
+  ) {
+    return true;
+  }
+
+  // field Heatmap has reserved subpaths. ex: "map_path", "Range"
+  if (
+    parentFType === HEATMAP_FIELD &&
+    HEATMAP_DISABLED_SUB_PATHS.includes(shortPath)
+  ) {
+    return true;
+  }
+
+  // field TemporalDetection has reserved subpaths. ex: "support", "tags"
+  if (
+    parentFType === TEMPORAL_DETECTION_FIELD &&
+    TEMPORAL_DETECTION_DISABLED_SUB_PATHS.includes(shortPath)
+  ) {
+    return true;
+  }
+
+  // field Geolocation has reserved subpaths. ex: "polygon", "line", "point"
+  if (
+    parentFType === GEO_LOCATION_FIELD &&
+    GEOLOCATION_DISABLED_SUB_PATHS.includes(shortPath)
+  ) {
+    return true;
+  }
+
+  // field Geolocations has reserved subpaths. ex: "polygons", "line", "point"
+  if (
+    parentFType === GEO_LOCATIONS_FIELD &&
+    GEOLOCATIONS_DISABLED_SUB_PATHS.includes(shortPath)
+  ) {
+    return true;
+  }
+
+  // list of any valid labels
+  if (embeddedDocType && ftype === LIST_FIELD) {
+    const embeddedRoot = embeddedDocType?.substring(
+      embeddedDocType.lastIndexOf(".") + 1,
+      embeddedDocType.length
+    );
+    if (VALID_LABEL_TYPES.includes(embeddedRoot)) {
+      return true;
+    }
+  }
+
+  return false;
 };
diff --git a/app/packages/state/src/recoil/aggregations.ts b/app/packages/state/src/recoil/aggregations.ts
index 837f45ec7a..f9c7df8c7a 100644
--- a/app/packages/state/src/recoil/aggregations.ts
+++ b/app/packages/state/src/recoil/aggregations.ts
@@ -203,7 +203,7 @@ export const stringCountResults = selectorFamily({
       const isSkeletonPoints =
         VALID_KEYPOINTS.includes(
           get(schemaAtoms.field(parent)).embeddedDocType
-        ) && keys[2] === "points";
+        ) && keys.slice(-1)[0] === "points";
 
       if (isSkeletonPoints) {
         const skeleton = get(selectors.skeleton(parent));
diff --git a/app/packages/state/src/recoil/groups.ts b/app/packages/state/src/recoil/groups.ts
index 7b6a373a09..b4cac99bad 100644
--- a/app/packages/state/src/recoil/groups.ts
+++ b/app/packages/state/src/recoil/groups.ts
@@ -71,7 +71,7 @@ export const groupSlices = selector<string[]>({
 
 export const hasGroupSlices = selector<boolean>({
   key: "hasGroupSlices",
-  get: ({ get }) => Boolean(get(groupSlices).length),
+  get: ({ get }) => get(isGroup) && Boolean(get(groupSlices).length),
 });
 
 export const defaultPcdSlice = selector<string | null>({
diff --git a/app/packages/state/src/recoil/schemaSettings.atoms.ts b/app/packages/state/src/recoil/schemaSettings.atoms.ts
new file mode 100644
index 0000000000..021f99ac51
--- /dev/null
+++ b/app/packages/state/src/recoil/schemaSettings.atoms.ts
@@ -0,0 +1,311 @@
+import { DefaultValue, atom, atomFamily, selector } from "recoil";
+import { disabledField, skipField } from "../hooks/useSchemaSettings.utils";
+import * as fos from "@fiftyone/state";
+import {
+  DYNAMIC_EMBEDDED_DOCUMENT_FIELD_V2,
+  EMBEDDED_DOCUMENT_FIELD,
+  LIST_FIELD,
+} from "@fiftyone/utilities";
+
+export const TAB_OPTIONS_MAP = {
+  SELECTION: "Selection",
+  FILTER_RULE: "Filter rule",
+};
+
+export const TAB_OPTIONS = Object.values(TAB_OPTIONS_MAP);
+
+export const schemaSearchTerm = atom<string>({
+  key: "schemaSearchTerm",
+  default: "",
+});
+
+export const showNestedFieldsState = atom<boolean>({
+  key: "showNestedFieldsState",
+  default: false,
+});
+
+export const schemaSelectedSettingsTab = atom<string>({
+  key: "schemaSelectedSettingsTab",
+  default: TAB_OPTIONS_MAP.SELECTION,
+});
+
+export const settingsModal = atom<{ open: boolean } | null>({
+  key: "settingsModal",
+  default: {
+    open: false,
+  },
+});
+
+export const allFieldsCheckedState = atom<boolean>({
+  key: "allFieldsCheckedState",
+  default: true,
+});
+
+export const expandedPathsState = atom<{} | null>({
+  key: "expandedPathsState",
+  default: null,
+});
+
+export const viewSchemaState = atom({
+  key: "viewSchemaState",
+  default: null,
+});
+
+export const fieldSchemaState = atom({
+  key: "fieldSchemaState",
+  default: null,
+});
+
+export const showMetadataState = atom({
+  key: "showMetadataState",
+  default: false,
+});
+
+export const includeNestedFieldsState = atom({
+  key: "includeNestedFieldsState",
+  default: true,
+});
+
+export const affectedPathCountState = atom({
+  key: "affectedPathCountState",
+  default: 0,
+});
+
+export const searchMetaFilterState = atom({
+  key: "searchMetaFilterState",
+  default: {},
+});
+
+export const lastAppliedPathsState = atom({
+  key: "lastAppliedExcludedPathsState",
+  default: {
+    excluded: [],
+    selected: [],
+  },
+});
+
+// tracks action and value - currently used for (un)select all action
+export const lastActionToggleSelectionState = atom<Record<
+  string,
+  boolean
+> | null>({
+  key: "lastActionToggleSelectionState",
+  default: null,
+});
+
+const getRawPath = (path: string) =>
+  path.startsWith("frames.") ? path.replace("frames.", "") : path;
+
+export const schemaSearchResultList = selector<string[]>({
+  key: "schemaSearchResultsSelector",
+  get: ({ get }) => get(schemaSearchResults),
+  set: ({ set, get }, newPaths) => {
+    if (newPaths instanceof DefaultValue) {
+      newPaths = [];
+    }
+    const viewSchema = get(viewSchemaState);
+    const fieldSchema = get(fieldSchemaState);
+    const combinedSchema = { ...fieldSchema, ...viewSchema };
+
+    const greenPaths = [...newPaths]
+      .filter((path) => {
+        const cleanPath = getRawPath(path);
+
+        return (
+          cleanPath &&
+          combinedSchema?.[cleanPath]?.ftype &&
+          !skipField(cleanPath, combinedSchema)
+        );
+      })
+      .map((path) => getRawPath(path));
+    set(schemaSearchResults, greenPaths);
+  },
+  cachePolicy_UNSTABLE: {
+    eviction: "most-recent",
+  },
+});
+
+export const schemaSearchResults = atom<string[]>({
+  key: "schemaSearchResults",
+  default: [],
+});
+
+export const selectedPathsState = atomFamily({
+  key: "selectedPathsState",
+  default: (param: {}) => param,
+  effects: [
+    ({ onSet, getPromise, setSelf }) => {
+      onSet(async (newPathsMap) => {
+        const dataset = await getPromise(fos.dataset);
+        const viewSchema = await getPromise(viewSchemaState);
+        const fieldSchema = await getPromise(fieldSchemaState);
+        const combinedSchema = { ...fieldSchema, ...viewSchema };
+        const isImage = dataset.mediaType === "image";
+        const isVideo = dataset.mediaType === "video";
+
+        const mapping = {};
+        Object.keys(combinedSchema).forEach((path) => {
+          if (isImage) {
+            mapping[path] = path;
+          }
+          if (isVideo && viewSchema) {
+            Object.keys(viewSchema).forEach((path) => {
+              mapping[path] = `frames.${path}`;
+            });
+          }
+        });
+
+        const newPaths = newPathsMap?.[dataset?.name] || [];
+        const greenPaths = [...newPaths]
+          .filter((path) => {
+            const skip = skipField(path, combinedSchema);
+            return !!path && !skip;
+          })
+          .map((path) => mapping?.[path] || path);
+
+        setSelf({
+          [dataset?.name]: new Set(greenPaths),
+        });
+      });
+    },
+  ],
+});
+
+export const excludedPathsState = atomFamily({
+  key: "excludedPathsState",
+  default: (param: {}) => param,
+  effects: [
+    ({ onSet, getPromise, setSelf }) => {
+      onSet(async (newPathsMap) => {
+        const viewSchema = await getPromise(fos.viewSchemaState);
+        const fieldSchema = await getPromise(fos.fieldSchemaState);
+        const dataset = await getPromise(fos.dataset);
+        const showNestedField = await getPromise(fos.showNestedFieldsState);
+        const searchResults = await getPromise(fos.schemaSearchResults);
+        const isFrameView = await getPromise(fos.isFramesView);
+        const isClipsView = await getPromise(fos.isClipsView);
+        const isPatchesView = await getPromise(fos.isPatchesView);
+        const isVideo = dataset.mediaType === "video";
+        const isImage = dataset.mediaType === "image";
+        const isInSearchMode = !!searchResults?.length;
+
+        if (!dataset) {
+          return;
+        }
+
+        const combinedSchema = { ...fieldSchema, ...viewSchema };
+        const mapping = {};
+        Object.keys(combinedSchema).forEach((path) => {
+          if (isImage) {
+            mapping[path] = path;
+          }
+          if (isVideo && viewSchema) {
+            Object.keys(viewSchema).forEach((path) => {
+              mapping[path] = `frames.${path}`;
+            });
+          }
+        });
+
+        const newPaths = newPathsMap?.[dataset?.name] || [];
+        const greenPaths = [...newPaths]
+          .filter((path) => {
+            const rawPath = path.replace("frames.", "");
+            return (
+              !!rawPath &&
+              !skipField(rawPath, combinedSchema) &&
+              !disabledField(
+                path,
+                combinedSchema,
+                dataset?.groupField,
+                isFrameView,
+                isClipsView,
+                isVideo,
+                isPatchesView
+              )
+            );
+          })
+          .map((path) => mapping?.[path] || path);
+
+        // if top level only, count should be top-level too
+        // if nested fields are shown, exclude more granular
+        let finalGreenPaths = greenPaths;
+        if (!showNestedField && !isInSearchMode) {
+          finalGreenPaths = greenPaths.filter((path) =>
+            isVideo
+              ? (path.split(".").length === 2 && path.startsWith("frames.")) ||
+                !path.includes(".")
+              : !path.includes(".")
+          );
+        }
+
+        const shouldFilterTopLevelFields = showNestedField || isInSearchMode;
+        finalGreenPaths = shouldFilterTopLevelFields
+          ? finalGreenPaths.filter((path) => {
+              const isEmbeddedOrListType = [
+                EMBEDDED_DOCUMENT_FIELD,
+                LIST_FIELD,
+              ].includes(combinedSchema[path]?.ftype);
+
+              // embedded document could break an exclude_field() call causing mongo query issue.
+              const hasDynamicEmbeddedDocument = [
+                DYNAMIC_EMBEDDED_DOCUMENT_FIELD_V2,
+              ].includes(combinedSchema[path]?.embeddedDocType);
+
+              const isTopLevelPath = isVideo
+                ? !(
+                    path.split(".").length === 2 && path.startsWith("frames.")
+                  ) || !path.includes(".")
+                : !path.includes(".");
+
+              return !(
+                isEmbeddedOrListType &&
+                hasDynamicEmbeddedDocument &&
+                isTopLevelPath
+              );
+            })
+          : finalGreenPaths;
+
+        // filter out subpaths if a parent (or higher) path is also in the list
+        const finalGreenPathsSet = new Set(finalGreenPaths);
+        if (showNestedField) {
+          finalGreenPaths = finalGreenPaths.filter((path) => {
+            let tmp = path;
+            while (tmp.indexOf(".") > 0) {
+              const parentPath = tmp.substring(0, tmp.lastIndexOf("."));
+              if (finalGreenPathsSet.has(parentPath) || path === parentPath) {
+                return false;
+              }
+              tmp = parentPath;
+            }
+            return true;
+          });
+        }
+
+        setSelf({
+          [dataset.name]: new Set(finalGreenPaths),
+        });
+      });
+    },
+  ],
+});
+
+export const selectedFieldsStageState = atom<any>({
+  key: "selectedFieldsStageState",
+  default: undefined,
+  effects: [
+    ({ onSet }) => {
+      onSet((value) => {
+        const context = fos.getContext();
+        if (context.loaded) {
+          context.history.replace(
+            `${context.history.location.pathname}${context.history.location.search}`,
+            {
+              ...context.history.location.state,
+              selectedFieldsStage: value || null,
+            }
+          );
+        }
+      });
+    },
+  ],
+});
diff --git a/app/packages/utilities/src/index.ts b/app/packages/utilities/src/index.ts
index 4b064cc75e..02d9bed337 100644
--- a/app/packages/utilities/src/index.ts
+++ b/app/packages/utilities/src/index.ts
@@ -286,6 +286,8 @@ export const DETECTION_FIELD = "fiftyone.core.labels.Detection";
 export const DETECTIONS_FIELD = "fiftyone.core.labels.Detections";
 export const TEMPORAL_DETECTION_FIELD =
   "fiftyone.core.labels.TemporalDetection";
+export const TEMPORAL_DETECTIONS_FIELD =
+  "fiftyone.core.labels.TemporalDetections";
 export const ARRAY_FIELD = "fiftyone.core.fields.ArrayField";
 export const BOOLEAN_FIELD = "fiftyone.core.fields.BooleanField";
 export const DATE_FIELD = "fiftyone.core.fields.DateField";
@@ -307,12 +309,31 @@ export const LIST_FIELD = "fiftyone.core.fields.ListField";
 export const JUST_FIELD = "fiftyone.core.fields.Field";
 export const VECTOR_FIELD = "fiftyone.core.fields.VectorField";
 export const DETECTION_FILED = "fiftyone.core.labels.Detection";
-export const KEYPOINT_FILED = "fiftyone.core.labels.Keypoint";
-export const REGRESSION_FILED = "fiftyone.core.labels.Regression";
+export const KEYPOINT_FIELD = "fiftyone.core.labels.Keypoint";
+export const KEYPOINTS_FIELD = "fiftyone.core.labels.Keypoints";
+export const REGRESSION_FIELD = "fiftyone.core.labels.Regression";
 export const GROUP = "fiftyone.core.groups.Group";
 
 export const VALID_LIST_FIELDS = [FRAME_SUPPORT_FIELD, LIST_FIELD];
 
+export const DISABLED_LABEL_FIELDS_VISIBILITY = [
+  DETECTION_FIELD,
+  DETECTIONS_FIELD,
+  CLASSIFICATION_FIELD,
+  CLASSIFICATIONS_FIELD,
+  KEYPOINT_FIELD,
+  KEYPOINTS_FIELD,
+  TEMPORAL_DETECTION_FIELD,
+  TEMPORAL_DETECTIONS_FIELD,
+  REGRESSION_FIELD,
+  HEATMAP_FIELD,
+  SEGMENTATION_FIELD,
+  GEO_LOCATION_FIELD,
+  GEO_LOCATIONS_FIELD,
+  POLYLINE_FIELD,
+  POLYLINES_FIELD,
+];
+
 export const VALID_PRIMITIVE_TYPES = [
   BOOLEAN_FIELD,
   DATE_FIELD,
@@ -387,6 +408,79 @@ export const CLIPS_FRAME_FIELDS = withPath(LABELS_PATH, [
   "Polylines",
 ]);
 
+export const DISABLED_PATHS = ["id", "filepath", "tags", "metadata"];
+
+const BASE_DISABLED_PATHS = ["id", "tags", "label", "confidence"];
+
+export const DETECTION_DISABLED_SUB_PATHS = [
+  ...BASE_DISABLED_PATHS,
+  "bounding_box",
+  "mask",
+  "index",
+];
+
+export const POLYLINE_DISABLED_SUB_PATHS = [
+  ...BASE_DISABLED_PATHS,
+  "points",
+  "closed",
+  "filled",
+  "index",
+];
+
+export const CLASSIFICATION_DISABLED_SUB_PATHS = [
+  ...BASE_DISABLED_PATHS,
+  "logits",
+];
+
+export const REGRESSION_DISABLED_SUB_PATHS = [
+  "id",
+  "tags",
+  "value",
+  "confidence",
+];
+
+export const KEYPOINT_DISABLED_SUB_PATHS = [
+  ...BASE_DISABLED_PATHS,
+  "points",
+  "index",
+];
+
+export const SEGMENTATION_DISABLED_SUB_PATHS = [
+  "id",
+  "tags",
+  "mask",
+  "mask_path",
+];
+
+export const HEATMAP_DISABLED_SUB_PATHS = [
+  "id",
+  "tags",
+  "map",
+  "map_path",
+  "range",
+];
+
+export const TEMPORAL_DETECTION_DISABLED_SUB_PATHS = [
+  ...BASE_DISABLED_PATHS,
+  "support",
+];
+
+export const GEOLOCATION_DISABLED_SUB_PATHS = [
+  "id",
+  "tags",
+  "point",
+  "line",
+  "polygon",
+];
+
+export const GEOLOCATIONS_DISABLED_SUB_PATHS = [
+  "id",
+  "tags",
+  "point",
+  "line",
+  "polygons",
+];
+
 export function withPath(path: string, types: string): string;
 export function withPath(path: string, types: string[]): string[];
 export function withPath(
diff --git a/app/vite.config.ts b/app/vite.config.ts
index 4d7bab4989..3858a723b1 100644
--- a/app/vite.config.ts
+++ b/app/vite.config.ts
@@ -6,7 +6,7 @@ export default defineConfig({
   test: {
     environment: "jsdom",
     coverage: {
-      reporter: ["json", "lcov"],
+      reporter: ["json", "lcov", "text", "html"],
       reportsDirectory: "./coverage",
       enabled: true,
       all: true,
diff --git a/docs/source/_static/images/integrations/lancedb.png b/docs/source/_static/images/integrations/lancedb.png
new file mode 100644
index 0000000000..051cd9c886
Binary files /dev/null and b/docs/source/_static/images/integrations/lancedb.png differ
diff --git a/docs/source/_static/images/integrations/milvus.png b/docs/source/_static/images/integrations/milvus.png
new file mode 100644
index 0000000000..269703944c
Binary files /dev/null and b/docs/source/_static/images/integrations/milvus.png differ
diff --git a/docs/source/faq/index.rst b/docs/source/faq/index.rst
index 5933381fe6..6fcce8b59d 100644
--- a/docs/source/faq/index.rst
+++ b/docs/source/faq/index.rst
@@ -18,7 +18,7 @@ web browser whenever you call
 You can also run FiftyOne
 :ref:`as a desktop application <faq-desktop-app-support>` if you prefer.
 
-Check out the :ref:`enviornments guide <environments>` to see how to use
+Check out the :ref:`environments guide <environments>` to see how to use
 FiftyOne in all common local, remote, cloud, and notebook environments.
 
 .. _faq-supported-browsers:
@@ -48,7 +48,7 @@ your browser or as a desktop App. You can also set the ``desktop_app`` flag of
 your :ref:`FiftyOne config <configuring-fiftyone>` to use the desktop App by
 default.
 
-Check out the :ref:`enviornments guide <environments>` to see how to use
+Check out the :ref:`environments guide <environments>` to see how to use
 FiftyOne in all common local, remote, cloud, and notebook environments.
 
 .. _faq-app-no-session:
@@ -518,7 +518,7 @@ On your local machine, you can
 :ref:`connect to these remote sessions <remote-app-local-machine>` using a
 different local port `XXXX` and `YYYY` for each.
 
-If you do not have Fiftyone installed on your local machine, open a new
+If you do not have FiftyOne installed on your local machine, open a new
 terminal window on your local machine and execute the following command to
 setup port forwarding to connect to your remote sessions:
 
@@ -680,7 +680,7 @@ Are the Brain methods open source?
 
 Although the `core library <https://github.com/voxel51/fiftyone>`_ is open
 source and the :ref:`Brain methods <fiftyone-brain>` are freely available for
-use for any commerical or non-commerical purposes, the Brain methods are closed
+use for any commercial or non-commercial purposes, the Brain methods are closed
 source.
 
 Check out the :ref:`Brain documentation <fiftyone-brain>` for detailed
diff --git a/docs/source/index.rst b/docs/source/index.rst
index 8dee03a3c4..fa2b69774a 100644
--- a/docs/source/index.rst
+++ b/docs/source/index.rst
@@ -91,6 +91,21 @@ learn how:
     :image_src: https://voxel51.com/images/integrations/qdrant-128.png
     :image_title: Qdrant
 
+.. customimagelink::
+    :image_link: tutorials/pinecone.html
+    :image_src: https://voxel51.com/images/integrations/pinecone-128.png
+    :image_title: Pinecone
+
+.. customimagelink::
+    :image_link: tutorials/milvus.html
+    :image_src: https://voxel51.com/images/integrations/milvus-128.png
+    :image_title: Milvus
+
+.. customimagelink::
+    :image_link: tutorials/lancedb.html
+    :image_src: https://voxel51.com/images/integrations/lancedb-128.png
+    :image_title: LanceDB
+
 .. customimagelink::
     :image_link: integrations/activitynet.html
     :image_src: https://voxel51.com/images/integrations/activitynet-128.png
diff --git a/docs/source/integrations/index.rst b/docs/source/integrations/index.rst
index 5bf28af7d3..f96bab04ba 100644
--- a/docs/source/integrations/index.rst
+++ b/docs/source/integrations/index.rst
@@ -90,6 +90,20 @@ on the cards below to see how!
     :image: ../_static/images/integrations/pinecone.png
     :tags: Brain,Embeddings,Filtering
 
+.. customcarditem::
+    :header: Milvus
+    :description: Use our Milvus integration to index your FiftyOne datasets and perform embeddings queries at scale.
+    :link: milvus.html
+    :image: ../_static/images/integrations/milvus.png
+    :tags: Brain,Embeddings,Filtering
+
+.. customcarditem::
+    :header: LanceDB
+    :description: Use our LancedDB integration to index your datasets and perform embeddings queries at scale without the need for a cloud service.
+    :link: lancedb.html
+    :image: ../_static/images/integrations/lancedb.png
+    :tags: Brain,Embeddings,Filtering
+
 .. customcarditem::
     :header: Lightning Flash
     :description: Train Flash models on FiftyOne datasets and use the FiftyOne App to visualize and improve your Flash models, all with just a few lines of code.
@@ -123,4 +137,6 @@ on the cards below to see how!
     Label Studio <labelstudio.rst>
     Qdrant <qdrant.rst>
     Pinecone <pinecone.rst>
+    Milvus <milvus.rst>
+    LanceDB <lancedb.rst>
     Lightning Flash <lightning_flash.rst>
diff --git a/docs/source/integrations/lancedb.rst b/docs/source/integrations/lancedb.rst
new file mode 100644
index 0000000000..c45d64d27d
--- /dev/null
+++ b/docs/source/integrations/lancedb.rst
@@ -0,0 +1,557 @@
+.. _lancedb-integration:
+
+LanceDB Integration
+===================
+
+.. default-role:: code
+
+`LanceDB <https://www.lancedb.com>`_ is a serverless vector database with deep 
+integrations with the Python ecosystem. It requires no setup and is free to
+use.
+
+FiftyOne provides an API to create LanceDB tables and run
+similarity queries, both :ref:`programmatically <LanceDB-query>` in Python and
+via point-and-click in the App.
+
+.. _lancedb-basic-recipe:
+
+Basic recipe
+____________
+
+The basic workflow to use LanceDB to create a similarity index on your FiftyOne
+datasets and use this to query your data is as follows:
+
+1)  Load a :ref:`dataset <loading-datasets>` into FiftyOne
+
+2)  Compute embedding vectors for samples or patches in your dataset, or select
+    a model to use to generate embeddings
+
+3)  Use the :meth:`compute_similarity() <fiftyone.brain.compute_similarity>`
+    method to generate a LanceDB table for the samples or object
+    patches embeddings in a dataset by setting the parameter `backend="lancedb"` and
+    specifying a `brain_key` of your choice
+
+4)  Use this LanceDB table to query your data with
+    :meth:`sort_by_similarity() <fiftyone.core.collections.SampleCollection.sort_by_similarity>`
+
+5) If desired, delete the table
+
+|br|
+The example below demonstrates this workflow.
+
+.. note::
+
+    You must install the
+    `LanceDB Python client <https://github.com/lancedb/lancedb>`_ to run this
+    example:
+
+    .. code-block:: shell
+
+        pip install lancedb
+
+    Note that, if you are using a custom LanceDB URI, you can store your
+    credentials as described in :ref:`this section <lancedb-setup>` to avoid
+    entering them manually each time you interact with your LanceDB index.
+
+.. code-block:: python
+    :linenos:
+
+    import fiftyone as fo
+    import fiftyone.brain as fob
+    import fiftyone.zoo as foz
+
+    # Step 1: Load your data into FiftyOne
+    dataset = foz.load_zoo_dataset("quickstart")
+
+    # Steps 2 and 3: Compute embeddings and create a similarity index
+    lancedb_index = fob.compute_similarity(
+        dataset, 
+        model="clip-vit-base32-torch",
+        brain_key="lancedb_index",
+        backend="lancedb",
+    )
+
+Once the similarity index has been generated, we can query our data in FiftyOne
+by specifying the `brain_key`:
+
+.. code-block:: python
+    :linenos:
+
+    # Step 4: Query your data
+    query = dataset.first().id  # query by sample ID
+    view = dataset.sort_by_similarity(
+        query, 
+        brain_key="lancedb_index",
+        k=10,  # limit to 10 most similar samples
+    )
+
+    # Step 5 (optional): Cleanup
+
+    # Delete the LanceDB table
+    lancedb_index.cleanup()
+
+    # Delete run record from FiftyOne
+    dataset.delete_brain_run("lancedb_index")
+
+.. _lancedb-setup:
+
+Setup
+_____
+
+You can get started using LanceDB by simply installing the
+`LanceDB Python client <https://github.com/lancedb/lancedb>`_:
+
+.. code-block:: shell
+
+    pip install lancedb
+
+Using the LanceDB backend
+-------------------------
+
+By default, calling
+:meth:`compute_similarity() <fiftyone.brain.compute_similarity>` or 
+:meth:`sort_by_similarity() <fiftyone.core.collections.SampleCollection.sort_by_similarity>`
+will use an sklearn backend.
+
+To use the LanceDB backend, simply set the optional `backend` parameter of
+:meth:`compute_similarity() <fiftyone.brain.compute_similarity>` to
+`"lancedb"`:
+
+.. code:: python
+    :linenos:
+
+    import fiftyone.brain as fob
+
+    fob.compute_similarity(..., backend="lancedb", ...)
+
+Alternatively, you can permanently configure FiftyOne to use the LanceDB
+backend by setting the following environment variable:
+
+.. code-block:: shell
+
+    export FIFTYONE_BRAIN_DEFAULT_SIMILARITY_BACKEND=lancedb
+
+or by setting the `default_similarity_backend` parameter of your
+:ref:`brain config <brain-config>` located at `~/.fiftyone/brain_config.json`:
+
+.. code-block:: json
+
+    {
+        "default_similarity_backend": "lancedb"
+    }
+
+.. _lancedb-config-parameters:
+
+LanceDB config parameters
+-------------------------
+
+The LanceDB backend supports query parameters that can be used to customize
+your similarity queries. These parameters include:
+
+*   **table_name** (*None*): the name of the LanceDB table to use. If none is
+    provided, a new table will be created
+*   **metric** (*"cosine"*): the embedding distance metric to use when creating
+    a new table. The supported values are ``("cosine", "euclidean")``
+*   **uri** (*"/tmp/lancedb"*): the database URI to use
+
+You can specify these parameters via any of the strategies described in the
+previous section. Here's an example of a :ref:`brain config <brain-config>`
+that includes all of the available parameters:
+
+.. code-block:: json
+
+    {
+        "similarity_backends": {
+            "lancedb": {
+                "table_name": "your-table",
+                "metric": "euclidean",
+                "uri": "/tmp/lancedb"
+            }
+        }
+    }
+
+However, typically these parameters are directly passed to
+:meth:`compute_similarity() <fiftyone.brain.compute_similarity>` to configure
+a specific new index:
+
+.. code:: python
+    :linenos:
+
+    lancedb_index = fob.compute_similarity(
+        ...
+        backend="lancedb",
+        brain_key="lancedb_index",
+        table_name="your-table",
+        metric="euclidean",
+        uri="/tmp/lancedb",
+    )
+
+.. _lancedb-managing-brain-runs:
+
+Managing brain runs
+___________________
+
+FiftyOne provides a variety of methods that you can use to manage brain runs.
+
+For example, you can call
+:meth:`list_brain_runs() <fiftyone.core.collections.SampleCollection.list_brain_runs>`
+to see the available brain keys on a dataset:
+
+.. code:: python
+    :linenos:
+
+    import fiftyone.brain as fob
+
+    # List all brain runs
+    dataset.list_brain_runs()
+
+    # Only list similarity runs
+    dataset.list_brain_runs(type=fob.Similarity)
+
+    # Only list specific similarity runs
+    dataset.list_brain_runs(
+        type=fob.Similarity,
+        patches_field="ground_truth",
+        supports_prompts=True,
+    )
+
+Or, you can use
+:meth:`get_brain_info() <fiftyone.core.collections.SampleCollection.get_brain_info>`
+to retrieve information about the configuration of a brain run:
+
+.. code:: python
+    :linenos:
+
+    info = dataset.get_brain_info(brain_key)
+    print(info)
+
+Use :meth:`load_brain_results() <fiftyone.core.collections.SampleCollection.load_brain_results>`
+to load the |SimilarityIndex| instance for a brain run.
+
+You can use
+:meth:`rename_brain_run() <fiftyone.core.collections.SampleCollection.rename_brain_run>`
+to rename the brain key associated with an existing similarity results run:
+
+.. code:: python
+    :linenos:
+
+    dataset.rename_brain_run(brain_key, new_brain_key)
+
+Finally, you can use
+:meth:`delete_brain_run() <fiftyone.core.collections.SampleCollection.delete_brain_run>`
+to delete the record of a similarity index computation from your FiftyOne
+dataset:
+
+.. code:: python
+    :linenos:
+
+    dataset.delete_brain_run(brain_key)
+
+.. note::
+
+    Calling
+    :meth:`delete_brain_run() <fiftyone.core.collections.SampleCollection.delete_brain_run>`
+    only deletes the **record** of the brain run from your FiftyOne dataset; it
+    will not delete any associated LanceDB table, which you can do as follows:
+
+    .. code:: python
+
+        # Delete the LanceDB table
+        lancedb_index = dataset.load_brain_results(brain_key)
+        lancedb_index.cleanup()
+
+.. _lancedb-examples:
+
+Examples
+________
+
+This section demonstrates how to perform some common vector search workflows on 
+a FiftyOne dataset using the LanceDB backend.
+
+.. _lancedb-new-similarity-index:
+
+Create a similarity index
+-------------------------
+
+In order to create a new LanceDB similarity index, you need to specify either
+the `embeddings` or `model` argument to
+:meth:`compute_similarity() <fiftyone.brain.compute_similarity>`. Here's a few
+possibilities:
+
+.. code:: python
+    :linenos:
+
+    import fiftyone as fo
+    import fiftyone.brain as fob
+    import fiftyone.zoo as foz
+
+    dataset = foz.load_zoo_dataset("quickstart")
+    model_name = "clip-vit-base32-torch"
+    model = foz.load_zoo_model(model_name)
+    brain_key = "lancedb_index"
+
+    # Option 1: Compute embeddings on the fly from model name
+    fob.compute_similarity(
+        dataset,
+        model=model_name,
+        backend="lancedb",
+        brain_key=brain_key,
+    )
+
+    # Option 2: Compute embeddings on the fly from model instance
+    fob.compute_similarity(
+        dataset,
+        model=model,
+        backend="lancedb",
+        brain_key=brain_key,
+    )
+
+    # Option 3: Pass precomputed embeddings as a numpy array
+    embeddings = dataset.compute_embeddings(model)
+    fob.compute_similarity(
+        dataset,
+        embeddings=embeddings,
+        backend="lancedb",
+        brain_key=brain_key,
+    )
+
+    # Option 4: Pass precomputed embeddings by field name
+    dataset.compute_embeddings(model, embeddings_field="embeddings")
+    fob.compute_similarity(
+        dataset,
+        embeddings="embeddings",
+        backend="lancedb",
+        brain_key=brain_key,
+    )
+
+.. note::
+
+    You can customize the LanceDB index by passing any
+    :ref:`supported parameters <lancedb-config-parameters>` as extra kwargs.
+
+.. _lancedb-patch-similarity-index:
+
+Create a patch similarity index
+-------------------------------
+
+You can also create a similarity index for
+:ref:`object patches <brain-object-similarity>` within your dataset by
+specifying a `patches_field` argument to
+:meth:`compute_similarity() <fiftyone.brain.compute_similarity>`:
+
+.. code:: python
+    :linenos:
+
+    import fiftyone as fo
+    import fiftyone.brain as fob
+    import fiftyone.zoo as foz
+
+    dataset = foz.load_zoo_dataset("quickstart")
+
+    fob.compute_similarity(
+        dataset,
+        patches_field="ground_truth",
+        model="clip-vit-base32-torch",
+        backend="lancedb",
+        brain_key="lancedb_index",
+    )
+
+.. note::
+
+    You can customize the LanceDB index by passing any
+    :ref:`supported parameters <lancedb-config-parameters>` as extra kwargs.
+
+.. _lancedb-connect-to-existing-index:
+
+Connect to an existing index
+----------------------------
+
+If you have already created a LanceDB table storing the embedding vectors for
+the samples or patches in your dataset, you can connect to it by passing the
+`table_name` to
+:meth:`compute_similarity() <fiftyone.brain.compute_similarity>`:
+
+.. code:: python
+    :linenos:
+
+    import fiftyone as fo
+    import fiftyone.brain as fob
+    import fiftyone.zoo as foz
+
+    dataset = foz.load_zoo_dataset("quickstart")
+
+    fob.compute_similarity(
+        dataset,
+        model="clip-vit-base32-torch",      # zoo model used (if applicable)
+        embeddings=False,                   # don't compute embeddings
+        table_name="your-table",            # the existing LanceDB table
+        brain_key="lancedb_index",
+        backend="lancedb",
+    )
+
+.. _lancedb-add-remove-embeddings:
+
+Add/remove embeddings from an index
+-----------------------------------
+
+You can use
+:meth:`add_to_index() <fiftyone.brain.similarity.SimilarityIndex.add_to_index>`
+and
+:meth:`remove_from_index() <fiftyone.brain.similarity.SimilarityIndex.remove_from_index>`
+to add and remove embeddings from an existing Lancedb index.
+
+These methods can come in handy if you modify your FiftyOne dataset and need
+to update the LanceDB index to reflect these changes:
+
+.. code:: python
+    :linenos:
+
+    import numpy as np
+
+    import fiftyone as fo
+    import fiftyone.brain as fob
+    import fiftyone.zoo as foz
+
+    dataset = foz.load_zoo_dataset("quickstart")
+
+    lancedb_index = fob.compute_similarity(
+        dataset,
+        model="clip-vit-base32-torch",
+        brain_key="lancedb_index",
+        backend="lancedb",
+    )
+    print(lancedb_index.total_index_size)  # 200
+
+    view = dataset.take(10)
+    ids = view.values("id")
+
+    # Delete 10 samples from a dataset
+    dataset.delete_samples(view)
+
+    # Delete the corresponding vectors from the index
+    lancedb_index.remove_from_index(sample_ids=ids)
+
+    # Add 20 samples to a dataset
+    samples = [fo.Sample(filepath="tmp%d.jpg" % i) for i in range(20)]
+    sample_ids = dataset.add_samples(samples)
+
+    # Add corresponding embeddings to the index
+    embeddings = np.random.rand(20, 512)
+    lancedb_index.add_to_index(embeddings, sample_ids)
+
+    print(lancedb_index.total_index_size)  # 210
+
+.. _lancedb-get-embeddings:
+
+Retrieve embeddings from an index
+---------------------------------
+
+You can use
+:meth:`get_embeddings() <fiftyone.brain.similarity.SimilarityIndex.get_embeddings>`
+to retrieve embeddings from a LanceDB index by ID:
+
+.. code:: python
+    :linenos:
+
+    import fiftyone as fo
+    import fiftyone.brain as fob
+    import fiftyone.zoo as foz
+
+    dataset = foz.load_zoo_dataset("quickstart")
+
+    lancedb_index = fob.compute_similarity(
+        dataset, 
+        model="clip-vit-base32-torch",
+        brain_key="lancedb_index",
+        backend="lancedb",
+    )
+
+    # Retrieve embeddings for the entire dataset
+    ids = dataset.values("id")
+    embeddings, sample_ids, _ = lancedb_index.get_embeddings(sample_ids=ids)
+    print(embeddings.shape)  # (200, 512)
+    print(sample_ids.shape)  # (200,)
+
+    # Retrieve embeddings for a view
+    ids = dataset.take(10).values("id")
+    embeddings, sample_ids, _ = lancedb_index.get_embeddings(sample_ids=ids)
+    print(embeddings.shape)  # (10, 512)
+    print(sample_ids.shape)  # (10,)
+
+.. _lancedb-query:
+
+Querying a LanceDB index
+------------------------
+
+You can query a LanceDB index by appending a
+:meth:`sort_by_similarity() <fiftyone.core.collections.SampleCollection.sort_by_similarity>`
+stage to any dataset or view. The query can be any of the following:
+
+*   An ID (sample or patch)
+*   A query vector of same dimension as the index
+*   A list of IDs (samples or patches)
+*   A text prompt (if :ref:`supported by the model <brain-similarity-text>`)
+
+.. code:: python
+    :linenos:
+
+    import numpy as np
+
+    import fiftyone as fo
+    import fiftyone.brain as fob
+    import fiftyone.zoo as foz
+
+    dataset = foz.load_zoo_dataset("quickstart")
+
+    fob.compute_similarity(
+        dataset, 
+        model="clip-vit-base32-torch",
+        brain_key="lancedb_index",
+        backend="lancedb",
+    )
+
+    # Query by vector
+    query = np.random.rand(512)  # matches the dimension of CLIP embeddings
+    view = dataset.sort_by_similarity(query, k=10, brain_key="lancedb_index")
+
+    # Query by sample ID
+    query = dataset.first().id
+    view = dataset.sort_by_similarity(query, k=10, brain_key="lancedb_index")
+
+    # Query by a list of IDs
+    query = [dataset.first().id, dataset.last().id]
+    view = dataset.sort_by_similarity(query, k=10, brain_key="lancedb_index")
+
+    # Query by text prompt
+    query = "a photo of a dog"
+    view = dataset.sort_by_similarity(query, k=10, brain_key="lancedb_index")
+
+.. note::
+
+    Performing a similarity search on a |DatasetView| will **only** return
+    results from the view; if the view contains samples that were not included
+    in the index, they will never be included in the result.
+
+    This means that you can index an entire |Dataset| once and then perform
+    searches on subsets of the dataset by
+    :ref:`constructing views <using-views>` that contain the images of
+    interest.
+
+.. _lancedb-advanced-usage:
+
+Advanced usage
+--------------
+
+LanceDB is compatible with the Python ecosystem and can be used with pandas,
+numpy, and arrow:
+
+.. code:: python
+    :linenos:
+
+    lancedb_index = fob.compute_similarity(..., backend="lancedb", ...)
+
+    # Retrieve the raw LanceDB table
+    table = lancedb_index.table
+
+    df = table.to_pandas()  # get the table as a pandas dataframe
+    pa = table.to_arrow()   # get the table as an arrow table
diff --git a/docs/source/integrations/milvus.rst b/docs/source/integrations/milvus.rst
new file mode 100644
index 0000000000..d8d2657998
--- /dev/null
+++ b/docs/source/integrations/milvus.rst
@@ -0,0 +1,731 @@
+.. _milvus-integration:
+
+Milvus Integration
+====================
+
+.. default-role:: code
+
+`Milvus <https://milvus.io/>`_ is one of the most popular vector databases
+available, and we've made it easy to use Milvus's vector search
+capabilities on your computer vision data directly from FiftyOne!
+
+Follow these :ref:`simple instructions <milvus-setup>` to get started using
+Milvus + FiftyOne.
+
+FiftyOne provides an API to create Milvus collections, upload vectors, and run
+similarity queries, both :ref:`programmatically <milvus-query>` in Python and
+via point-and-click in the App.
+
+.. note::
+
+    Did you know? You can
+    :ref:`search by natural language <brain-similarity-text>` using Milvus
+    similarity indexes!
+
+.. image:: /images/brain/brain-object-similarity.gif
+   :alt: object-similarity
+   :align: center
+
+.. _milvus-basic-recipe:
+
+Basic recipe
+____________
+
+The basic workflow to use Milvus to create a similarity index on your FiftyOne
+datasets and use this to query your data is as follows:
+
+1)  Load a :ref:`dataset <loading-datasets>` into FiftyOne
+
+2)  Compute embedding vectors for samples or patches in your dataset, or select
+    a model to use to generate embeddings
+
+3)  Use the :meth:`compute_similarity() <fiftyone.brain.compute_similarity>`
+    methodto generate a Milvus similarity index for the samples or object
+    patches in a dataset by setting the parameter `backend="milvus"` and
+    specifying a `brain_key` of your choice
+
+4)  Use this Milvus similarity index to query your data with
+    :meth:`sort_by_similarity() <fiftyone.core.collections.SampleCollection.sort_by_similarity>`
+
+5)  If desired, delete the index
+
+|br|
+The example below demonstrates this workflow.
+
+.. note::
+
+    You must `connect to a Milvus server <https://milvus.io/docs/install_standalone-docker.md>`_ 
+    and install the
+    `Milvus Python client <https://github.com/milvus-io/pymilvus>`_
+    to run this example:
+
+    .. code-block:: shell
+
+        wget https://github.com/milvus-io/milvus/releases/download/v2.2.11/milvus-standalone-docker-compose.yml -O docker-compose.yml
+        sudo docker compose up -d
+
+        pip install pymilvus
+
+    Note that, if you are using a custom Milvus server, you can store your
+    credentials as described in :ref:`this section <milvus-setup>` to avoid
+    entering them manually each time you interact with your Milvus index.
+
+First let's load a dataset into FiftyOne and compute embeddings for the
+samples:
+
+.. code-block:: python
+    :linenos:
+
+    import fiftyone as fo
+    import fiftyone.brain as fob
+    import fiftyone.zoo as foz
+
+    # Step 1: Load your data into FiftyOne
+    dataset = foz.load_zoo_dataset("quickstart")
+
+    # Steps 2 and 3: Compute embeddings and create a similarity index
+    milvus_index = fob.compute_similarity(
+        dataset, 
+        brain_key="milvus_index",
+        backend="milvus",
+    )
+
+Once the similarity index has been generated, we can query our data in FiftyOne
+by specifying the `brain_key`:
+
+.. code-block:: python
+    :linenos:
+
+    # Step 4: Query your data
+    query = dataset.first().id  # query by sample ID
+    view = dataset.sort_by_similarity(
+        query, 
+        brain_key="milvus_index",
+        k=10,  # limit to 10 most similar samples
+    )
+
+    # Step 5 (optional): Cleanup
+
+    # Delete the Milvus collection
+    milvus_index.cleanup()
+
+    # Delete run record from FiftyOne
+    dataset.delete_brain_run("milvus_index")
+
+.. note::
+
+    Skip to :ref:`this section <milvus-examples>` to see a variety of common
+    Milvus query patterns.
+
+.. _milvus-setup:
+
+Setup
+_____
+
+The easiest way to get started is to
+`install Milvus standalone via Docker Compose <https://milvus.io/docs/install_standalone-docker.md>`_:
+
+.. code-block:: shell
+
+    wget https://github.com/milvus-io/milvus/releases/download/v2.2.11/milvus-standalone-docker-compose.yml -O docker-compose.yml
+    sudo docker compose up -d
+
+Installing the Milvus client
+----------------------------
+
+In order to use the Milvus backend, you must also install the
+`Milvus Python client <https://github.com/milvus-io/pymilvus>`_:
+
+.. code-block:: shell
+
+    pip install pymilvus
+
+Using the Milvus backend
+------------------------
+
+By default, calling
+:meth:`compute_similarity() <fiftyone.brain.compute_similarity>` or 
+:meth:`sort_by_similarity() <fiftyone.core.collections.SampleCollection.sort_by_similarity>`
+will use an sklearn backend.
+
+To use the Milvus backend, simply set the optional `backend` parameter of
+:meth:`compute_similarity() <fiftyone.brain.compute_similarity>` to
+`"milvus"`:
+
+.. code:: python
+    :linenos:
+
+    import fiftyone.brain as fob
+
+    fob.compute_similarity(..., backend="milvus", ...)
+
+Alternatively, you can permanently configure FiftyOne to use the Milvus
+backend by setting the following environment variable:
+
+.. code-block:: shell
+
+    export FIFTYONE_BRAIN_DEFAULT_SIMILARITY_BACKEND=milvus
+
+or by setting the `default_similarity_backend` parameter of your
+:ref:`brain config <brain-config>` located at `~/.fiftyone/brain_config.json`:
+
+.. code-block:: json
+
+    {
+        "default_similarity_backend": "milvus"
+    }
+
+Authentication
+--------------
+
+If you are using a custom Milvus server, you can provide your credentials in a
+variety of ways.
+
+**Environment variables (recommended)**
+
+The recommended way to configure your Milvus credentials is to store them
+in the environment variables shown below, which are  automatically accessed by
+FiftyOne whenever a connection to Milvus is made.
+
+.. code-block:: shell
+
+    export FIFTYONE_BRAIN_SIMILARITY_MILVUS_USER=XXXXXX
+    export FIFTYONE_BRAIN_SIMILARITY_MILVUS_PASSWORD=XXXXXX
+    export FIFTYONE_BRAIN_SIMILARITY_MILVUS_URI=XXXXXX
+
+**FiftyOne Brain config**
+
+You can also store your credentials in your :ref:`brain config <brain-config>`
+located at `~/.fiftyone/brain_config.json`:
+
+.. code-block:: json
+
+    {
+        "similarity_backends": {
+            "milvus": {
+                "user": "XXXXXXXXXXXX",
+                "password": "XXXXXXXXXXXX",
+                "uri": "XXXXXXXXXXXX"
+            }
+        }
+    }
+
+Note that this file will not exist until you create it.
+
+**Keyword arguments**
+
+You can manually provide your Milvus credentials as keyword arguments each
+time you call methods like
+:meth:`compute_similarity() <fiftyone.brain.compute_similarity>` that require
+connections to Milvus:
+
+.. code:: python
+    :linenos:
+
+    import fiftyone.brain as fob 
+    
+    milvus_index = fob.compute_similarity(
+        ...
+        backend="milvus",
+        brain_key="milvus_index",
+        user="XXXXXX",
+        password="XXXXXX",
+        uri="XXXXXX",
+    )
+
+Note that, when using this strategy, you must manually provide the credentials
+when loading an index later via
+:meth:`load_brain_results() <fiftyone.core.collections.SampleCollection.load_brain_results>`:
+
+.. code:: python
+    :linenos:
+
+    milvus_index = dataset.load_brain_results(
+        "milvus_index",
+        user="XXXXXX",
+        password="XXXXXX",
+        uri="XXXXXX",
+    )
+
+.. _milvus-config-parameters:
+
+Milvus config parameters
+------------------------
+
+The Milvus backend supports a variety of query parameters that can be used to
+customize your similarity queries. These parameters include:
+
+-   **collection_name** (*None*): the name of the Milvus collection to use or
+    create. If none is provided, a new collection will be created
+-   **metric** (*"dotproduct"*): the embedding distance metric to use when
+    creating a new index. The supported values are
+    ``("dotproduct", "euclidean")``
+-   **consistency_level** (*"Session"*):  the consistency level to use.
+    Supported values are ``("Strong", "Session", "Bounded", "Eventually")``
+
+For detailed information on these parameters, see the 
+`Milvus authentication documentation <https://milvus.io/docs/authenticate.md>`_ 
+and `Milvus consistency levels documentation <https://milvus.io/docs/consistency.md#Consistency-levels>`_.
+
+You can specify these parameters via any of the strategies described in the
+previous section. Here's an example of a :ref:`brain config <brain-config>`
+that includes all of the available parameters:
+
+.. code-block:: json
+
+    {
+        "similarity_backends": {
+            "milvus": {
+                "collection_name": "your_collection",
+                "metric": "dotproduct",
+                "consistency_level": "Strong"
+            }
+        }
+    }
+
+However, typically these parameters are directly passed to
+:meth:`compute_similarity() <fiftyone.brain.compute_similarity>` to configure
+a specific new index:
+
+.. code:: python
+    :linenos:
+
+    milvus_index = fob.compute_similarity(
+        ...
+        backend="milvus",
+        brain_key="milvus_index",
+        collection_name="your_collection",
+        metric="dotproduct",
+        consistency_level="Strong",
+    )
+
+.. _milvus-managing-brain-runs:
+
+Managing brain runs
+___________________
+
+FiftyOne provides a variety of methods that you can use to manage brain runs.
+
+For example, you can call
+:meth:`list_brain_runs() <fiftyone.core.collections.SampleCollection.list_brain_runs>`
+to see the available brain keys on a dataset:
+
+.. code:: python
+    :linenos:
+
+    import fiftyone.brain as fob
+
+    # List all brain runs
+    dataset.list_brain_runs()
+
+    # Only list similarity runs
+    dataset.list_brain_runs(type=fob.Similarity)
+
+    # Only list specific similarity runs
+    dataset.list_brain_runs(
+        type=fob.Similarity,
+        patches_field="ground_truth",
+        supports_prompts=True,
+    )
+
+Or, you can use
+:meth:`get_brain_info() <fiftyone.core.collections.SampleCollection.get_brain_info>`
+to retrieve information about the configuration of a brain run:
+
+.. code:: python
+    :linenos:
+
+    info = dataset.get_brain_info(brain_key)
+    print(info)
+
+Use :meth:`load_brain_results() <fiftyone.core.collections.SampleCollection.load_brain_results>`
+to load the |SimilarityIndex| instance for a brain run.
+
+You can use
+:meth:`rename_brain_run() <fiftyone.core.collections.SampleCollection.rename_brain_run>`
+to rename the brain key associated with an existing similarity results run:
+
+.. code:: python
+    :linenos:
+
+    dataset.rename_brain_run(brain_key, new_brain_key)
+
+Finally, you can use
+:meth:`delete_brain_run() <fiftyone.core.collections.SampleCollection.delete_brain_run>`
+to delete the record of a similarity index computation from your FiftyOne 
+dataset:
+
+.. code:: python
+    :linenos:
+
+    dataset.delete_brain_run(brain_key)
+
+.. note::
+
+    Calling
+    :meth:`delete_brain_run() <fiftyone.core.collections.SampleCollection.delete_brain_run>`
+    only deletes the **record** of the brain run from your FiftyOne dataset; it
+    will not delete any associated Milvus collection, which you can do as follows:
+
+    .. code:: python
+
+        # Delete the Milvus collection
+        milvus_index = dataset.load_brain_results(brain_key)
+        milvus_index.cleanup()
+
+.. _milvus-examples:
+
+Examples
+________
+
+This section demonstrates how to perform some common vector search workflows on 
+a FiftyOne dataset using the Milvus backend.
+
+.. note::
+
+    All of the examples below assume you have configured your Milvus server
+    and connection as described in :ref:`this section <milvus-setup>`.
+
+.. _milvus-new-similarity-index:
+
+Create a similarity index
+-------------------------
+
+In order to create a new Milvus similarity index, you need to specify either
+the `embeddings` or `model` argument to
+:meth:`compute_similarity() <fiftyone.brain.compute_similarity>`. Here's a few
+possibilities:
+
+.. code:: python
+    :linenos:
+
+    import fiftyone as fo
+    import fiftyone.brain as fob
+    import fiftyone.zoo as foz
+
+    dataset = foz.load_zoo_dataset("quickstart")
+    model_name = "clip-vit-base32-torch"
+    model = foz.load_zoo_model(model_name)
+    brain_key = "milvus_index"
+
+    # Option 1: Compute embeddings on the fly from model name
+    fob.compute_similarity(
+        dataset,
+        model=model_name,
+        backend="milvus",
+        brain_key=brain_key,
+    )
+
+    # Option 2: Compute embeddings on the fly from model instance
+    fob.compute_similarity(
+        dataset,
+        model=model,
+        backend="milvus",
+        brain_key=brain_key,
+    )
+
+    # Option 3: Pass precomputed embeddings as a numpy array
+    embeddings = dataset.compute_embeddings(model)
+    fob.compute_similarity(
+        dataset,
+        embeddings=embeddings,
+        backend="milvus",
+        brain_key=brain_key,
+    )
+
+    # Option 4: Pass precomputed embeddings by field name
+    dataset.compute_embeddings(model, embeddings_field="embeddings")
+    fob.compute_similarity(
+        dataset,
+        embeddings="embeddings",
+        backend="milvus",
+        brain_key=brain_key,
+    )
+
+.. note::
+
+    You can customize the Milvus similarity index by passing any
+    :ref:`supported parameters <milvus-config-parameters>` as extra kwargs.
+
+.. _milvus-patch-similarity-index:
+
+Create a patch similarity index
+-------------------------------
+
+You can also create a similarity index for
+:ref:`object patches <brain-object-similarity>` within your dataset by
+specifying a `patches_field` argument to
+:meth:`compute_similarity() <fiftyone.brain.compute_similarity>`:
+
+.. code:: python
+    :linenos:
+
+    import fiftyone as fo
+    import fiftyone.brain as fob
+    import fiftyone.zoo as foz
+
+    dataset = foz.load_zoo_dataset("quickstart")
+
+    fob.compute_similarity(
+        dataset,
+        patches_field="ground_truth",
+        model="clip-vit-base32-torch",
+        backend="milvus",
+        brain_key="milvus_patches",
+    )
+
+.. note::
+
+    You can customize the Milvus index by passing any
+    :ref:`supported parameters <milvus-config-parameters>` as extra kwargs.
+
+.. _milvus-connect-to-existing-collection:
+
+Connect to an existing collection
+---------------------------------
+
+If you have already created a Milvus collection storing the embedding vectors
+for the samples or patches in your dataset, you can connect to it by passing
+the `collection_name` to
+:meth:`compute_similarity() <fiftyone.brain.compute_similarity>`:
+
+.. code:: python
+    :linenos:
+
+    import fiftyone as fo
+    import fiftyone.brain as fob
+    import fiftyone.zoo as foz
+
+    dataset = foz.load_zoo_dataset("quickstart")
+
+    fob.compute_similarity(
+        dataset,
+        model="clip-vit-base32-torch",      # zoo model used (if applicable)
+        embeddings=False,                   # don't compute embeddings
+        collection_name="your_collection",  # the existing Milvus collection
+        brain_key="milvus_index",
+        backend="milvus",
+    )
+
+.. _milvus-add-remove-embeddings:
+
+Add/remove embeddings from an index
+-----------------------------------
+
+You can use
+:meth:`add_to_index() <fiftyone.brain.similarity.SimilarityIndex.add_to_index>`
+and
+:meth:`remove_from_index() <fiftyone.brain.similarity.SimilarityIndex.remove_from_index>`
+to add and remove embeddings from an existing Milvus similarity index.
+
+These methods can come in handy if you modify your FiftyOne dataset and need
+to update the Milvus similarity index to reflect these changes:
+
+.. code:: python
+    :linenos:
+
+    import numpy as np
+
+    import fiftyone as fo
+    import fiftyone.brain as fob
+    import fiftyone.zoo as foz
+
+    dataset = foz.load_zoo_dataset("quickstart")
+
+    milvus_index = fob.compute_similarity(
+        dataset,
+        model="clip-vit-base32-torch",
+        brain_key="milvus_index",
+        backend="milvus",
+    )
+    print(milvus_index.total_index_size)  # 200
+
+    view = dataset.take(10)
+    ids = view.values("id")
+
+    # Delete 10 samples from a dataset
+    dataset.delete_samples(view)
+
+    # Delete the corresponding vectors from the index
+    milvus_index.remove_from_index(sample_ids=ids)
+
+    # Add 20 samples to a dataset
+    samples = [fo.Sample(filepath="tmp%d.jpg" % i) for i in range(20)]
+    sample_ids = dataset.add_samples(samples)
+
+    # Add corresponding embeddings to the index
+    embeddings = np.random.rand(20, 512)
+    milvus_index.add_to_index(embeddings, sample_ids)
+
+    print(milvus_index.total_index_size)  # 210
+
+.. _milvus-get-embeddings:
+
+Retrieve embeddings from an index
+---------------------------------
+
+You can use
+:meth:`get_embeddings() <fiftyone.brain.similarity.SimilarityIndex.get_embeddings>`
+to retrieve embeddings from a Milvus index by ID:
+
+.. code:: python
+    :linenos:
+
+    import fiftyone as fo
+    import fiftyone.brain as fob
+    import fiftyone.zoo as foz
+
+    dataset = foz.load_zoo_dataset("quickstart")
+
+    milvus_index = fob.compute_similarity(
+        dataset, 
+        model="clip-vit-base32-torch",
+        brain_key="milvus_index",
+        backend="milvus",
+    )
+
+    # Retrieve embeddings for the entire dataset
+    ids = dataset.values("id")
+    embeddings, sample_ids, _ = milvus_index.get_embeddings(sample_ids=ids)
+    print(embeddings.shape)  # (200, 512)
+    print(sample_ids.shape)  # (200,)
+
+    # Retrieve embeddings for a view
+    ids = dataset.take(10).values("id")
+    embeddings, sample_ids, _ = milvus_index.get_embeddings(sample_ids=ids)
+    print(embeddings.shape)  # (10, 512)
+    print(sample_ids.shape)  # (10,)
+
+.. _milvus-query:
+
+Querying a Milvus index
+-----------------------
+
+You can query a Milvus index by appending a
+:meth:`sort_by_similarity() <fiftyone.core.collections.SampleCollection.sort_by_similarity>`
+stage to any dataset or view. The query can be any of the following:
+
+*   An ID (sample or patch)
+*   A query vector of same dimension as the index
+*   A list of IDs (samples or patches)
+*   A text prompt (if :ref:`supported by the model <brain-similarity-text>`)
+
+.. code:: python
+    :linenos:
+
+    import numpy as np
+
+    import fiftyone as fo
+    import fiftyone.brain as fob
+    import fiftyone.zoo as foz
+
+    dataset = foz.load_zoo_dataset("quickstart")
+
+    fob.compute_similarity(
+        dataset, 
+        model="clip-vit-base32-torch",
+        brain_key="milvus_index",
+        backend="milvus",
+    )
+
+    # Query by vector
+    query = np.random.rand(512)  # matches the dimension of CLIP embeddings
+    view = dataset.sort_by_similarity(query, k=10, brain_key="milvus_index")
+
+    # Query by sample ID
+    query = dataset.first().id
+    view = dataset.sort_by_similarity(query, k=10, brain_key="milvus_index")
+
+    # Query by a list of IDs
+    query = [dataset.first().id, dataset.last().id]
+    view = dataset.sort_by_similarity(query, k=10, brain_key="milvus_index")
+
+    # Query by text prompt
+    query = "a photo of a dog"
+    view = dataset.sort_by_similarity(query, k=10, brain_key="milvus_index")
+
+.. note::
+
+    Performing a similarity search on a |DatasetView| will **only** return
+    results from the view; if the view contains samples that were not included
+    in the index, they will never be included in the result.
+
+    This means that you can index an entire |Dataset| once and then perform
+    searches on subsets of the dataset by
+    :ref:`constructing views <using-views>` that contain the images of
+    interest.
+
+.. _milvus-access-client:
+
+Accessing the Milvus client
+---------------------------
+
+You can use the `collection` property of a Milvus index to directly access the
+underlying Milvus collection and use its methods as desired:
+
+.. code:: python
+    :linenos:
+
+    import fiftyone as fo
+    import fiftyone.brain as fob
+    import fiftyone.zoo as foz
+
+    dataset = foz.load_zoo_dataset("quickstart")
+
+    milvus_index = fob.compute_similarity(
+        dataset,
+        model="clip-vit-base32-torch",
+        brain_key="milvus_index",
+        backend="milvus",
+    )
+
+    print(milvus_index.collection)
+
+    # The Milvus SDK is already initialized for you as well
+    import pymilvus
+    print(pymilvus.utility.list_collections())
+
+.. _milvus-advanced-usage:
+
+Advanced usage
+--------------
+
+As :ref:`previously mentioned <milvus-config-parameters>`, you can customize
+your Milvus indexes by providing optional parameters to
+:meth:`compute_similarity() <fiftyone.brain.compute_similarity>`.
+
+Here's an example of creating a similarity index backed by a customized
+Milvus similarity index. Just for fun, we'll specify a custom collection name,
+use euclidean distance, and populate the index for only a subset of our
+dataset:
+
+.. code:: python
+    :linenos:
+
+    import fiftyone as fo
+    import fiftyone.brain as fob
+    import fiftyone.zoo as foz
+
+    dataset = foz.load_zoo_dataset("quickstart")
+
+    # Create a custom Milvus index
+    milvus_index = fob.compute_similarity(
+        dataset,
+        model="clip-vit-base32-torch",
+        embeddings=False,  # we'll add embeddings below
+        metric="euclidean",
+        brain_key="milvus_index",
+        backend="milvus",
+        collection_name="custom_milvus_collection",
+    )
+
+    # Add embeddings for a subset of the dataset
+    view = dataset.take(10)
+    embeddings, sample_ids, _ = milvus_index.compute_embeddings(view)
+    milvus_index.add_to_index(embeddings, sample_ids)
+
+    print(milvus_index.collection)
+
+    # The Milvus SDK is already initialized for you as well
+    import pymilvus
+    print(pymilvus.utility.list_collections())
diff --git a/docs/source/integrations/pinecone.rst b/docs/source/integrations/pinecone.rst
index b584c5fc43..15e7c96dbc 100644
--- a/docs/source/integrations/pinecone.rst
+++ b/docs/source/integrations/pinecone.rst
@@ -57,7 +57,7 @@ The example below demonstrates this workflow.
     You must create a `Pinecone account <https://www.pinecone.io/>`_, download
     a `Pinecone API key <https://app.pinecone.io/organizations>`_, and install
     the
-    `Pinecone Python client <hhttps://github.com/pinecone-io/pinecone-python-client>`_
+    `Pinecone Python client <https://github.com/pinecone-io/pinecone-python-client>`_
     to run this example:
 
     .. code-block:: shell
@@ -155,8 +155,7 @@ To use the Pinecone backend, simply set the optional `backend` parameter of
     fob.compute_similarity(..., backend="pinecone", ...)
 
 Alternatively, you can permanently configure FiftyOne to use the Pinecone
-backend by setting the `FIFTYONE_BRAIN_DEFAULT_SIMILARITY_BACKEND` environment
-variable:
+backend by setting the following environment variable:
 
 .. code-block:: shell
 
@@ -174,17 +173,14 @@ or by setting the `default_similarity_backend` parameter of your
 Authentication
 --------------
 
-In order to connect to a Pinecone server, you must provide your API key and
-environment, which can be done in a variety of ways.
+In order to connect to a Pinecone server, you must provide your credentials,
+which can be done in a variety of ways.
 
 **Environment variables (recommended)**
 
 The recommended way to configure your Pinecone credentials is to store them
-in the
-`FIFTYONE_BRAIN_SIMILARITY_PINECONE_API_KEY` and
-`FIFTYONE_BRAIN_SIMILARITY_PINECONE_ENVIRONMENT` environment variables. These
-are automatically accessed by FiftyOne whenever a connection to Pinecone is
-made.
+in the environment variables shown below, which are automatically accessed by
+FiftyOne whenever a connection to Pinecone is made:
 
 .. code-block:: shell
 
@@ -250,16 +246,21 @@ Pinecone config parameters
 The Pinecone backend supports a variety of query parameters that can be used to
 customize your similarity queries. These parameters include:
 
-*   **metric**: the distance/similarity metric to use for the index. If not
-    specified, the default value is `"cosine"`. Supported values are
-    `("cosine", "dotproduct", "euclidean")`
-*   **index_name**: the name of the Pinecone index to use or create. If not
-    specified, a new unique name is generated automatically
-*   **pods**: an optional number of pods to use when creating a new index
-*   **pod_type**: an optional pod type to use when creating a new index
-*   **replicas**: an optional number of replicas to use when creating a new
+-   **index_name** (*None*): the name of the Pinecone index to use or create.
+    If not specified, a new unique name is generated automatically
+-   **index_type** (*None*): the index type to use when creating a new index
+-   **namespace** (*None*): a namespace under which to store vectors added to
+    the index
+-   **metric** (*"cosine"*): the distance/similarity metric to use for the
+    index. Supported values are ``("cosine", "dotproduct", "euclidean")``
+-   **replicas** (*None*): an optional number of replicas to use when creating
+    a new index
+-   **shards** (*None*): an optional number of shards to use when creating a
+    new index
+-   **pods** (*None*): an optional number of pods to use when creating a new
+    index
+-   **pod_type** (*None*): an optional pod type to use when creating a new
     index
-*   **shards**: an optional number of shards to use when creating a new index
 
 For detailed information on these parameters, see the 
 `Pinecone documentation <https://docs.pinecone.io/docs/indexes>`_.
@@ -273,9 +274,7 @@ that includes all of the available parameters:
     {
         "similarity_backends": {
             "pinecone": {
-                "api_key": "XXXXXXXXXXXX",
-                "environment": "us-west1-gcp",
-                "project_name": null,
+                "index_name": "your-index",
                 "index_type": null,
                 "namespace": null,
                 "metric": "cosine",
@@ -298,7 +297,7 @@ a specific new index:
         ...
         backend="pinecone",
         brain_key="pinecone_index",
-        index_name="your-index-name",
+        index_name="your-index",
         metric="cosine",
         pod_type="s1",
         pods=2,
@@ -424,7 +423,7 @@ possibilities:
     # Option 2: Compute embeddings on the fly from model instance
     fob.compute_similarity(
         dataset,
-        model=model
+        model=model,
         backend="pinecone",
         brain_key=brain_key,
     )
@@ -584,7 +583,7 @@ to retrieve embeddings from a Pinecone index by ID:
 
     pinecone_index = fob.compute_similarity(
         dataset, 
-        model="clip-vit-base32-torch"
+        model="clip-vit-base32-torch",
         brain_key="pinecone_index",
         backend="pinecone",
     )
@@ -628,7 +627,7 @@ stage to any dataset or view. The query can be any of the following:
 
     fob.compute_similarity(
         dataset, 
-        model="clip-vit-base32-torch"
+        model="clip-vit-base32-torch",
         brain_key="pinecone_index",
         backend="pinecone",
     )
@@ -679,7 +678,7 @@ underlying Pinecone client instance and use its methods as desired:
 
     pinecone_index = fob.compute_similarity(
         dataset,
-        model="clip-vit-base32-torch"
+        model="clip-vit-base32-torch",
         brain_key="pinecone_index",
         backend="pinecone",
     )
diff --git a/docs/source/integrations/qdrant.rst b/docs/source/integrations/qdrant.rst
index 256c14d932..ff4c00bb07 100644
--- a/docs/source/integrations/qdrant.rst
+++ b/docs/source/integrations/qdrant.rst
@@ -56,27 +56,22 @@ The example below demonstrates this workflow.
 
 .. note::
 
-    You must install `Qdrant <https://qdrant.tech>`_ and install the
+    You must `launch a Qdrant server <https://qdrant.tech>`_ and install the
     `Qdrant Python client <https://github.com/qdrant/qdrant_client>`_ to run
     this example:
 
     .. code-block:: shell
 
         docker pull qdrant/qdrant
-        pip install qdrant-client
-
-    Note that you can store your Qdrant credentials as described in
-    :ref:`this section <qdrant-setup>` to avoid entering them manually each
-    time you interact with your Qdrant index.
+        docker run -p 6333:6333 qdrant/qdrant
 
-First, let's start the Qdrant service locally:
+        pip install qdrant-client
 
-.. code-block:: bash
+    Note that, if you are using a custom Qdrant server, you can store your
+    credentials as described in :ref:`this section <qdrant-setup>` to avoid
+    entering them manually each time you interact with your Qdrant index.
 
-    # Step 1: Run Qdrant service
-    docker run -p 6333:6333 qdrant/qdrant
-
-Next let's load a dataset into FiftyOne and compute embeddings for the samples:
+First let's load a dataset into FiftyOne and compute embeddings for the samples:
 
 .. code-block:: python
     :linenos:
@@ -85,10 +80,10 @@ Next let's load a dataset into FiftyOne and compute embeddings for the samples:
     import fiftyone.brain as fob
     import fiftyone.zoo as foz
 
-    # Step 2: Load your data into FiftyOne
+    # Step 1: Load your data into FiftyOne
     dataset = foz.load_zoo_dataset("quickstart")
 
-    # Steps 3 and 4: Compute embeddings and create a similarity index
+    # Steps 2 and 3: Compute embeddings and create a similarity index
     qdrant_index = fob.compute_similarity(
         dataset, 
         brain_key="qdrant_index",
@@ -101,7 +96,7 @@ by specifying the `brain_key`:
 .. code-block:: python
     :linenos:
 
-    # Step 5: Query your data
+    # Step 4: Query your data
     query = dataset.first().id  # query by sample ID
     view = dataset.sort_by_similarity(
         query, 
@@ -109,7 +104,7 @@ by specifying the `brain_key`:
         k=10,  # limit to 10 most similar samples
     )
 
-    # Step 6 (optional): Cleanup
+    # Step 5 (optional): Cleanup
 
     # Delete the Qdrant collection
     qdrant_index.cleanup()
@@ -164,8 +159,7 @@ To use the Qdrant backend, simply set the optional `backend` parameter of
     fob.compute_similarity(..., backend="qdrant", ...)
 
 Alternatively, you can permanently configure FiftyOne to use the Qdrant backend
-by setting the `FIFTYONE_BRAIN_DEFAULT_SIMILARITY_BACKEND` environment
-variable:
+by setting the following environment variable:
 
 .. code-block:: shell
 
@@ -183,18 +177,19 @@ or by setting the `default_similarity_backend` parameter of your
 Authentication
 --------------
 
-In order to connect to a Qdrant server, you must provide your server URL, which
-can be done in a variety of ways.
+If you are using a custom Qdrant server, you can provide your credentials in a
+variety of ways.
 
 **Environment variables (recommended)**
 
-The recommended way to configure your Qdrant server URL is to store it in the 
-`FIFTYONE_BRAIN_SIMILARITY_QDRANT_URL` environment variable. This is
-automatically accessed by FiftyOne whenever a connection to Qdrant is made.
+The recommended way to configure your Qdrant credentials is to store them in
+the environment variables shown below, which are automatically accessed by
+FiftyOne whenever a connection to Qdrant is made.
 
 .. code-block:: shell
 
     export FIFTYONE_BRAIN_SIMILARITY_QDRANT_URL=localhost:6333
+    export FIFTYONE_BRAIN_SIMILARITY_QDRANT_API_KEY=XXXXXXXX
 
 **FiftyOne Brain config**
 
@@ -206,7 +201,8 @@ located at `~/.fiftyone/brain_config.json`:
     {
         "similarity_backends": {
             "qdrant": {
-                "url": "http://localhost:6333"
+                "url": "http://localhost:6333",
+                "api_key": "XXXXXXXX"
             }
         }
     }
@@ -215,10 +211,9 @@ Note that this file will not exist until you create it.
 
 **Keyword arguments**
 
-You can manually provide the server URL as a keyword argument each time you
-call methods
-like :meth:`compute_similarity() <fiftyone.brain.compute_similarity>` that
-require connections to Qdrant:
+You can manually provide credentials as keyword arguments each time you call
+methods like :meth:`compute_similarity() <fiftyone.brain.compute_similarity>`
+that require connections to Qdrant:
 
 .. code:: python
     :linenos:
@@ -230,6 +225,7 @@ require connections to Qdrant:
         backend="qdrant",
         brain_key="qdrant_index",
         url="http://localhost:6333",
+        api_key="XXXXXXXX",
     )
 
 Note that, when using this strategy, you must manually provide the credentials
@@ -242,6 +238,7 @@ when loading an index later via
     qdrant_index = dataset.load_brain_results(
         "qdrant_index",
         url="http://localhost:6333",
+        api_key="XXXXXXXX",
     )
 
 .. _qdrant-config-parameters:
@@ -271,7 +268,6 @@ that includes all of the available parameters:
     {
         "similarity_backends": {
             "qdrant": {
-                "url": "http://localhost:6333",
                 "metric": "cosine",
                 "replication_factor": null,
                 "shard_number": null,
@@ -439,7 +435,7 @@ possibilities:
     # Option 2: Compute embeddings on the fly from model instance
     fob.compute_similarity(
         dataset,
-        model=model
+        model=model,
         backend="qdrant",
         brain_key=brain_key,
     )
diff --git a/docs/source/plugins/index.rst b/docs/source/plugins/index.rst
index 89e68871c6..40f882d9bf 100644
--- a/docs/source/plugins/index.rst
+++ b/docs/source/plugins/index.rst
@@ -374,7 +374,7 @@ You can then download plugins using any of the methods described below:
         # Download plugin(s) from a GitHub repository
         fiftyone plugins download https://github.com/<user>/<repo>[/tree/branch]
 
-        # Download plugin(b) by specifying the GitHub repository details
+        # Download plugin(s) by specifying the GitHub repository details
         fiftyone plugins download <user>/<repo>[/<ref>]
 
         # Download specific plugins from a GitHub repository
diff --git a/docs/source/release-notes.rst b/docs/source/release-notes.rst
index 3841706034..7c78888c0c 100644
--- a/docs/source/release-notes.rst
+++ b/docs/source/release-notes.rst
@@ -3,6 +3,63 @@ FiftyOne Release Notes
 
 .. default-role:: code
 
+.. _release-notes-teams-v1.3.3:
+
+FiftyOne Teams 1.3.3
+--------------------
+*Released July 12, 2023*
+
+Includes all updates from :ref:`FiftyOne 0.21.3 <release-notes-v0.21.3>`, plus:
+
+SDK
+
+- Added a `cache=True` option to the
+  :ref:`upload_media() <teams-cloud-api-reference>` utility that allows for
+  automatically adding any uploaded files to your local cache
+
+API connections
+
+- Fixed a bug when launching the App locally via API connections
+
+.. _release-notes-v0.21.3:
+
+FiftyOne 0.21.3
+---------------
+*Released July 12, 2023*
+
+News
+
+- Released a :ref:`Milvus integration <milvus-integration>` for native text and
+  image searches on FiftyOne datasets!
+- Released a :ref:`LanceDB integration <lancedb-integration>` for native text
+  and image searches on FiftyOne datasets!
+
+App
+
+- Added support for embedded keypoint fields in
+  :meth:`filter_keypoints() <fiftyone.core.collections.SampleCollection.filter_keypoints>`
+  `#3279 <https://github.com/voxel51/fiftyone/pull/3279>`_
+- Fixed keypoint filtering
+  `#3270 <https://github.com/voxel51/fiftyone/pull/3280>`_
+- Fixed a bug that caused non-matching samples to remain in the grid when
+  applying multiple sidebar filters
+  `#3270 <https://github.com/voxel51/fiftyone/pull/3270>`_
+- Fixed a bug when filtering by IDs in the sidebar
+  `#3270 <https://github.com/voxel51/fiftyone/pull/3270>`_
+- Fixed label tags grid bubbles for filterless views
+  `#3257 <https://github.com/voxel51/fiftyone/pull/3267>`_
+
+Core
+
+- Added a :meth:`merge_sample() <fiftyone.core.dataset.Dataset.merge_sample>`
+  method for merging individual samples into existing datasets
+  `#3274 <https://github.com/voxel51/fiftyone/pull/3274>`_
+- Fixed a bug when passing dict-valued `points` to
+  :func:`compute_visualization() <fiftyone.brain.compute_visualization>`
+  `#3268 <https://github.com/voxel51/fiftyone/pull/3268>`_
+- Fixed a bug when filtering keypoints stored in embedded documents
+  `#3279 <https://github.com/voxel51/fiftyone/pull/3279>`_
+
 .. _release-notes-teams-v1.3.2:
 
 FiftyOne Teams 1.3.2
@@ -24,7 +81,6 @@ App
 - Fixes redundant sidebar groups for custom schemas
   `#3250 <https://github.com/voxel51/fiftyone/pull/3250>`_
 
-
 .. _release-notes-teams-v1.3.1:
 
 FiftyOne Teams 1.3.1
@@ -49,6 +105,7 @@ API connections
   :ref:`direct database connections <configuring-mongodb-connection>`
 - Fixed a bug when connecting to Teams deployments with non-standard database
   names via API connections
+- Fixed a bug when saving run results using API connections
 - Fixed a bug when deleting datasets using API connections
 
 Management SDK
diff --git a/docs/source/teams/api_connection.rst b/docs/source/teams/api_connection.rst
index 9c80fd154b..51bca5e2b8 100644
--- a/docs/source/teams/api_connection.rst
+++ b/docs/source/teams/api_connection.rst
@@ -15,8 +15,8 @@ dataset permissions *are enforced*.
 
 .. note::
 
-   API connections are currently in beta. If preferred, you can also directly
-   connect to your Teams deployment's
+   **API connections are currently in beta.** The recommended stable solution
+   is to use your Teams deployment's
    :ref:`MongoDB connection <configuring-mongodb-connection>`.
 
 Configuring an API connection
diff --git a/docs/source/teams/cloud_media.rst b/docs/source/teams/cloud_media.rst
index 1261fbeb23..920dfb577c 100644
--- a/docs/source/teams/cloud_media.rst
+++ b/docs/source/teams/cloud_media.rst
@@ -561,6 +561,7 @@ _____________
         rel_dir=None,
         media_field="filepath",
         update_filepaths=False,
+        cache=False,
         overwrite=False,
         skip_failures=False,
         progress=False,
@@ -582,6 +583,12 @@ _____________
             media_field ("filepath"): the field containing the media paths
             update_filepaths (False): whether to update the ``media_field`` of each
                 sample in the collection to its remote path
+            cache (False): whether to store the uploaded media in your local media
+                cache. The supported values are:
+
+                -   ``False`` (default): do not cache the media
+                -   ``True`` or ``"copy"``: copy the media into your local cache
+                -   ``"move"``: move the media into your local cache
             overwrite (False): whether to overwrite (True) or skip (False) existing
                 remote files
             skip_failures (False): whether to gracefully continue without raising
diff --git a/docs/source/teams/index.rst b/docs/source/teams/index.rst
index 1f928a01ad..36bcf60b50 100644
--- a/docs/source/teams/index.rst
+++ b/docs/source/teams/index.rst
@@ -95,7 +95,7 @@ pages on this site apply to Teams deployments as well.
 
     Overview <overview>
     Installation <installation>
-    API Connection <api_connection>
+    API connection <api_connection>
     Cloud-backed media <cloud_media>
     Roles and permissions <roles_and_permissions>
     FiftyOne Teams App <teams_app>
diff --git a/docs/source/teams/installation.rst b/docs/source/teams/installation.rst
index f6752b4a60..cbf97cd264 100644
--- a/docs/source/teams/installation.rst
+++ b/docs/source/teams/installation.rst
@@ -85,7 +85,7 @@ _________
 To work with FiftyOne datasets whose media are stored in Amazon S3, you simply
 need to provide
 `AWS credentials <https://boto3.amazonaws.com/v1/documentation/api/latest/guide/configuration.html#using-a-configuration-file>`_
-to your Teams client with read access to the relevant files.
+to your Teams client with read access to the relevant objects and buckets.
 
 You can do this in any of the following ways:
 
@@ -106,6 +106,15 @@ following keys to your :ref:`media cache config <teams-media-cache-config>`:
 In the above, the `.ini` file should use the syntax of the
 `boto3 configuration file <https://boto3.amazonaws.com/v1/documentation/api/latest/guide/configuration.html#using-a-configuration-file>`_.
 
+.. note::
+
+    FiftyOne Teams requires either the `s3:ListBucket` or
+    `s3:GetBucketLocation` permission in order to access objects in S3 buckets.
+
+    If you wish to use multi-account credentials, your credentials must have
+    the `s3:ListBucket` permission, as `s3:GetBucketLocation` does not support
+    this.
+
 .. _teams-google-cloud:
 
 Google Cloud Storage
@@ -114,7 +123,7 @@ ____________________
 To work with FiftyOne datasets whose media are stored in Google Cloud Storage,
 you simply need to provide
 `service account credentials <https://cloud.google.com/iam/docs/service-accounts>`_
-to your Teams client with read access to the relevant files.
+to your Teams client with read access to the relevant objects and buckets.
 
 You can register GCP credentials on a particular machine by adding the
 following key to your :ref:`media cache config <teams-media-cache-config>`:
@@ -133,7 +142,7 @@ _______________
 To work with FiftyOne datasets whose media are stored in Azure Storage, you
 simply need to provide
 `Azure credentials <https://learn.microsoft.com/en-us/azure/storage/blobs/authorize-data-operations-cli>`_
-to your Teams client with read access to the relevant files.
+to your Teams client with read access to the relevant objects and containers.
 
 You can do this in any of the following ways:
 
@@ -243,7 +252,7 @@ _____
 
 To work with FiftyOne datasets whose media are stored in
 `MinIO <https://min.io/>`_, you simply need to provide the credentials to your
-Teams client with read access to the relevant files.
+Teams client with read access to the relevant objects and buckets.
 
 You can do this in any of the following ways:
 
diff --git a/docs/source/teams/overview.rst b/docs/source/teams/overview.rst
index 4ff008c681..c63dbfca54 100644
--- a/docs/source/teams/overview.rst
+++ b/docs/source/teams/overview.rst
@@ -115,7 +115,7 @@ would with open source FiftyOne:
      - | :ref:`Exporting data for model training <exporting-datasets>`
        | `Adding model predictions to FiftyOne <https://voxel51.com/docs/fiftyone/tutorials/evaluate_detections.html#Add-predictions-to-dataset>`_
        | :ref:`Evaluating models in FiftyOne <evaluating-models>`
-       | :ref:`Using interactice plots to explore results <interactive-plots>`
+       | :ref:`Using interactive plots to explore results <interactive-plots>`
 
 .. _teams-system-architecture:
 
diff --git a/docs/source/user_guide/app.rst b/docs/source/user_guide/app.rst
index 44e4e7bb16..a1b0849b58 100644
--- a/docs/source/user_guide/app.rst
+++ b/docs/source/user_guide/app.rst
@@ -472,10 +472,15 @@ to index the field or embedded field that you wish to filter by:
 
     session = fo.launch_app(dataset)
 
+You can use
+:meth:`list_indexes() <fiftyone.core.collections.SampleCollection.list_indexes>`
+to view the existing indexes on a dataset, and you can use
+:meth:`drop_index() <fiftyone.core.collections.SampleCollection.drop_index>`
+to delete indexes that you no longer need.
 
-For group datasets, a compound index should be added in addition to the
-individual field index when using the default `slice` App setting. See
-:ref:`Groups in the App <groups-app>` for more information about `slice` mode.
+For :ref:`group datasets <groups>`, you should also add a compound index that
+includes your group `name` field to optimize filters applied when viewing a
+single :ref:`group slice <groups-app>`:
 
 .. code-block:: python
     :linenos:
@@ -485,23 +490,14 @@ individual field index when using the default `slice` App setting. See
 
     dataset = foz.load_zoo_dataset("quickstart-groups")
 
-    # Add field index to optimize ground truth label filters in "group" mode
+    # Add index to optimize detections label filters in "group" mode
     dataset.create_index("detections.detections.label")
     
-    # Add field and group compound index to optimize detection label filters
-    # in "slice" mode
-    dataset.create_index(
-        [("group.name", 1), ("detections.detections.label", 1)]
-    )
+    # Add compound index to optimize detections label filters in "slice" mode
+    dataset.create_index([("group.name", 1), ("detections.detections.label", 1)])
 
     session = fo.launch_app(dataset)
 
-You can use
-:meth:`list_indexes() <fiftyone.core.collections.SampleCollection.list_indexes>`
-to view the existing indexes on a dataset, and you can use
-:meth:`drop_index() <fiftyone.core.collections.SampleCollection.drop_index>`
-to delete indexes that you no longer need.
-
 .. _app-create-view:
 
 Using the view bar
diff --git a/docs/source/user_guide/brain.rst b/docs/source/user_guide/brain.rst
index ec50bdbd30..d644fcfbd0 100644
--- a/docs/source/user_guide/brain.rst
+++ b/docs/source/user_guide/brain.rst
@@ -329,6 +329,8 @@ another supported backend:
     backend
 -   **qdrant**: a :ref:`Qdrant backend <qdrant-integration>`
 -   **pinecone**: a :ref:`Pinecone backend <pinecone-integration>`
+-   **milvus**: a :ref:`Milvus backend <milvus-integration>`
+-   **lancedb**: a :ref:`LanceDB backend <lancedb-integration>`
 
 .. note::
 
@@ -714,6 +716,8 @@ The relevant classes for the builtin similarity backends are:
 -   **sklearn**: :class:`fiftyone.brain.internal.core.sklearn.SklearnSimilarityConfig`
 -   **qdrant**: :class:`fiftyone.brain.internal.core.qdrant.QdrantSimilarityConfig`
 -   **pinecone**: :class:`fiftyone.brain.internal.core.pinecone.PineconeSimilarityConfig`
+-   **milvus**: :class:`fiftyone.brain.internal.core.milvus.MilvusSimilarityConfig`
+-   **lancedb**: :class:`fiftyone.brain.internal.core.lancedb.LanceDBSimilarityConfig`
 
 You can configure a similarity backend's parameters for a specific index by
 simply passing supported config parameters as keyword arguments each time you
@@ -983,8 +987,10 @@ to add new embeddings or overwrite existing embeddings in an index at any time:
     the database.
 
     This is not required when using external vector databases like
-    like :ref:`Qdrant <qdrant-integration>` and
-    :ref:`Pinecone <pinecone-integration>`.
+    like :ref:`Qdrant <qdrant-integration>`,
+    :ref:`Pinecone <pinecone-integration>`,
+    :ref:`Milvus <milvus-integration>`, and
+    :ref:`LanceDB <lancedb-integration>`
 
 .. note::
 
@@ -1091,15 +1097,17 @@ to delete embeddings from an index by their ID:
     the database.
 
     This is not required when using external vector databases like
-    like :ref:`Qdrant <qdrant-integration>` and
-    :ref:`Pinecone <pinecone-integration>`.
+    like :ref:`Qdrant <qdrant-integration>`,
+    :ref:`Pinecone <pinecone-integration>`,
+    :ref:`Milvus <milvus-integration>`, and
+    :ref:`LanceDB <lancedb-integration>`
 
 Deleting an index
 ~~~~~~~~~~~~~~~~~
 
-When working with backends like :ref:`Qdrant <qdrant-integration>` and
-:ref:`Pinecone <pinecone-integration>` that leverage external vector databases,
-you can call
+When working with backends like :ref:`Qdrant <qdrant-integration>`,
+:ref:`Pinecone <pinecone-integration>`, and :ref:`Milvus <milvus-integration>`
+that leverage external vector databases, you can call
 :meth:`cleanup() <fiftyone.brain.similarity.SimilarityIndex.cleanup>` to delete
 the external index/collection:
 
@@ -1714,6 +1722,9 @@ and the CLI:
         {
             "default_similarity_backend": "sklearn",
             "similarity_backends": {
+                "milvus": {
+                    "config_cls": "fiftyone.brain.internal.core.milvus.MilvusSimilarityConfig"
+                },
                 "pinecone": {
                     "config_cls": "fiftyone.brain.internal.core.pinecone.PineconeSimilarityConfig"
                 },
@@ -1722,6 +1733,9 @@ and the CLI:
                 },
                 "sklearn": {
                     "config_cls": "fiftyone.brain.internal.core.sklearn.SklearnSimilarityConfig"
+                },
+                "lancedb": {
+                    "config_cls": "fiftyone.brain.internal.core.lancedb.LanceDBSimilarityConfig"
                 }
             }
         }
@@ -1738,6 +1752,9 @@ and the CLI:
         {
             "default_similarity_backend": "sklearn",
             "similarity_backends": {
+                "milvus": {
+                    "config_cls": "fiftyone.brain.internal.core.milvus.MilvusSimilarityConfig"
+                },
                 "pinecone": {
                     "config_cls": "fiftyone.brain.internal.core.pinecone.PineconeSimilarityConfig"
                 },
@@ -1746,6 +1763,9 @@ and the CLI:
                 },
                 "sklearn": {
                     "config_cls": "fiftyone.brain.internal.core.sklearn.SklearnSimilarityConfig"
+                },
+                "lancedb": {
+                    "config_cls": "fiftyone.brain.internal.core.lancedb.LanceDBSimilarityConfig"
                 }
             }
         }
diff --git a/fiftyone/core/collections.py b/fiftyone/core/collections.py
index 0619199755..cdcc194bc2 100644
--- a/fiftyone/core/collections.py
+++ b/fiftyone/core/collections.py
@@ -788,6 +788,10 @@ def one(self, expr, exact=False):
             exact (False): whether to raise an error if multiple samples match
                 the expression
 
+        Raises:
+            ValueError: if no samples match the expression or if ``exact=True``
+            and multiple samples match the expression
+
         Returns:
             a :class:`fiftyone.core.sample.SampleView`
         """
@@ -1620,7 +1624,13 @@ def _edit_label_tags(
                     label_ids = self.values(id_path)
 
             for _label_ids in fou.iter_batches(label_ids, 100000):
-                ops.append(UpdateMany({_id_path: {"$in": _label_ids}}, update))
+                _label_ids = [_id for _id in _label_ids if _id is not None]
+                ops.append(
+                    UpdateMany(
+                        {_id_path: {"$in": _label_ids}},
+                        update,
+                    )
+                )
 
         if ops:
             self._dataset._bulk_write(ops, frames=is_frame_field)
@@ -9777,7 +9787,7 @@ def _make_set_field_pipeline(
             self,
             field,
             expr,
-            embedded_root,
+            embedded_root=embedded_root,
             allow_missing=allow_missing,
             new_field=new_field,
             context=context,
@@ -10357,7 +10367,9 @@ def _parse_field_name(
     other_list_fields = sorted(other_list_fields)
 
     def _replace(path):
-        return ".".join([new_field] + path.split(".")[1:])
+        n = new_field.count(".") + 1
+        chunks = path.split(".", n)
+        return new_field + "." + chunks[-1] if len(chunks) > n else new_field
 
     if new_field:
         field_name = _replace(field_name)
@@ -10448,7 +10460,7 @@ def _make_set_field_pipeline(
     sample_collection,
     field,
     expr,
-    embedded_root,
+    embedded_root=False,
     allow_missing=False,
     new_field=None,
     context=None,
diff --git a/fiftyone/core/dataset.py b/fiftyone/core/dataset.py
index c42cce62ae..b15b9d7a8b 100644
--- a/fiftyone/core/dataset.py
+++ b/fiftyone/core/dataset.py
@@ -2679,6 +2679,108 @@ def _merge_doc(
             overwrite_info=overwrite_info,
         )
 
+    def merge_sample(
+        self,
+        sample,
+        key_field="filepath",
+        skip_existing=False,
+        insert_new=True,
+        fields=None,
+        omit_fields=None,
+        merge_lists=True,
+        overwrite=True,
+        expand_schema=True,
+        validate=True,
+        dynamic=False,
+    ):
+        """Merges the fields of the given sample into this dataset.
+
+        By default, the sample is merged with an existing sample with the same
+        absolute ``filepath``, if one exists. Otherwise a new sample is
+        inserted. You can customize this behavior via the ``key_field``,
+        ``skip_existing``, and ``insert_new`` parameters.
+
+        The behavior of this method is highly customizable. By default, all
+        top-level fields from the provided sample are merged in, overwriting
+        any existing values for those fields, with the exception of list fields
+        (e.g., ``tags``) and label list fields (e.g.,
+        :class:`fiftyone.core.labels.Detections` fields), in which case the
+        elements of the lists themselves are merged. In the case of label list
+        fields, labels with the same ``id`` in both samples are updated rather
+        than duplicated.
+
+        To avoid confusion between missing fields and fields whose value is
+        ``None``, ``None``-valued fields are always treated as missing while
+        merging.
+
+        This method can be configured in numerous ways, including:
+
+        -   Whether new fields can be added to the dataset schema
+        -   Whether list fields should be treated as ordinary fields and merged
+            as a whole rather than merging their elements
+        -   Whether to merge only specific fields, or all but certain fields
+        -   Mapping input sample fields to different field names of this sample
+
+        Args:
+            sample: a :class:`fiftyone.core.sample.Sample`
+            key_field ("filepath"): the sample field to use to decide whether
+                to join with an existing sample
+            skip_existing (False): whether to skip existing samples (True) or
+                merge them (False)
+            insert_new (True): whether to insert new samples (True) or skip
+                them (False)
+            fields (None): an optional field or iterable of fields to which to
+                restrict the merge. May contain frame fields for video samples.
+                This can also be a dict mapping field names of the input sample
+                to field names of this dataset
+            omit_fields (None): an optional field or iterable of fields to
+                exclude from the merge. May contain frame fields for video
+                samples
+            merge_lists (True): whether to merge the elements of list fields
+                (e.g., ``tags``) and label list fields (e.g.,
+                :class:`fiftyone.core.labels.Detections` fields) rather than
+                merging the entire top-level field like other field types.
+                For label lists fields, existing
+                :class:`fiftyone.core.label.Label` elements are either replaced
+                (when ``overwrite`` is True) or kept (when ``overwrite`` is
+                False) when their ``id`` matches a label from the provided
+                sample
+            overwrite (True): whether to overwrite (True) or skip (False)
+                existing fields and label elements
+            expand_schema (True): whether to dynamically add new fields
+                encountered to the dataset schema. If False, an error is raised
+                if any fields are not in the dataset schema
+            validate (True): whether to validate values for existing fields
+            dynamic (False): whether to declare dynamic embedded document
+                fields
+        """
+        try:
+            F = foe.ViewField
+            existing_sample = self.one(F(key_field) == sample[key_field])
+        except ValueError:
+            if insert_new:
+                self.add_sample(
+                    sample,
+                    expand_schema=expand_schema,
+                    dynamic=dynamic,
+                    validate=validate,
+                )
+
+            return
+
+        if not skip_existing:
+            existing_sample.merge(
+                sample,
+                fields=fields,
+                omit_fields=omit_fields,
+                merge_lists=merge_lists,
+                overwrite=overwrite,
+                expand_schema=expand_schema,
+                validate=validate,
+                dynamic=dynamic,
+            )
+            existing_sample.save()
+
     def merge_samples(
         self,
         samples,
diff --git a/fiftyone/core/odm/mixins.py b/fiftyone/core/odm/mixins.py
index 681e9faaea..ba53df04a4 100644
--- a/fiftyone/core/odm/mixins.py
+++ b/fiftyone/core/odm/mixins.py
@@ -993,6 +993,19 @@ def _merge_field(cls, path, field, validate=True, recursive=True):
                 ):
                     return {path: field}
 
+            #
+            # In principle, merging an untyped list field into a typed list
+            # field --- eg ListField(StringField) --- should not be allowed, as
+            # the untyped list may contain incompatible values.
+            #
+            # However, we are intentionally skipping validation here so that
+            # the following will work::
+            #
+            #   doc.set_field("tags", [], validate=True)
+            #
+            if is_list_field and field is None:
+                return
+
             if validate:
                 validate_fields_match(path, field, existing_field)
 
diff --git a/fiftyone/core/session/client.py b/fiftyone/core/session/client.py
index d75b8e78c1..c791aac210 100644
--- a/fiftyone/core/session/client.py
+++ b/fiftyone/core/session/client.py
@@ -9,7 +9,7 @@
 from dataclasses import asdict, dataclass
 import logging
 from retrying import retry
-from threading import Thread
+from threading import Thread, Event as ThreadEvent
 import time
 import typing as t
 
@@ -49,15 +49,27 @@ class Client:
     def __post_init__(self) -> None:
         self._subscription = str(uuid4())
         self._connected = True
+        self._closed = ThreadEvent()
+        self._closed.set()
         self._listeners: t.Dict[str, t.Set[t.Callable]] = defaultdict(set)
 
-    def run(self, state: fos.StateDescription) -> None:
-        """Runs the client subscription in a background thread
+    @property
+    def origin(self) -> str:
+        """The origin of the server"""
+        return f"http://{self.address}:{self.port}"
+
+    @property
+    def is_open(self) -> str:
+        """Whether the client is connected"""
+        return not self._closed.is_set()
+
+    def open(self, state: fos.StateDescription) -> None:
+        """Open the client connection
 
         Arg:
             state: the initial state description
         """
-        if hasattr(self, "_thread"):
+        if not self._closed.is_set():
             raise RuntimeError("Client is already running")
 
         def run_client() -> None:
@@ -97,23 +109,27 @@ def subscribe() -> None:
                     self._connected = True
                     subscribe()
                 except Exception as e:
-                    if foc.DEV_INSTALL:
+                    if logger.level == logging.DEBUG:
                         raise e
 
-                    self._connected = False
-                    print(
-                        "\r\nCould not connect session, trying again "
-                        "in 10 seconds\r\n"
-                    )
-                    time.sleep(10)
+                if self._closed.is_set():
+                    break
+
+                self._connected = False
+                print(
+                    "\r\nCould not connect session, trying again "
+                    "in 10 seconds\r\n"
+                )
+                time.sleep(10)
 
         self._thread = Thread(target=run_client, daemon=True)
         self._thread.start()
 
-    @property
-    def origin(self) -> str:
-        """The origin of the server"""
-        return f"http://{self.address}:{self.port}"
+    def close(self):
+        """Close the client connection"""
+        self._closed.set()
+        self._thread.join(timeout=0)
+        self._thread = None
 
     def send_event(self, event: EventType) -> None:
         """Sends an event to the server
@@ -121,8 +137,12 @@ def send_event(self, event: EventType) -> None:
         Args:
             event: the event
         """
+        if self._closed.is_set():
+            return
+
         if not self._connected:
             raise RuntimeError("Client is not connected")
+
         self._post_event(event)
         self._dispatch_event(event)
 
@@ -156,6 +176,9 @@ def _dispatch_event(self, event: EventType) -> None:
             listener(event)
 
     def _post_event(self, event: Event) -> None:
+        if self._closed.is_set():
+            return
+
         response = requests.post(
             f"{self.origin}/event",
             headers={"Content-type": "application/json"},
diff --git a/fiftyone/core/session/session.py b/fiftyone/core/session/session.py
index 84a74c38ba..232482be81 100644
--- a/fiftyone/core/session/session.py
+++ b/fiftyone/core/session/session.py
@@ -422,7 +422,7 @@ def __init__(
             remote=remote,
             start_time=self._get_time(),
         )
-        self._client.run(self._state)
+        self._client.open(self._state)
         _attach_listeners(self)
         _register_session(self)
 
@@ -515,6 +515,7 @@ def __del__(self) -> None:
                 # logger may already have been garbage-collected
                 print(_WAIT_INSTRUCTIONS)
 
+            self._client.close()
             _unregister_session(self)
         except:
             # e.g. globals were already garbage-collected
@@ -970,9 +971,10 @@ def open(self) -> None:
         -   Desktop: opens the desktop App, if necessary
         -   Other (non-remote): opens the App in a new browser tab
         """
-        if self.remote:
-            logger.warning("Remote sessions cannot open new App windows")
-            return
+        _register_session(self)
+
+        if not self._client.is_open:
+            self._client.open(self._state)
 
         if self.plots:
             self.plots.connect()
@@ -1102,13 +1104,14 @@ def wait(self, wait: float = 3) -> None:
 
     def close(self) -> None:
         """Closes the session and terminates the App, if necessary."""
-        if self.remote:
-            return
+        if self.desktop:
+            self._app_service.stop()
 
-        if self._client._connected and focx._get_context() == focx._NONE:
-            self._client.send_event(CloseSession())
+        if self._client.is_open and focx.is_notebook_context():
+            self.freeze()
 
         self.plots.disconnect()
+        self.__del__()
 
     def freeze(self) -> None:
         """Screenshots the active App cell, replacing it with a static image.
diff --git a/fiftyone/core/stages.py b/fiftyone/core/stages.py
index a18e6ef371..5c05bab244 100644
--- a/fiftyone/core/stages.py
+++ b/fiftyone/core/stages.py
@@ -1791,6 +1791,7 @@ def to_mongo(self, sample_collection):
 
         if is_frame_field:
             return _get_filter_frames_field_pipeline(
+                sample_collection,
                 field_name,
                 new_field,
                 self._filter,
@@ -1798,6 +1799,7 @@ def to_mongo(self, sample_collection):
             )
 
         return _get_filter_field_pipeline(
+            sample_collection,
             field_name,
             new_field,
             self._filter,
@@ -1875,6 +1877,7 @@ def validate(self, sample_collection):
 
 
 def _get_filter_field_pipeline(
+    sample_collection,
     filter_field,
     new_field,
     filter_arg,
@@ -1908,25 +1911,40 @@ def _get_field_only_matches_expr(field):
 
 
 def _get_filter_frames_field_pipeline(
+    sample_collection,
     filter_field,
     new_field,
     filter_arg,
     only_matches=True,
 ):
     cond = _get_field_mongo_filter(filter_arg, prefix="$frame." + filter_field)
-    merge = {
-        "$cond": {
-            "if": cond,
-            "then": "$$frame." + filter_field,
-            "else": None,
-        }
-    }
 
     if "." in new_field:
-        parent, child = new_field.split(".")
-        obj = {parent: {child: merge}}
+        parent, child = new_field.split(".", 1)
+        obj = {
+            "$cond": {
+                "if": {"$gt": ["$$frame." + filter_field, None]},
+                "then": {
+                    "$cond": {
+                        "if": cond,
+                        "then": {parent: {child: "$$frame." + filter_field}},
+                        "else": None,
+                    }
+                },
+                "else": {},
+            },
+        }
+
     else:
-        obj = {new_field: merge}
+        obj = {
+            new_field: {
+                "$cond": {
+                    "if": cond,
+                    "then": "$$frame." + filter_field,
+                    "else": None,
+                }
+            }
+        }
 
     pipeline = [
         {
@@ -2333,6 +2351,7 @@ def to_mongo(self, sample_collection):
             _make_filter_pipeline = _get_filter_field_pipeline
 
         filter_pipeline = _make_filter_pipeline(
+            sample_collection,
             labels_field,
             new_field,
             label_filter,
@@ -2433,6 +2452,7 @@ def validate(self, sample_collection):
 
 
 def _get_filter_list_field_pipeline(
+    sample_collection,
     filter_field,
     new_field,
     filter_arg,
@@ -2464,19 +2484,31 @@ def _get_list_field_only_matches_expr(field):
 
 
 def _get_filter_frames_list_field_pipeline(
+    sample_collection,
     filter_field,
     new_field,
     filter_arg,
     only_matches=True,
 ):
     cond = _get_list_field_mongo_filter(filter_arg)
-    label_field, labels_list = new_field.split(".")[-2:]
 
-    old_field = filter_field.split(".")[0]
+    parent, leaf = filter_field.split(".", 1)
+    new_parent, _ = new_field.split(".", 1)
+    if not issubclass(
+        sample_collection.get_field(f"frames.{parent}").document_type,
+        fol.Label,
+    ):
+        label_field, labels_list = leaf.split(".")
+        obj = lambda merge: {new_parent: {label_field: merge}}
+        label_path = f"{parent}.{label_field}"
+    else:
+        label_field, labels_list = new_parent, leaf
+        label_path = label_field
+        obj = lambda merge: {label_field: merge}
 
     merge = {
         "$mergeObjects": [
-            "$$frame." + old_field,
+            "$$frame." + label_path,
             {
                 labels_list: {
                     "$filter": {
@@ -2487,11 +2519,6 @@ def _get_filter_frames_list_field_pipeline(
             },
         ]
     }
-    if "." in label_field:
-        parent, label_field = label_field.split(".")
-        obj = {parent: {label_field: merge}}
-    else:
-        obj = {label_field: merge}
 
     pipeline = [
         {
@@ -2500,7 +2527,7 @@ def _get_filter_frames_list_field_pipeline(
                     "$map": {
                         "input": "$frames",
                         "as": "frame",
-                        "in": {"$mergeObjects": ["$$frame", obj]},
+                        "in": {"$mergeObjects": ["$$frame", obj(merge)]},
                     }
                 }
             }
@@ -2706,7 +2733,6 @@ def to_mongo(self, sample_collection):
         _, points_path = sample_collection._get_label_field_path(
             self._field, "points"
         )
-        new_field = self._get_new_field(sample_collection)
 
         pipeline = []
 
@@ -2781,25 +2807,17 @@ def to_mongo(self, sample_collection):
 
         if self._only_matches:
             # Remove Keypoint objects with no points after filtering
+            has_points = (
+                F("points").filter(F()[0] != float("nan")).length() > 0
+            )
             if is_list_field:
-                has_points = (
-                    F("points").filter(F()[0] != float("nan")).length() > 0
-                )
-                match_expr = F("keypoints").filter(has_points)
+                only_expr = F().filter(has_points)
             else:
-                field, _ = sample_collection._handle_frame_field(new_field)
-                has_points = (
-                    F(field + ".points")
-                    .filter(F()[0] != float("nan"))
-                    .length()
-                    > 0
-                )
-                match_expr = has_points.if_else(F(field), None)
+                only_expr = has_points.if_else(F(), None)
 
             _pipeline, _ = sample_collection._make_set_field_pipeline(
                 root_path,
-                match_expr,
-                embedded_root=True,
+                only_expr,
                 allow_missing=True,
                 new_field=self._new_field,
             )
diff --git a/fiftyone/server/query.py b/fiftyone/server/query.py
index 21bc66d89f..29dea9df70 100644
--- a/fiftyone/server/query.py
+++ b/fiftyone/server/query.py
@@ -8,6 +8,7 @@
 from dataclasses import asdict
 from datetime import date, datetime
 from enum import Enum
+import logging
 import os
 import typing as t
 
@@ -524,7 +525,13 @@ def _flatten_fields(
 ) -> t.List[t.Dict]:
     result = []
     for field in fields:
-        key = field.pop("name")
+        key = field.pop("name", None)
+        if key is None:
+            # Issues with concurrency can cause this to happen.
+            # Until it's fixed, just ignore these fields to avoid throwing hard
+            # errors when loading in the app.
+            logging.debug("Skipping field with no name: %s", field)
+            continue
         field_path = path + [key]
         field["path"] = ".".join(field_path)
         result.append(field)
diff --git a/fiftyone/server/samples.py b/fiftyone/server/samples.py
index 5918e116a7..6e2d0d0c83 100644
--- a/fiftyone/server/samples.py
+++ b/fiftyone/server/samples.py
@@ -78,7 +78,6 @@ async def paginate_samples(
         stages=stages,
         filters=filters,
         pagination_data=pagination_data,
-        count_label_tags=True,
         extended_stages=extended_stages,
         sample_filter=sample_filter,
         reload=reload,
diff --git a/fiftyone/server/view.py b/fiftyone/server/view.py
index d88b75836f..778bf92831 100644
--- a/fiftyone/server/view.py
+++ b/fiftyone/server/view.py
@@ -77,7 +77,6 @@ def get_view(
     stages=None,
     filters=None,
     pagination_data=False,
-    count_label_tags=False,
     extended_stages=None,
     sample_filter=None,
     reload=True,
@@ -90,8 +89,6 @@ def get_view(
         stages (None): an optional list of serialized
             :class:`fiftyone.core.stages.ViewStage` instances
         filters (None): an optional ``dict`` of App defined filters
-        count_label_tags (False): whether to includes hidden ``_label_tags``
-            counts on sample documents
         pagination_data (False): whether process samples as pagination data
             - excludes all :class:`fiftyone.core.fields.DictField` values
             - filters label fields
@@ -134,11 +131,10 @@ def get_view(
         # omit all dict field values for performance, not needed by grid
         view = _project_pagination_paths(view)
 
-    if filters or extended_stages:
+    if filters or extended_stages or pagination_data:
         view = get_extended_view(
             view,
             filters,
-            count_label_tags=count_label_tags,
             pagination_data=pagination_data,
             extended_stages=extended_stages,
         )
@@ -149,7 +145,6 @@ def get_view(
 def get_extended_view(
     view,
     filters=None,
-    count_label_tags=False,
     extended_stages=None,
     pagination_data=False,
 ):
@@ -158,8 +153,6 @@ def get_extended_view(
     Args:
         view: a :class:`fiftyone.core.collections.SampleCollection`
         filters: an optional ``dict`` of App defined filters
-        count_label_tags (False): whether to set the hidden ``_label_tags``
-            field with counts of tags with respect to all label fields
         extended_stages (None): extended view stages
         pagination_data (False): filters label data
 
@@ -187,17 +180,12 @@ def get_extended_view(
         if label_tags:
             view = _match_label_tags(view, label_tags)
 
-        stages = _make_filter_stages(
-            view,
-            filters,
-            count_label_tags=count_label_tags,
-            pagination_data=pagination_data,
-        )
+        stages = _make_filter_stages(view, filters)
 
         for stage in stages:
             view = view.add_stage(stage)
 
-    if count_label_tags:
+    if pagination_data:
         view = _add_labels_tags_counts(view)
 
     return view
@@ -272,85 +260,83 @@ def _project_pagination_paths(view: foc.SampleCollection):
 def _make_filter_stages(
     view,
     filters,
-    count_label_tags=False,
-    pagination_data=False,
 ):
     stages = []
     queries = []
-    for path, field, prefix, args in _iter_paths(view, filters):
+    for path, label_path, field, args in _iter_paths(view, filters):
         is_matching = args.get("isMatching", True)
-        only_matches = args.get("onlyMatch", True)
-
+        path_field = view.get_field(path)
         is_label_field = _is_label(field)
-        if is_label_field and issubclass(
-            field.document_type, (fol.Keypoint, fol.Keypoints)
+        if (
+            is_label_field
+            and issubclass(field.document_type, (fol.Keypoint, fol.Keypoints))
+            and isinstance(path_field, (fof.KeypointsField, fof.ListField))
         ):
             continue
 
-        if not is_label_field or (is_matching or only_matches):
-            queries.append(_make_query(path, view.get_field(path), args))
+        if args.get("exclude") and not is_matching:
+            continue
+
+        queries.append(_make_query(path, path_field, args))
 
     if queries:
         stages.append(fosg.Match({"$and": queries}))
 
-    for path, field, prefix, args in _iter_paths(view, filters):
-        if not _is_label(field):
-            continue
-
+    for path, label_path, label_field, args in _iter_paths(
+        view, filters, labels=True
+    ):
         is_matching = args.get("isMatching", True)
-        only_matches = args.get("onlyMatch", True)
-        parent = field
         field = view.get_field(path)
-        if issubclass(parent.document_type, (fol.Keypoint, fol.Keypoints)):
+        if issubclass(
+            label_field.document_type, (fol.Keypoint, fol.Keypoints)
+        ) and isinstance(field, fof.ListField):
             expr = _make_keypoint_list_filter(args, view, path, field)
             if expr is not None:
                 stages.append(
                     fosg.FilterKeypoints(
-                        prefix + parent.name,
-                        only_matches=only_matches,
+                        label_path,
+                        only_matches=True,
                         **expr,
                     )
                 )
 
-        elif not is_matching and (pagination_data or not count_label_tags):
+        elif not is_matching:
             key = field.db_field if field.db_field else field.name
             expr = _make_scalar_expression(F(key), args, field, is_label=True)
             if expr is not None:
                 stages.append(
                     fosg.FilterLabels(
-                        prefix + parent.name,
+                        label_path,
                         expr,
-                        only_matches=False,
+                        only_matches=not args.get("exclude", False),
                     )
                 )
 
     return stages
 
 
-def _iter_paths(view, filters):
-    field_schema = view.get_field_schema()
-    if view.media_type != fom.IMAGE:
-        frame_field_schema = view.get_frame_field_schema()
-    else:
-        frame_field_schema = None
-
+def _iter_paths(view, filters, labels=False):
     for path in sorted(filters):
         if path == "tags" or path.startswith("_"):
             continue
 
-        args = filters[path]
-        frames = path.startswith(view._FRAMES_PREFIX)
-        keys = path.split(".")
-        if frames:
-            field = frame_field_schema[keys[1]]
-            keys = keys[2:]
-            prefix = "frames."
+        if "." in path:
+            parent_path = ".".join(path.split(".")[:-1])
         else:
-            field = field_schema[keys[0]]
-            keys = keys[1:]
-            prefix = ""
+            parent_path = path
 
-        yield path, field, prefix, args
+        parent_field = view.get_field(parent_path)
+        if isinstance(parent_field, fof.ListField) and isinstance(
+            parent_field.field, fof.EmbeddedDocumentField
+        ):
+            if issubclass(parent_field.field.document_type, fol.Label):
+                parent_path = ".".join(parent_path.split(".")[:-1])
+                parent_field = view.get_field(parent_path)
+
+        if labels and not _is_label(parent_field):
+            continue
+
+        yield path, parent_path, parent_field, filters[path]
 
 
 def _is_support(field):
@@ -378,11 +364,14 @@ def _is_label(field):
 
 
 def _make_query(path, field, args):
-    if isinstance(field, fof.ListField):
+    keys = path.split(".")
+    path = ".".join(keys[:-1] + [field.db_field or field.name])
+    if isinstance(field, fof.ListField) and field.field:
         field = field.field
 
     if isinstance(
-        field, (fof.DateField, fof.DateTimeField, fof.FloatField, fof.IntField)
+        field,
+        (fof.DateField, fof.DateTimeField, fof.FloatField, fof.IntField),
     ):
         mn, mx = args["range"]
         if isinstance(field, (fof.DateField, fof.DateTimeField)):
@@ -403,7 +392,7 @@ def _make_query(path, field, args):
             ]
         }
 
-    values = args["values"]
+    values = args.get("values", None)
     if isinstance(field, fof.ObjectIdField):
         values = list(map(lambda v: ObjectId(v), args["values"]))
 
@@ -418,10 +407,10 @@ def _make_query(path, field, args):
             }
 
         if not true and false:
-            return {path: {"$neq" if args["exclude"] else "$eq": False}}
+            return {path: {"$ne" if args["exclude"] else "$eq": False}}
 
         if true and not false:
-            return {path: {"$neq" if args["exclude"] else "$eq": True}}
+            return {path: {"$ne" if args["exclude"] else "$eq": True}}
 
         if not true and not false:
             return {
@@ -474,6 +463,10 @@ def _make_scalar_expression(f, args, field, list_field=False, is_label=False):
         expr = f.is_in(values)
         exclude = args["exclude"]
 
+        if exclude:
+            # pylint: disable=invalid-unary-operand-type
+            expr = ~expr
+
         if none and not is_label and not list_field:
             if exclude:
                 expr &= f.exists()
@@ -681,18 +674,19 @@ def _match_label_tags(view: foc.SampleCollection, label_tags):
     matching = label_tags["isMatching"]
     expr = lambda exclude, values: {"$nin" if exclude else "$in": values}
 
-    view = view.mongo(
-        [
-            {
-                "$match": {
-                    "$or": [
-                        {f"{path}.tags": expr(exclude, values)}
-                        for path in label_paths
-                    ]
+    if not exclude or matching:
+        view = view.mongo(
+            [
+                {
+                    "$match": {
+                        "$or": [
+                            {f"{path}.tags": expr(exclude, values)}
+                            for path in label_paths
+                        ]
+                    }
                 }
-            }
-        ]
-    )
+            ]
+        )
 
     if not matching and exclude:
         view = view.exclude_labels(
diff --git a/package/desktop/setup.py b/package/desktop/setup.py
index f0d0b6bb5d..248f511adf 100644
--- a/package/desktop/setup.py
+++ b/package/desktop/setup.py
@@ -16,7 +16,7 @@
 import shutil
 
 
-VERSION = "0.28.1"
+VERSION = "0.28.2"
 
 
 def get_version():
diff --git a/setup.py b/setup.py
index 90533623ee..826a6ba39a 100644
--- a/setup.py
+++ b/setup.py
@@ -16,7 +16,7 @@
 from setuptools import setup, find_packages
 
 
-VERSION = "0.21.2"
+VERSION = "0.21.3"
 
 
 def get_version():
@@ -73,7 +73,7 @@ def get_version():
     "xmltodict",
     "universal-analytics-python3>=1.0.1,<2",
     # internal packages
-    "fiftyone-brain>=0.12,<0.13",
+    "fiftyone-brain>=0.13,<0.14",
     "fiftyone-db>=0.4,<0.5",
     "voxel51-eta>=0.10,<0.11",
 ]
@@ -112,7 +112,7 @@ def get_install_requirements(install_requires, choose_install_requires):
     return install_requires
 
 
-EXTRAS_REQUIREMENTS = {"desktop": ["fiftyone-desktop>=0.28.1,<0.29"]}
+EXTRAS_REQUIREMENTS = {"desktop": ["fiftyone-desktop>=0.28.2,<0.29"]}
 
 
 with open("README.md", "r") as fh:
diff --git a/tests/unittests/dataset_tests.py b/tests/unittests/dataset_tests.py
index a95c42365e..ebb45e43bb 100644
--- a/tests/unittests/dataset_tests.py
+++ b/tests/unittests/dataset_tests.py
@@ -1119,6 +1119,86 @@ def test_add_list_subfield(self):
         self.assertIsInstance(field.field, fo.EmbeddedDocumentField)
         self.assertEqual(field.field.document_type, fo.DynamicEmbeddedDocument)
 
+    @drop_datasets
+    def test_one(self):
+        samples = [
+            fo.Sample(filepath="image1.jpg"),
+            fo.Sample(filepath="image2.png"),
+            fo.Sample(filepath="image3.jpg"),
+        ]
+
+        dataset = fo.Dataset()
+        dataset.add_samples(samples)
+
+        filepath = dataset.first().filepath
+
+        sample = dataset.one(F("filepath") == filepath)
+
+        self.assertEqual(sample.filepath, filepath)
+
+        with self.assertRaises(ValueError):
+            _ = dataset.one(F("filepath") == "bad")
+
+        sample = dataset.one(F("filepath").ends_with(".jpg"))
+
+        self.assertTrue(sample.filepath.endswith(".jpg"))
+
+        with self.assertRaises(ValueError):
+            _ = dataset.one(F("filepath").ends_with(".jpg"), exact=True)
+
+    @drop_datasets
+    def test_merge_sample(self):
+        sample1 = fo.Sample(filepath="image.jpg", foo="bar", tags=["a"])
+        sample2 = fo.Sample(filepath="image.jpg", spam="eggs", tags=["b"])
+        sample3 = fo.Sample(filepath="image.jpg", tags=[])
+
+        # No dataset
+
+        s1 = sample1.copy()
+        s2 = sample2.copy()
+        s3 = sample3.copy()
+
+        s1.merge(s2)
+        s1.merge(s3)
+
+        self.assertListEqual(s1["tags"], ["a", "b"])
+        self.assertEqual(s1["foo"], "bar")
+        self.assertEqual(s1["spam"], "eggs")
+
+        # In dataset
+
+        s1 = sample1.copy()
+        s2 = sample2.copy()
+        s3 = sample3.copy()
+
+        dataset = fo.Dataset()
+        dataset.add_sample(s1)
+
+        dataset.merge_sample(s2)
+        dataset.merge_sample(s3)
+
+        self.assertListEqual(s1["tags"], ["a", "b"])
+        self.assertEqual(s1["foo"], "bar")
+        self.assertEqual(s1["spam"], "eggs")
+
+        # List merging variations
+
+        s1 = sample1.copy()
+        s2 = sample2.copy()
+        s3 = sample3.copy()
+
+        dataset = fo.Dataset()
+        dataset.add_sample(s1)
+
+        dataset.merge_sample(s2, merge_lists=False)
+
+        self.assertListEqual(s1["tags"], ["b"])
+
+        # Tests an edge case when setting a typed list field to an empty list
+        dataset.merge_sample(s3, merge_lists=False, dynamic=True)
+
+        self.assertListEqual(s1["tags"], [])
+
     @drop_datasets
     def test_merge_samples1(self):
         # Windows compatibility
@@ -4995,11 +5075,10 @@ def test_from_images(self):
             fo.Dataset.from_images(filepaths, name=dataset.name)
 
         dataset2 = fo.Dataset.from_images(
-            filepaths, name=dataset.name, overwrite=True, persistent=True
+            filepaths, name=dataset.name, overwrite=True
         )
 
         self.assertEqual(len(dataset2), 1)
-        self.assertTrue(dataset2.persistent)
 
         samples = [{"filepath": "image.jpg"}]
         sample_parser = _ImageSampleParser()
@@ -5019,11 +5098,9 @@ def test_from_images(self):
             sample_parser=sample_parser,
             name=dataset.name,
             overwrite=True,
-            persistent=True,
         )
 
         self.assertEqual(len(dataset2), 1)
-        self.assertTrue(dataset2.persistent)
 
     @drop_datasets
     def test_from_videos(self):
@@ -5036,11 +5113,10 @@ def test_from_videos(self):
             fo.Dataset.from_videos(filepaths, name=dataset.name)
 
         dataset2 = fo.Dataset.from_videos(
-            filepaths, name=dataset.name, overwrite=True, persistent=True
+            filepaths, name=dataset.name, overwrite=True
         )
 
         self.assertEqual(len(dataset2), 1)
-        self.assertTrue(dataset2.persistent)
 
         samples = [{"filepath": "video.mp4"}]
         sample_parser = _VideoSampleParser()
@@ -5060,11 +5136,9 @@ def test_from_videos(self):
             sample_parser=sample_parser,
             name=dataset.name,
             overwrite=True,
-            persistent=True,
         )
 
         self.assertEqual(len(dataset2), 1)
-        self.assertTrue(dataset2.persistent)
 
     @drop_datasets
     def test_from_labeled_images(self):
@@ -5090,11 +5164,9 @@ def test_from_labeled_images(self):
             label_field="ground_truth",
             name=dataset.name,
             overwrite=True,
-            persistent=True,
         )
 
         self.assertEqual(dataset2.values("ground_truth.label"), ["label"])
-        self.assertTrue(dataset2.persistent)
 
     @drop_datasets
     def test_from_labeled_videos(self):
@@ -5120,11 +5192,9 @@ def test_from_labeled_videos(self):
             label_field="ground_truth",
             name=dataset.name,
             overwrite=True,
-            persistent=True,
         )
 
         self.assertEqual(dataset2.values("ground_truth.label"), ["label"])
-        self.assertTrue(dataset2.persistent)
 
 
 class _ImageSampleParser(foud.ImageSampleParser):
diff --git a/tests/unittests/label_tests.py b/tests/unittests/label_tests.py
index 36f7d99509..efb922b4d7 100644
--- a/tests/unittests/label_tests.py
+++ b/tests/unittests/label_tests.py
@@ -15,6 +15,9 @@
 from decorators import drop_datasets
 
 
+F = fo.ViewField
+
+
 class LabelTests(unittest.TestCase):
     @drop_datasets
     def test_id(self):
@@ -187,6 +190,155 @@ def test_dynamic_label_tags(self):
             {},
         )
 
+    @drop_datasets
+    def test_dynamic_frame_label_fields(self):
+        dynamic_doc = fo.DynamicEmbeddedDocument(
+            classification=fo.Classification(label="label"),
+            classifications=fo.Classifications(
+                classifications=[fo.Classification(label="label")]
+            ),
+        )
+        sample = fo.Sample(filepath="video.mp4")
+        sample.frames[1]["dynamic"] = dynamic_doc
+
+        dataset = fo.Dataset()
+        dataset.add_sample(sample)
+        dataset.add_dynamic_frame_fields()
+
+        label_id = dynamic_doc["classification"].id
+        view = dataset.select_labels(
+            [
+                {
+                    "label_id": label_id,
+                    "sample_id": sample.id,
+                    "frame_number": 1,
+                    "field": "frames.dynamic.classification",
+                }
+            ]
+        )
+        dynamic = view.first().frames[1].dynamic
+        self.assertTrue(label_id == dynamic.classification.id)
+        self.assertFalse("classifications" in dynamic)
+
+        view = dataset.filter_labels(
+            "frames.dynamic.classification", F("label") == "label"
+        )
+        dynamic = view.first().frames[1].dynamic
+        self.assertTrue(label_id == dynamic.classification.id)
+
+        label_id = dynamic_doc["classifications"].classifications[0].id
+        view = dataset.select_labels(
+            [
+                {
+                    "label_id": label_id,
+                    "sample_id": sample.id,
+                    "frame_number": 1,
+                    "field": "frames.dynamic.classifications",
+                }
+            ]
+        )
+        dynamic = view.first().frames[1].dynamic
+        self.assertTrue(
+            label_id == dynamic.classifications.classifications[0].id
+        )
+        self.assertFalse("classification" in dynamic)
+
+        view = dataset.filter_labels(
+            "frames.dynamic.classifications", F("label") == "label"
+        )
+        dynamic = view.first().frames[1].dynamic
+        self.assertTrue(
+            label_id == dynamic.classifications.classifications[0].id
+        )
+
+    @drop_datasets
+    def test_dynamic_frame_label_tags(self):
+        sample1 = fo.Sample(
+            filepath="video1.mp4",
+        )
+        sample1.frames[1]["dynamic"] = fo.DynamicEmbeddedDocument(
+            classification=fo.Classification(label="hi"),
+            classifications=fo.Classifications(
+                classifications=[
+                    fo.Classification(label="spam"),
+                    fo.Classification(label="eggs"),
+                ]
+            ),
+        )
+        # test with empty documents
+        sample1.frames[2]["dynamic"] = fo.DynamicEmbeddedDocument()
+
+        sample2 = fo.Sample(filepath="video2.mp4")
+
+        dataset = fo.Dataset()
+        dataset.add_samples([sample1, sample2], dynamic=True)
+
+        label_fields = set(dataset._get_label_fields())
+
+        self.assertSetEqual(
+            label_fields,
+            {
+                "frames.dynamic.classification",
+                "frames.dynamic.classifications",
+            },
+        )
+
+        self.assertDictEqual(dataset.count_label_tags(), {})
+
+        dataset.tag_labels("test")
+        self.assertDictEqual(dataset.count_label_tags(), {"test": 3})
+        self.assertDictEqual(
+            dataset.count_label_tags(
+                label_fields="frames.dynamic.classification"
+            ),
+            {"test": 1},
+        )
+        self.assertDictEqual(
+            dataset.count_label_tags(
+                label_fields="frames.dynamic.classifications"
+            ),
+            {"test": 2},
+        )
+
+        dataset.untag_labels("test")
+        self.assertDictEqual(dataset.count_label_tags(), {})
+
+        dataset.tag_labels(
+            "test", label_fields="frames.dynamic.classification"
+        )
+        self.assertDictEqual(dataset.count_label_tags(), {"test": 1})
+        self.assertDictEqual(
+            dataset.count_label_tags(
+                label_fields="frames.dynamic.classification"
+            ),
+            {"test": 1},
+        )
+
+        dataset.untag_labels("test")
+        self.assertDictEqual(dataset.count_label_tags(), {})
+
+        dataset.tag_labels(
+            "test", label_fields="frames.dynamic.classifications"
+        )
+        self.assertDictEqual(dataset.count_label_tags(), {"test": 2})
+        self.assertDictEqual(
+            dataset.count_label_tags(
+                label_fields="frames.dynamic.classifications"
+            ),
+            {"test": 2},
+        )
+
+        dataset.untag_labels(
+            "test", label_fields="frames.dynamic.classifications"
+        )
+        self.assertDictEqual(dataset.count_label_tags(), {})
+        self.assertDictEqual(
+            dataset.count_label_tags(
+                label_fields="frames.dynamic.classifications"
+            ),
+            {},
+        )
+
 
 if __name__ == "__main__":
     fo.config.show_progress_bars = False
diff --git a/tests/unittests/server_tests.py b/tests/unittests/server_tests.py
index 5d2169b851..88f1ea164c 100644
--- a/tests/unittests/server_tests.py
+++ b/tests/unittests/server_tests.py
@@ -5,11 +5,15 @@
 | `voxel51.com <https://voxel51.com/>`_
 |
 """
+import math
 import unittest
 
+import fiftyone as fo
 import fiftyone.core.dataset as fod
 import fiftyone.core.fields as fof
 import fiftyone.core.labels as fol
+import fiftyone.core.odm as foo
+import fiftyone.core.sample as fos
 import fiftyone.server.view as fosv
 
 from decorators import drop_datasets
@@ -17,645 +21,761 @@
 
 class ServerViewTests(unittest.TestCase):
     @drop_datasets
-    def test_extended_view_image_label_filters_samples(self):
+    def test_extended_image_sample(self):
+        dataset = fod.Dataset("test")
+        sample = fos.Sample(
+            filepath="image.png",
+            predictions=fol.Detections(
+                detections=[
+                    fol.Detection(
+                        label="carrot", confidence=0.25, tags=["one", "two"]
+                    ),
+                    fol.Detection(
+                        label="not_carrot", confidence=0.75, tags=["two"]
+                    ),
+                ]
+            ),
+            bool=True,
+            int=1,
+            str="str",
+            list_bool=[True],
+            list_int=[1, 2],
+            list_str=["one", "two"],
+        )
+        dataset.add_sample(sample)
+        filters = {
+            "id": {
+                "values": [dataset.first().id],
+                "exclude": False,
+            }
+        }
+        view = fosv.get_view("test", filters=filters)
+        self.assertEqual(len(view), 1)
+
+        filters = {
+            "id": {
+                "values": [dataset.first().id],
+                "exclude": True,
+            }
+        }
+        view = fosv.get_view("test", filters=filters)
+        self.assertEqual(len(view), 0)
+
         filters = {
             "predictions.detections.label": {
                 "values": ["carrot"],
                 "exclude": False,
-                "onlyMatch": True,
                 "isMatching": False,
-                "_CLS": "str",
             },
             "predictions.detections.confidence": {
                 "range": [0.5, 1],
-                "_CLS": "numeric",
                 "exclude": False,
-                "onlyMatch": True,
                 "isMatching": False,
             },
         }
+        view = fosv.get_view("test", filters=filters)
+        self.assertEqual(len(view), 0)
 
-        dataset = fod.Dataset("test")
-        dataset.add_sample_field(
-            "predictions", fof.EmbeddedDocumentField, fol.Detections
-        )
-
-        returned = fosv.get_view(
-            "test",
-            filters=filters,
-            count_label_tags=True,
-        )._pipeline()
-
-        expected = [
-            {
-                "$match": {
-                    "$and": [
-                        {
-                            "$and": [
-                                {
-                                    "predictions.detections.confidence": {
-                                        "$gte": 0.5
-                                    }
-                                },
-                                {
-                                    "predictions.detections.confidence": {
-                                        "$lte": 1
-                                    }
-                                },
-                            ],
-                        },
-                        {"predictions.detections.label": {"$in": ["carrot"]}},
-                    ],
-                },
-            },
-            {"$addFields": {"_label_tags": []}},
-            {
-                "$addFields": {
-                    "_label_tags": {
-                        "$cond": {
-                            "if": {"$gt": ["$predictions", None]},
-                            "then": {
-                                "$concatArrays": [
-                                    "$_label_tags",
-                                    {
-                                        "$reduce": {
-                                            "input": "$predictions.detections",
-                                            "initialValue": [],
-                                            "in": {
-                                                "$concatArrays": [
-                                                    "$$value",
-                                                    "$$this.tags",
-                                                ],
-                                            },
-                                        },
-                                    },
-                                ],
-                            },
-                            "else": "$_label_tags",
-                        },
-                    },
-                },
-            },
-            {
-                "$addFields": {
-                    "_label_tags": {
-                        "$function": {
-                            "body": "function(items) {let counts = {};items && items.forEach((i) => {counts[i] = 1 + (counts[i] || 0);});return counts;}",
-                            "args": ["$_label_tags"],
-                            "lang": "js",
-                        },
-                    },
-                },
-            },
-        ]
-
-        self.assertEqual(expected, returned)
-
-    @drop_datasets
-    def test_extended_view_image_label_filters_aggregations(self):
         filters = {
             "predictions.detections.label": {
                 "values": ["carrot"],
                 "exclude": False,
-                "onlyMatch": True,
                 "isMatching": False,
-                "_CLS": "str",
             },
             "predictions.detections.confidence": {
-                "range": [0.5, 1],
-                "_CLS": "numeric",
+                "range": [0.0, 0.5],
                 "exclude": False,
-                "onlyMatch": True,
                 "isMatching": False,
             },
         }
+        view = fosv.get_view("test", filters=filters)
+        self.assertEqual(len(view), 1)
+        self.assertEqual(len(view.first().predictions.detections), 1)
 
-        dataset = fod.Dataset("test")
-        dataset.add_sample_field(
-            "predictions", fof.EmbeddedDocumentField, fol.Detections
+        filters = {
+            "list_str": {
+                "values": ["one"],
+                "exclude": False,
+            },
+            "list_int": {
+                "range": [0, 2],
+                "exclude": False,
+            },
+        }
+        view = fosv.get_view("test", filters=filters)
+        self.assertEqual(len(view), 1)
+        self.assertEqual(len(view.first().list_str), 2)
+        self.assertEqual(len(view.first().list_int), 2)
+
+        filters = {
+            "list_str": {
+                "values": ["empty"],
+                "exclude": False,
+            },
+            "list_int": {
+                "range": [0, 2],
+                "exclude": False,
+            },
+        }
+        view = fosv.get_view("test", filters=filters)
+        self.assertEqual(len(view), 0)
+
+        filters = {
+            "list_str": {
+                "values": ["one"],
+                "exclude": False,
+            },
+            "list_int": {
+                "range": [3, 4],
+                "exclude": False,
+            },
+        }
+        view = fosv.get_view("test", filters=filters)
+        self.assertEqual(len(view), 0)
+
+        filters = {
+            "list_bool": {
+                "true": False,
+                "false": True,
+                "exclude": False,
+            },
+        }
+        view = fosv.get_view("test", filters=filters)
+        self.assertEqual(len(view), 0)
+
+        filters = {
+            "list_bool": {
+                "true": False,
+                "false": True,
+                "exclude": True,
+            },
+        }
+        view = fosv.get_view("test", filters=filters)
+        self.assertEqual(len(view), 1)
+
+        filters = {
+            "list_bool": {
+                "true": True,
+                "false": False,
+                "exclude": False,
+            },
+        }
+        view = fosv.get_view("test", filters=filters)
+        self.assertEqual(len(view), 1)
+
+        view = fosv.get_view("test", pagination_data=True)
+        (sample,) = list(
+            foo.aggregate(
+                foo.get_db_conn()[view._dataset._sample_collection_name],
+                view._pipeline(),
+            )
         )
+        self.assertIn("_label_tags", sample)
+        self.assertDictEqual(sample["_label_tags"], {"one": 1, "two": 2})
 
-        returned = fosv.get_view(
-            "test", filters=filters, count_label_tags=False
-        )._pipeline()
-
-        expected = [
-            {
-                "$match": {
-                    "$and": [
-                        {
-                            "$and": [
-                                {
-                                    "predictions.detections.confidence": {
-                                        "$gte": 0.5
-                                    }
-                                },
-                                {
-                                    "predictions.detections.confidence": {
-                                        "$lte": 1
-                                    }
-                                },
-                            ],
-                        },
-                        {"predictions.detections.label": {"$in": ["carrot"]}},
-                    ],
-                },
-            },
-            {
-                "$addFields": {
-                    "predictions.detections": {
-                        "$filter": {
-                            "input": "$predictions.detections",
-                            "cond": {
-                                "$or": [
-                                    {
-                                        "$and": [
-                                            {
-                                                "$gte": [
-                                                    "$$this.confidence",
-                                                    0.5,
-                                                ]
-                                            },
-                                            {"$lte": ["$$this.confidence", 1]},
-                                        ],
-                                    },
-                                    {"$in": ["$$this.confidence", []]},
-                                ],
-                            },
-                        },
-                    },
-                },
-            },
-            {
-                "$addFields": {
-                    "predictions.detections": {
-                        "$filter": {
-                            "input": "$predictions.detections",
-                            "cond": {"$in": ["$$this.label", ["carrot"]]},
-                        },
-                    },
-                },
-            },
-        ]
-
-        self.assertEqual(expected, returned)
+        filters = {
+            "_label_tags": {
+                "values": ["two"],
+                "exclude": False,
+                "isMatching": True,
+            },
+        }
+        view = fosv.get_view("test", filters=filters)
+        self.assertEqual(len(view), 1)
+        self.assertEqual(len(view.first().predictions.detections), 2)
 
-    @drop_datasets
-    def test_extended_view_video_label_filters_samples(self):
         filters = {
-            "frames.detections.detections.index": {
-                "range": [27, 54],
-                "_CLS": "numeric",
+            "_label_tags": {
+                "values": ["one"],
                 "exclude": False,
-                "onlyMatch": True,
                 "isMatching": False,
             },
-            "frames.detections.detections.label": {
-                "values": ["vehicle"],
-                "exclude": False,
-                "onlyMatch": True,
+        }
+        view = fosv.get_view("test", filters=filters)
+        self.assertEqual(len(view), 1)
+        self.assertEqual(len(view.first().predictions.detections), 1)
+
+        view = fosv.get_view("test", pagination_data=True, filters=filters)
+        (sample,) = list(
+            foo.aggregate(
+                foo.get_db_conn()[view._dataset._sample_collection_name],
+                view._pipeline(),
+            )
+        )
+        self.assertIn("_label_tags", sample)
+        self.assertDictEqual(sample["_label_tags"], {"one": 1, "two": 1})
+
+        filters = {
+            "_label_tags": {
+                "values": ["two"],
+                "exclude": True,
                 "isMatching": False,
-                "_CLS": "str",
             },
         }
+        view = fosv.get_view("test", filters=filters)
+        self.assertEqual(len(view), 1)
+        self.assertEqual(len(view.first().predictions.detections), 0)
 
-        dataset = fod.Dataset("test")
-        dataset.media_type = "video"
-        dataset.add_frame_field(
-            "detections", fof.EmbeddedDocumentField, fol.Detections
+        filters = {
+            "_label_tags": {
+                "values": ["one"],
+                "exclude": True,
+                "isMatching": False,
+            },
+        }
+        view = fosv.get_view("test", filters=filters)
+        self.assertEqual(len(view), 1)
+        self.assertEqual(
+            view.first().predictions.detections[0].label, "not_carrot"
         )
 
-        returned = fosv.get_view(
-            "test",
-            filters=filters,
-            count_label_tags=True,
-        )._pipeline()[1:]
-
-        expected = [
-            {
-                "$match": {
-                    "$and": [
-                        {
-                            "$and": [
-                                {
-                                    "frames.detections.detections.index": {
-                                        "$gte": 27
-                                    }
-                                },
-                                {
-                                    "frames.detections.detections.index": {
-                                        "$lte": 54
-                                    }
-                                },
-                            ],
-                        },
-                        {
-                            "frames.detections.detections.label": {
-                                "$in": ["vehicle"]
-                            }
-                        },
-                    ],
-                },
-            },
-            {"$addFields": {"_label_tags": []}},
-            {
-                "$addFields": {
-                    "_label_tags": {
-                        "$concatArrays": [
-                            "$_label_tags",
-                            {
-                                "$reduce": {
-                                    "input": "$frames",
-                                    "initialValue": [],
-                                    "in": {
-                                        "$concatArrays": [
-                                            "$$value",
-                                            {
-                                                "$cond": {
-                                                    "if": {
-                                                        "$gt": [
-                                                            "$$this.detections.detections",
-                                                            None,
-                                                        ],
-                                                    },
-                                                    "then": {
-                                                        "$reduce": {
-                                                            "input": "$$this.detections.detections",
-                                                            "initialValue": [],
-                                                            "in": {
-                                                                "$concatArrays": [
-                                                                    "$$value",
-                                                                    "$$this.tags",
-                                                                ],
-                                                            },
-                                                        },
-                                                    },
-                                                    "else": [],
-                                                },
-                                            },
-                                        ],
-                                    },
-                                },
-                            },
-                        ],
-                    },
-                },
-            },
-            {
-                "$addFields": {
-                    "_label_tags": {
-                        "$function": {
-                            "body": "function(items) {let counts = {};items && items.forEach((i) => {counts[i] = 1 + (counts[i] || 0);});return counts;}",
-                            "args": ["$_label_tags"],
-                            "lang": "js",
-                        },
-                    },
-                },
-            },
-        ]
-
-        self.assertEqual(expected, returned)
+        view = fosv.get_view("test", pagination_data=True, filters=filters)
+        (sample,) = list(
+            foo.aggregate(
+                foo.get_db_conn()[view._dataset._sample_collection_name],
+                view._pipeline(),
+            )
+        )
+        self.assertIn("_label_tags", sample)
+        self.assertDictEqual(sample["_label_tags"], {"two": 1})
+
+        filters = {
+            "_label_tags": {
+                "values": ["one"],
+                "exclude": True,
+                "isMatching": True,
+            },
+        }
+        view = fosv.get_view("test", filters=filters)
+        self.assertEqual(len(view), 0)
 
     @drop_datasets
-    def test_extended_view_video_label_filters_aggregations(self):
+    def test_extended_frame_sample(self):
+        dataset = fod.Dataset("test")
+        sample = fos.Sample(
+            filepath="video.mp4",
+        )
+        sample.frames[1] = fo.Frame(
+            predictions=fol.Detections(
+                detections=[
+                    fol.Detection(
+                        label="carrot", confidence=0.25, tags=["one", "two"]
+                    ),
+                    fol.Detection(
+                        label="not_carrot", confidence=0.75, tags=["two"]
+                    ),
+                ]
+            )
+        )
+        dataset.add_sample(sample)
+
         filters = {
-            "frames.detections.detections.index": {
-                "range": [27, 54],
-                "_CLS": "numeric",
+            "frames.predictions.detections.label": {
+                "values": ["carrot"],
                 "exclude": False,
-                "onlyMatch": True,
                 "isMatching": False,
             },
-            "frames.detections.detections.label": {
-                "values": ["vehicle"],
+            "frames.predictions.detections.confidence": {
+                "range": [0.5, 1],
                 "exclude": False,
-                "onlyMatch": True,
                 "isMatching": False,
-                "_CLS": "str",
             },
         }
+        view = fosv.get_view("test", filters=filters)
+        self.assertEqual(len(view), 0)
 
-        dataset = fod.Dataset("test")
-        dataset.media_type = "video"
-        dataset.add_frame_field(
-            "detections", fof.EmbeddedDocumentField, fol.Detections
+        filters = {
+            "frames.predictions.detections.label": {
+                "values": ["carrot"],
+                "exclude": False,
+                "isMatching": False,
+            },
+            "frames.predictions.detections.confidence": {
+                "range": [0.0, 0.5],
+                "exclude": False,
+                "isMatching": False,
+            },
+        }
+        view = fosv.get_view("test", filters=filters)
+        self.assertEqual(len(view), 1)
+        self.assertEqual(len(view.first().frames[1].predictions.detections), 1)
+
+        view = fosv.get_view("test", pagination_data=True)
+        (sample,) = list(
+            foo.aggregate(
+                foo.get_db_conn()[view._dataset._sample_collection_name],
+                view._pipeline(),
+            )
         )
+        self.assertIn("_label_tags", sample)
+        self.assertDictEqual(sample["_label_tags"], {"one": 1, "two": 2})
 
-        returned = fosv.get_view(
-            "test", filters=filters, count_label_tags=False
-        )._pipeline()[1:]
-
-        expected = [
-            {
-                "$match": {
-                    "$and": [
-                        {
-                            "$and": [
-                                {
-                                    "frames.detections.detections.index": {
-                                        "$gte": 27
-                                    }
-                                },
-                                {
-                                    "frames.detections.detections.index": {
-                                        "$lte": 54
-                                    }
-                                },
-                            ],
-                        },
-                        {
-                            "frames.detections.detections.label": {
-                                "$in": ["vehicle"]
-                            }
-                        },
-                    ],
-                },
-            },
-            {
-                "$addFields": {
-                    "frames": {
-                        "$map": {
-                            "input": "$frames",
-                            "as": "frame",
-                            "in": {
-                                "$mergeObjects": [
-                                    "$$frame",
-                                    {
-                                        "detections": {
-                                            "$mergeObjects": [
-                                                "$$frame.detections",
-                                                {
-                                                    "detections": {
-                                                        "$filter": {
-                                                            "input": "$$frame.detections.detections",
-                                                            "cond": {
-                                                                "$or": [
-                                                                    {
-                                                                        "$and": [
-                                                                            {
-                                                                                "$gte": [
-                                                                                    "$$this.index",
-                                                                                    27,
-                                                                                ],
-                                                                            },
-                                                                            {
-                                                                                "$lte": [
-                                                                                    "$$this.index",
-                                                                                    54,
-                                                                                ],
-                                                                            },
-                                                                        ],
-                                                                    },
-                                                                    {
-                                                                        "$in": [
-                                                                            "$$this.index",
-                                                                            [],
-                                                                        ],
-                                                                    },
-                                                                ],
-                                                            },
-                                                        },
-                                                    },
-                                                },
-                                            ],
-                                        },
-                                    },
-                                ],
-                            },
-                        },
-                    },
-                },
-            },
-            {
-                "$addFields": {
-                    "frames": {
-                        "$map": {
-                            "input": "$frames",
-                            "as": "frame",
-                            "in": {
-                                "$mergeObjects": [
-                                    "$$frame",
-                                    {
-                                        "detections": {
-                                            "$mergeObjects": [
-                                                "$$frame.detections",
-                                                {
-                                                    "detections": {
-                                                        "$filter": {
-                                                            "input": "$$frame.detections.detections",
-                                                            "cond": {
-                                                                "$in": [
-                                                                    "$$this.label",
-                                                                    [
-                                                                        "vehicle"
-                                                                    ],
-                                                                ],
-                                                            },
-                                                        },
-                                                    },
-                                                },
-                                            ],
-                                        },
-                                    },
-                                ],
-                            },
-                        },
-                    },
-                },
-            },
-        ]
-
-        self.assertEqual(expected, returned)
+        filters = {
+            "_label_tags": {
+                "values": ["two"],
+                "exclude": False,
+                "isMatching": True,
+            },
+        }
+        view = fosv.get_view("test", filters=filters)
+        self.assertEqual(len(view), 1)
+        self.assertEqual(len(view.first().frames[1].predictions.detections), 2)
 
-    @drop_datasets
-    def test_extended_view_video_match_label_tags_aggregations(self):
         filters = {
             "_label_tags": {
                 "values": ["one"],
                 "exclude": False,
+                "isMatching": False,
+            },
+        }
+        view = fosv.get_view("test", filters=filters)
+        self.assertEqual(len(view), 1)
+        self.assertEqual(len(view.first().frames[1].predictions.detections), 1)
+
+        view = fosv.get_view("test", pagination_data=True, filters=filters)
+        (sample,) = list(
+            foo.aggregate(
+                foo.get_db_conn()[view._dataset._sample_collection_name],
+                view._pipeline(),
+            )
+        )
+        self.assertIn("_label_tags", sample)
+        self.assertDictEqual(sample["_label_tags"], {"one": 1, "two": 1})
+
+        filters = {
+            "_label_tags": {
+                "values": ["two"],
+                "exclude": True,
+                "isMatching": False,
+            },
+        }
+        view = fosv.get_view("test", filters=filters)
+        self.assertEqual(len(view), 1)
+        self.assertEqual(len(view.first().frames[1].predictions.detections), 0)
+
+        filters = {
+            "_label_tags": {
+                "values": ["one"],
+                "exclude": True,
+                "isMatching": False,
+            },
+        }
+        view = fosv.get_view("test", filters=filters)
+        self.assertEqual(len(view), 1)
+        self.assertEqual(
+            view.first().frames[1].predictions.detections[0].label,
+            "not_carrot",
+        )
+
+        view = fosv.get_view("test", pagination_data=True, filters=filters)
+        (sample,) = list(
+            foo.aggregate(
+                foo.get_db_conn()[view._dataset._sample_collection_name],
+                view._pipeline(),
+            )
+        )
+        self.assertIn("_label_tags", sample)
+        self.assertDictEqual(sample["_label_tags"], {"two": 1})
+
+        filters = {
+            "_label_tags": {
+                "values": ["one"],
+                "exclude": True,
                 "isMatching": True,
-            }
+            },
         }
+        view = fosv.get_view("test", filters=filters)
+        self.assertEqual(len(view), 0)
 
+    @drop_datasets
+    def test_extended_dynamic_image_sample(self):
         dataset = fod.Dataset("test")
-        dataset.media_type = "video"
-        dataset.add_frame_field(
-            "detections", fof.EmbeddedDocumentField, fol.Detections
+        sample = fos.Sample(
+            filepath="image.png",
+            dynamic=fo.DynamicEmbeddedDocument(
+                predictions=fol.Detections(
+                    detections=[
+                        fol.Detection(
+                            label="carrot",
+                            confidence=0.25,
+                            tags=["one", "two"],
+                        ),
+                        fol.Detection(
+                            label="not_carrot", confidence=0.75, tags=["two"]
+                        ),
+                    ]
+                ),
+                bool=True,
+                int=1,
+                str="str",
+                list_bool=[True],
+                list_int=[1, 2],
+                list_str=["one", "two"],
+            ),
+            dynamic_list=[
+                fo.DynamicEmbeddedDocument(
+                    bool=True,
+                    int=1,
+                    str="str",
+                    list_bool=[True],
+                    list_int=[1, 2],
+                    list_str=["one", "two"],
+                )
+            ],
         )
+        dataset.add_sample(sample)
+        dataset.add_dynamic_sample_fields()
 
-        returned = fosv.get_view(
-            "test", filters=filters, count_label_tags=True
-        )._pipeline()[1:]
-
-        expected = [
-            {
-                "$match": {
-                    "$or": [
-                        {"frames.detections.detections.tags": {"$in": ["one"]}}
-                    ],
-                },
-            },
-            {"$addFields": {"_label_tags": []}},
-            {
-                "$addFields": {
-                    "_label_tags": {
-                        "$concatArrays": [
-                            "$_label_tags",
-                            {
-                                "$reduce": {
-                                    "input": "$frames",
-                                    "initialValue": [],
-                                    "in": {
-                                        "$concatArrays": [
-                                            "$$value",
-                                            {
-                                                "$cond": {
-                                                    "if": {
-                                                        "$gt": [
-                                                            "$$this.detections.detections",
-                                                            None,
-                                                        ],
-                                                    },
-                                                    "then": {
-                                                        "$reduce": {
-                                                            "input": "$$this.detections.detections",
-                                                            "initialValue": [],
-                                                            "in": {
-                                                                "$concatArrays": [
-                                                                    "$$value",
-                                                                    "$$this.tags",
-                                                                ],
-                                                            },
-                                                        },
-                                                    },
-                                                    "else": [],
-                                                },
-                                            },
-                                        ],
-                                    },
-                                },
-                            },
-                        ],
-                    },
-                },
-            },
-            {
-                "$addFields": {
-                    "_label_tags": {
-                        "$function": {
-                            "body": "function(items) {let counts = {};items && items.forEach((i) => {counts[i] = 1 + (counts[i] || 0);});return counts;}",
-                            "args": ["$_label_tags"],
-                            "lang": "js",
-                        },
-                    },
-                },
-            },
-        ]
-
-        self.assertEqual(expected, returned)
+        filters = {
+            "dynamic.predictions.detections.label": {
+                "values": ["carrot"],
+                "exclude": False,
+                "isMatching": False,
+            },
+            "dynamic.predictions.detections.confidence": {
+                "range": [0.5, 1],
+                "exclude": False,
+                "isMatching": False,
+            },
+        }
+        view = fosv.get_view("test", filters=filters)
+        self.assertEqual(len(view), 0)
+
+        filters = {
+            "dynamic.predictions.detections.label": {
+                "values": ["carrot"],
+                "exclude": False,
+                "isMatching": False,
+            },
+            "dynamic.predictions.detections.confidence": {
+                "range": [0.0, 0.5],
+                "exclude": False,
+                "isMatching": False,
+            },
+        }
+        view = fosv.get_view("test", filters=filters)
+        self.assertEqual(len(view), 1)
+        self.assertEqual(len(view.first().dynamic.predictions.detections), 1)
+
+        filters = {
+            "dynamic.list_str": {
+                "values": ["one"],
+                "exclude": False,
+            },
+            "dynamic.list_int": {
+                "range": [0, 2],
+                "exclude": False,
+            },
+        }
+        view = fosv.get_view("test", filters=filters)
+        self.assertEqual(len(view), 1)
+        self.assertEqual(len(view.first().dynamic.list_str), 2)
+        self.assertEqual(len(view.first().dynamic.list_int), 2)
+
+        filters = {
+            "dynamic.list_str": {
+                "values": ["empty"],
+                "exclude": False,
+            },
+            "dynamic.list_int": {
+                "range": [0, 2],
+                "exclude": False,
+            },
+        }
+        view = fosv.get_view("test", filters=filters)
+        self.assertEqual(len(view), 0)
+
+        filters = {
+            "dynamic.list_str": {
+                "values": ["one"],
+                "exclude": False,
+            },
+            "dynamic.list_int": {
+                "range": [3, 4],
+                "exclude": False,
+            },
+        }
+        view = fosv.get_view("test", filters=filters)
+        self.assertEqual(len(view), 0)
+
+        filters = {
+            "dynamic.list_bool": {
+                "true": False,
+                "false": True,
+                "exclude": False,
+            },
+        }
+        view = fosv.get_view("test", filters=filters)
+        self.assertEqual(len(view), 0)
+
+        filters = {
+            "dynamic.list_bool": {
+                "true": False,
+                "false": True,
+                "exclude": True,
+            },
+        }
+        view = fosv.get_view("test", filters=filters)
+        self.assertEqual(len(view), 1)
+
+        filters = {
+            "dynamic.list_bool": {
+                "true": True,
+                "false": False,
+                "exclude": False,
+            },
+        }
+        view = fosv.get_view("test", filters=filters)
+        self.assertEqual(len(view), 1)
+
+        view = fosv.get_view("test", pagination_data=True)
+        (sample,) = list(
+            foo.aggregate(
+                foo.get_db_conn()[view._dataset._sample_collection_name],
+                view._pipeline(),
+            )
+        )
+        self.assertIn("_label_tags", sample)
+        self.assertDictEqual(sample["_label_tags"], {"one": 1, "two": 2})
+
+        filters = {
+            "_label_tags": {
+                "values": ["two"],
+                "exclude": False,
+                "isMatching": True,
+            },
+        }
+        view = fosv.get_view("test", filters=filters)
+        self.assertEqual(len(view), 1)
+        self.assertEqual(len(view.first().dynamic.predictions.detections), 2)
 
-    @drop_datasets
-    def test_extended_view_video_match_label_tags_samples(self):
         filters = {
             "_label_tags": {
                 "values": ["one"],
                 "exclude": False,
                 "isMatching": False,
-            }
+            },
         }
+        view = fosv.get_view("test", filters=filters)
+        self.assertEqual(len(view), 1)
+        self.assertEqual(len(view.first().dynamic.predictions.detections), 1)
+
+        view = fosv.get_view("test", pagination_data=True, filters=filters)
+        (sample,) = list(
+            foo.aggregate(
+                foo.get_db_conn()[view._dataset._sample_collection_name],
+                view._pipeline(),
+            )
+        )
+        self.assertIn("_label_tags", sample)
+        self.assertDictEqual(sample["_label_tags"], {"one": 1, "two": 1})
 
+        filters = {
+            "_label_tags": {
+                "values": ["two"],
+                "exclude": True,
+                "isMatching": False,
+            },
+        }
+        view = fosv.get_view("test", filters=filters)
+        self.assertEqual(len(view), 1)
+        self.assertEqual(len(view.first().dynamic.predictions.detections), 0)
+
+        filters = {
+            "_label_tags": {
+                "values": ["one"],
+                "exclude": True,
+                "isMatching": False,
+            },
+        }
+        view = fosv.get_view("test", filters=filters)
+        self.assertEqual(len(view), 1)
+        self.assertEqual(
+            view.first().dynamic.predictions.detections[0].label, "not_carrot"
+        )
+
+        view = fosv.get_view("test", pagination_data=True, filters=filters)
+        (sample,) = list(
+            foo.aggregate(
+                foo.get_db_conn()[view._dataset._sample_collection_name],
+                view._pipeline(),
+            )
+        )
+        self.assertIn("_label_tags", sample)
+        self.assertDictEqual(sample["_label_tags"], {"two": 1})
+
+        filters = {
+            "_label_tags": {
+                "values": ["one"],
+                "exclude": True,
+                "isMatching": True,
+            },
+        }
+        view = fosv.get_view("test", filters=filters)
+        self.assertEqual(len(view), 0)
+
+        filters = {
+            "dynamic_list.bool": {
+                "true": False,
+                "false": True,
+                "exclude": False,
+            },
+        }
+        view = fosv.get_view("test", filters=filters)
+        self.assertEqual(len(view), 0)
+
+        filters = {
+            "dynamic_list.list_bool": {
+                "true": False,
+                "false": True,
+                "exclude": False,
+            },
+        }
+        view = fosv.get_view("test", filters=filters)
+        self.assertEqual(len(view), 0)
+
+        filters = {
+            "dynamic_list.bool": {
+                "true": True,
+                "false": False,
+                "exclude": False,
+            },
+        }
+        view = fosv.get_view("test", filters=filters)
+        self.assertEqual(len(view), 1)
+
+        filters = {
+            "dynamic_list.list_bool": {
+                "true": True,
+                "false": False,
+                "exclude": False,
+            },
+        }
+        view = fosv.get_view("test", filters=filters)
+        self.assertEqual(len(view), 1)
+
+        filters = {
+            "dynamic_list.int": {
+                "range": [-1, 0],
+                "exclude": False,
+            },
+        }
+        view = fosv.get_view("test", filters=filters)
+        self.assertEqual(len(view), 0)
+
+        filters = {
+            "dynamic_list.list_int": {
+                "range": [-1, 0],
+                "exclude": False,
+            },
+        }
+        view = fosv.get_view("test", filters=filters)
+        self.assertEqual(len(view), 0)
+
+        filters = {
+            "dynamic_list.int": {
+                "range": [0, 1],
+                "exclude": False,
+            },
+        }
+        view = fosv.get_view("test", filters=filters)
+        self.assertEqual(len(view), 1)
+
+        filters = {
+            "dynamic_list.list_int": {
+                "range": [0, 1],
+                "exclude": False,
+            },
+        }
+        view = fosv.get_view("test", filters=filters)
+        self.assertEqual(len(view), 1)
+
+        filters = {
+            "dynamic_list.int": {
+                "range": [0, 2],
+                "exclude": True,
+            },
+        }
+        view = fosv.get_view("test", filters=filters)
+        self.assertEqual(len(view), 0)
+
+        filters = {
+            "dynamic_list.list_int": {
+                "range": [0, 2],
+                "exclude": True,
+            },
+        }
+        view = fosv.get_view("test", filters=filters)
+        self.assertEqual(len(view), 0)
+
+    @drop_datasets
+    def test_extended_keypoint_sample(self):
         dataset = fod.Dataset("test")
-        dataset.media_type = "video"
-        dataset.add_frame_field(
-            "detections", fof.EmbeddedDocumentField, fol.Detections
+        dataset.default_skeleton = fo.KeypointSkeleton(
+            labels=["top-left", "center", "bottom-right"], edges=[[0, 1, 2]]
         )
+        sample = fos.Sample(
+            filepath="video.mp4",
+            keypoint=fo.Keypoint(
+                label="keypoint",
+                points=[[0, 0], [0.5, 0.5], [1, 1]],
+                confidence=[0, 0.5, 1],
+                dynamic=["one", "two", "three"],
+                tags=["keypoint"],
+            ),
+            keypoints=fo.Keypoints(
+                keypoints=[
+                    fo.Keypoint(
+                        label="keypoint",
+                        points=[[0, 0], [0.5, 0.5], [1, 1]],
+                        confidence=[0, 0.5, 1],
+                        dynamic=["one", "two", "three"],
+                        tags=["keypoint"],
+                    )
+                ]
+            ),
+        )
+
+        dataset.add_sample(sample)
+        dataset.add_dynamic_sample_fields()
+        dataset.add_dynamic_frame_fields()
 
-        returned = fosv.get_view(
-            "test", filters=filters, count_label_tags=False
-        )._pipeline()[1:]
-
-        expected = [
-            {
-                "$match": {
-                    "$or": [
-                        {"frames.detections.detections.tags": {"$in": ["one"]}}
-                    ],
-                },
-            },
-            {
-                "$addFields": {
-                    "frames": {
-                        "$map": {
-                            "input": "$frames",
-                            "as": "frame",
-                            "in": {
-                                "$mergeObjects": [
-                                    "$$frame",
-                                    {
-                                        "detections": {
-                                            "$mergeObjects": [
-                                                "$$frame.detections",
-                                                {
-                                                    "detections": {
-                                                        "$filter": {
-                                                            "input": "$$frame.detections.detections",
-                                                            "cond": {
-                                                                "$cond": {
-                                                                    "if": {
-                                                                        "$gt": [
-                                                                            "$$this.tags",
-                                                                            None,
-                                                                        ],
-                                                                    },
-                                                                    "then": {
-                                                                        "$in": [
-                                                                            "one",
-                                                                            "$$this.tags",
-                                                                        ],
-                                                                    },
-                                                                    "else": False,
-                                                                },
-                                                            },
-                                                        },
-                                                    },
-                                                },
-                                            ],
-                                        },
-                                    },
-                                ],
-                            },
-                        },
-                    },
-                },
-            },
-            {
-                "$match": {
-                    "$expr": {
-                        "$gt": [
-                            {
-                                "$reduce": {
-                                    "input": "$frames",
-                                    "initialValue": 0,
-                                    "in": {
-                                        "$add": [
-                                            "$$value",
-                                            {
-                                                "$size": {
-                                                    "$ifNull": [
-                                                        "$$this.detections.detections",
-                                                        [],
-                                                    ],
-                                                },
-                                            },
-                                        ],
-                                    },
-                                },
-                            },
-                            0,
-                        ],
-                    },
-                },
-            },
-        ]
-
-        self.assertEqual(expected, returned)
+        filters = {
+            "keypoint.label": {
+                "values": ["empty"],
+                "exclude": False,
+            },
+        }
+        view = fosv.get_view("test", filters=filters)
+        self.assertEqual(len(view), 0)
+
+        filters = {
+            "keypoint.label": {
+                "values": ["keypoint"],
+                "exclude": True,
+            },
+        }
+        view = fosv.get_view("test", filters=filters)
+        self.assertEqual(len(view), 0)
+
+        filters = {
+            "keypoint.points": {
+                "values": ["top-left"],
+                "exclude": False,
+            },
+        }
+        view = fosv.get_view("test", filters=filters)
+        self.assertEqual(len(view), 1)
+        self.assertListEqual(view.first().keypoint.points[0], [0, 0])
+        for point in view.first().keypoint.points[1:]:
+            self.assertTrue(math.isnan(point[0]))
+            self.assertTrue(math.isnan(point[1]))
+
+        filters = {
+            "keypoint.points": {
+                "values": ["top-left"],
+                "exclude": False,
+            },
+        }
+        view = fosv.get_view("test", filters=filters)
+        self.assertEqual(len(view), 1)
diff --git a/tests/unittests/view_tests.py b/tests/unittests/view_tests.py
index 441ba2ab85..603817d48b 100644
--- a/tests/unittests/view_tests.py
+++ b/tests/unittests/view_tests.py
@@ -2738,6 +2738,152 @@ def test_filter_keypoints(self):
         view = dataset.filter_keypoints("kps", labels=[])
         self.assertEqual(len(view), 0)
 
+    def test_filter_keypoints_embedded_document(self):
+        sample1 = fo.Sample(
+            filepath="image1.jpg",
+            dynamic=fo.DynamicEmbeddedDocument(
+                kp=fo.Keypoint(
+                    label="person",
+                    points=[(0, 0), (0, 0), (0, 0), (0, 0), (0, 0)],
+                    confidence=[0.5, 0.6, 0.7, 0.8, 0.9],
+                ),
+                kps=fo.Keypoints(
+                    keypoints=[
+                        fo.Keypoint(
+                            label="person",
+                            points=[(0, 0), (0, 0), (0, 0), (0, 0), (0, 0)],
+                            confidence=[0.5, 0.6, 0.7, 0.8, 0.9],
+                        ),
+                        fo.Keypoint(),
+                    ]
+                ),
+            ),
+        )
+
+        sample2 = fo.Sample(filepath="image2.jpg")
+
+        dataset = fo.Dataset()
+        dataset.add_samples([sample1, sample2], dynamic=True)
+
+        dataset.default_skeleton = fo.KeypointSkeleton(
+            labels=["nose", "left eye", "right eye", "left ear", "right ear"],
+            edges=[[0, 1, 2, 0], [0, 3], [0, 4]],
+        )
+
+        count_nans = lambda points: len([p for p in points if np.isnan(p[0])])
+
+        #
+        # Test `Keypoint` sample fields
+        #
+
+        # only_matches=True
+        view = dataset.filter_keypoints(
+            "dynamic.kp", filter=F("confidence") > 0.75
+        )
+        self.assertEqual(len(view), 1)
+        sample = view.first()
+        self.assertEqual(len(sample["dynamic.kp"].points), 5)
+        self.assertEqual(count_nans(sample["dynamic.kp"].points), 3)
+
+        # only_matches=False
+        view = dataset.filter_keypoints(
+            "dynamic.kp", filter=F("confidence") > 0.75, only_matches=False
+        )
+        self.assertEqual(len(view), 2)
+        sample = view.first()
+        self.assertEqual(len(sample["dynamic.kp"].points), 5)
+        self.assertEqual(count_nans(sample["dynamic.kp"].points), 3)
+
+        # view with no matches
+        view = dataset.filter_keypoints(
+            "dynamic.kp", filter=F("confidence") > 0.95
+        )
+        self.assertEqual(len(view), 0)
+
+        # only_matches=True
+        view = dataset.filter_keypoints(
+            "dynamic.kp", labels=["left eye", "right eye"]
+        )
+        self.assertEqual(len(view), 1)
+        sample = view.first()
+        self.assertEqual(len(sample["dynamic.kp"].points), 5)
+        self.assertEqual(count_nans(sample["dynamic.kp"].points), 3)
+
+        # only_matches=False
+        view = dataset.filter_keypoints(
+            "dynamic.kp", labels=["left eye", "right eye"], only_matches=False
+        )
+        self.assertEqual(len(view), 2)
+        sample = view.first()
+        self.assertEqual(len(sample["dynamic.kp"].points), 5)
+        self.assertEqual(count_nans(sample["dynamic.kp"].points), 3)
+
+        # view with no matches
+        view = dataset.filter_keypoints("dynamic.kp", labels=[])
+        self.assertEqual(len(view), 0)
+
+        #
+        # Test `Keypoints` sample fields
+        #
+
+        # only_matches=True
+        view = dataset.filter_keypoints(
+            "dynamic.kps", filter=F("confidence") > 0.75
+        )
+        self.assertEqual(len(view), 1)
+        self.assertEqual(view.count("dynamic.kps.keypoints"), 1)
+        sample = view.first()
+        self.assertEqual(len(sample["dynamic.kps"].keypoints[0].points), 5)
+        self.assertEqual(
+            count_nans(sample["dynamic.kps"].keypoints[0].points), 3
+        )
+
+        # only_matches=False
+        view = dataset.filter_keypoints(
+            "dynamic.kps", filter=F("confidence") > 0.75, only_matches=False
+        )
+        self.assertEqual(len(view), 2)
+        self.assertEqual(view.count("dynamic.kps.keypoints"), 2)
+        sample = view.first()
+        self.assertEqual(len(sample["dynamic.kps"].keypoints[0].points), 5)
+        self.assertEqual(
+            count_nans(sample["dynamic.kps"].keypoints[0].points), 3
+        )
+
+        # view with no matches
+        view = dataset.filter_keypoints(
+            "dynamic.kps", filter=F("confidence") > 0.95
+        )
+        self.assertEqual(len(view), 0)
+
+        # only_matches=True
+        view = dataset.filter_keypoints(
+            "dynamic.kps", labels=["left eye", "right eye"]
+        )
+        self.assertEqual(len(view), 1)
+        self.assertEqual(view.count("dynamic.kps.keypoints"), 1)
+        sample = view.first()
+        self.assertEqual(len(sample["dynamic.kps"].keypoints[0].points), 5)
+        self.assertEqual(
+            count_nans(sample["dynamic.kps"].keypoints[0].points), 3
+        )
+
+        # only_matches=False
+        view = dataset.filter_keypoints(
+            "dynamic.kps", labels=["left eye", "right eye"], only_matches=False
+        )
+        self.assertEqual(len(view), 2)
+        self.assertEqual(view.count("dynamic.kps.keypoints"), 2)
+        sample = view.first()
+        self.assertEqual(len(sample["dynamic.kps"].keypoints[0].points), 5)
+        self.assertEqual(
+            count_nans(sample["dynamic.kps"].keypoints[0].points), 3
+        )
+
+        # view with no matches
+        view = dataset.filter_keypoints("dynamic.kps", labels=[])
+        self.assertEqual(len(view), 0)
+
     def test_filter_keypoints_frames(self):
         sample1 = fo.Sample(filepath="video1.mp4")
         sample1.frames[1] = fo.Frame(