diff --git a/apps/roam/src/components/AdvancedNodeSearchDialog/AdvancedSearchDialog.tsx b/apps/roam/src/components/AdvancedNodeSearchDialog/AdvancedSearchDialog.tsx
index ed7694537..a5d6bbdd6 100644
--- a/apps/roam/src/components/AdvancedNodeSearchDialog/AdvancedSearchDialog.tsx
+++ b/apps/roam/src/components/AdvancedNodeSearchDialog/AdvancedSearchDialog.tsx
@@ -43,6 +43,7 @@ import {
   splitWithHighlights,
   stripTypePrefix,
 } from "./utils";
+import { DiscourseNodeTypeFilter } from "~/components/AdvancedNodeSearchDialog/DiscourseNodeTypeFilter";
 import { RenderRoamBlock, RenderRoamPage } from "~/utils/roamReactComponents";
 import { AdvancedSearchFooter } from "./AdvancedSearchFooter";
 
@@ -157,6 +158,8 @@ const AdvancedNodeSearchDialog = ({
   const [activeIndex, setActiveIndex] = useState(0);
   const [results, setResults] = useState<SearchResult[]>([]);
   const [sort, setSort] = useState<SortConfig>(DEFAULT_SORT_CONFIG);
+  const [discourseNodes, setDiscourseNodes] = useState<DiscourseNode[]>([]);
+  const [selectedNodeTypeIds, setSelectedNodeTypeIds] = useState<string[]>([]);
   const miniSearchRef = useRef<MiniSearch<
     SearchResult & { id: string }
   > | null>(null);
@@ -165,14 +168,9 @@ const AdvancedNodeSearchDialog = ({
   const inputRef = useRef<HTMLInputElement | null>(null);
   const [insertTarget, setInsertTarget] = useState<InsertTarget | null>(null);
 
-  const nodeConfigByType = useMemo(() => {
-    const discourseNodes = getDiscourseNodes().filter(
-      (node) => node.backedBy === "user",
-    );
-    return Object.fromEntries(
-      discourseNodes.map((node) => [node.type, node]),
-    ) as Record<string, DiscourseNode>;
-  }, []);
+  const nodeConfigByType = Object.fromEntries(
+    discourseNodes.map((node) => [node.type, node]),
+  );
 
   const activeResult = results[activeIndex] ?? null;
   const keywords = debouncedSearchTerm.split(/\s+/).filter(Boolean);
@@ -200,6 +198,7 @@ const AdvancedNodeSearchDialog = ({
       setDebouncedSearchTerm("");
       setActiveIndex(0);
       setSort(DEFAULT_SORT_CONFIG);
+      setSelectedNodeTypeIds([]);
       setResults([]);
       setIndexError(false);
     }
@@ -221,10 +220,18 @@ const AdvancedNodeSearchDialog = ({
       miniSearch: miniSearchRef.current,
       allResults: allResultsRef.current,
       searchTerm: debouncedSearchTerm,
+      typeFilter: selectedNodeTypeIds.length ? selectedNodeTypeIds : undefined,
     });
 
     setResults(sortSearchResults({ hits: scoredHits, sort }));
-  }, [debouncedSearchTerm, indexError, isIndexLoading, isOpen, sort]);
+  }, [
+    debouncedSearchTerm,
+    indexError,
+    isIndexLoading,
+    isOpen,
+    selectedNodeTypeIds,
+    sort,
+  ]);
 
   useEffect(() => {
     let cancelled = false;
@@ -234,6 +241,7 @@ const AdvancedNodeSearchDialog = ({
     const discourseNodes = getDiscourseNodes().filter(
       (node) => node.backedBy === "user",
     );
+    setDiscourseNodes(discourseNodes);
 
     void buildSearchIndex(discourseNodes)
       .then(({ miniSearch, results: indexedResults }) => {
@@ -270,7 +278,7 @@ const AdvancedNodeSearchDialog = ({
 
   useEffect(() => {
     setActiveIndex(0);
-  }, [debouncedSearchTerm, sort]);
+  }, [debouncedSearchTerm, selectedNodeTypeIds, sort]);
 
   useEffect(() => {
     const panel = resultsPanelRef.current;
@@ -419,7 +427,11 @@ const AdvancedNodeSearchDialog = ({
             placeholder="Search discourse nodes..."
             value={searchTerm}
           />
-
+          <DiscourseNodeTypeFilter
+            nodeTypes={discourseNodes}
+            onSelectedTypeIdsChange={setSelectedNodeTypeIds}
+            selectedTypeIds={selectedNodeTypeIds}
+          />
           <DiscourseNodeSortControl
             disabled={isIndexLoading || indexError}
             onSortChange={handleSortChange}
diff --git a/apps/roam/src/components/AdvancedNodeSearchDialog/DiscourseNodeTypeFilter.tsx b/apps/roam/src/components/AdvancedNodeSearchDialog/DiscourseNodeTypeFilter.tsx
new file mode 100644
index 000000000..3ce067d4c
--- /dev/null
+++ b/apps/roam/src/components/AdvancedNodeSearchDialog/DiscourseNodeTypeFilter.tsx
@@ -0,0 +1,319 @@
+import React, {
+  useCallback,
+  useEffect,
+  useMemo,
+  useRef,
+  useState,
+} from "react";
+import {
+  Button,
+  Checkbox,
+  InputGroup,
+  Popover,
+  Position,
+} from "@blueprintjs/core";
+import { formatHexColor } from "~/components/settings/DiscourseNodeCanvasSettings";
+import { type DiscourseNode } from "~/utils/getDiscourseNodes";
+import {
+  NODE_TYPE_FILTER_SEARCH_THRESHOLD,
+  filterDiscourseNodesByQuery,
+  fromPopoverSelectedIds,
+  getSelectAllCheckState,
+  hasActiveTypeFilter,
+  toPopoverSelectedIds,
+} from "~/utils/discourseNodeTypeFilter";
+
+export type DiscourseNodeTypeFilterProps = {
+  nodeTypes: DiscourseNode[];
+  selectedTypeIds: string[];
+  onSelectedTypeIdsChange: (ids: string[]) => void;
+  onPopoverOpenChange?: (isOpen: boolean) => void;
+};
+
+const getNodeIndicatorColor = (node: DiscourseNode): string =>
+  formatHexColor(node.canvasSettings?.color) || "#000";
+
+const NodeTypeFilterRow = ({
+  isChecked,
+  node,
+  onSelectOnly,
+  onToggle,
+}: {
+  isChecked: boolean;
+  node: DiscourseNode;
+  onSelectOnly: () => void;
+  onToggle: () => void;
+}): React.ReactElement => (
+  <div className="group flex items-center gap-2 px-3 py-1.5 hover:bg-gray-900/[0.04]">
+    <Checkbox
+      checked={isChecked}
+      className="mb-0 flex-1 text-sm font-normal text-gray-900"
+      labelElement={
+        <span className="inline-flex items-center gap-2 font-normal">
+          <span
+            className="h-3 w-3 rounded-full"
+            style={{ backgroundColor: getNodeIndicatorColor(node) }}
+          />
+          <span className="font-normal">{node.text}</span>
+        </span>
+      }
+      onChange={onToggle}
+    />
+    <Button
+      className="!px-2 !py-1 opacity-0 transition-opacity group-focus-within:opacity-100 group-hover:opacity-100"
+      minimal
+      onClick={(event) => {
+        event.stopPropagation();
+        onSelectOnly();
+      }}
+      onMouseDown={(event) => event.preventDefault()}
+      small
+      text="Only"
+    />
+  </div>
+);
+
+const FilterPopoverPanel = ({
+  isOpen,
+  nodeTypes,
+  onSelectedIdsChange,
+  selectedIds,
+}: {
+  isOpen: boolean;
+  nodeTypes: DiscourseNode[];
+  onSelectedIdsChange: (ids: string[]) => void;
+  selectedIds: string[];
+}): React.ReactElement => {
+  const [query, setQuery] = useState("");
+  const searchRef = useRef<HTMLInputElement>(null);
+
+  const showTypeSearch = nodeTypes.length > NODE_TYPE_FILTER_SEARCH_THRESHOLD;
+
+  const filteredNodes = useMemo(
+    () => filterDiscourseNodesByQuery(nodeTypes, query),
+    [nodeTypes, query],
+  );
+
+  const selectedIdSet = useMemo(() => new Set(selectedIds), [selectedIds]);
+
+  const selectAllState = getSelectAllCheckState({
+    selectedIds,
+    totalCount: nodeTypes.length,
+  });
+
+  const handleSelectAll = useCallback((): void => {
+    if (selectAllState === "off") {
+      onSelectedIdsChange(nodeTypes.map((node) => node.type));
+      return;
+    }
+    onSelectedIdsChange([]);
+  }, [nodeTypes, onSelectedIdsChange, selectAllState]);
+
+  const toggleType = useCallback(
+    (id: string): void => {
+      const nextSelectedIds = selectedIdSet.has(id)
+        ? selectedIds.filter((selectedId) => selectedId !== id)
+        : [...selectedIds, id];
+      onSelectedIdsChange(nextSelectedIds);
+    },
+    [onSelectedIdsChange, selectedIdSet, selectedIds],
+  );
+
+  const handleOnly = useCallback(
+    (id: string): void => {
+      onSelectedIdsChange([id]);
+    },
+    [onSelectedIdsChange],
+  );
+
+  useEffect(() => {
+    if (!isOpen) {
+      setQuery("");
+      return;
+    }
+    if (!showTypeSearch) return;
+    searchRef.current?.focus();
+  }, [isOpen, showTypeSearch]);
+
+  const hasTypeSearchQuery = query.trim().length > 0;
+
+  return (
+    <div className="w-64 overflow-hidden rounded-lg bg-white p-0">
+      {showTypeSearch && (
+        <div className="p-2">
+          <InputGroup
+            inputRef={searchRef}
+            leftIcon="search"
+            onChange={(event: React.ChangeEvent<HTMLInputElement>) =>
+              setQuery(event.target.value)
+            }
+            placeholder="Filter types…"
+            small
+            value={query}
+          />
+        </div>
+      )}
+      <div className="max-h-64 overflow-y-auto p-2">
+        {filteredNodes.length === 0 ? (
+          <div className="p-4 text-center text-sm text-gray-500">
+            No matching node types
+          </div>
+        ) : (
+          <>
+            {!hasTypeSearchQuery && (
+              <div className="border-b border-gray-900/10 px-3 py-1.5 hover:bg-gray-900/[0.04]">
+                <Checkbox
+                  checked={selectAllState !== "off"}
+                  className="mb-0 text-sm text-gray-900"
+                  indeterminate={selectAllState === "indeterminate"}
+                  labelElement={
+                    <span className="font-semibold">Select all</span>
+                  }
+                  onChange={handleSelectAll}
+                />
+              </div>
+            )}
+            <div className="pt-1">
+              {filteredNodes.map((node) => (
+                <NodeTypeFilterRow
+                  isChecked={selectedIdSet.has(node.type)}
+                  key={node.type}
+                  node={node}
+                  onSelectOnly={() => handleOnly(node.type)}
+                  onToggle={() => toggleType(node.type)}
+                />
+              ))}
+            </div>
+          </>
+        )}
+      </div>
+    </div>
+  );
+};
+
+export const DiscourseNodeTypeFilter = ({
+  nodeTypes,
+  onPopoverOpenChange,
+  onSelectedTypeIdsChange,
+  selectedTypeIds,
+}: DiscourseNodeTypeFilterProps): React.ReactElement => {
+  const [isOpen, setIsOpen] = useState(false);
+  const triggerRef = useRef<HTMLButtonElement>(null);
+  const popoverRef = useRef<HTMLElement | null>(null);
+
+  const allTypeIds = useMemo(
+    () => nodeTypes.map((node) => node.type),
+    [nodeTypes],
+  );
+  const isFilterActive = hasActiveTypeFilter({
+    selectedTypeIds,
+    allTypeIds,
+  });
+  const isFilterReady = nodeTypes.length > 0;
+
+  const popoverSelectedIds = useMemo(
+    () =>
+      toPopoverSelectedIds({
+        selectedTypeIds,
+        allTypeIds,
+      }),
+    [allTypeIds, selectedTypeIds],
+  );
+
+  const activeFilterCount = isFilterActive ? selectedTypeIds.length : 0;
+
+  const setPopoverOpen = useCallback(
+    (nextOpen: boolean): void => {
+      setIsOpen(nextOpen);
+      onPopoverOpenChange?.(nextOpen);
+    },
+    [onPopoverOpenChange],
+  );
+
+  const handlePopoverInteraction = useCallback(
+    (nextOpen: boolean, event?: React.SyntheticEvent<HTMLElement>): void => {
+      if (!isFilterReady) return;
+      if (nextOpen) {
+        event?.stopPropagation();
+      }
+      setPopoverOpen(nextOpen);
+    },
+    [isFilterReady, setPopoverOpen],
+  );
+
+  const handlePopoverSelectedIdsChange = useCallback(
+    (nextPopoverSelectedIds: string[]): void => {
+      onSelectedTypeIdsChange(
+        fromPopoverSelectedIds({
+          popoverSelectedIds: nextPopoverSelectedIds,
+          allTypeIds,
+        }),
+      );
+    },
+    [allTypeIds, onSelectedTypeIdsChange],
+  );
+
+  const isTriggerActive = isOpen || isFilterActive;
+
+  const filterButton = (
+    <Button
+      aria-expanded={isOpen}
+      aria-label="Filter by type"
+      className="p-0"
+      disabled={!isFilterReady}
+      elementRef={triggerRef}
+      icon="filter"
+      minimal
+      onMouseDown={(event) => event.preventDefault()}
+      style={{
+        position: "relative",
+        color: isTriggerActive ? "#5f57c0" : "rgba(31, 31, 31, 0.6)",
+        background: isTriggerActive ? "rgba(95, 87, 192, 0.1)" : "transparent",
+      }}
+      title={
+        isFilterReady ? "Filter by type" : "Loading discourse node types..."
+      }
+    >
+      {activeFilterCount > 0 && (
+        <span
+          style={{ position: "absolute", right: 2, top: 2 }}
+          className="inline-flex h-3.5 min-w-3.5 items-center justify-center rounded-lg bg-blue-600 px-1 text-xs font-semibold leading-none text-white"
+        >
+          {activeFilterCount}
+        </span>
+      )}
+    </Button>
+  );
+
+  return (
+    <Popover
+      autoFocus={false}
+      canEscapeKeyClose
+      content={
+        <FilterPopoverPanel
+          isOpen={isOpen}
+          nodeTypes={nodeTypes}
+          onSelectedIdsChange={handlePopoverSelectedIdsChange}
+          selectedIds={popoverSelectedIds}
+        />
+      }
+      enforceFocus={false}
+      isOpen={isOpen}
+      minimal
+      modifiers={{
+        flip: { enabled: true },
+        preventOverflow: {
+          enabled: true,
+          boundariesElement: "viewport",
+        },
+      }}
+      onClose={() => setPopoverOpen(false)}
+      onInteraction={handlePopoverInteraction}
+      popoverClassName="p-0 overflow-hidden"
+      popoverRef={popoverRef}
+      position={Position.BOTTOM_RIGHT}
+      target={filterButton}
+      usePortal
+    />
+  );
+};
diff --git a/apps/roam/src/components/AdvancedNodeSearchDialog/utils.ts b/apps/roam/src/components/AdvancedNodeSearchDialog/utils.ts
index 2a91d8f1d..c75c887c2 100644
--- a/apps/roam/src/components/AdvancedNodeSearchDialog/utils.ts
+++ b/apps/roam/src/components/AdvancedNodeSearchDialog/utils.ts
@@ -251,19 +251,25 @@ export const searchIndexedNodes = ({
   miniSearch,
   allResults,
   searchTerm,
+  typeFilter,
 }: {
   miniSearch: MiniSearch<MiniSearchDocument>;
   allResults: SearchResult[];
   searchTerm: string;
+  typeFilter?: string[];
 }): ScoredSearchHit[] => {
   const resultsByUid = new Map(
     allResults.map((result) => [result.uid, result]),
   );
+  const allowedTypes = typeFilter?.length ? new Set(typeFilter) : null;
 
   return miniSearch
     .search(searchTerm, {
       fields: ["title", "nodeTypeLabel"],
       ...DISCOURSE_NODE_MINI_SEARCH_OPTIONS,
+      filter: allowedTypes
+        ? (result) => allowedTypes.has(String(result.type))
+        : undefined,
     })
     .filter((result) => result.score > DISCOURSE_NODE_MIN_SEARCH_SCORE)
     .slice(0, MAX_RESULTS)
diff --git a/apps/roam/src/utils/discourseNodeTypeFilter.ts b/apps/roam/src/utils/discourseNodeTypeFilter.ts
new file mode 100644
index 000000000..30508db1f
--- /dev/null
+++ b/apps/roam/src/utils/discourseNodeTypeFilter.ts
@@ -0,0 +1,61 @@
+import { type DiscourseNode } from "~/utils/getDiscourseNodes";
+
+/** Advanced search: empty `selectedTypeIds` means all types; partial list is an active filter. */
+export const NODE_TYPE_FILTER_SEARCH_THRESHOLD = 7;
+
+export type SelectAllCheckState = "off" | "indeterminate" | "on";
+
+export const hasActiveTypeFilter = ({
+  selectedTypeIds,
+  allTypeIds,
+}: {
+  selectedTypeIds: string[];
+  allTypeIds: string[];
+}): boolean =>
+  selectedTypeIds.length > 0 && selectedTypeIds.length < allTypeIds.length;
+
+export const toPopoverSelectedIds = ({
+  selectedTypeIds,
+  allTypeIds,
+}: {
+  selectedTypeIds: string[];
+  allTypeIds: string[];
+}): string[] => (selectedTypeIds.length === 0 ? allTypeIds : selectedTypeIds);
+
+export const fromPopoverSelectedIds = ({
+  popoverSelectedIds,
+  allTypeIds,
+}: {
+  popoverSelectedIds: string[];
+  allTypeIds: string[];
+}): string[] => {
+  if (
+    popoverSelectedIds.length === 0 ||
+    popoverSelectedIds.length === allTypeIds.length
+  ) {
+    return [];
+  }
+  return popoverSelectedIds;
+};
+
+export const filterDiscourseNodesByQuery = (
+  nodes: DiscourseNode[],
+  query: string,
+): DiscourseNode[] => {
+  const trimmedQuery = query.trim().toLowerCase();
+  if (!trimmedQuery) return nodes;
+
+  return nodes.filter((node) => node.text.toLowerCase().includes(trimmedQuery));
+};
+
+export const getSelectAllCheckState = ({
+  selectedIds,
+  totalCount,
+}: {
+  selectedIds: string[];
+  totalCount: number;
+}): SelectAllCheckState => {
+  if (selectedIds.length === 0) return "off";
+  if (selectedIds.length === totalCount) return "on";
+  return "indeterminate";
+};