diff --git a/src/common/api/collectionsApi.ts b/src/common/api/collectionsApi.ts
index bc5129f8..b0ade21e 100644
--- a/src/common/api/collectionsApi.ts
+++ b/src/common/api/collectionsApi.ts
@@ -197,6 +197,13 @@ export type ColumnMeta = {
       max_value: undefined;
       enum_values: string[];
     }
+  | {
+      type: 'bool';
+      filter_strategy: undefined;
+      min_value: undefined;
+      max_value: undefined;
+      enum_values: undefined;
+    }
 );
 
 interface CollectionsResults {
diff --git a/src/common/components/FilterChip.tsx b/src/common/components/FilterChip.tsx
index 521017e0..f6a89365 100644
--- a/src/common/components/FilterChip.tsx
+++ b/src/common/components/FilterChip.tsx
@@ -18,7 +18,7 @@ export const FilterChip = ({
   ...chipProps
 }: FilterChipProps) => {
   let filterString = '';
-  if (filter.value) {
+  if (filter.value !== undefined && filter.value !== null) {
     if (
       filter.type === 'date' ||
       filter.type === 'int' ||
@@ -30,6 +30,8 @@ export const FilterChip = ({
         })
         .map((val) => val.toLocaleString());
       filterString = `${minString} to ${maxString}`;
+    } else if (filter.type === 'bool') {
+      filterString = Boolean(filter.value).toString();
     } else {
       const val = filter.value;
       if (typeof val === 'string') {
diff --git a/src/features/collections/CollectionDetail.tsx b/src/features/collections/CollectionDetail.tsx
index 2dde7f64..19d194ee 100644
--- a/src/features/collections/CollectionDetail.tsx
+++ b/src/features/collections/CollectionDetail.tsx
@@ -41,11 +41,15 @@ import {
   Accordion,
   AccordionSummary,
   AccordionDetails,
+  FormControl,
+  Select,
+  MenuItem,
+  SelectChangeEvent,
 } from '@mui/material';
 import { useForm } from 'react-hook-form';
 import { CollectionOverview } from './CollectionOverview';
 import { FilterChip } from '../../common/components/FilterChip';
-import { FilterContextTabs } from './Filters';
+import { filterContextScope, FilterContextTabs } from './Filters';
 
 export const detailPath = ':id';
 export const detailDataProductPath = ':id/:data_product';
@@ -63,8 +67,8 @@ const pageConfig: Record<
   }
 > = {
   samples: { features: ['filter'] },
-  biolog: { features: [] },
-  microtrait: { features: [] },
+  biolog: { features: ['filter'] },
+  microtrait: { features: ['filter'] },
   genome_attribs: {
     features: ['filter', 'match', 'search'],
   },
@@ -178,7 +182,8 @@ export const CollectionDetail = () => {
       !filter ||
       filter.type === 'int' ||
       filter.type === 'float' ||
-      filter.type === 'date'
+      filter.type === 'date' ||
+      filter.type === 'bool'
     )
       return;
     if (e.target.value === filter.value) return;
@@ -401,6 +406,7 @@ const useFilterEntries = (collectionId: string) => {
 };
 
 const FilterChips = ({ collectionId }: { collectionId: string }) => {
+  const { columnMeta } = useFilters(collectionId);
   const { filterEntries, clearFilterState, context } =
     useFilterEntries(collectionId);
   if (filterEntries.length === 0) return <></>;
@@ -411,7 +417,7 @@ const FilterChips = ({ collectionId }: { collectionId: string }) => {
           <FilterChip
             filter={filter}
             key={`${column}-${context}-${filter.type}`}
-            name={column}
+            name={columnMeta?.[column]?.display_name || column}
             onDelete={() => clearFilterState(column)}
           />
         );
@@ -451,11 +457,19 @@ const FilterMenu = ({
     setExpandedCategory(expanded ? category : '');
   };
 
+  const menuLabel = {
+    DEFAULT: 'Filters',
+    genomes: 'Genome Filters',
+    samples: 'Sample Filters',
+    biolog: 'Biolog Filters',
+    microtrait: 'Microtrait Filters',
+  }[filterContextScope(context) || 'DEFAULT'];
+
   if (open) {
     return (
       <div className={styles['filters_panel']}>
         <Stack direction="row" className={styles['filters-panel-header']}>
-          <h3>Genome Filters</h3>
+          <h3>{menuLabel}</h3>
           <Stack direction="row" spacing={1}>
             <Button
               size="small"
@@ -503,7 +517,8 @@ const FilterMenu = ({
                 <AccordionDetails>
                   <Stack spacing={3}>
                     {category.filters.flatMap(([column, filter]) => {
-                      const hasVal = Boolean(filter.value);
+                      const hasVal =
+                        filter.value !== undefined && filter.value !== null;
                       return (
                         <Stack
                           className={styles['filter-container']}
@@ -596,6 +611,15 @@ const FilterControls = ({
         collectionId={collectionId}
       />
     );
+  } else if (filter.type === 'bool') {
+    return (
+      <BooleanFilterControls
+        column={column}
+        filter={filter}
+        context={context}
+        collectionId={collectionId}
+      />
+    );
   }
   return null;
 };
@@ -859,7 +883,7 @@ const RangeFilterControls = ({
   const [filterMin, filterMax] = [filter.min_value, filter.max_value];
   useEffect(() => {
     //Clear when the filter is cleared
-    if (!filter.value) {
+    if (filter.value === undefined || filter.value === null) {
       setValue('min', filterMin);
       setValue('max', filterMax);
       setSliderPosition([filterMin, filterMax]);
@@ -977,3 +1001,73 @@ const TextFilterControls = ({
     />
   );
 };
+
+const BooleanFilterControls = ({
+  column,
+  filter,
+  collectionId,
+  context,
+}: FilterControlProps & {
+  filter: { type: 'bool' };
+}) => {
+  const dispatch = useAppDispatch();
+  // Convert boolean values to proper dropdown values
+  const getBooleanDropdownValue = (value?: number | boolean) => {
+    if (value === true || value === 1) {
+      return 'true';
+    } else if (value === false || value === 0) {
+      return 'false';
+    } else {
+      return 'any';
+    }
+  };
+  const [selectValue, setSelectValue] = useState<string>(() => {
+    return getBooleanDropdownValue(filter.value);
+  });
+
+  const handleChange = (event: SelectChangeEvent) => {
+    setSelectValue(event.target.value as string);
+  };
+
+  // In order not to create a dependency loop when filter changes within the below effect,
+  // use a filter ref
+  const filterRef = useRef(filter);
+  filterRef.current = filter;
+
+  useEffect(() => {
+    let value;
+    if (selectValue === 'true') {
+      value = 1;
+    } else if (selectValue === 'false') {
+      value = 0;
+    }
+    dispatch(
+      setFilter([
+        collectionId,
+        context,
+        column,
+        { ...filterRef.current, value },
+      ])
+    );
+  }, [selectValue, collectionId, context, column, dispatch]);
+
+  useEffect(() => {
+    //Clear when the filter is cleared
+    // Use 'any' for empty value so the select stays controlled and shows "Any" in the dropdown
+    if (filter.value === undefined || filter.value === null) {
+      setSelectValue('any');
+    } else if (filter.value !== filterRef.current.value) {
+      setSelectValue(getBooleanDropdownValue(filter.value));
+    }
+  }, [filter.value, setSelectValue]);
+
+  return (
+    <FormControl fullWidth>
+      <Select value={selectValue} onChange={handleChange}>
+        <MenuItem value="true">True</MenuItem>
+        <MenuItem value="false">False</MenuItem>
+        <MenuItem value="any">Any</MenuItem>
+      </Select>
+    </FormControl>
+  );
+};
diff --git a/src/features/collections/Filters.tsx b/src/features/collections/Filters.tsx
index a22c555f..9b8cabb4 100644
--- a/src/features/collections/Filters.tsx
+++ b/src/features/collections/Filters.tsx
@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
 import { Chip, Stack, Tab, Tabs } from '@mui/material';
 import { useCallback, useEffect, useRef } from 'react';
 import { toast } from 'react-hot-toast';
@@ -147,25 +148,22 @@ export const useContextFilterQueryManagement = (
     <T extends CommonResult>(
       result: T,
       collectionId: string | undefined
-    ): { filterData?: T['data']; context?: FilterContext } => {
+    ): { filterData?: T['data'] } => {
       if (result.isError) {
         const err = parseError(result.error);
         if (err.name !== 'AbortError')
           toast('Filter Loading failed: ' + parseError(result.error).message);
       }
-      const context = result.requestId
-        ? requestContext.current[result.requestId]
-        : undefined;
-      if (!collectionId || !result?.data || !context || result.isError)
-        return {};
-      return { filterData: result.data, context };
+
+      if (!collectionId || !result?.data || result.isError) return {};
+      return { filterData: result.data };
     },
     []
   );
 
   const handleTableFilters = useCallback(
     <T extends typeof genomeResult | typeof sampleResult>(result: T) => {
-      const { filterData, context } = handleResult(result, collectionId);
+      const { filterData } = handleResult(result, collectionId);
       if (!filterData || !collectionId || !context) return;
       dispatch(clearFiltersAndColumnMeta([collectionId, context]));
       filterData.columns.forEach((column) => {
@@ -214,50 +212,88 @@ export const useContextFilterQueryManagement = (
         }
       });
     },
-    [collectionId, dispatch, handleResult]
+    [collectionId, dispatch, handleResult, context]
   );
 
   const handleHeatmapFilters = useCallback(
     <T extends typeof biologResult | typeof microtraitResult>(result: T) => {
-      const { filterData, context } = handleResult(result, collectionId);
+      const { filterData } = handleResult(result, collectionId);
       if (!filterData || !collectionId || !context) return;
       dispatch(clearFiltersAndColumnMeta([collectionId, context]));
       filterData.categories.forEach((category) => {
         category.columns.forEach((column) => {
           const current =
             filtersRef.current && filtersRef.current[column.col_id];
-          const filterMeta: ColumnMeta = {
-            type: 'int',
-            key: column.col_id,
-            max_value: filterData.max_value,
-            min_value: filterData.min_value,
-            category: category.category,
-            description: column.description,
-            display_name: column.name,
-            filter_strategy: undefined,
-            enum_values: undefined,
-          };
-          dispatch(
-            setColumnMeta([collectionId, context, column.col_id, filterMeta])
-          );
-          dispatch(
-            setFilter([
-              collectionId,
-              context,
-              column.col_id,
-              {
-                type: filterMeta.type,
-                min_value: filterMeta.min_value,
-                max_value: filterMeta.max_value,
-                value:
-                  current?.type === column.type ? current.value : undefined,
-              },
-            ])
-          );
+          if (column.type === 'bool') {
+            dispatch(
+              setColumnMeta([
+                collectionId,
+                context,
+                column.col_id,
+                {
+                  type: 'bool',
+                  key: column.col_id,
+                  max_value: undefined,
+                  min_value: undefined,
+                  category: category.category,
+                  description: column.description,
+                  display_name: column.name,
+                  filter_strategy: undefined,
+                  enum_values: undefined,
+                },
+              ])
+            );
+            dispatch(
+              setFilter([
+                collectionId,
+                context,
+                column.col_id,
+                {
+                  type: 'bool',
+                  value:
+                    current?.type === column.type
+                      ? typeof current.value !== 'undefined'
+                        ? Boolean(current.value)
+                        : undefined
+                      : undefined,
+                },
+              ])
+            );
+          } else {
+            // column.type === 'count'
+            const filterMeta: ColumnMeta = {
+              type: 'int',
+              key: column.col_id,
+              max_value: filterData.max_value,
+              min_value: filterData.min_value,
+              category: category.category,
+              description: column.description,
+              display_name: column.name,
+              filter_strategy: undefined,
+              enum_values: undefined,
+            };
+            dispatch(
+              setColumnMeta([collectionId, context, column.col_id, filterMeta])
+            );
+            dispatch(
+              setFilter([
+                collectionId,
+                context,
+                column.col_id,
+                {
+                  type: 'int',
+                  min_value: filterMeta.min_value,
+                  max_value: filterMeta.max_value,
+                  value:
+                    current?.type === column.type ? current.value : undefined,
+                },
+              ])
+            );
+          }
         });
       });
     },
-    [collectionId, dispatch, handleResult]
+    [collectionId, dispatch, handleResult, context]
   );
 
   // When the context (or collection) changes, set the filter context and trigger appropriate query
@@ -277,8 +313,6 @@ export const useContextFilterQueryManagement = (
     } else {
       throw new Error(`No filter query matches filter context "${context}"`);
     }
-    requestContext.current[request.requestId] = context;
-
     return () => {
       // Abort request if context changes while running (prevents race conditions)
       if (request) {
diff --git a/src/features/collections/collectionsSlice.ts b/src/features/collections/collectionsSlice.ts
index 5de28867..1237afe6 100644
--- a/src/features/collections/collectionsSlice.ts
+++ b/src/features/collections/collectionsSlice.ts
@@ -40,6 +40,10 @@ export type FilterState =
       value?: FilterRange;
       min_value: number;
       max_value: number;
+    }
+  | {
+      type: 'bool';
+      value?: boolean | number;
     };
 
 interface ClnState {
@@ -420,7 +424,7 @@ export const useFilters = (
   );
 
   const formattedFilters = Object.entries(filters ?? {})
-    .filter(([column, filterState]) => Boolean(filterState.value))
+    .filter(([column, filterState]) => filterState.value !== undefined)
     .map(([column, filterState]) => {
       const paramName = `filter_${column}`;
       let filterValue: string | undefined;
@@ -431,6 +435,11 @@ export const useFilters = (
         filterState.type === 'ngram'
       ) {
         if (filterState.value !== undefined) filterValue = filterState.value;
+      } else if (
+        filterState.type === 'bool' &&
+        filterState.value !== undefined
+      ) {
+        filterValue = Boolean(filterState.value).toString();
       } else if (
         (filterState.type === 'date' ||
           filterState.type === 'int' ||
diff --git a/src/features/collections/data_products/Biolog.tsx b/src/features/collections/data_products/Biolog.tsx
index 0ded26b5..24931be6 100644
--- a/src/features/collections/data_products/Biolog.tsx
+++ b/src/features/collections/data_products/Biolog.tsx
@@ -20,6 +20,7 @@ import { formatNumber } from '../../../common/utils/stringUtils';
 import classes from '../Collections.module.scss';
 import {
   useFilterContextState,
+  useFilters,
   useGenerateSelectionId,
   useMatchId,
 } from '../collectionsSlice';
@@ -128,6 +129,10 @@ const useBiolog = (collection_id: string | undefined) => {
     pageSize: 56,
   });
   const context = useFilterContextState(collection_id);
+  const { filterParams } = useFilters(collection_id, context);
+  const allFilters = useFilters(collection_id, 'biolog.all').filterParams;
+  const matchFilters = useFilters(collection_id, 'biolog.matched').filterParams;
+  const selFilters = useFilters(collection_id, 'biolog.selected').filterParams;
 
   const pageLastIdCache: Record<string, string> = useMemo(
     () => ({}),
@@ -157,7 +162,8 @@ const useBiolog = (collection_id: string | undefined) => {
       context,
     ]
   );
-  const allCountParams = useMemo(
+
+  const countParams = useMemo(
     () => ({
       ...heatMapParams,
       count: true,
@@ -171,7 +177,15 @@ const useBiolog = (collection_id: string | undefined) => {
     [collection_id]
   );
 
-  const biologQuery = getBiolog.useQuery(heatMapParams, {
+  const filteredParams = useMemo(
+    () => ({
+      ...heatMapParams,
+      ...filterParams,
+    }),
+    [heatMapParams, filterParams]
+  );
+
+  const biologQuery = getBiolog.useQuery(filteredParams, {
     skip: !collection_id,
   });
   const biolog = biologQuery.data;
@@ -204,24 +218,30 @@ const useBiolog = (collection_id: string | undefined) => {
     skip: !collection_id,
   });
 
-  const { data: count, ...countQuery } = getBiolog.useQuery(allCountParams, {
-    skip: !collection_id,
-  });
-
-  const [matchCountParams, selCountParams] = useMemo(
+  const [allCountParams, matchCountParams, selCountParams] = useMemo(
     () => [
       {
-        ...allCountParams,
+        ...countParams,
+        ...allFilters,
+      },
+      {
+        ...countParams,
         match_mark: false,
+        ...matchFilters,
       },
       {
-        ...allCountParams,
+        ...countParams,
         selection_mark: false,
+        ...selFilters,
       },
     ],
-    [allCountParams]
+    [allFilters, countParams, matchFilters, selFilters]
   );
 
+  const { data: count, ...countQuery } = getBiolog.useQuery(allCountParams, {
+    skip: !collection_id,
+  });
+
   const matchCount = getBiolog.useQuery(matchCountParams, {
     skip: !collection_id || !matchId,
   });
diff --git a/src/features/collections/data_products/Microtrait.tsx b/src/features/collections/data_products/Microtrait.tsx
index f64d30a5..429c407e 100644
--- a/src/features/collections/data_products/Microtrait.tsx
+++ b/src/features/collections/data_products/Microtrait.tsx
@@ -22,6 +22,7 @@ import {
   useMatchId,
   useGenerateSelectionId,
   useFilterContextState,
+  useFilters,
 } from '../collectionsSlice';
 import { useFilterContexts } from '../Filters';
 import { useProcessStatePolling } from '../hooks';
@@ -148,6 +149,10 @@ const useMicrotrait = (collection_id: string | undefined) => {
     skip: !collection_id,
   });
   const context = useFilterContextState(collection_id);
+  const { filterParams } = useFilters(collection_id, context);
+  const allFilters = useFilters(collection_id, 'biolog.all').filterParams;
+  const matchFilters = useFilters(collection_id, 'biolog.matched').filterParams;
+  const selFilters = useFilters(collection_id, 'biolog.selected').filterParams;
 
   const [pagination, setPagination] = useState<PaginationState>({
     pageIndex: 0,
@@ -182,7 +187,7 @@ const useMicrotrait = (collection_id: string | undefined) => {
       context,
     ]
   );
-  const allCountParams = useMemo(
+  const countParams = useMemo(
     () => ({
       ...heatMapParams,
       count: true,
@@ -197,7 +202,14 @@ const useMicrotrait = (collection_id: string | undefined) => {
   );
 
   // HeatMap cell query
-  const microtraitQuery = getMicroTrait.useQuery(heatMapParams, {
+  const filteredParams = useMemo(
+    () => ({
+      ...heatMapParams,
+      ...filterParams,
+    }),
+    [heatMapParams, filterParams]
+  );
+  const microtraitQuery = getMicroTrait.useQuery(filteredParams, {
     skip: !collection_id,
   });
   const microtrait = microtraitQuery.data;
@@ -230,25 +242,31 @@ const useMicrotrait = (collection_id: string | undefined) => {
     skip: !collection_id,
   });
 
-  const { data: count, ...countQuery } = getMicroTrait.useQuery(
-    allCountParams,
-    {
-      skip: !collection_id,
-    }
-  );
-
-  const [matchCountParams, selCountParams] = useMemo(
+  const [allCountParams, matchCountParams, selCountParams] = useMemo(
     () => [
       {
-        ...allCountParams,
+        ...countParams,
+        ...allFilters,
+      },
+      {
+        ...countParams,
         match_mark: false,
+        ...matchFilters,
       },
       {
-        ...allCountParams,
+        ...countParams,
         selection_mark: false,
+        ...selFilters,
       },
     ],
-    [allCountParams]
+    [allFilters, countParams, matchFilters, selFilters]
+  );
+
+  const { data: count, ...countQuery } = getMicroTrait.useQuery(
+    allCountParams,
+    {
+      skip: !collection_id,
+    }
   );
 
   const matchCount = getMicroTrait.useQuery(matchCountParams, {