diff --git a/src/components/experimental/duo/chat/components/duo_chat_context/duo_chat_context_item_menu/duo_chat_context_item_menu.spec.js b/src/components/experimental/duo/chat/components/duo_chat_context/duo_chat_context_item_menu/duo_chat_context_item_menu.spec.js
index 5079c3a2d22710afb553010fca2864617726af53..9e3633e5319347e5835ee63c4481e919e8dc955e 100644
--- a/src/components/experimental/duo/chat/components/duo_chat_context/duo_chat_context_item_menu/duo_chat_context_item_menu.spec.js
+++ b/src/components/experimental/duo/chat/components/duo_chat_context/duo_chat_context_item_menu/duo_chat_context_item_menu.spec.js
@@ -7,6 +7,7 @@ import {
 } from '../constants';
 import GlDuoChatContextItemSelections from '../duo_chat_context_item_selections/duo_chat_context_item_selections.vue';
 import GlDuoChatContextItemMenuCategoryItems from './duo_chat_context_item_menu_category_items.vue';
+import GlDuoChatContextItemMenuSearchItems from './duo_chat_context_item_menu_search_items.vue';
 import GlDuoChatContextItemMenu from './duo_chat_context_item_menu.vue';
 
 jest.mock('lodash/debounce', () => jest.fn((fn) => fn));
@@ -34,7 +35,7 @@ describe('GlDuoChatContextItemMenu', () => {
   const findMenu = () => findByTestId('context-item-menu');
   const findContextItemSelections = () => wrapper.findComponent(GlDuoChatContextItemSelections);
   const findCategoryItems = () => wrapper.findComponent(GlDuoChatContextItemMenuCategoryItems);
-  const findResultItems = () => findByTestId('context-menu-search-items');
+  const findSearchItems = () => wrapper.findComponent(GlDuoChatContextItemMenuSearchItems);
 
   describe('context item selection', () => {
     describe('and there are selections', () => {
@@ -113,37 +114,52 @@ describe('GlDuoChatContextItemMenu', () => {
       });
 
       it('shows search result items', () => {
-        expect(findResultItems().exists()).toBe(true);
+        expect(findSearchItems().props()).toEqual({
+          activeIndex: 0,
+          category,
+          error: null,
+          loading: false,
+          results,
+          searchQuery: '',
+        });
       });
 
       it('selects the item when clicked', async () => {
-        await findResultItems().find('li').trigger('click');
+        await findSearchItems().vm.$emit('select', results.at(0));
         expect(wrapper.emitted('select').at(0)).toEqual([results.at(0)]);
       });
 
       it('emits "close" event when selecting an item', async () => {
-        await findResultItems().find('li').trigger('click');
+        await findSearchItems().vm.$emit('select', results.at(0));
         expect(wrapper.emitted('close')).toHaveLength(1);
       });
 
       it('does not select a disabled item when clicked', async () => {
-        const item = findResultItems()
-          .findAll('li')
-          .wrappers.find((i) => i.text().includes(results.at(1).metadata.name));
-        await item.trigger('click');
-
+        await findSearchItems().vm.$emit('select', results.at(1));
         expect(wrapper.emitted('select')).toBeUndefined();
       });
 
       describe('when searching', () => {
+        const query = 'e';
         beforeEach(async () => {
+          await findSearchItems().vm.$emit('update:searchQuery', query);
+
           await wrapper.setProps({
             loading: true,
           });
         });
 
+        it('emits search event', async () => {
+          expect(wrapper.emitted('search').at(1)).toEqual([
+            {
+              category: categoryValue,
+              query,
+            },
+          ]);
+        });
+
         it('shows loading state', async () => {
-          expect(wrapper.text()).toContain('Loading...');
+          expect(findSearchItems().props('loading')).toBe(true);
         });
 
         describe('when there is an error', () => {
@@ -155,7 +171,7 @@ describe('GlDuoChatContextItemMenu', () => {
           });
 
           it('shows error state', async () => {
-            expect(wrapper.text()).toContain('Error: oh no');
+            expect(findSearchItems().props('error')).toBe('oh no');
           });
         });
 
@@ -171,8 +187,7 @@ describe('GlDuoChatContextItemMenu', () => {
           });
 
           it('shows matching results', async () => {
-            expect(findResultItems().findAll('li')).toHaveLength(1);
-            expect(findResultItems().text()).toContain(matchingResult.metadata.name);
+            expect(findSearchItems().props('results')).toEqual([matchingResult]);
           });
         });
       });
diff --git a/src/components/experimental/duo/chat/components/duo_chat_context/duo_chat_context_item_menu/duo_chat_context_item_menu.vue b/src/components/experimental/duo/chat/components/duo_chat_context/duo_chat_context_item_menu/duo_chat_context_item_menu.vue
index 197a314b8ccccb21b7479773e8e7424e7b677e4b..e2c4043f3f8b87a7079dfd0155b208881da9466b 100644
--- a/src/components/experimental/duo/chat/components/duo_chat_context/duo_chat_context_item_menu/duo_chat_context_item_menu.vue
+++ b/src/components/experimental/duo/chat/components/duo_chat_context/duo_chat_context_item_menu/duo_chat_context_item_menu.vue
@@ -1,15 +1,20 @@
 <script>
+import debounce from 'lodash/debounce';
 import { translate } from '../../../../../../../utils/i18n';
 import GlCard from '../../../../../../base/card/card.vue';
 import { categoriesValidator, contextItemsValidator } from '../utils';
 import GlDuoChatContextItemSelections from '../duo_chat_context_item_selections/duo_chat_context_item_selections.vue';
 import GlDuoChatContextItemMenuCategoryItems from './duo_chat_context_item_menu_category_items.vue';
+import GlDuoChatContextItemMenuSearchItems from './duo_chat_context_item_menu_search_items.vue';
+
+const SEARCH_DEBOUNCE_MS = 30;
 
 export default {
   name: 'GlDuoChatContextItemMenu',
   components: {
     GlCard,
     GlDuoChatContextItemMenuCategoryItems,
+    GlDuoChatContextItemMenuSearchItems,
     GlDuoChatContextItemSelections,
   },
   props: {
@@ -63,6 +68,7 @@ export default {
   data() {
     return {
       activeIndex: 0,
+      searchQuery: '',
       selectedCategory: null,
     };
   },
@@ -77,11 +83,15 @@ export default {
         this.resetSelection();
       }
     },
+    searchQuery(query) {
+      this.debouncedSearch(query);
+    },
   },
   methods: {
     selectCategory(category) {
-      this.selectedCategory = category;
       this.activeIndex = 0;
+      this.searchQuery = '';
+      this.selectedCategory = category;
 
       /**
        * Emitted when a search should be performed.
@@ -121,6 +131,12 @@ export default {
        */
       this.$emit('remove', item);
     },
+    debouncedSearch: debounce(function search(query) {
+      this.$emit('search', {
+        category: this.selectedCategory.value,
+        query,
+      });
+    }, SEARCH_DEBOUNCE_MS),
     resetSelection() {
       this.selectedCategory = null;
       this.activeIndex = 0;
@@ -159,16 +175,17 @@ export default {
         @select="selectCategory"
         @active-index-change="activeIndex = $event"
       />
-      <div v-else data-testid="context-menu-search-items">
-        <!-- Placeholder for GlDuoChatContextItemMenuSearchItem component coming in a future iteration -->
-        <template v-if="loading">Loading...</template>
-        <template v-else-if="error">Error: {{ error }}</template>
-        <ul v-else>
-          <li v-for="result of results" :key="result.id" @click="selectItem(result)">
-            {{ result.metadata.name }} {{ result.isEnabled ? '' : '(disabled)' }}
-          </li>
-        </ul>
-      </div>
+      <gl-duo-chat-context-item-menu-search-items
+        v-else
+        v-model="searchQuery"
+        :active-index="activeIndex"
+        :category="selectedCategory"
+        :loading="loading"
+        :error="error"
+        :results="results"
+        @select="selectItem"
+        @active-index-change="activeIndex = $event"
+      />
     </gl-card>
   </div>
 </template>
diff --git a/src/components/experimental/duo/chat/components/duo_chat_context/duo_chat_context_item_menu/duo_chat_context_item_menu_search_items.spec.js b/src/components/experimental/duo/chat/components/duo_chat_context/duo_chat_context_item_menu/duo_chat_context_item_menu_search_items.spec.js
new file mode 100644
index 0000000000000000000000000000000000000000..00787560f12cfc56ea9c27704bf8e39e242a9f82
--- /dev/null
+++ b/src/components/experimental/duo/chat/components/duo_chat_context/duo_chat_context_item_menu/duo_chat_context_item_menu_search_items.spec.js
@@ -0,0 +1,242 @@
+import { shallowMount } from '@vue/test-utils';
+import { MOCK_CATEGORIES, getMockContextItems } from '../mock_context_data';
+import {
+  CONTEXT_ITEM_TYPE_ISSUE,
+  CONTEXT_ITEM_TYPE_MERGE_REQUEST,
+  CONTEXT_ITEM_TYPE_PROJECT_FILE,
+} from '../constants';
+import GlDuoChatContextItemMenuSearchItems from './duo_chat_context_item_menu_search_items.vue';
+import GlDuoChatContextItemMenuSearchItemsLoading from './duo_chat_context_item_menu_search_items_loading.vue';
+
+describe('GlDuoChatContextItemMenuSearchItems', () => {
+  let wrapper;
+  let category;
+  let results;
+
+  const createWrapper = (props = {}) => {
+    category = props.category || MOCK_CATEGORIES.at(0);
+    results = props.results || getMockContextItems().filter((item) => item.type === category.value);
+
+    wrapper = shallowMount(GlDuoChatContextItemMenuSearchItems, {
+      propsData: {
+        activeIndex: 0,
+        searchQuery: '',
+        category,
+        loading: false,
+        error: null,
+        results,
+        ...props,
+      },
+    });
+  };
+
+  const findByTestId = (testId) => wrapper.find(`[data-testid="${testId}"]`);
+  const findAllByTestId = (testId) => wrapper.findAll(`[data-testid="${testId}"]`);
+
+  const findSearchInput = () => findByTestId('context-menu-search-input');
+  const findLoadingIndicator = () =>
+    wrapper.findComponent(GlDuoChatContextItemMenuSearchItemsLoading);
+  const findLoadingError = () => findByTestId('search-results-error');
+  const findEmptyState = () => findByTestId('search-results-empty-state');
+  const findResultItems = () => findAllByTestId('search-result-item');
+  const findActiveItem = () => wrapper.find('.active-command');
+  const findActiveItemDetails = () =>
+    findActiveItem().find('[data-testid="search-result-item-details"]');
+
+  describe('default rendering', () => {
+    beforeEach(() => createWrapper());
+
+    it('renders the search input', () => {
+      expect(findSearchInput().exists()).toBe(true);
+    });
+
+    it('does not render the loading state', () => {
+      expect(findLoadingIndicator().exists()).toBe(false);
+    });
+
+    it('does not render the error state', () => {
+      expect(findLoadingError().exists()).toBe(false);
+    });
+
+    it('does not render the empty state', () => {
+      expect(findEmptyState().exists()).toBe(false);
+    });
+  });
+
+  describe('when searching', () => {
+    const query = 'e';
+    beforeEach(async () => {
+      createWrapper();
+      await findSearchInput().vm.$emit('input', query);
+
+      await wrapper.setProps({
+        loading: true,
+        searchQuery: query,
+      });
+    });
+
+    it('emits query input', async () => {
+      expect(wrapper.emitted('update:searchQuery').at(0)).toEqual([query]);
+    });
+
+    describe('when loading', () => {
+      it('shows loading state', async () => {
+        expect(findLoadingIndicator().exists()).toBe(true);
+      });
+
+      describe.each([
+        { numResults: 0, expectedRows: 1 },
+        { numResults: 1, expectedRows: 1 },
+        { numResults: 2, expectedRows: 2 },
+        { numResults: 3, expectedRows: 3 },
+        { numResults: 4, expectedRows: 4 },
+        { numResults: 5, expectedRows: 5 },
+      ])('when there are $numResults results', ({ numResults, expectedRows }) => {
+        beforeEach(async () => {
+          await wrapper.setProps({
+            loading: false,
+            results: getMockContextItems().slice(0, numResults),
+          });
+          await wrapper.setProps({
+            loading: true,
+          });
+        });
+
+        it(`shows ${expectedRows} loading rows next time when searching`, () => {
+          expect(findLoadingIndicator().props('rows')).toBe(expectedRows);
+        });
+      });
+    });
+
+    describe('when there is an error', () => {
+      beforeEach(async () => {
+        await wrapper.setProps({
+          loading: false,
+          error: 'oh no',
+        });
+      });
+
+      it('shows error state', async () => {
+        expect(findLoadingError().text()).toBe('oh no');
+      });
+
+      it('does not render the loading state', () => {
+        expect(findLoadingIndicator().exists()).toBe(false);
+      });
+
+      it('does not render the empty state', () => {
+        expect(findEmptyState().exists()).toBe(false);
+      });
+    });
+
+    describe('when there are no results', () => {
+      beforeEach(async () => {
+        await wrapper.setProps({
+          loading: false,
+          error: null,
+          results: [],
+        });
+      });
+
+      it('shows empty state', async () => {
+        expect(findEmptyState().text()).toBe('No results found');
+      });
+
+      it('does not render the loading state', () => {
+        expect(findLoadingIndicator().exists()).toBe(false);
+      });
+
+      it('does not render the error state', () => {
+        expect(findLoadingError().exists()).toBe(false);
+      });
+    });
+
+    describe('when there are results', () => {
+      beforeEach(() =>
+        wrapper.setProps({
+          loading: false,
+        })
+      );
+
+      it('shows matching results', async () => {
+        const matchingResult = results.at(0);
+        await wrapper.setProps({
+          results: [matchingResult],
+        });
+
+        expect(findResultItems()).toHaveLength(1);
+        expect(findByTestId('search-result-item-details').text()).toEqual(
+          matchingResult.metadata.name
+        );
+      });
+
+      it('marks the correct item as active', async () => {
+        expect(findActiveItemDetails().text()).toEqual(results.at(0).metadata.name);
+
+        await wrapper.setProps({
+          activeIndex: 1,
+        });
+
+        expect(findActiveItemDetails().text()).toEqual(results.at(1).metadata.name);
+      });
+
+      it('emits "active-index-change" event when hovering over an item', async () => {
+        const index = 1;
+        await findResultItems().wrappers.at(index).find('div').trigger('mouseenter');
+
+        expect(wrapper.emitted('active-index-change').at(0)).toEqual([index]);
+      });
+
+      describe('when there are disabled results', () => {
+        let disabledItem;
+        beforeEach(async () => {
+          const disabledIndex = 2;
+          await wrapper.setProps({
+            results: results.map((result, index) => ({
+              ...result,
+              isEnabled: index !== disabledIndex,
+            })),
+          });
+
+          disabledItem = findResultItems().at(disabledIndex);
+        });
+
+        it('does not emit "active-index-change" event when hovering over a disabled item', async () => {
+          await disabledItem.find('div').trigger('mouseenter');
+
+          expect(wrapper.emitted('active-index-change')).toBeUndefined();
+        });
+
+        it('disables the item', () => {
+          expect(disabledItem.attributes('tabindex')).toBe('-1');
+          expect(disabledItem.classes()).toContain('disabled');
+        });
+      });
+    });
+  });
+
+  describe.each([
+    {
+      testCase: MOCK_CATEGORIES.find((cat) => cat.value === CONTEXT_ITEM_TYPE_PROJECT_FILE),
+      expectedPlaceholder: 'Search files...',
+    },
+    {
+      testCase: MOCK_CATEGORIES.find((cat) => cat.value === CONTEXT_ITEM_TYPE_ISSUE),
+      expectedPlaceholder: 'Search issues...',
+    },
+    {
+      testCase: MOCK_CATEGORIES.find((cat) => cat.value === CONTEXT_ITEM_TYPE_MERGE_REQUEST),
+      expectedPlaceholder: 'Search merge requests...',
+    },
+  ])('when category is "$testCase.label"', ({ testCase, expectedPlaceholder }) => {
+    beforeEach(() =>
+      createWrapper({
+        category: testCase,
+      })
+    );
+
+    it('renders the expected input placeholder text', () => {
+      expect(findSearchInput().attributes('placeholder')).toEqual(expectedPlaceholder);
+    });
+  });
+});
diff --git a/src/components/experimental/duo/chat/components/duo_chat_context/duo_chat_context_item_menu/duo_chat_context_item_menu_search_items.vue b/src/components/experimental/duo/chat/components/duo_chat_context/duo_chat_context_item_menu/duo_chat_context_item_menu_search_items.vue
new file mode 100644
index 0000000000000000000000000000000000000000..2a5badf650ebde95cea90a08d1e98488b8444aae
--- /dev/null
+++ b/src/components/experimental/duo/chat/components/duo_chat_context/duo_chat_context_item_menu/duo_chat_context_item_menu_search_items.vue
@@ -0,0 +1,144 @@
+<script>
+import GlDropdownItem from '../../../../../../base/dropdown/dropdown_item.vue';
+import GlFormInput from '../../../../../../base/form/form_input/form_input.vue';
+import GlAlert from '../../../../../../base/alert/alert.vue';
+import { sprintf, translate } from '../../../../../../../utils/i18n';
+import { categoryValidator, contextItemsValidator } from '../utils';
+import GlDuoChatContextItemMenuSearchItemsLoading from './duo_chat_context_item_menu_search_items_loading.vue';
+
+export default {
+  name: 'GlDuoChatContextItemMenuSearchItems',
+  components: {
+    GlAlert,
+    GlFormInput,
+    GlDropdownItem,
+    GlDuoChatContextItemMenuSearchItemsLoading,
+  },
+  model: {
+    prop: 'searchQuery',
+    event: 'update:searchQuery',
+  },
+  props: {
+    activeIndex: {
+      type: Number,
+      required: true,
+    },
+    searchQuery: {
+      type: String,
+      required: true,
+    },
+    category: {
+      type: Object,
+      required: true,
+      validator: categoryValidator,
+    },
+    loading: {
+      type: Boolean,
+      required: true,
+    },
+    error: {
+      type: [String, null],
+      required: false,
+      default: null,
+    },
+    results: {
+      type: Array,
+      required: true,
+      validator: contextItemsValidator,
+    },
+  },
+  data() {
+    return {
+      userInitiatedSearch: false,
+      numLoadingItems: 3,
+    };
+  },
+  computed: {
+    showEmptyState() {
+      return Boolean(
+        this.userInitiatedSearch && !this.loading && !this.error && !this.results.length
+      );
+    },
+    searchInputPlaceholder() {
+      return sprintf(
+        translate('GlDuoChatContextItemMenu.searchInputPlaceholder', 'Search %{categoryLabel}...'),
+        {
+          categoryLabel: this.category.label.toLowerCase(),
+        }
+      );
+    },
+  },
+  watch: {
+    searchQuery() {
+      this.userInitiatedSearch = true;
+    },
+    results(results) {
+      this.numLoadingItems = Math.max(1, results.length);
+    },
+  },
+  methods: {
+    selectItem(item) {
+      this.$emit('select', item);
+      this.userInitiatedSearch = false;
+    },
+    setActiveIndex(index) {
+      if (this.results[index]?.isEnabled) {
+        this.$emit('active-index-change', index);
+      }
+    },
+  },
+  i18n: {
+    emptyStateMessage: translate('GlDuoChatContextItemMenu.emptyStateMessage', 'No results found'),
+  },
+};
+</script>
+<template>
+  <div>
+    <div class="gl-max-h-31 gl-overflow-y-scroll">
+      <gl-duo-chat-context-item-menu-search-items-loading v-if="loading" :rows="numLoadingItems" />
+      <gl-alert
+        v-else-if="error"
+        variant="danger"
+        :dismissible="false"
+        class="gl-m-3"
+        data-testid="search-results-error"
+      >
+        {{ error }}
+      </gl-alert>
+      <div
+        v-else-if="showEmptyState"
+        class="gl-rounded-base gl-p-3 gl-text-center gl-text-secondary"
+        data-testid="search-results-empty-state"
+      >
+        {{ $options.i18n.emptyStateMessage }}
+      </div>
+      <ul v-else class="gl-mb-1 gl-list-none gl-flex-row gl-pl-0">
+        <gl-dropdown-item
+          v-for="(item, index) in results"
+          :id="`dropdown-item-${index}`"
+          :key="item.id"
+          :class="[{ 'active-command': index === activeIndex, disabled: !item.isEnabled }]"
+          :tabindex="!item.isEnabled ? -1 : undefined"
+          class="duo-chat-context-search-result-item"
+          data-testid="search-result-item"
+          @click="selectItem(item)"
+        >
+          <div @mouseenter="setActiveIndex(index)">
+            <div data-testid="search-result-item-details">
+              <!-- Placeholder for upcoming GlDuoChatContextItemMenuSearchItem component -->
+              {{ item.metadata.name }} {{ item.isEnabled ? '' : '(disabled)' }}
+            </div>
+          </div>
+        </gl-dropdown-item>
+      </ul>
+    </div>
+    <gl-form-input
+      ref="contextMenuSearchInput"
+      :value="searchQuery"
+      :placeholder="searchInputPlaceholder"
+      autofocus
+      data-testid="context-menu-search-input"
+      @input="$emit('update:searchQuery', $event)"
+    />
+  </div>
+</template>
diff --git a/src/components/experimental/duo/chat/components/duo_chat_context/duo_chat_context_item_menu/duo_chat_context_item_menu_search_items_loading.spec.js b/src/components/experimental/duo/chat/components/duo_chat_context/duo_chat_context_item_menu/duo_chat_context_item_menu_search_items_loading.spec.js
new file mode 100644
index 0000000000000000000000000000000000000000..44a312902699859641ab3273cf63a7e1fa49d588
--- /dev/null
+++ b/src/components/experimental/duo/chat/components/duo_chat_context/duo_chat_context_item_menu/duo_chat_context_item_menu_search_items_loading.spec.js
@@ -0,0 +1,28 @@
+import { shallowMount } from '@vue/test-utils';
+import GlDuoChatContextItemMenuSearchItemsLoading from './duo_chat_context_item_menu_search_items_loading.vue';
+
+describe('GlDuoChatContextItemMenuSearchItemsLoading', () => {
+  let wrapper;
+
+  const createWrapper = (props = {}) => {
+    wrapper = shallowMount(GlDuoChatContextItemMenuSearchItemsLoading, {
+      propsData: {
+        rows: 3,
+        ...props,
+      },
+    });
+  };
+
+  const findAllByTestId = (testId) => wrapper.findAll(`[data-testid="${testId}"]`);
+  const findLoadingRows = () => findAllByTestId('search-results-loading');
+
+  it('should render the accessible loading text', () => {
+    createWrapper();
+    expect(wrapper.text()).toContain('Loading...');
+  });
+
+  it.each([1, 2, 3, 4, 5])('renders %s rows', (rows) => {
+    createWrapper({ rows });
+    expect(findLoadingRows()).toHaveLength(rows);
+  });
+});
diff --git a/src/components/experimental/duo/chat/components/duo_chat_context/duo_chat_context_item_menu/duo_chat_context_item_menu_search_items_loading.vue b/src/components/experimental/duo/chat/components/duo_chat_context/duo_chat_context_item_menu/duo_chat_context_item_menu_search_items_loading.vue
new file mode 100644
index 0000000000000000000000000000000000000000..c44f17ec1d54538da3d1d0ec1d143b2d4dd31279
--- /dev/null
+++ b/src/components/experimental/duo/chat/components/duo_chat_context/duo_chat_context_item_menu/duo_chat_context_item_menu_search_items_loading.vue
@@ -0,0 +1,34 @@
+<script>
+import { translate } from '../../../../../../../utils/i18n';
+
+export default {
+  name: 'GlDuoChatContextItemMenuSearchItemsLoading',
+  props: {
+    rows: {
+      type: Number,
+      required: true,
+    },
+  },
+  i18n: {
+    loadingMessage: translate('GlDuoChatContextItemMenu.loadingMessage', 'Loading...'),
+  },
+};
+</script>
+
+<template>
+  <div>
+    <div
+      v-for="index in rows"
+      :key="index"
+      class="gl-mx-3 gl-mb-4 gl-pt-3"
+      data-testid="search-results-loading"
+    >
+      <div class="gl-mb-2 gl-flex">
+        <div class="gl-animate-skeleton-loader gl-mr-3 gl-h-5 gl-w-5 gl-rounded-base"></div>
+        <div class="gl-animate-skeleton-loader gl-h-5 gl-grow gl-rounded-base"></div>
+      </div>
+      <div class="gl-animate-skeleton-loader gl-h-4 gl-w-1/2 gl-rounded-base"></div>
+    </div>
+    <span class="sr-only">{{ $options.i18n.loadingMessage }}</span>
+  </div>
+</template>
diff --git a/src/components/experimental/duo/chat/components/duo_chat_context/utils.js b/src/components/experimental/duo/chat/components/duo_chat_context/utils.js
index e4c2bb344c8f492d3c211482a56c425172809be5..d8baa557125040a5294792296bc85fe1a5698a3f 100644
--- a/src/components/experimental/duo/chat/components/duo_chat_context/utils.js
+++ b/src/components/experimental/duo/chat/components/duo_chat_context/utils.js
@@ -1,4 +1,4 @@
-function categoryValidator(category) {
+export function categoryValidator(category) {
   return Boolean(category && category.value && category.label && category.icon);
 }
 
@@ -14,7 +14,7 @@ function disabledReasonsValidator(disabledReasons) {
   );
 }
 
-function contextItemValidator(item) {
+export function contextItemValidator(item) {
   return Boolean(
     item &&
       item.id &&
diff --git a/src/components/experimental/duo/chat/components/duo_chat_context/utils.spec.js b/src/components/experimental/duo/chat/components/duo_chat_context/utils.spec.js
index 50a7b0bf0f641b8896cd89e9969fa28d5c1a8288..330cfe1cf17ad3e797b98c40019b773d98eb7213 100644
--- a/src/components/experimental/duo/chat/components/duo_chat_context/utils.spec.js
+++ b/src/components/experimental/duo/chat/components/duo_chat_context/utils.spec.js
@@ -1,11 +1,34 @@
-import { categoriesValidator, contextItemsValidator } from './utils';
+import {
+  categoriesValidator,
+  categoryValidator,
+  contextItemsValidator,
+  contextItemValidator,
+} from './utils';
 import {
   MOCK_CATEGORIES,
   MOCK_CONTEXT_ITEM_FILE,
+  MOCK_CONTEXT_ITEM_FILE_DISABLED,
   MOCK_CONTEXT_ITEM_MERGE_REQUEST,
 } from './mock_context_data';
 
 describe('duo_chat_context utils', () => {
+  describe('categoryValidator', () => {
+    it.each(MOCK_CATEGORIES)('returns true for a valid category', (category) => {
+      expect(categoryValidator(category)).toBe(true);
+    });
+
+    it.each([
+      { value: { value: 'test', label: 'Test' }, description: 'missing icon' },
+      { value: { value: 'test', icon: 'icon' }, description: 'missing label' },
+      { value: { label: 'Test', icon: 'icon' }, description: 'missing value' },
+      { value: {}, description: 'empty object' },
+      { value: null, description: 'null' },
+      { value: undefined, description: 'undefined' },
+    ])('returns false for "$description"', ({ value }) => {
+      expect(categoryValidator(value)).toBe(false);
+    });
+  });
+
   describe('categoriesValidator', () => {
     it('returns true for valid categories', () => {
       expect(categoriesValidator(MOCK_CATEGORIES)).toBe(true);
@@ -38,6 +61,70 @@ describe('duo_chat_context utils', () => {
     });
   });
 
+  describe('contextItemValidator', () => {
+    describe('with a valid item', () => {
+      it('returns true for a valid file item', () => {
+        expect(contextItemValidator(MOCK_CONTEXT_ITEM_FILE)).toBe(true);
+      });
+
+      it('returns true for a valid merge request item', () => {
+        expect(contextItemValidator(MOCK_CONTEXT_ITEM_MERGE_REQUEST)).toBe(true);
+      });
+
+      it('returns true for a valid disabled item', () => {
+        expect(contextItemValidator(MOCK_CONTEXT_ITEM_FILE_DISABLED)).toBe(true);
+      });
+    });
+
+    describe.each([
+      { value: null, description: 'null' },
+      { value: undefined, description: 'undefined' },
+      { value: {}, description: 'empty object' },
+      { value: 'not an item', description: 'string instead of object' },
+      { value: 42, description: 'number instead of object' },
+      {
+        value: { ...MOCK_CONTEXT_ITEM_FILE, id: undefined },
+        description: 'missing id',
+      },
+      {
+        value: { ...MOCK_CONTEXT_ITEM_FILE, type: undefined },
+        description: 'missing type',
+      },
+      {
+        value: {
+          ...MOCK_CONTEXT_ITEM_FILE,
+          isEnabled: undefined,
+        },
+        description: 'missing enabled',
+      },
+      {
+        value: {
+          ...MOCK_CONTEXT_ITEM_FILE,
+          isEnabled: 'true',
+        },
+        description: 'non-boolean enabled',
+      },
+      {
+        value: {
+          ...MOCK_CONTEXT_ITEM_FILE,
+          disabledReasons: 'not an array',
+        },
+        description: 'non-array disabledReasons',
+      },
+      {
+        value: {
+          ...MOCK_CONTEXT_ITEM_FILE,
+          disabledReasons: [42],
+        },
+        description: 'non-string items in disabledReasons array',
+      },
+    ])('with "$description"', ({ value }) => {
+      it('returns false', () => {
+        expect(contextItemValidator(value)).toBe(false);
+      });
+    });
+  });
+
   describe('contextItemsValidator', () => {
     describe.each([
       { value: [], description: 'empty array' },
diff --git a/translations.js b/translations.js
index 60a0904b009f7be77a68ac55247b7c2b684edeb8..1e235fac6d64ff12d4e31bfb54ce24079d8a4050 100644
--- a/translations.js
+++ b/translations.js
@@ -8,6 +8,9 @@ export default {
   'GlBreadcrumb.showMoreLabel': 'Show more breadcrumbs',
   'GlBroadcastMessage.closeButtonTitle': 'Dismiss',
   'GlCollapsibleListbox.srOnlyResultsLabel': null,
+  'GlDuoChatContextItemMenu.emptyStateMessage': 'No results found',
+  'GlDuoChatContextItemMenu.loadingMessage': 'Loading...',
+  'GlDuoChatContextItemMenu.searchInputPlaceholder': 'Search %{categoryLabel}...',
   'GlDuoChatContextItemMenu.selectedContextItemsTitle': 'Included references',
   'GlDuoChatMessage.SelectedContextItemsTitleAssistantMessage': null,
   'GlDuoChatMessage.SelectedContextItemsTitleUserMessage': null,