diff --git a/packages/ui/Release.md b/packages/ui/Release.md
index 680a8cc4b..a3330a721 100644
--- a/packages/ui/Release.md
+++ b/packages/ui/Release.md
@@ -1,3 +1,6 @@
+### 10.10.7 2024-10-11
+- feat: CLIN-2989 Filter flag dropdown and querybuilder not includes tablefitler
+
 ### 10.10.6 2024-10-02
 - fix: CLIN-2673 Allow SelectRange filtering on 0 value
 
diff --git a/packages/ui/package-lock.json b/packages/ui/package-lock.json
index 3c9e1e0c2..dae7f05af 100644
--- a/packages/ui/package-lock.json
+++ b/packages/ui/package-lock.json
@@ -1,12 +1,12 @@
 {
     "name": "@ferlab/ui",
-    "version": "10.10.6",
+    "version": "10.10.7",
     "lockfileVersion": 2,
     "requires": true,
     "packages": {
         "": {
             "name": "@ferlab/ui",
-            "version": "10.10.6",
+            "version": "10.10.7",
             "license": "SEE LICENSE IN LICENSE",
             "dependencies": {
                 "@ant-design/icons": "^4.7.0",
diff --git a/packages/ui/package.json b/packages/ui/package.json
index 6ed733e09..6cd4720b9 100644
--- a/packages/ui/package.json
+++ b/packages/ui/package.json
@@ -1,6 +1,6 @@
 {
     "name": "@ferlab/ui",
-    "version": "10.10.6",
+    "version": "10.10.7",
     "description": "Core components for scientific research data portals",
     "publishConfig": {
         "access": "public"
diff --git a/packages/ui/src/components/Flag/FlagFilter/index.tsx b/packages/ui/src/components/Flag/FlagFilter/index.tsx
index 7b31e0885..94e585ada 100644
--- a/packages/ui/src/components/Flag/FlagFilter/index.tsx
+++ b/packages/ui/src/components/Flag/FlagFilter/index.tsx
@@ -11,36 +11,44 @@ import styles from './index.module.css';
 export type TFlagFilter = {
     dictionary?: IFlagDictionary | Record<string, never>;
     confirm?: (param?: FilterConfirmProps) => void;
-    selectedKeys?: React.Key[];
-    setSelectedKeys?: (selectedKeys: React.Key[]) => void;
+    selectedKeys: React.Key[];
+    setSelectedKeys: (selectedKeys: React.Key[]) => void;
+    selectedFilter?: string[];
     isClear: boolean;
 };
 
-const FlagFilter = ({ confirm, dictionary, isClear, selectedKeys, setSelectedKeys }: TFlagFilter): ReactElement => {
-    const [selectedOption, setSelectedOption] = useState<React.Key[]>(selectedKeys ? selectedKeys : []);
+const FlagFilter = ({
+    confirm,
+    dictionary,
+    isClear,
+    selectedFilter,
+    selectedKeys,
+    setSelectedKeys,
+}: TFlagFilter): ReactElement => {
+    const [selectedOption, setSelectedOption] = useState<React.Key[]>(selectedFilter ? selectedFilter : []);
+    useEffect(() => {
+        setSelectedOption(selectedFilter ? selectedFilter : []);
+    }, [selectedFilter]);
 
     useEffect(() => {
         if (selectedKeys && setSelectedKeys) {
             setSelectedKeys(selectedOption);
         }
     }, [selectedOption]);
-
     useEffect(() => {
         if (isClear) {
-            setSelectedOption([]);
             setSelectedKeys && setSelectedKeys([]);
             confirm && confirm();
         }
     }, [isClear]);
 
     const handleSelect = (value: string) => {
-        if (selectedKeys && setSelectedKeys) {
-            selectedKeys.includes(value)
-                ? setSelectedKeys(selectedKeys.filter((item: React.Key) => item !== value))
-                : setSelectedKeys([value, ...selectedKeys]);
+        if (selectedOption?.includes(value)) {
+            setSelectedOption(selectedOption.filter((item: React.Key) => item !== value));
+        } else {
+            setSelectedOption([value, ...selectedOption]);
         }
     };
-
     return (
         <>
             <div className={styles.flagContainer}>
@@ -118,7 +126,7 @@ const FlagFilter = ({ confirm, dictionary, isClear, selectedKeys, setSelectedKey
                 </Button>
                 <Button
                     onClick={() => {
-                        confirm;
+                        confirm && confirm();
                     }}
                     size="small"
                     type="primary"
diff --git a/packages/ui/src/components/QueryBuilder/index.tsx b/packages/ui/src/components/QueryBuilder/index.tsx
index 706edf3a9..a697b6c0b 100644
--- a/packages/ui/src/components/QueryBuilder/index.tsx
+++ b/packages/ui/src/components/QueryBuilder/index.tsx
@@ -17,7 +17,7 @@ import {
 } from '../../data/sqon/utils';
 import ConditionalWrapper from '../utils/ConditionalWrapper';
 
-import { isQueryStateEqual } from './utils/helper';
+import { isQueryStateEqual, removeIgnoreFieldFromQueryContent } from './utils/helper';
 import useQueryBuilderState, { setQueryBuilderState } from './utils/useQueryBuilderState';
 import {
     defaultCustomPillConfig,
@@ -61,6 +61,7 @@ export interface IQueryBuilderProps {
     fetchQueryCount: IFetchQueryCount;
     getResolvedQueryForCount: IGetResolvedQueryForCount;
     remoteComponentMapping?: (props: IRemoteComponent) => void;
+    filterQueryToIgnore?: string[];
 }
 
 const QueryBuilder = ({
@@ -73,6 +74,7 @@ const QueryBuilder = ({
     enableSingleQuery = false,
     facetFilterConfig = defaultFacetFilterConfig,
     fetchQueryCount,
+    filterQueryToIgnore,
     getResolvedQueryForCount,
     headerConfig = defaultHeaderConfig,
     IconTotal = null,
@@ -82,32 +84,41 @@ const QueryBuilder = ({
     remoteComponentMapping,
     total = 0,
 }: IQueryBuilderProps): JSX.Element => {
+    const removeIgnoreFieldFromQueryList = (sqon: ISyntheticSqon[]) => {
+        const queries = cloneDeep(sqon);
+        const newQuery: ISyntheticSqon[] = [];
+        queries.map((q) => {
+            newQuery.push(removeIgnoreFieldFromQueryContent(q, filterQueryToIgnore));
+        });
+        return newQuery;
+    };
     const [selectedSavedFilter, setSelectedSavedFilter] = useState(headerConfig?.selectedSavedFilter || null);
     const { state: queryBuilderState } = useQueryBuilderState(id);
     const [queriesState, setQueriesState] = useState<IQueriesState>({
         activeId: queryBuilderState?.active || v4(),
         queries: queryBuilderState?.state || [],
     });
+    const queryStateQueriesWithoutFilter = removeIgnoreFieldFromQueryList(queriesState.queries);
     const [showLabels, setShowLabels] = useState(initialShowLabelState);
     const [selectedQueryIndices, setSelectedQueryIndices] = useState<number[]>([]);
-    const emptyQueries = queriesState.queries.filter((sqon) => isEmptySqon(sqon));
-    const noQueries = queriesState.queries.length === emptyQueries.length;
-    const queryCount = queriesState.queries.length - emptyQueries.length;
+    const emptyQueries = queryStateQueriesWithoutFilter.filter((sqon) => isEmptySqon(sqon));
+    const noQueries = queryStateQueriesWithoutFilter.length === emptyQueries.length;
+    const queryCount = queryStateQueriesWithoutFilter.length - emptyQueries.length;
     const hasEmptyQuery = emptyQueries.length >= 1;
-    const getQueryIndexById = (id: string) => queriesState.queries.findIndex((obj) => obj.id === id);
+    const getQueryIndexById = (id: string) => queryStateQueriesWithoutFilter.findIndex((obj) => obj.id === id);
     const canCombine =
-        queriesState.queries.filter((sqon) => isNotEmptySqon(sqon)).length >= 2 && selectedQueryIndices.length >= 2;
+        queryStateQueriesWithoutFilter.filter((sqon) => isNotEmptySqon(sqon)).length >= 2 &&
+        selectedQueryIndices.length >= 2;
     const currentActiveSqonIndex = getQueryIndexById(queriesState.activeId);
-    const selectedSyntheticSqon = queriesState.queries[currentActiveSqonIndex];
+    const selectedSyntheticSqon = queryStateQueriesWithoutFilter[currentActiveSqonIndex];
     const getColorForReference = (refIndex: number) => referenceColors[refIndex % referenceColors.length];
-
     const updateQueryById = (id: string, newQuery: ISyntheticSqon) => {
         if (!id) return;
         if (isEmpty(newQuery.content)) {
             deleteQueryAndSetNext(id);
         } else {
             const currentQueryIndex = getQueryIndexById(id);
-            const updatedQueries = cloneDeep(queriesState.queries);
+            const updatedQueries = cloneDeep(queryStateQueriesWithoutFilter);
             updatedQueries[currentQueryIndex] = {
                 ...newQuery,
                 content: newQuery.content,
@@ -144,11 +155,11 @@ const QueryBuilder = ({
     };
 
     const deleteQueryAndSetNext = (id: string) => {
-        if (queriesState.queries.length === 1) {
+        if (queryStateQueriesWithoutFilter.length === 1) {
             resetQueries(id);
         } else {
             const currentQueryIndex = getQueryIndexById(id);
-            const updatedQueries = cleanUpQueries(removeSqonAtIndex(currentQueryIndex, queriesState.queries));
+            const updatedQueries = cleanUpQueries(removeSqonAtIndex(currentQueryIndex, queryStateQueriesWithoutFilter));
 
             if (updatedQueries.length) {
                 const nextSelectedIndex = findNextSelectedQuery(updatedQueries, currentQueryIndex);
@@ -178,7 +189,7 @@ const QueryBuilder = ({
         const newQuery = { content: content, id: id, op: op };
         setQueriesState({
             activeId: id,
-            queries: cleanUpQueries(cloneDeep([...queriesState.queries, newQuery])),
+            queries: cleanUpQueries(cloneDeep([...queryStateQueriesWithoutFilter, newQuery])),
         });
     };
 
@@ -225,7 +236,7 @@ const QueryBuilder = ({
 
     useEffect(() => {
         if (
-            isEmpty(queriesState.queries) &&
+            isEmpty(queryStateQueriesWithoutFilter) &&
             isEmptySqon(currentQuery) &&
             total === 0 &&
             !headerConfig.savedFilters?.length
@@ -237,7 +248,7 @@ const QueryBuilder = ({
     useEffect(() => {
         if (isEmptySqon(currentQuery) && total === 0) return;
 
-        if (queriesState.queries.length === 0) {
+        if (queryStateQueriesWithoutFilter.length === 0) {
             setQueriesState({
                 ...queriesState,
                 queries: [
@@ -249,13 +260,13 @@ const QueryBuilder = ({
                 ],
             });
         } else {
-            const index = queriesState.queries.findIndex((obj) => obj.id == queriesState.activeId);
-            const current = queriesState.queries[index];
+            const index = queryStateQueriesWithoutFilter.findIndex((obj) => obj.id == queriesState.activeId);
+            const current = queryStateQueriesWithoutFilter[index];
 
             if (current.content && current.content.length > 0 && isEmpty(currentQuery)) {
                 deleteQueryAndSetNext(queriesState.activeId);
             } else {
-                const tmpQuery = queriesState.queries.map((obj) => {
+                const tmpQuery = queryStateQueriesWithoutFilter.map((obj) => {
                     // Ensure there is always a op and content
                     if (obj.id === queriesState.activeId) {
                         return {
@@ -295,7 +306,7 @@ const QueryBuilder = ({
             if (!isQueryStateEqual(queryBuilderState, queriesState)) {
                 setQueryBuilderState(id, {
                     active: queriesState.activeId,
-                    state: queriesState.queries,
+                    state: queryStateQueriesWithoutFilter,
                 });
             }
         }
@@ -335,7 +346,7 @@ const QueryBuilder = ({
                 >
                     <div className={`${styles.queryBuilderContainer} ${className}`}>
                         <div className={styles.queryBars}>
-                            {queriesState.queries.map((sqon, i) => (
+                            {queryStateQueriesWithoutFilter.map((sqon, i) => (
                                 <QueryBar
                                     Icon={IconTotal}
                                     actionDisabled={isEmptySqon(sqon)}
@@ -358,7 +369,7 @@ const QueryBuilder = ({
                                         }));
                                     }}
                                     onCombineChange={(id, combinator) => {
-                                        const updatedQueries = cloneDeep(queriesState.queries);
+                                        const updatedQueries = cloneDeep(queryStateQueriesWithoutFilter);
                                         const currentQueryIndex = getQueryIndexById(id);
                                         const currentQuery = updatedQueries[currentQueryIndex];
                                         const newQuery = changeCombineOperator(combinator, currentQuery);
@@ -399,9 +410,9 @@ const QueryBuilder = ({
                                     query={sqon}
                                     remoteComponentMapping={remoteComponentMapping}
                                     selectionDisabled={
-                                        queriesState.queries.length === 1 ||
+                                        queryStateQueriesWithoutFilter.length === 1 ||
                                         !enableCombine ||
-                                        queriesState.queries[i].content.length === 0
+                                        queryStateQueriesWithoutFilter[i].content.length === 0
                                     }
                                     updateQueryById={updateQueryById}
                                 />
diff --git a/packages/ui/src/components/QueryBuilder/utils/helper.ts b/packages/ui/src/components/QueryBuilder/utils/helper.ts
index 926f31f58..3aaec2c00 100644
--- a/packages/ui/src/components/QueryBuilder/utils/helper.ts
+++ b/packages/ui/src/components/QueryBuilder/utils/helper.ts
@@ -1,6 +1,6 @@
 import { cloneDeep, isEqual } from 'lodash';
 
-import { ISyntheticSqon } from '../../../data/sqon/types';
+import { ISyntheticSqon, IValueContent, IValueFilter } from '../../../data/sqon/types';
 import { IQueriesState, IQueryBuilderState } from '../types';
 
 const removeTotal = (sqonList: ISyntheticSqon[]) =>
@@ -21,3 +21,30 @@ export const isQueryStateEqual = (queryBuilderState: IQueryBuilderState, queries
 
     return isEqual(cleanedQueryBuilderState, cleanedQueriesState);
 };
+
+export const removeIgnoreFieldFromQueryContent = (
+    query: ISyntheticSqon,
+    filterQueryToIgnore?: string[],
+): ISyntheticSqon => {
+    const queryToRemove = query.content.filter((c) => {
+        let toKeep = false;
+        if (((c as IValueFilter).content as unknown as IValueContent[]).length !== 0) {
+            if (!filterQueryToIgnore?.includes(((c as IValueFilter).content as IValueContent).field)) {
+                toKeep = true;
+            }
+            if (Array.isArray((c as IValueFilter).content)) {
+                const { field } = ((c as IValueFilter).content as unknown as IValueFilter[])[0]
+                    .content as IValueContent;
+                if (filterQueryToIgnore?.includes(field)) {
+                    toKeep = false;
+                }
+            }
+        }
+        return toKeep;
+    });
+    return {
+        content: queryToRemove,
+        id: query.id,
+        op: query.op,
+    };
+};
diff --git a/packages/ui/src/components/QueryBuilder/utils/useQueryBuilderState.tsx b/packages/ui/src/components/QueryBuilder/utils/useQueryBuilderState.tsx
index 90457852d..7e6383788 100644
--- a/packages/ui/src/components/QueryBuilder/utils/useQueryBuilderState.tsx
+++ b/packages/ui/src/components/QueryBuilder/utils/useQueryBuilderState.tsx
@@ -170,7 +170,7 @@ export const updateActiveQueryField = ({
         queryBuilderId,
     });
 
-const updateQuery = ({ query, queryBuilderId }: { queryBuilderId: string; query: ISyntheticSqon }) => {
+export const updateQuery = ({ query, queryBuilderId }: { queryBuilderId: string; query: ISyntheticSqon }) => {
     const qbState = getQueryBuilderState(queryBuilderId);
     const queryToUpdate = qbState?.state?.find(({ id }) => id === query.id);
     if (queryToUpdate) {