diff --git a/cypress/e2e/2_cache-detail-search.cy.js b/cypress/e2e/2_cache-detail-search.cy.js
index dd960e65..6dd13e06 100644
--- a/cypress/e2e/2_cache-detail-search.cy.js
+++ b/cypress/e2e/2_cache-detail-search.cy.js
@@ -17,13 +17,13 @@ describe('Cache Detail Overview', () => {
   it('successfully deletes by query', () => {
     cy.get('[data-cy=manageEntriesTab]').click();
     cy.get('[data-cy=queriesTab]').click();
-    cy.get('#textSearchByQuery').click().type('from org.infinispan.Person where age = 9');
-    cy.get('button[aria-label=searchButton]').click();
+    cy.get('#textSearchByQuery').find('textarea').type('from org.infinispan.Person where age = 9', { force: true });
+    cy.get('[data-cy=searchButton]').click();
     cy.contains('1 - 1 of 1');
     cy.contains('Oihana');
     cy.get('[data-cy=deleteByQueryButton]').click();
     cy.get('[data-cy=deleteButton]').click();
-    cy.get('button[aria-label=searchButton]').click();
+    cy.get('[data-cy=searchButton]').click();
     cy.contains('Values not found.');
     cy.get('[data-cy=deleteByQueryButton]').should('be.disabled');
   })
@@ -32,16 +32,17 @@ describe('Cache Detail Overview', () => {
     // Going back to cache entries page
     cy.get('[data-cy=manageEntriesTab]').click();
     cy.get('[data-cy=queriesTab]').click();
-    cy.get('#textSearchByQuery').click().type('from org.infinispan.Person where age > 2');
-    cy.get('button[aria-label=searchButton]').click();
+    cy.get('#textSearchByQuery').find('textarea').type('from org.infinispan.Person where age > 2', { force: true });
+    cy.get('[data-cy=searchButton]').click();
     cy.contains('1 - 1 of 1');
     cy.contains('Elaia');
 
     // Going back to cache entries page
     cy.get('[data-cy=manageEntriesTab]').click();
     cy.get('[data-cy=queriesTab]').click();
-    cy.get('#textSearchByQuery').click().clear().type("from org.infinispan.Person where name = 'Elaia'");
-    cy.get('button[aria-label=searchButton]').click();
+    cy.get('#textSearchByQuery').find('textarea').type('{selectall}{backspace}', { force: true });
+    cy.get('#textSearchByQuery').find('textarea').type("from org.infinispan.Person where name = 'Elaia'", { force: true });
+    cy.get('[data-cy=searchButton]').click();
     cy.contains('1 - 1 of 1');
     cy.contains('Elaia');
 
@@ -49,8 +50,9 @@ describe('Cache Detail Overview', () => {
     cy.get('[data-cy=manageEntriesTab]').click();
     cy.get('[data-cy=queriesTab]').click();
 
-    cy.get('#textSearchByQuery').click().clear().type('from org.infinispan.Person where age=2');
-    cy.get('button[aria-label=searchButton]').click();
+    cy.get('#textSearchByQuery').find('textarea').type('{selectall}{backspace}', { force: true });
+    cy.get('#textSearchByQuery').find('textarea').type('from org.infinispan.Person where age=2', { force: true });
+    cy.get('[data-cy=searchButton]').click();
     cy.contains('Values not found.');
 
     // Verify query metrics available
diff --git a/cypress/e2e/2_cache-query-history.cy.js b/cypress/e2e/2_cache-query-history.cy.js
new file mode 100644
index 00000000..f36dadac
--- /dev/null
+++ b/cypress/e2e/2_cache-query-history.cy.js
@@ -0,0 +1,144 @@
+describe('Query History', () => {
+  const username = Cypress.env('username');
+  const password = Cypress.env('password');
+
+  before(() => {
+    // Ensure test data exists
+    cy.cleanupTest(username, password, '/caches/indexed-cache/query-history-test', 'DELETE');
+    const payload = '{"_type": "org.infinispan.Person", "name": "HistoryTest", "age": "25", "city": "Madrid"}';
+    cy.cleanupTest(username, password, '/caches/indexed-cache/query-history-test', 'POST', payload);
+  });
+
+  beforeEach(() => {
+    // Clear localStorage to start with clean query history
+    cy.clearLocalStorage('cache-query-history');
+    cy.login(username, password, '/cache/indexed-cache');
+  });
+
+  it('successfully records a search query in history', () => {
+    // Navigate to queries tab and execute a search
+    cy.get('[data-cy=manageEntriesTab]').click();
+    cy.get('[data-cy=queriesTab]').click();
+    cy.get('#textSearchByQuery').find('textarea').type('from org.infinispan.Person where age > 2', { force: true });
+    cy.get('[data-cy=searchButton]').click();
+    cy.contains('Elaia');
+
+    // Navigate to query history tab
+    cy.get('[data-cy=queryHistoryTab]').click();
+
+    // Verify the query appears in the history table
+    cy.get('[data-cy=queryHistoryTable]').should('exist');
+    cy.contains('from org.infinispan.Person where age > 2');
+    cy.contains('Search');
+  });
+
+  it('successfully records a delete query in history', () => {
+    // Navigate to queries tab and execute a delete query
+    cy.get('[data-cy=manageEntriesTab]').click();
+    cy.get('[data-cy=queriesTab]').click();
+    cy.get('#textSearchByQuery').find('textarea').type("delete from org.infinispan.Person where name = 'HistoryTest'", { force: true });
+    cy.get('[data-cy=deleteByQueryButton]').click();
+    cy.get('[data-cy=deleteButton]').click();
+
+    // Navigate to query history tab
+    cy.get('[data-cy=queryHistoryTab]').click();
+
+    // Verify the delete query appears in history with Delete type label
+    cy.get('[data-cy=queryHistoryTable]').should('exist');
+    cy.contains('delete from org.infinispan.Person');
+    cy.contains('Delete');
+
+    // Re-create test data for subsequent tests
+    cy.cleanupTest(username, password, '/caches/indexed-cache/query-history-test', 'DELETE');
+    const payload = '{"_type": "org.infinispan.Person", "name": "HistoryTest", "age": "25", "city": "Madrid"}';
+    cy.cleanupTest(username, password, '/caches/indexed-cache/query-history-test', 'POST', payload);
+  });
+
+  it('successfully deletes a single history item', () => {
+    // First, create a history entry by running a query
+    cy.get('[data-cy=manageEntriesTab]').click();
+    cy.get('[data-cy=queriesTab]').click();
+    cy.get('#textSearchByQuery').find('textarea').type('from org.infinispan.Person where age > 2', { force: true });
+    cy.get('[data-cy=searchButton]').click();
+    cy.contains('Elaia');
+
+    // Navigate to query history tab
+    cy.get('[data-cy=queryHistoryTab]').click();
+    cy.get('[data-cy=queryHistoryTable]').should('exist');
+    cy.contains('from org.infinispan.Person where age > 2');
+
+    // Open actions menu on the first row and click delete
+    cy.get('[data-cy=actions-0]').find('button').click();
+    cy.contains('button', 'Delete').click();
+
+    // Verify the query is removed from history
+    cy.contains('from org.infinispan.Person where age > 2').should('not.exist');
+  });
+
+  it('successfully clears all query history', () => {
+    // Create history entries by running queries
+    cy.get('[data-cy=manageEntriesTab]').click();
+    cy.get('[data-cy=queriesTab]').click();
+    cy.get('#textSearchByQuery').find('textarea').type('from org.infinispan.Person where age > 2', { force: true });
+    cy.get('[data-cy=searchButton]').click();
+    cy.contains('Elaia');
+
+    cy.get('#textSearchByQuery').find('textarea').type('{selectall}{backspace}', { force: true });
+    cy.get('#textSearchByQuery').find('textarea').type('from org.infinispan.Person where age > 10', { force: true });
+    cy.get('[data-cy=searchButton]').click();
+
+    // Navigate to query history tab
+    cy.get('[data-cy=queryHistoryTab]').click();
+    cy.get('[data-cy=queryHistoryTable]').should('exist');
+
+    // Click clear all button
+    cy.get('[data-cy=removeAllQueryHistory]').click();
+
+    // Verify all history is cleared
+    cy.contains('from org.infinispan.Person where age > 2').should('not.exist');
+    cy.contains('from org.infinispan.Person where age > 10').should('not.exist');
+  });
+
+  it('successfully executes a query from history', () => {
+    // Create a history entry
+    cy.get('[data-cy=manageEntriesTab]').click();
+    cy.get('[data-cy=queriesTab]').click();
+    cy.get('#textSearchByQuery').find('textarea').type('from org.infinispan.Person where age > 2', { force: true });
+    cy.get('[data-cy=searchButton]').click();
+    cy.contains('Elaia');
+
+    // Navigate to query history tab
+    cy.get('[data-cy=queryHistoryTab]').click();
+    cy.get('[data-cy=queryHistoryTable]').should('exist');
+
+    // Execute the query from history
+    cy.get('[data-cy=actions-0]').find('button').click();
+    cy.contains('button', 'Execute').click();
+
+    // Verify we are back on the queries tab
+    cy.get('[data-cy=queriesTab]').should('have.attr', 'aria-selected', 'true');
+  });
+
+  it('successfully records an error query in history', () => {
+    // Execute a query with an invalid type
+    cy.get('[data-cy=manageEntriesTab]').click();
+    cy.get('[data-cy=queriesTab]').click();
+    cy.get('#textSearchByQuery').find('textarea').type('from com.NonExistent', { force: true });
+    cy.get('[data-cy=searchButton]').click();
+
+    // Wait for the error response
+    cy.contains('Query error');
+
+    // Navigate to query history tab
+    cy.get('[data-cy=queryHistoryTab]').click();
+    cy.get('[data-cy=queryHistoryTable]').should('exist');
+
+    // Verify the error query is shown with Error label
+    cy.contains('from com.NonExistent');
+    cy.contains('Error');
+  });
+
+  after(() => {
+    cy.cleanupTest(username, password, '/caches/indexed-cache/query-history-test', 'DELETE');
+  });
+});
diff --git a/src/app/AppLayout/AppLayout.tsx b/src/app/AppLayout/AppLayout.tsx
index 9161a0be..b94127f6 100644
--- a/src/app/AppLayout/AppLayout.tsx
+++ b/src/app/AppLayout/AppLayout.tsx
@@ -56,7 +56,7 @@ import {
 import { ConsoleACL } from '@services/securityService';
 import { DARK, LIGHT, ThemeContext } from '@app/providers/ThemeProvider';
 import { PopoverHelp } from '@app/Common/PopoverHelp';
-import { LanguageSelector } from `@app/Common/LanguageSelector`;
+import { LanguageSelector } from '@app/Common/LanguageSelector';
 
 interface IAppLayout {
   children: React.ReactNode;
diff --git a/src/app/Caches/DetailCache.tsx b/src/app/Caches/DetailCache.tsx
index 29539766..8910f6dc 100644
--- a/src/app/Caches/DetailCache.tsx
+++ b/src/app/Caches/DetailCache.tsx
@@ -62,6 +62,8 @@ import { InfinispanComponentStatus } from '@app/Common/InfinispanComponentStatus
 import { PageHeader } from '@patternfly/react-component-groups';
 import { UpdateAliasCache } from '@app/Caches/UpdateAliasCache';
 import { DeleteCache } from '@app/Caches/DeleteCache';
+import { QueryHistory } from '@app/Caches/Query/QueryHistory';
+import { QueryContextProvider } from '@app/providers/QueryContextProvider';
 
 const DetailCache = (props: { cacheName: string }) => {
   const cacheName = props.cacheName;
@@ -110,26 +112,40 @@ const DetailCache = (props: { cacheName: string }) => {
     }
 
     return (
-      <Tabs
-        unmountOnExit
-        isSubtab={true}
-        activeKey={activeTabKey2}
-        aria-label="Entries tab"
-        component={TabsComponent.nav}
-        style={theme === DARK ? {} : { backgroundColor: t_global_background_color_100.value }}
-        onSelect={(event, tabIndex) => setActiveTabKey2(tabIndex)}
-      >
-        <Tab
-          eventKey={10}
-          title={<TabTitleText>{t('caches.tabs.entries-manage')}</TabTitleText>}
-          data-cy="manageEntriesTab"
+      <QueryContextProvider>
+        <Tabs
+          unmountOnExit
+          isSubtab={true}
+          activeKey={activeTabKey2}
+          aria-label="Entries tab"
+          component={TabsComponent.nav}
+          style={theme === DARK ? {} : { backgroundColor: t_global_background_color_100.value }}
+          onSelect={(event, tabIndex) => setActiveTabKey2(tabIndex)}
         >
-          <CacheEntries />
-        </Tab>
-        <Tab eventKey={11} data-cy="queriesTab" title={<TabTitleText>{t('caches.tabs.query-values')}</TabTitleText>}>
-          <QueryEntries cacheName={cacheName} changeTab={() => setActiveTabKey1(2)} />
-        </Tab>
-      </Tabs>
+          <Tab
+            eventKey={10}
+            title={<TabTitleText>{t('caches.tabs.entries-manage')}</TabTitleText>}
+            data-cy="manageEntriesTab"
+          >
+            <CacheEntries />
+          </Tab>
+          <Tab eventKey={11} data-cy="queriesTab" title={<TabTitleText>{t('caches.tabs.query-values')}</TabTitleText>}>
+            <QueryEntries cacheName={cacheName} changeTab={() => setActiveTabKey1(2)} />
+          </Tab>
+          <Tab
+            eventKey={12}
+            data-cy="queryHistoryTab"
+            title={<TabTitleText>{t('caches.tabs.query-history')}</TabTitleText>}
+          >
+            <QueryHistory
+              cacheName={cacheName}
+              changeTab={() => {
+                setActiveTabKey2(11);
+              }}
+            />
+          </Tab>
+        </Tabs>
+      </QueryContextProvider>
     );
   };
 
diff --git a/src/app/Caches/Query/DeleteByQueryEntries.tsx b/src/app/Caches/Query/DeleteByQueryEntries.tsx
index 310e3ae6..76b3bf81 100644
--- a/src/app/Caches/Query/DeleteByQueryEntries.tsx
+++ b/src/app/Caches/Query/DeleteByQueryEntries.tsx
@@ -1,8 +1,7 @@
 import React from 'react';
 import { Button, ButtonVariant, Content, Modal, ModalBody, ModalFooter, ModalHeader } from '@patternfly/react-core';
-import { useApiAlert } from '@app/utils/useApiAlert';
 import { useTranslation } from 'react-i18next';
-import { ConsoleServices } from '@services/ConsoleServices';
+import { useDeleteByQuery } from '@app/services/searchHook';
 
 const DeleteByQueryEntries = (props: {
   cacheName: string;
@@ -10,22 +9,8 @@ const DeleteByQueryEntries = (props: {
   isModalOpen: boolean;
   closeModal: () => void;
 }) => {
-  const { addAlert } = useApiAlert();
   const { t } = useTranslation();
-
-  const onClickOnDeleteByQuery = () => {
-    const match = props.query.match(/FROM\s+.+$/i);
-    if (match) {
-      ConsoleServices.search()
-        .deleteByQuery(props.cacheName, `DELETE ${match[0]}`, t('caches.query.modal-action-entries-success'))
-        .then((actionResponse) => {
-          addAlert(actionResponse);
-        })
-        .finally(props.closeModal);
-    } else {
-      props.closeModal();
-    }
-  };
+  const { setExecute } = useDeleteByQuery(props.cacheName, props.query, props.closeModal);
 
   return (
     <Modal
@@ -37,12 +22,14 @@ const DeleteByQueryEntries = (props: {
       <ModalHeader titleIconVariant={'warning'} title={t('caches.query.modal-delete-entries-title')} />
       <ModalBody>
         <Content component={'p'}>
-          {t('caches.query.modal-delete-entries-body-line-one', { cacheName: props.cacheName })}
+          {t('caches.query.modal-delete-entries-body-line-one', {
+            cacheName: props.cacheName
+          })}
         </Content>
         <Content component={'p'}>{t('caches.query.modal-delete-entries-body-line-two')}</Content>
       </ModalBody>
       <ModalFooter>
-        <Button data-cy="deleteButton" key="confirm" variant={ButtonVariant.danger} onClick={onClickOnDeleteByQuery}>
+        <Button data-cy="deleteButton" key="confirm" variant={ButtonVariant.danger} onClick={() => setExecute(true)}>
           {t('common.actions.delete')}
         </Button>
         <Button data-cy="cancelButton" key="cancel" variant="link" onClick={props.closeModal}>
diff --git a/src/app/Caches/Query/QueryEntries.tsx b/src/app/Caches/Query/QueryEntries.tsx
index 838798f0..bc1a8457 100644
--- a/src/app/Caches/Query/QueryEntries.tsx
+++ b/src/app/Caches/Query/QueryEntries.tsx
@@ -5,40 +5,40 @@ import {
   Card,
   CardBody,
   Checkbox,
-  Divider,
+  Content,
   EmptyState,
   EmptyStateBody,
   EmptyStateVariant,
+  Flex,
+  FlexItem,
+  Grid,
+  GridItem,
   Pagination,
-  Popover,
-  SearchInput,
   Spinner,
   Toolbar,
   ToolbarContent,
   ToolbarItem
 } from '@patternfly/react-core';
-import { ExternalLinkSquareAltIcon, HelpIcon, SearchIcon } from '@patternfly/react-icons';
-import displayUtils from '../../../services/displayUtils';
+import { ExternalLinkSquareAltIcon, SearchIcon, TrashIcon } from '@patternfly/react-icons';
 import SyntaxHighlighter from 'react-syntax-highlighter';
 import { useTranslation } from 'react-i18next';
-import { Table, Tbody, Td, Th, Thead, Tr } from '@patternfly/react-table';
-import { t_global_spacer_md } from '@patternfly/react-tokens';
-import { ThemeContext } from '@app/providers/ThemeProvider';
+import { Table, Tbody, Td, Tr } from '@patternfly/react-table';
+import { DARK, ThemeContext } from '@app/providers/ThemeProvider';
 import { useSearch } from '@app/services/searchHook';
 import { DeleteByQueryEntries } from '@app/Caches/Query/DeleteByQueryEntries';
+import { CodeEditor, CodeEditorControl, Language } from '@patternfly/react-code-editor';
+import displayUtils from '@services/displayUtils';
 
 const QueryEntries = (props: { cacheName: string; changeTab: () => void }) => {
   const { t } = useTranslation();
   const brandname = t('brandname.brandname');
-  const { search, setSearch } = useSearch(props.cacheName);
-  const { syntaxHighLighterTheme } = useContext(ThemeContext);
+  const { search, onStoreQuery, storeResult, startSearch, clearSearch, onPerPageSelect, onSetPage } = useSearch(
+    props.cacheName
+  );
+  const { syntaxHighLighterTheme, theme } = useContext(ThemeContext);
   const [deleteByQueryOpen, setDeleteByQueryOpen] = useState(false);
   const [trim, setTrim] = useState<boolean>(false);
 
-  const columnNames = {
-    value: 'Value'
-  };
-
   const displayValue = (value: string) => {
     return (
       <SyntaxHighlighter
@@ -52,73 +52,15 @@ const QueryEntries = (props: { cacheName: string; changeTab: () => void }) => {
     );
   };
 
-  const onSearch = () => {
-    setSearch((prevState) => {
-      return { ...prevState, loading: true };
-    });
-  };
-
-  const onClear = () => {
-    setSearch((prevState) => {
-      return {
-        ...prevState,
-        query: '',
-        searchResult: {
-          total: 0,
-          values: [],
-          error: false,
-          cause: '',
-          executed: false
-        },
-        loading: false
-      };
-    });
-  };
-
-  const onChangeSearch = (value) => {
-    setSearch((prevState) => {
-      return { ...prevState, query: value };
-    });
+  const onChangeSearch = (value: string) => {
     if (value.length == 0) {
-      onClear();
+      clearSearch();
+    } else {
+      onStoreQuery(value);
+      storeResult({ total: 0, values: [], error: false, cause: '', executed: false });
     }
   };
 
-  const onSetPage = (_event, pageNumber) => {
-    setSearch((prevState) => {
-      return { ...prevState, page: pageNumber, loading: true };
-    });
-  };
-
-  const onPerPageSelect = (_event, perPage) => {
-    setSearch((prevState) => {
-      return { ...prevState, perPage: perPage, loading: true };
-    });
-  };
-
-  const buildButtons = () => {
-    return (
-      <React.Fragment>
-        <Divider orientation={{ default: 'vertical' }} inset={{ default: 'insetSm' }} />
-        <ToolbarItem>
-          <Button
-            variant={ButtonVariant.link}
-            onClick={() => setDeleteByQueryOpen(true)}
-            data-cy="deleteByQueryButton"
-            isDisabled={search.searchResult.total <= 0}
-          >
-            {t('caches.query.button-delete-entries')}
-          </Button>
-        </ToolbarItem>
-        <ToolbarItem>
-          <Button variant={ButtonVariant.secondary} onClick={() => props.changeTab()} data-cy="viewQueryMetricsButton">
-            {t('caches.query.view-all-query-stats')}
-          </Button>
-        </ToolbarItem>
-      </React.Fragment>
-    );
-  };
-
   const toolbarPagination = (dropDirection) => {
     return (
       <Pagination
@@ -136,50 +78,7 @@ const QueryEntries = (props: { cacheName: string; changeTab: () => void }) => {
   };
 
   const toolbar = (
-    <Toolbar id="cache-query-toolbar" style={{ paddingLeft: 0 }}>
-      <ToolbarContent>
-        <ToolbarItem>
-          <SearchInput
-            name="textSearchByQuery"
-            id="textSearchByQuery"
-            aria-label="Query textfield"
-            placeholder={t('caches.query.ickle-query')}
-            type="search"
-            submitSearchButtonLabel={'searchButton'}
-            style={{ width: '35rem' }}
-            onChange={(e, value) => onChangeSearch(value)}
-            onSearch={onSearch}
-            onClear={onClear}
-          />
-          <Popover
-            headerContent={t('caches.query.ickle-query')}
-            bodyContent={t('caches.query.ickle-query-tooltip', {
-              brandname: brandname
-            })}
-            footerContent={
-              <Button
-                variant={'link'}
-                style={{ paddingLeft: 0 }}
-                iconPosition={'start'}
-                icon={<ExternalLinkSquareAltIcon />}
-                onClick={() => window.open(t('brandname.ickle-query-docs-link'), '_blank')}
-              >
-                {t('caches.query.ickle-query-docs')}
-              </Button>
-            }
-          >
-            <Button
-              variant="plain"
-              aria-label={'more-info-ickle'}
-              onClick={(e) => e.preventDefault()}
-              aria-describedby={'helpickle'}
-              icon={<HelpIcon />}
-            />
-          </Popover>
-        </ToolbarItem>
-        {buildButtons()}
-        <ToolbarItem variant="pagination">{toolbarPagination('down')}</ToolbarItem>
-      </ToolbarContent>
+    <Toolbar id="cache-query-toolbar" style={{ paddingLeft: 0 }} isSticky>
       <ToolbarContent>
         <ToolbarItem>
           <Checkbox
@@ -189,6 +88,7 @@ const QueryEntries = (props: { cacheName: string; changeTab: () => void }) => {
             onClick={() => setTrim(!trim)}
           />
         </ToolbarItem>
+        <ToolbarItem variant="pagination">{toolbarPagination('down')}</ToolbarItem>
       </ToolbarContent>
     </Toolbar>
   );
@@ -229,11 +129,6 @@ const QueryEntries = (props: { cacheName: string; changeTab: () => void }) => {
     return (
       <React.Fragment>
         <Table data-cy="queryTable" className={'query-table'} aria-label={'query-table-label'} variant="compact">
-          <Thead>
-            <Tr>
-              <Th>{columnNames.value}</Th>
-            </Tr>
-          </Thead>
           <Tbody>
             {search.searchResult.values.length == 0 ? (
               <Tr>
@@ -243,7 +138,7 @@ const QueryEntries = (props: { cacheName: string; changeTab: () => void }) => {
               search.searchResult.values.map((row, index) => {
                 return (
                   <Tr key={index}>
-                    <Td dataLabel={columnNames.value}>{displayValue(row)}</Td>
+                    <Td dataLabel={'Value'}>{displayValue(row)}</Td>
                   </Tr>
                 );
               })
@@ -257,15 +152,117 @@ const QueryEntries = (props: { cacheName: string; changeTab: () => void }) => {
     );
   };
 
+  const customControl = (
+    <CodeEditorControl
+      icon={<SearchIcon />}
+      aria-label="Execute code"
+      tooltipProps={{ content: 'Execute code' }}
+      onClick={startSearch}
+      isVisible
+    />
+  );
+
+  const ickleHelp = (
+    <Content>
+      {' '}
+      {t('caches.query.ickle-query-tooltip', {
+        brandname: brandname
+      })}
+      <Content component={'p'}></Content>
+      <Content component={'small'}>
+        <code>FROM Entity</code>
+      </Content>
+      <Content component={'small'}>
+        <code>SELECT ... FROM Entity WHERE ...</code>
+      </Content>
+      <Content component={'small'}>
+        <code>DELETE FROM Entity</code>
+      </Content>
+    </Content>
+  );
+
+  const shortcutsPopoverProps = {
+    headerContent: t('caches.query.ickle-query'),
+    footerContent: (
+      <Button
+        variant={'link'}
+        style={{ paddingLeft: 0 }}
+        iconPosition={'start'}
+        icon={<ExternalLinkSquareAltIcon />}
+        onClick={() => window.open(t('brandname.ickle-query-docs-link'), '_blank')}
+      >
+        {t('caches.query.ickle-query-docs')}
+      </Button>
+    ),
+    bodyContent: ickleHelp
+  };
+
   return (
     <Card isPlain isFullHeight>
       <CardBody>
+        <Grid hasGutter>
+          <GridItem span={9}>
+            <CodeEditor
+              headerMainContent={brandname + ' Ickle Query Language'}
+              name="textSearchByQuery"
+              id="textSearchByQuery"
+              isLineNumbersVisible
+              isLanguageLabelVisible={false}
+              language={Language.sql}
+              code={search.query}
+              onChange={(value, event) => onChangeSearch(value)}
+              isFullHeight
+              height={'sizeToFit'}
+              isDarkTheme={theme === DARK}
+              shortcutsPopoverButtonText={''}
+              shortcutsPopoverProps={shortcutsPopoverProps}
+            />
+          </GridItem>
+          <GridItem span={3}>
+            <Flex direction={{ default: 'column' }} spaceItems={{ default: 'spaceItemsXs' }}>
+              <FlexItem>
+                <Button
+                  variant={ButtonVariant.primary}
+                  size={'sm'}
+                  onClick={startSearch}
+                  data-cy="searchButton"
+                  icon={<SearchIcon />}
+                  isDisabled={search.query.trim().length == 0 || search.query.toLowerCase().startsWith('delete')}
+                >
+                  {'Search values'}
+                </Button>
+              </FlexItem>
+              <FlexItem>
+                <Button
+                  variant={ButtonVariant.secondary}
+                  isDanger
+                  onClick={() => setDeleteByQueryOpen(true)}
+                  data-cy="deleteByQueryButton"
+                  icon={<TrashIcon />}
+                  isDisabled={search.query.trim().length == 0 || !search.query.toLowerCase().startsWith('delete')}
+                  size={'sm'}
+                >
+                  {t('caches.query.button-delete-entries')}
+                </Button>
+              </FlexItem>
+              <FlexItem>
+                <Button
+                  variant={ButtonVariant.link}
+                  onClick={() => props.changeTab()}
+                  data-cy="viewQueryMetricsButton"
+                  size={'sm'}
+                >
+                  {t('caches.query.view-all-query-stats')}
+                </Button>
+              </FlexItem>
+            </Flex>
+          </GridItem>
+        </Grid>
         {toolbar}
         {displayContent()}
         <DeleteByQueryEntries
           isModalOpen={deleteByQueryOpen}
           closeModal={() => {
-            onSearch();
             setDeleteByQueryOpen(false);
           }}
           cacheName={props.cacheName}
diff --git a/src/app/Caches/Query/QueryHistory.tsx b/src/app/Caches/Query/QueryHistory.tsx
new file mode 100644
index 00000000..6981cbf9
--- /dev/null
+++ b/src/app/Caches/Query/QueryHistory.tsx
@@ -0,0 +1,292 @@
+import React, { useContext, useMemo, useState } from 'react';
+import {
+  Alert,
+  Button,
+  ButtonVariant,
+  Card,
+  CardBody,
+  Divider,
+  EmptyState,
+  EmptyStateBody,
+  Label,
+  Pagination,
+  Toolbar,
+  ToolbarContent,
+  ToolbarItem
+} from '@patternfly/react-core';
+import { useTranslation } from 'react-i18next';
+import { ActionsColumn, ExpandableRowContent, Table, Tbody, Td, Th, Thead, Tr } from '@patternfly/react-table';
+import { useLocalStorage } from '@utils/localStorage';
+import { ThemeContext } from '@app/providers/ThemeProvider';
+import SyntaxHighlighter from 'react-syntax-highlighter';
+import { useSearch } from '@app/services/searchHook';
+import displayUtils from '@services/displayUtils';
+import { ContentType } from '@services/infinispanRefData';
+import { FlagIcon } from '@patternfly/react-icons';
+
+const QueryHistory = (props: { cacheName: string; changeTab: () => void }) => {
+  const { t } = useTranslation();
+  const { syntaxHighLighterTheme } = useContext(ThemeContext);
+  const { onStoreQuery } = useSearch(props.cacheName);
+  const [history, setHistory] = useLocalStorage<HistoryMap>('cache-query-history', {});
+  const currentHistory = useMemo(() => history[props.cacheName] || [], [history, props.cacheName]);
+  const [expandedQueries, setExpandedQueries] = useState<string[]>([]);
+  const [queryHistoryPagination, setQueryHistoryPagination] = useLocalStorage('query-history-table', {
+    page: 1,
+    perPage: 10
+  });
+
+  const onSetPage = (_event, pageNumber) => {
+    setQueryHistoryPagination({
+      ...queryHistoryPagination,
+      page: pageNumber
+    });
+  };
+
+  const onPerPageSelect = (_event, perPage) => {
+    setQueryHistoryPagination({
+      page: 1,
+      perPage: perPage
+    });
+  };
+
+  const columnNames = {
+    query: t('caches.query.history.query'),
+    total: t('caches.query.history.total'),
+    execution: t('caches.query.history.execution')
+  };
+
+  const emptySearchMessage = (
+    <EmptyState>
+      <EmptyStateBody>{t('caches.query.history.empty')}</EmptyStateBody>
+    </EmptyState>
+  );
+
+  const toolbarPagination = (dropDirection) => {
+    return (
+      <Pagination
+        data-cy="queryHistoryPaginationArea"
+        itemCount={currentHistory.length}
+        perPage={queryHistoryPagination.perPage}
+        page={queryHistoryPagination.page}
+        onSetPage={onSetPage}
+        widgetId="pagination-query-history"
+        onPerPageSelect={onPerPageSelect}
+        isCompact
+        dropDirection={dropDirection}
+      />
+    );
+  };
+
+  const getSlice = () => {
+    return (queryHistoryPagination.page - 1) * queryHistoryPagination.perPage;
+  };
+
+  const toolbar = (
+    <Toolbar id="cache-query-history-toolbar" style={{ paddingLeft: 0 }}>
+      <ToolbarContent>
+        <ToolbarItem>
+          <Button
+            variant={ButtonVariant.danger}
+            size={'sm'}
+            onClick={() =>
+              setHistory({
+                ...history,
+                [props.cacheName]: []
+              })
+            }
+            data-cy="removeAllQueryHistory"
+          >
+            {t('caches.query.history.clear')}
+          </Button>
+        </ToolbarItem>
+        <ToolbarItem variant="pagination">{toolbarPagination('down')}</ToolbarItem>
+      </ToolbarContent>
+    </Toolbar>
+  );
+
+  const deleteHistoryItem = (query: string) => {
+    setHistory({
+      ...history,
+      [props.cacheName]: currentHistory.filter((item) => item.query !== query)
+    });
+  };
+
+  const executeQuery = (query: string) => {
+    props.changeTab();
+    onStoreQuery(query);
+  };
+
+  const actions = (query: string) => {
+    return [
+      {
+        'aria-label': 'executeQueryHistoryItem',
+        title: t('caches.query.history.execute'),
+        onClick: () => executeQuery(query)
+      },
+      {
+        'aria-label': 'deleteQueryHistoryItem',
+        title: t('caches.query.history.delete'),
+        onClick: () => deleteHistoryItem(query)
+      }
+    ];
+  };
+
+  const isQueryExpanded = (query: string) => expandedQueries.includes(query);
+  const toggleQueryExpanded = (query: string) => {
+    setExpandedQueries((prev) => (prev.includes(query) ? prev.filter((q) => q !== query) : [...prev, query]));
+  };
+  const isQueryLong = (query: string) => query.length > 100;
+  const isExpandable = (historyItem: QueryHistoryItem) => isQueryLong(historyItem.query) || historyItem.error;
+
+  const historyTypeColor = (queryType: 'Search' | 'Delete' | 'Vector') => {
+    if (queryType == 'Vector') {
+      return 'purple';
+    }
+
+    if (queryType == 'Delete') {
+      return 'red';
+    }
+
+    return 'blue';
+  };
+
+  const displayError = (historyItem: QueryHistoryItem) => {
+    if (!historyItem.error) {
+      return <></>;
+    }
+
+    return (
+      <Alert title={t('caches.query.history.error-detail')} variant={'danger'} isInline isPlain>
+        {historyItem.cause}
+      </Alert>
+    );
+  };
+  const displayContent = () => {
+    return (
+      <React.Fragment>
+        <Table
+          hasAnimations
+          isExpandable
+          data-cy="queryHistoryTable"
+          className={'query-history-table'}
+          aria-label={'query-history-table-label'}
+          variant="compact"
+        >
+          <Thead>
+            <Tr>
+              <Th screenReaderText="Row expansion" />
+              <Th colSpan={1}>{columnNames.query}</Th>
+              <Th colSpan={1}>{columnNames.total}</Th>
+              <Th colSpan={1}>{columnNames.execution}</Th>
+            </Tr>
+          </Thead>
+          {currentHistory.length == 0 ? (
+            <Tbody>
+              <Tr>
+                <Td>{emptySearchMessage}</Td>
+              </Tr>
+            </Tbody>
+          ) : (
+            currentHistory.slice(getSlice(), getSlice() + queryHistoryPagination.perPage).map((historyItem, index) => {
+              const longQuery = isQueryLong(historyItem.query);
+              const expandable = isExpandable(historyItem);
+              const expanded = isQueryExpanded(historyItem.query);
+              const truncatedQuery = displayUtils.formatContentToDisplayWithTruncate(
+                historyItem.query,
+                ContentType.string
+              );
+              return (
+                <Tbody key={index} isExpanded={expandable && expanded}>
+                  <Tr>
+                    <Td
+                      expand={
+                        expandable
+                          ? {
+                              rowIndex: index,
+                              isExpanded: expanded,
+                              onToggle: () => toggleQueryExpanded(historyItem.query),
+                              expandId: index + '-expandable-query'
+                            }
+                          : undefined
+                      }
+                    />
+                    <Td dataLabel={columnNames.query}>
+                      <SyntaxHighlighter
+                        wrapLines={true}
+                        wrapLongLines={true}
+                        lineProps={{
+                          style: {
+                            wordBreak: 'break-all',
+                            whiteSpace: 'pre-wrap'
+                          }
+                        }}
+                        style={syntaxHighLighterTheme}
+                        useInlineStyles={true}
+                      >
+                        {longQuery ? truncatedQuery : historyItem.query}
+                      </SyntaxHighlighter>
+                      <Label isCompact color={historyTypeColor(historyItem.type)}>
+                        {historyItem.type}
+                      </Label>
+                      {historyItem.error && (
+                        <Label isCompact variant={'outline'} status={'danger'} style={{ marginLeft: '0.5rem' }}>
+                          {t('caches.query.history.error')}
+                        </Label>
+                      )}
+                    </Td>
+                    <Td dataLabel={columnNames.total}>{historyItem.total}</Td>
+                    <Td dataLabel={columnNames.execution}>{historyItem.milliseconds}</Td>
+                    <Td isActionCell data-cy={`actions-${index}`}>
+                      <ActionsColumn items={actions(historyItem.query)} />
+                    </Td>
+                  </Tr>
+                  {expandable && (
+                    <Tr isExpanded={expanded}>
+                      <Td />
+                      <Td colSpan={4}>
+                        <ExpandableRowContent>
+                          {longQuery && (
+                            <SyntaxHighlighter
+                              wrapLines={true}
+                              wrapLongLines={true}
+                              lineProps={{
+                                style: {
+                                  wordBreak: 'break-all',
+                                  whiteSpace: 'pre-wrap'
+                                }
+                              }}
+                              style={syntaxHighLighterTheme}
+                              useInlineStyles={true}
+                            >
+                              {historyItem.query}
+                            </SyntaxHighlighter>
+                          )}
+                          {displayError(historyItem)}
+                        </ExpandableRowContent>
+                      </Td>
+                    </Tr>
+                  )}
+                </Tbody>
+              );
+            })
+          )}
+        </Table>
+        <Toolbar id="query-history-table-toolbar" className={'query-history-table-display'}>
+          <ToolbarItem variant="pagination">{toolbarPagination('up')}</ToolbarItem>
+        </Toolbar>
+      </React.Fragment>
+    );
+  };
+
+  return (
+    <Card isPlain isFullHeight>
+      <CardBody>
+        {toolbar}
+        {displayContent()}
+      </CardBody>
+    </Card>
+  );
+};
+
+export { QueryHistory };
diff --git a/src/app/assets/languages/en.json b/src/app/assets/languages/en.json
index bd99c375..579cdf29 100644
--- a/src/app/assets/languages/en.json
+++ b/src/app/assets/languages/en.json
@@ -593,7 +593,8 @@
       "metrics-enabled": "Metrics (Enabled)",
       "metrics-disabled": "Metrics (Not enabled)",
       "entries-manage": "Manage entries",
-      "query-values": "Query values"
+      "query-values": "Query values",
+      "query-history": "Query history"
     },
     "info": {
       "breadcrumb": "Detail of cache {{cacheName}}",
@@ -699,7 +700,7 @@
       "query-error": "Query error",
       "ickle-query": "Ickle query",
       "ickle-query-docs": "Ickle query syntax",
-      "ickle-query-tooltip": "{{brandname}} provides an Ickle query language that lets you create relational and full-text queries.",
+      "ickle-query-tooltip": "{{brandname}} provides an Ickle query language that lets you create relational and full-text queries",
       "view-all-query-stats": "View all query statistics",
       "query-metrics-title": "Query metrics",
       "query-metrics-tooltip": "Average time, in nanoseconds, for queries on this cache.",
@@ -718,7 +719,18 @@
       "modal-delete-entries-title": "Permanently delete matching entries?",
       "modal-delete-entries-body-line-one": "This action will permanently delete all the mathing entries in {{cacheName}}, executing a 'DELETE' Ickle Query statement.",
       "modal-delete-entries-body-line-two": "This cannot be undone. You can always create the entries again.",
-      "modal-action-entries-success": "Delete by query successfully executed."
+      "modal-action-entries-success": "Delete by query successfully executed.",
+      "history": {
+        "clear": "Clear history",
+        "execute": "Execute",
+        "delete": "Delete",
+        "empty": "Query history is empty.",
+        "query": "Query",
+        "total": "Total",
+        "execution": "Execution",
+        "error": "Error",
+        "error-detail": "Error detail"
+      }
     },
     "index": {
       "title": "Index management",
diff --git a/src/app/providers/QueryContextProvider.tsx b/src/app/providers/QueryContextProvider.tsx
new file mode 100644
index 00000000..12d624d3
--- /dev/null
+++ b/src/app/providers/QueryContextProvider.tsx
@@ -0,0 +1,105 @@
+import React, { useCallback, useState } from 'react';
+
+const initialContext = {
+  search: {
+    page: 1,
+    perPage: 10,
+    searchResult: {
+      total: 0,
+      values: [],
+      error: false,
+      cause: '',
+      executed: false
+    } as SearchResult,
+    loading: false,
+    query: ''
+  },
+  storeResult: (result: SearchResult) => {},
+  execute: (query: string) => {},
+  startSearch: () => {},
+  endSearch: () => {},
+  clearSearch: () => {},
+  onSetPage: (_event: any, pageNumber: number) => {},
+  onPerPageSelect: (_event: any, pageNumber: number) => {},
+  onStoreQuery: (query: string) => {}
+};
+
+export const QueryContext = React.createContext(initialContext);
+
+const QueryContextProvider = ({ children }) => {
+  const [search, setSearch] = useState(initialContext.search);
+
+  const onStoreQuery = (query: string) => {
+    setSearch((prevState) => {
+      return { ...prevState, query: query };
+    });
+  };
+
+  const executeQuery = (query: string) => {
+    setSearch((prevState) => {
+      return { ...prevState, query: query, loading: true };
+    });
+  };
+
+  const onSetPage = (_event: any, pageNumber: number) => {
+    setSearch((prevState) => {
+      return { ...prevState, page: pageNumber, loading: true };
+    });
+  };
+
+  const onPerPageSelect = (_event: any, perPage: number) => {
+    setSearch((prevState) => {
+      return { ...prevState, perPage: perPage, loading: true };
+    });
+  };
+
+  const clearSearch = () => {
+    setSearch((prevState) => {
+      return {
+        ...prevState,
+        query: '',
+        searchResult: {
+          total: 0,
+          values: [],
+          error: false,
+          cause: '',
+          executed: false
+        },
+        loading: false
+      };
+    });
+  };
+
+  const storeResult = (searchResult: SearchResult) => {
+    setSearch((prevState) => {
+      return { ...prevState, searchResult: searchResult };
+    });
+  };
+
+  const startSearch = () => {
+    setSearch((prevState) => {
+      return { ...prevState, loading: true };
+    });
+  };
+
+  const endSearch = () => {
+    setSearch((prevState) => {
+      return { ...prevState, loading: false };
+    });
+  };
+
+  const contextValue = {
+    search: search,
+    execute: useCallback(executeQuery, []),
+    storeResult: useCallback(storeResult, []),
+    startSearch: useCallback(startSearch, []),
+    endSearch: useCallback(endSearch, []),
+    clearSearch: useCallback(clearSearch, []),
+    onSetPage: useCallback(onSetPage, []),
+    onPerPageSelect: useCallback(onPerPageSelect, []),
+    onStoreQuery: useCallback(onStoreQuery, [])
+  };
+  return <QueryContext.Provider value={contextValue}>{children}</QueryContext.Provider>;
+};
+
+export { QueryContextProvider };
diff --git a/src/app/services/searchHook.ts b/src/app/services/searchHook.ts
index 6d2fd8c6..3ed0a7db 100644
--- a/src/app/services/searchHook.ts
+++ b/src/app/services/searchHook.ts
@@ -1,39 +1,100 @@
-import { useEffect, useState } from 'react';
+import { useContext, useEffect, useMemo, useState } from 'react';
 import { ConsoleServices } from '@services/ConsoleServices';
+import { useLocalStorage } from '@utils/localStorage';
+import { convertToTimeQuantity } from '@utils/convertToTimeQuantity';
+import { useApiAlert } from '@utils/useApiAlert';
+import { useTranslation } from 'react-i18next';
+import { UserContext } from '@app/providers/UserContextProvider';
+import { QueryContext } from '@app/providers/QueryContextProvider';
 
 export function useSearch(cacheName: string) {
-  const [search, setSearch] = useState({
-    page: 1,
-    perPage: 10,
-    searchResult: <SearchResult>{
-      total: 0,
-      values: [],
-      error: false,
-      cause: '',
-      executed: false
-    },
-    loading: false,
-    query: ''
-  });
+  const [history, setHistory] = useLocalStorage<HistoryMap>('cache-query-history', {});
+  const currentHistory = useMemo(() => history[cacheName] || [], [history, cacheName]);
+  const { search, storeResult, startSearch, endSearch, clearSearch, onPerPageSelect, onSetPage, onStoreQuery } =
+    useContext(QueryContext);
 
   useEffect(() => {
     if (search.loading && search.query.length > 0) {
+      const start: number = Date.now();
       ConsoleServices.search()
         .searchValues(cacheName, search.query, search.perPage, search.page - 1)
         .then((searchResult) => {
-          setSearch((prevState) => {
-            return { ...prevState, searchResult: searchResult };
+          storeResult(searchResult);
+          const end: number = Date.now();
+          const historyItem = <QueryHistoryItem>{
+            query: search.query,
+            total: searchResult.total,
+            error: searchResult.error,
+            cause: searchResult.cause,
+            milliseconds: convertToTimeQuantity(end - start),
+            type: search.query.includes('<->') ? 'Vector' : 'Search'
+          };
+          const newHistory = [historyItem, ...currentHistory.filter((i) => i.query !== search.query)].slice(0, 50);
+          setHistory({
+            ...history,
+            [cacheName]: newHistory
           });
         })
-        .then(() =>
-          setSearch((prevState) => {
-            return { ...prevState, loading: false };
-          })
-        );
+        .finally(() => endSearch());
     }
   }, [search]);
 
-  return { search, setSearch };
+  return {
+    search,
+    startSearch,
+    storeResult,
+    clearSearch,
+    onPerPageSelect,
+    onSetPage,
+    onStoreQuery
+  };
+}
+
+export function useDeleteByQuery(cacheName: string, deleteQuery: string, finalAction: () => void) {
+  const [history, setHistory] = useLocalStorage<HistoryMap>('cache-query-history', {});
+  const currentHistory = useMemo(() => history[cacheName] || [], [history, cacheName]);
+
+  const { addAlert } = useApiAlert();
+  const { t } = useTranslation();
+  const [execute, setExecute] = useState(false);
+
+  useEffect(() => {
+    if (execute) {
+      setExecute(false);
+      const start: number = Date.now();
+      ConsoleServices.search()
+        .deleteByQuery(cacheName, deleteQuery)
+        .then((either) => {
+          if (either.isRight()) {
+            // Add success alert
+            addAlert({
+              message: t('caches.query.modal-action-entries-success'),
+              success: true
+            });
+          } else {
+            addAlert(either.value);
+          }
+          // Handle History
+          const end: number = Date.now();
+          const historyItem = <QueryHistoryItem>{
+            query: deleteQuery,
+            total: either.isRight() ? either.value.hit_count : 0,
+            error: either.isLeft(),
+            cause: either.isLeft() ? either.value.message : '',
+            milliseconds: convertToTimeQuantity(end - start),
+            type: 'Delete'
+          };
+          const newHistory = [historyItem, ...currentHistory.filter((i) => i.query !== deleteQuery)].slice(0, 50);
+          setHistory({
+            ...history,
+            [cacheName]: newHistory
+          });
+        })
+        .finally(finalAction);
+    }
+  }, [execute]);
+
+  return { setExecute };
 }
 
 export function useIndexMetamodel(cacheName: string) {
diff --git a/src/app/utils/localStorage.ts b/src/app/utils/localStorage.ts
index f09fb131..dd8e837f 100644
--- a/src/app/utils/localStorage.ts
+++ b/src/app/utils/localStorage.ts
@@ -1,4 +1,4 @@
-import { useState, useEffect } from 'react';
+import { useState } from 'react';
 
 export function useLocalStorage<T>(key: string, initialValue: T): [T, (value: T) => void] {
   // Get initial value from local storage or use provided default
diff --git a/src/services/searchService.ts b/src/services/searchService.ts
index 6d7a61ef..c2fc4759 100644
--- a/src/services/searchService.ts
+++ b/src/services/searchService.ts
@@ -86,36 +86,34 @@ export class SearchService {
    * @param cacheName
    * @param query
    */
-  public async deleteByQuery(cacheName: string, query: string, message: string): Promise<ActionResponse> {
+  public async deleteByQuery(cacheName: string, query: string): Promise<Either<ActionResponse, DeleteByQueryResult>> {
     const url = this.endpoint + encodeURIComponent(cacheName) + '?action=deleteByQuery';
     const body = JSON.stringify({
       query: query
     });
+    // @ts-ignore
     return this.utils
       .fetch(url, 'POST', undefined, body)
       .then((response) => {
-        if (response.ok || response.status == 400) {
-          // Ok or bad request
-          return response.json();
+        if (response.ok) {
+          return response.json().then((data) =>
+            right(<DeleteByQueryResult>{
+              hit_count: data.hit_count,
+              hit_count_exact: data.hit_count_exact
+            })
+          );
         }
 
-        return response.text().then((text) => {
-          throw text;
+        return response.json().then((data) => {
+          const message = data.error?.cause || data.error?.message || response.statusText;
+          throw message;
         });
       })
-      .then(
-        () =>
-          <ActionResponse>{
-            message: message,
-            success: true
-          }
-      )
-      .catch(
-        (err) =>
-          <ActionResponse>{
-            message: err as string,
-            success: false
-          }
+      .catch((err) =>
+        left(<ActionResponse>{
+          message: err as string,
+          success: false
+        })
       );
   }
 
diff --git a/src/types/InfinispanTypes.ts b/src/types/InfinispanTypes.ts
index d97a645f..b016ec5f 100644
--- a/src/types/InfinispanTypes.ts
+++ b/src/types/InfinispanTypes.ts
@@ -224,6 +224,11 @@ interface SearchResult {
   executed: boolean;
 }
 
+interface DeleteByQueryResult {
+  hit_count: number;
+  hit_count_exact: number;
+}
+
 interface ProtoError {
   message: string;
   cause: string;
@@ -566,3 +571,14 @@ interface EditableConfig {
   tracingEnabled: boolean;
   tracingCategories: string[];
 }
+
+interface QueryHistoryItem {
+  query: string;
+  total: number;
+  milliseconds: string;
+  error: boolean;
+  cause: string;
+  type: 'Search' | 'Delete' | 'Vector';
+}
+
+type HistoryMap = Record<string, QueryHistoryItem[]>;