diff --git a/api/server/routes/categories.js b/api/server/routes/categories.js
index 612bc378603..afd2f17c210 100644
--- a/api/server/routes/categories.js
+++ b/api/server/routes/categories.js
@@ -1,15 +1,31 @@
 const express = require('express');
+const { PermissionTypes, Permissions } = require('librechat-data-provider');
+const { checkAccess, createGetPromptCategoriesHandler } = require('@librechat/api');
+const { requireJwtAuth, configMiddleware } = require('~/server/middleware');
+const {
+  getRoleByName,
+  getPromptGroupAccessContext,
+  getDistinctPromptGroupCategories,
+} = require('~/models');
+
 const router = express.Router();
-const { requireJwtAuth } = require('~/server/middleware');
-const { getCategories } = require('~/models');
 
-router.get('/', requireJwtAuth, async (req, res) => {
-  try {
-    const categories = await getCategories();
-    res.status(200).send(categories);
-  } catch (error) {
-    res.status(500).send({ message: 'Failed to retrieve categories', error: error.message });
-  }
-});
+router.get(
+  '/',
+  requireJwtAuth,
+  configMiddleware,
+  createGetPromptCategoriesHandler({
+    getPromptGroupAccessContext,
+    getDistinctPromptGroupCategories,
+    canUsePrompts: (req) =>
+      checkAccess({
+        req,
+        user: req.user,
+        permissionType: PermissionTypes.PROMPTS,
+        permissions: [Permissions.USE],
+        getRoleByName,
+      }),
+  }),
+);
 
 module.exports = router;
diff --git a/api/server/routes/categories.test.js b/api/server/routes/categories.test.js
new file mode 100644
index 00000000000..6654db995ae
--- /dev/null
+++ b/api/server/routes/categories.test.js
@@ -0,0 +1,217 @@
+const express = require('express');
+const request = require('supertest');
+const mongoose = require('mongoose');
+const { MongoMemoryServer } = require('mongodb-memory-server');
+const {
+  SystemRoles,
+  ResourceType,
+  AccessRoleIds,
+  PrincipalType,
+  PermissionBits,
+  PermissionTypes,
+  Permissions,
+} = require('librechat-data-provider');
+let mockBaseConfig = {};
+
+const mockHrOverride = {
+  principalType: 'role',
+  principalId: 'HR',
+  priority: 10,
+  overrides: {
+    prompts: {
+      categories: {
+        enableDefaultCategories: false,
+        list: [{ value: 'benefits', label: 'Benefits' }],
+      },
+    },
+  },
+};
+
+jest.mock('~/server/services/Config', () => ({
+  getAppConfig: jest.fn(async ({ role } = {}) => {
+    const { mergeConfigOverrides } = require('@librechat/data-schemas');
+    return role === 'HR' ? mergeConfigOverrides(mockBaseConfig, [mockHrOverride]) : mockBaseConfig;
+  }),
+}));
+
+jest.mock('~/models', () => {
+  const mongoose = require('mongoose');
+  const { createMethods } = require('@librechat/data-schemas');
+  const methods = createMethods(mongoose, {
+    removeAllPermissions: async ({ resourceType, resourceId }) => {
+      await mongoose.models.AclEntry?.deleteMany({ resourceType, resourceId });
+    },
+  });
+  return {
+    ...methods,
+    getPromptGroupAccessContext: jest.fn(methods.getPromptGroupAccessContext),
+    getDistinctPromptGroupCategories: jest.fn(methods.getDistinctPromptGroupCategories),
+  };
+});
+
+jest.mock('~/server/middleware', () => ({
+  requireJwtAuth: (req, res, next) => next(),
+  configMiddleware: jest.requireActual('~/server/middleware/config/app'),
+}));
+
+const builtins = [
+  { label: 'com_ui_idea', value: 'idea' },
+  { label: 'com_ui_travel', value: 'travel' },
+  { label: 'com_ui_teach_or_explain', value: 'teach_or_explain' },
+  { label: 'com_ui_write', value: 'write' },
+  { label: 'com_ui_shop', value: 'shop' },
+  { label: 'com_ui_code', value: 'code' },
+  { label: 'com_ui_misc', value: 'misc' },
+  { label: 'com_ui_roleplay', value: 'roleplay' },
+  { label: 'com_ui_finance', value: 'finance' },
+];
+
+let app;
+let mongoServer;
+let models;
+let users;
+let currentUser;
+
+beforeAll(async () => {
+  mongoServer = await MongoMemoryServer.create();
+  await mongoose.connect(mongoServer.getUri());
+
+  const { AccessRole, User, Role } = require('~/db/models');
+  await Role.create({
+    name: 'NO_PROMPTS',
+    permissions: { [PermissionTypes.PROMPTS]: { [Permissions.USE]: false } },
+  });
+  await AccessRole.create({
+    accessRoleId: AccessRoleIds.PROMPTGROUP_OWNER,
+    name: 'Owner',
+    resourceType: ResourceType.PROMPTGROUP,
+    permBits:
+      PermissionBits.VIEW | PermissionBits.EDIT | PermissionBits.DELETE | PermissionBits.SHARE,
+  });
+  users = {
+    a: await User.create({ name: 'A', email: 'a@example.com', role: SystemRoles.USER }),
+    b: await User.create({ name: 'B', email: 'b@example.com', role: SystemRoles.USER }),
+    hr: await User.create({ name: 'HR', email: 'hr@example.com', role: 'HR' }),
+    noPrompts: await User.create({ name: 'NP', email: 'np@example.com', role: 'NO_PROMPTS' }),
+  };
+  models = require('~/models');
+
+  app = express();
+  app.use((req, res, next) => {
+    req.user = {
+      id: currentUser._id.toString(),
+      _id: currentUser._id,
+      role: currentUser.role,
+    };
+    next();
+  });
+  app.use('/api/categories', require('./categories'));
+});
+
+beforeEach(() => {
+  currentUser = users.a;
+  mockBaseConfig = {};
+  jest.clearAllMocks();
+});
+
+afterAll(async () => {
+  await mongoose.disconnect();
+  await mongoServer.stop();
+});
+
+describe('GET /api/categories', () => {
+  it('defaults unchanged when no prompts config is set', async () => {
+    const res = await request(app).get('/api/categories');
+
+    expect(res.status).toBe(200);
+    expect(res.body).toEqual(builtins);
+  });
+
+  it('applies the role override per requesting role', async () => {
+    currentUser = users.hr;
+    const hr = await request(app).get('/api/categories');
+    expect(hr.status).toBe(200);
+    expect(hr.body).toEqual([{ value: 'benefits', label: 'Benefits' }]);
+
+    currentUser = users.a;
+    const user = await request(app).get('/api/categories');
+    expect(user.body).toEqual(builtins);
+  });
+
+  it('gives no error leak when the custom category read fails', async () => {
+    mockBaseConfig = { prompts: { categories: { allowCustom: true } } };
+    models.getDistinctPromptGroupCategories.mockRejectedValueOnce(new Error('secret db detail'));
+
+    const res = await request(app).get('/api/categories');
+
+    expect(res.status).toBe(500);
+    expect(res.body).toEqual({ message: 'Failed to retrieve categories' });
+    expect(res.text).not.toContain('secret');
+  });
+
+  it('keeps custom categories access scoped to the requesting user', async () => {
+    mockBaseConfig = { prompts: { categories: { allowCustom: true } } };
+    const { grantPermission } = require('~/server/services/PermissionService');
+    const { group } = await models.createPromptGroup({
+      prompt: { prompt: 'secret text', type: 'text' },
+      group: { name: 'private group', category: 'A-Private' },
+      author: users.a._id.toString(),
+      authorName: users.a.name,
+    });
+    await grantPermission({
+      principalType: PrincipalType.USER,
+      principalId: users.a._id,
+      resourceType: ResourceType.PROMPTGROUP,
+      resourceId: group._id,
+      accessRoleId: AccessRoleIds.PROMPTGROUP_OWNER,
+      grantedBy: users.a._id,
+    });
+
+    currentUser = users.b;
+    const forB = await request(app).get('/api/categories');
+    expect(forB.body.map((c) => c.value)).not.toContain('A-Private');
+
+    currentUser = users.a;
+    const forA = await request(app).get('/api/categories');
+    expect(forA.body).toContainEqual({ value: 'A-Private', label: 'A-Private', custom: true });
+  });
+
+  it('serves configured categories only to a user without prompt-use permission', async () => {
+    mockBaseConfig = {
+      prompts: {
+        categories: { allowCustom: true, enableDefaultCategories: false, list: [{ value: 'hr' }] },
+      },
+    };
+    const { grantPermission } = require('~/server/services/PermissionService');
+    const { group } = await models.createPromptGroup({
+      prompt: { prompt: 'text', type: 'text' },
+      group: { name: 'shared group', category: 'Stored' },
+      author: users.noPrompts._id.toString(),
+      authorName: users.noPrompts.name,
+    });
+    await grantPermission({
+      principalType: PrincipalType.USER,
+      principalId: users.noPrompts._id,
+      resourceType: ResourceType.PROMPTGROUP,
+      resourceId: group._id,
+      accessRoleId: AccessRoleIds.PROMPTGROUP_OWNER,
+      grantedBy: users.noPrompts._id,
+    });
+
+    currentUser = users.noPrompts;
+    const denied = await request(app).get('/api/categories');
+    expect(denied.status).toBe(200);
+    expect(denied.body).toEqual([{ value: 'hr', label: 'hr' }]);
+    expect(models.getDistinctPromptGroupCategories).not.toHaveBeenCalled();
+  });
+
+  it('no reads when off: custom categories disabled', async () => {
+    mockBaseConfig = { prompts: { categories: { allowCustom: false } } };
+
+    const res = await request(app).get('/api/categories');
+
+    expect(res.status).toBe(200);
+    expect(models.getPromptGroupAccessContext).not.toHaveBeenCalled();
+    expect(models.getDistinctPromptGroupCategories).not.toHaveBeenCalled();
+  });
+});
diff --git a/api/server/routes/config.js b/api/server/routes/config.js
index fd0adb57ae9..b1a11ed4728 100644
--- a/api/server/routes/config.js
+++ b/api/server/routes/config.js
@@ -22,6 +22,7 @@ const {
   resolveCodeEnvironmentMoveCapabilities,
   resolveCodeWorkspaceInheritanceCapability,
   resolveCodeEnvironmentTransitionVersion,
+  getPromptCategoriesStartupConfig,
   loadConversationListLimits,
 } = require('@librechat/api');
 const {
@@ -315,6 +316,7 @@ router.get('/', async function (req, res) {
         appConfig,
         endpoint: EModelEndpoint.agents,
       }),
+      promptCategories: getPromptCategoriesStartupConfig(appConfig),
       turnstile: appConfig?.turnstileConfig,
       modelSpecs: sanitizeModelSpecs(excludeHiddenModelSpecs(appConfig?.modelSpecs)),
       balance: balanceConfig,
diff --git a/api/server/routes/prompts.test.js b/api/server/routes/prompts.test.js
index 57b89b57c67..2bf0205ead9 100644
--- a/api/server/routes/prompts.test.js
+++ b/api/server/routes/prompts.test.js
@@ -313,6 +313,31 @@ describe('Prompt Routes - ACL Permissions', () => {
       await expect(PromptGroup.countDocuments()).resolves.toBe(0);
     });
 
+    it('should reject a reserved category on create', async () => {
+      const response = await request(app)
+        .post('/api/prompts')
+        .send({
+          prompt: { prompt: 'Category prompt', type: 'text' },
+          group: { name: 'Category Group', category: 'sys__x' },
+        });
+
+      expect(response.status).toBe(400);
+      await expect(PromptGroup.countDocuments()).resolves.toBe(0);
+    });
+
+    it('should store a valid custom category trimmed on create', async () => {
+      const response = await request(app)
+        .post('/api/prompts')
+        .send({
+          prompt: { prompt: 'Category prompt', type: 'text' },
+          group: { name: 'Category Group', category: '  Onboarding  ' },
+        });
+
+      expect(response.status).toBe(200);
+      const stored = await PromptGroup.findOne({ name: 'Category Group' }).lean();
+      expect(stored.category).toBe('Onboarding');
+    });
+
     it('should create a prompt and grant owner permissions', async () => {
       const promptData = {
         prompt: {
@@ -943,6 +968,16 @@ describe('Prompt Routes - ACL Permissions', () => {
       await AclEntry.deleteMany({});
     });
 
+    it('should reject an over-long category on update and keep the stored category', async () => {
+      await request(app)
+        .patch(`/api/prompts/groups/${testGroup._id}`)
+        .send({ category: 'a'.repeat(101) })
+        .expect(400);
+
+      const stored = await PromptGroup.findById(testGroup._id).lean();
+      expect(stored.category).toBe('security-test');
+    });
+
     it('should allow updating allowed fields (name, category, oneliner)', async () => {
       const updateData = {
         name: 'Updated Group Name',
diff --git a/client/src/components/Prompts/fields/CategorySelector.tsx b/client/src/components/Prompts/fields/CategorySelector.tsx
index b0d163d21bc..f02e96282d8 100644
--- a/client/src/components/Prompts/fields/CategorySelector.tsx
+++ b/client/src/components/Prompts/fields/CategorySelector.tsx
@@ -1,12 +1,18 @@
-import React, { useId, useMemo, useState } from 'react';
+import React, { useCallback, useEffect, useId, useMemo, useRef, useState } from 'react';
 import * as Ariakit from '@ariakit/react';
 import { useTranslation } from 'react-i18next';
-import { DropdownPopup } from '@librechat/client';
-import { LocalStorageKeys } from 'librechat-data-provider';
 import { useFormContext, Controller } from 'react-hook-form';
+import { Button, DropdownPopup, Input } from '@librechat/client';
+import {
+  LocalStorageKeys,
+  SYSTEM_CATEGORY_PREFIX,
+  promptCategoryValueSchema,
+} from 'librechat-data-provider';
 import type { MenuItemProps } from '@librechat/client';
 import type { ReactNode } from 'react';
+import { useGetStartupConfig } from '~/data-provider';
 import { usePromptGroupsContext } from '~/Providers';
+import { CategoryIcon } from '~/components/Prompts';
 import { useCategories } from '~/hooks';
 import { cn } from '~/utils';
 
@@ -29,6 +35,12 @@ const CategorySelector: React.FC<CategorySelectorProps> = ({
   const { t } = useTranslation();
   const formContext = useFormContext();
   const [isOpen, setIsOpen] = useState(false);
+  const [isCreating, setIsCreating] = useState(false);
+  const [draft, setDraft] = useState('');
+  const triggerRef = useRef<HTMLButtonElement>(null);
+  const inputRef = useRef<HTMLInputElement>(null);
+  const { data: startupConfig } = useGetStartupConfig();
+  const allowCustom = startupConfig?.promptCategories?.allowCustom === true;
   const { hasAccess } = usePromptGroupsContext() ?? {};
   const { categories, emptyCategory } = useCategories({ hasAccess });
 
@@ -38,13 +50,17 @@ const CategorySelector: React.FC<CategorySelectorProps> = ({
 
   const watchedCategory = watch ? watch('category') : currentCategory;
 
-  const categoryOption = useMemo(
-    () =>
-      (categories ?? []).find(
-        (category) => category.value === (watchedCategory ?? currentCategory),
-      ) ?? emptyCategory,
-    [watchedCategory, categories, currentCategory, emptyCategory],
-  );
+  const categoryOption = useMemo(() => {
+    const selected = watchedCategory ?? currentCategory;
+    const found = (categories ?? []).find((category) => category.value === selected);
+    if (found) {
+      return found;
+    }
+    if (selected && allowCustom) {
+      return { value: selected, label: selected, icon: <CategoryIcon category={selected} /> };
+    }
+    return emptyCategory;
+  }, [watchedCategory, categories, currentCategory, emptyCategory, allowCustom]);
 
   const displayCategory = useMemo(() => {
     if (!categoryOption.value && !('icon' in categoryOption)) {
@@ -57,29 +73,101 @@ const CategorySelector: React.FC<CategorySelectorProps> = ({
     return categoryOption;
   }, [categoryOption, t]);
 
+  const selectCategory = useCallback(
+    (value: string) => {
+      if (formContext && setValue) {
+        setValue('category', value, { shouldDirty: false });
+      }
+      localStorage.setItem(LocalStorageKeys.LAST_PROMPT_CATEGORY, value);
+      onValueChange?.(value);
+      setIsOpen(false);
+    },
+    [formContext, setValue, onValueChange],
+  );
+
   const menuItems: MenuItemProps[] = useMemo(() => {
     if (!categories) return [];
 
-    return categories.map((category) => ({
+    const items: MenuItemProps[] = categories.map((category) => ({
       id: `${menuId}-item-${category.value}`,
       label: category.label,
       icon: 'icon' in category ? category.icon : undefined,
-      onClick: () => {
-        const value = category.value || '';
-        if (formContext && setValue) {
-          setValue('category', value, { shouldDirty: false });
-        }
-        localStorage.setItem(LocalStorageKeys.LAST_PROMPT_CATEGORY, value);
-        onValueChange?.(value);
-        setIsOpen(false);
-      },
+      onClick: () => selectCategory(category.value || ''),
     }));
-  }, [categories, formContext, menuId, setValue, onValueChange]);
+
+    if (allowCustom) {
+      items.push({
+        id: `${menuId}-new-category`,
+        label: t('com_ui_new_category'),
+        onClick: () => {
+          setIsOpen(false);
+          setIsCreating(true);
+        },
+      });
+    }
+    return items;
+  }, [categories, allowCustom, menuId, selectCategory, t]);
+
+  useEffect(() => {
+    if (isCreating) {
+      inputRef.current?.focus();
+    }
+  }, [isCreating]);
+
+  const trimmed = draft.trim();
+  const existing = useMemo(() => {
+    const needle = trimmed.toLowerCase();
+    return (categories ?? []).find(
+      (category) =>
+        category.value &&
+        (category.value.toLowerCase() === needle || category.label.toLowerCase() === needle),
+    );
+  }, [categories, trimmed]);
+  const parsed = promptCategoryValueSchema.safeParse(draft);
+  const invalidReason = (() => {
+    if (existing || parsed.success || !trimmed) {
+      return null;
+    }
+    if (trimmed.startsWith(SYSTEM_CATEGORY_PREFIX)) {
+      return t('com_ui_category_reserved_prefix');
+    }
+    return parsed.error.issues.some((issue) => issue.code === 'too_big')
+      ? t('com_ui_category_too_long')
+      : t('com_ui_category_invalid_chars');
+  })();
+  const canSubmit = existing != null || parsed.success;
+  const reasonId = `${menuId}-new-category-reason`;
+
+  const closeCreate = () => {
+    setIsCreating(false);
+    setDraft('');
+  };
+
+  const submitDraft = () => {
+    if (!canSubmit) {
+      return;
+    }
+    selectCategory(existing ? existing.value : trimmed);
+    closeCreate();
+  };
+
+  const handleDraftKeyDown = (e: React.KeyboardEvent) => {
+    if (e.key === 'Escape') {
+      e.preventDefault();
+      closeCreate();
+      triggerRef.current?.focus();
+    }
+    if (e.key === 'Enter' && !(e.nativeEvent.isComposing || e.keyCode === 229)) {
+      e.preventDefault();
+      submitDraft();
+    }
+  };
 
   const trigger = (
     <Ariakit.MenuButton
+      ref={triggerRef}
       className={cn(
-        'relative inline-flex h-9 items-center justify-between rounded-xl border border-border-medium bg-transparent px-3 text-sm text-text-primary transition-all duration-200 ease-in-out hover:bg-surface-hover hover:text-text-primary focus:ring-2 focus:ring-ring-primary',
+        'border-border-medium text-text-primary hover:bg-surface-hover hover:text-text-primary focus:ring-ring-primary relative inline-flex h-9 items-center justify-between rounded-xl border bg-transparent px-3 text-sm transition-all duration-200 ease-in-out focus:ring-2',
         'gap-2 sm:w-fit',
         className,
       )}
@@ -96,23 +184,7 @@ const CategorySelector: React.FC<CategorySelectorProps> = ({
     </Ariakit.MenuButton>
   );
 
-  return formContext ? (
-    <Controller
-      name="category"
-      control={control}
-      render={() => (
-        <DropdownPopup
-          trigger={trigger}
-          items={menuItems}
-          isOpen={isOpen}
-          setIsOpen={setIsOpen}
-          menuId={menuId}
-          className="mt-2"
-          portal={portal}
-        />
-      )}
-    />
-  ) : (
+  const popup = (
     <DropdownPopup
       trigger={trigger}
       items={menuItems}
@@ -123,6 +195,42 @@ const CategorySelector: React.FC<CategorySelectorProps> = ({
       portal={portal}
     />
   );
+
+  const createForm = isCreating && (
+    <div className="mt-2 flex items-center gap-2">
+      <Input
+        ref={inputRef}
+        value={draft}
+        onChange={(e) => setDraft(e.target.value)}
+        onKeyDown={handleDraftKeyDown}
+        aria-label={t('com_ui_category_name')}
+        aria-describedby={invalidReason ? reasonId : undefined}
+        aria-invalid={invalidReason ? true : undefined}
+      />
+      <Button
+        type="button"
+        disabled={!canSubmit}
+        onClick={submitDraft}
+        aria-describedby={invalidReason ? reasonId : undefined}
+      >
+        {existing
+          ? t('com_ui_use_category', { 0: existing.label })
+          : t('com_ui_create_category', { 0: trimmed })}
+      </Button>
+      {invalidReason && (
+        <span id={reasonId} className="text-text-secondary text-sm">
+          {invalidReason}
+        </span>
+      )}
+    </div>
+  );
+
+  return (
+    <>
+      {formContext ? <Controller name="category" control={control} render={() => popup} /> : popup}
+      {createForm}
+    </>
+  );
 };
 
 export default CategorySelector;
diff --git a/client/src/components/Prompts/fields/__tests__/CategorySelector.spec.tsx b/client/src/components/Prompts/fields/__tests__/CategorySelector.spec.tsx
new file mode 100644
index 00000000000..20fff3ea026
--- /dev/null
+++ b/client/src/components/Prompts/fields/__tests__/CategorySelector.spec.tsx
@@ -0,0 +1,198 @@
+import React from 'react';
+import { RecoilRoot } from 'recoil';
+import '@testing-library/jest-dom/extend-expect';
+import { FormProvider, useForm } from 'react-hook-form';
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import { render, screen, fireEvent, waitFor } from '@testing-library/react';
+import type { TCategory } from 'librechat-data-provider';
+import { useGetCategories, useUpdatePromptGroup } from '~/data-provider';
+import CategorySelector from '../CategorySelector';
+
+const mockGetCategories = jest.fn();
+const mockGetStartupConfig = jest.fn();
+const mockUpdatePromptGroup = jest.fn();
+
+jest.mock('librechat-data-provider', () => {
+  const actual = jest.requireActual('librechat-data-provider');
+  return {
+    ...actual,
+    dataService: {
+      ...actual.dataService,
+      getCategories: () => mockGetCategories(),
+      getStartupConfig: () => mockGetStartupConfig(),
+      updatePromptGroup: (vars: unknown) => mockUpdatePromptGroup(vars),
+    },
+  };
+});
+
+const categories: TCategory[] = [
+  { value: 'hr', label: 'Human Resources' },
+  { value: 'idea', label: 'com_ui_idea' },
+];
+
+let formValues: { category?: string } = {};
+
+const FormProbe = ({ initial = '' }: { initial?: string }) => {
+  const methods = useForm({ defaultValues: { category: initial } });
+  formValues = methods.watch();
+  return (
+    <FormProvider {...methods}>
+      <CategorySelector portal={false} />
+    </FormProvider>
+  );
+};
+
+const renderSelector = (allowCustom?: boolean, initial?: string) => {
+  mockGetStartupConfig.mockResolvedValue(
+    allowCustom === undefined ? {} : { promptCategories: { allowCustom } },
+  );
+  const queryClient = new QueryClient();
+  const utils = render(
+    <QueryClientProvider client={queryClient}>
+      <RecoilRoot>
+        <FormProbe initial={initial} />
+      </RecoilRoot>
+    </QueryClientProvider>,
+  );
+  return { ...utils, queryClient };
+};
+
+const openMenu = async () => {
+  await waitFor(() => expect(mockGetCategories).toHaveBeenCalled());
+  fireEvent.click(screen.getByRole('button', { name: /category/i }));
+};
+
+const openForm = async () => {
+  await openMenu();
+  fireEvent.click(await screen.findByRole('menuitem', { name: /New category/ }));
+  return screen.findByRole('textbox', { name: 'Category name' });
+};
+
+describe('CategorySelector custom categories', () => {
+  beforeEach(() => {
+    formValues = {};
+    mockGetCategories.mockResolvedValue(categories);
+  });
+
+  afterEach(() => {
+    mockGetCategories.mockReset();
+    mockGetStartupConfig.mockReset();
+    mockUpdatePromptGroup.mockReset();
+    localStorage.clear();
+  });
+
+  it('creates a category from the keyboard and shows it in the trigger', async () => {
+    renderSelector(true);
+    const input = await openForm();
+    await waitFor(() => expect(input).toHaveFocus());
+
+    fireEvent.change(input, { target: { value: 'Onboarding' } });
+    expect(screen.getByRole('button', { name: 'Create “Onboarding”' })).toBeEnabled();
+    fireEvent.keyDown(input, { key: 'Enter' });
+
+    await waitFor(() => expect(formValues.category).toBe('Onboarding'));
+    expect(screen.getByRole('button', { name: /category/i })).toHaveTextContent('Onboarding');
+    expect(screen.queryByRole('textbox', { name: 'Category name' })).not.toBeInTheDocument();
+  });
+
+  it('closes the form on Escape and returns focus to the trigger', async () => {
+    renderSelector(true);
+    const input = await openForm();
+
+    fireEvent.keyDown(input, { key: 'Escape' });
+
+    expect(screen.queryByRole('textbox', { name: 'Category name' })).not.toBeInTheDocument();
+    expect(screen.getByRole('button', { name: /category/i })).toHaveFocus();
+  });
+
+  it.each([' hr ', 'human resources'])('reuses the existing category for %p', async (typed) => {
+    renderSelector(true);
+    const input = await openForm();
+
+    fireEvent.change(input, { target: { value: typed } });
+    fireEvent.click(screen.getByRole('button', { name: 'Use “Human Resources”' }));
+
+    await waitFor(() => expect(formValues.category).toBe('hr'));
+  });
+
+  it.each([
+    ['sys__x', 'reserved'],
+    ['a'.repeat(101), 'too long'],
+  ])('disables creation for %p and links the reason', async (typed, reason) => {
+    renderSelector(true);
+    const input = await openForm();
+
+    fireEvent.change(input, { target: { value: typed } });
+
+    const button = screen.getByRole('button', { name: /^Create/ });
+    expect(button).toBeDisabled();
+    const describedBy = button.getAttribute('aria-describedby') ?? '';
+    const message = document.getElementById(describedBy);
+    expect(message).toHaveTextContent(new RegExp(reason === 'reserved' ? 'sys__' : '100'));
+  });
+
+  it('offers no new-category item when custom categories are not allowed', async () => {
+    renderSelector(false);
+    await openMenu();
+
+    await screen.findByRole('menuitem', { name: /Human Resources/ });
+    expect(screen.queryByRole('menuitem', { name: /New category/ })).not.toBeInTheDocument();
+  });
+});
+
+describe('CategorySelector selected value missing from the list', () => {
+  beforeEach(() => {
+    mockGetCategories.mockResolvedValue(categories);
+  });
+
+  afterEach(() => {
+    mockGetCategories.mockReset();
+    mockGetStartupConfig.mockReset();
+  });
+
+  it('shows the placeholder when custom categories are not allowed', async () => {
+    renderSelector(false, 'travel');
+    await waitFor(() => expect(mockGetStartupConfig).toHaveBeenCalled());
+
+    const trigger = screen.getByRole('button', { name: /category/i });
+    expect(trigger).toHaveTextContent('Category');
+    expect(trigger).not.toHaveTextContent('travel');
+  });
+
+  it('shows the value itself when custom categories are allowed', async () => {
+    renderSelector(true, 'Onboarding');
+
+    await waitFor(() =>
+      expect(screen.getByRole('button', { name: /category/i })).toHaveTextContent('Onboarding'),
+    );
+  });
+});
+
+describe('categories invalidation after saving a group', () => {
+  it('refetches categories after a group update', async () => {
+    mockGetCategories.mockResolvedValue(categories);
+    mockUpdatePromptGroup.mockResolvedValue({ _id: 'g1' });
+    const Harness = () => {
+      useGetCategories();
+      const { mutate } = useUpdatePromptGroup();
+      return (
+        <button
+          data-testid="save"
+          onClick={() => mutate({ id: 'g1', payload: { category: 'x' } })}
+        />
+      );
+    };
+    render(
+      <QueryClientProvider client={new QueryClient()}>
+        <RecoilRoot>
+          <Harness />
+        </RecoilRoot>
+      </QueryClientProvider>,
+    );
+    await waitFor(() => expect(mockGetCategories).toHaveBeenCalledTimes(1));
+
+    fireEvent.click(screen.getByTestId('save'));
+
+    await waitFor(() => expect(mockGetCategories).toHaveBeenCalledTimes(2));
+  });
+});
diff --git a/client/src/components/Prompts/fields/__tests__/PromptDropdownIds.spec.tsx b/client/src/components/Prompts/fields/__tests__/PromptDropdownIds.spec.tsx
index 9252e839770..aaf0069e105 100644
--- a/client/src/components/Prompts/fields/__tests__/PromptDropdownIds.spec.tsx
+++ b/client/src/components/Prompts/fields/__tests__/PromptDropdownIds.spec.tsx
@@ -19,6 +19,10 @@ jest.mock('~/hooks', () => ({
   }),
 }));
 
+jest.mock('~/data-provider', () => ({
+  useGetStartupConfig: () => ({ data: undefined }),
+}));
+
 jest.mock('~/Providers', () => ({
   usePromptGroupsContext: () => ({ hasAccess: true }),
   useLiveAnnouncer: () => ({ announcePolite: mockAnnouncePolite }),
diff --git a/client/src/components/Prompts/sidebar/__tests__/FilterPrompts.spec.tsx b/client/src/components/Prompts/sidebar/__tests__/FilterPrompts.spec.tsx
new file mode 100644
index 00000000000..53bc47493e9
--- /dev/null
+++ b/client/src/components/Prompts/sidebar/__tests__/FilterPrompts.spec.tsx
@@ -0,0 +1,90 @@
+import React from 'react';
+import { RecoilRoot, useRecoilValue } from 'recoil';
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import { render, screen, fireEvent, waitFor } from '@testing-library/react';
+import type { TCategory } from 'librechat-data-provider';
+import FilterPrompts from '../FilterPrompts';
+import store from '~/store';
+
+jest.mock('../../buttons/CreatePromptButton', () => ({
+  __esModule: true,
+  default: () => null,
+}));
+
+const mockGetCategories = jest.fn();
+
+jest.mock('librechat-data-provider', () => {
+  const actual = jest.requireActual('librechat-data-provider');
+  return {
+    ...actual,
+    dataService: { ...actual.dataService, getCategories: () => mockGetCategories() },
+  };
+});
+
+const categories: TCategory[] = [
+  { value: 'hr', label: 'Human Resources', icon: 'users', color: 'series-7' },
+  { value: 'idea', label: 'com_ui_idea' },
+  { value: 'Onboarding', label: 'Onboarding', custom: true },
+];
+
+const CategoryProbe = () => (
+  <span data-testid="category">{useRecoilValue(store.promptsCategory)}</span>
+);
+
+const renderFilter = () =>
+  render(
+    <QueryClientProvider client={new QueryClient()}>
+      <RecoilRoot>
+        <FilterPrompts />
+        <CategoryProbe />
+      </RecoilRoot>
+    </QueryClientProvider>,
+  );
+
+describe('FilterPrompts', () => {
+  beforeEach(() => {
+    mockGetCategories.mockResolvedValue(categories);
+  });
+
+  afterEach(() => {
+    mockGetCategories.mockReset();
+  });
+
+  const openFilter = async () => {
+    await waitFor(() => expect(mockGetCategories).toHaveBeenCalled());
+    fireEvent.click(screen.getByRole('combobox', { name: 'Filter Prompts' }));
+    return screen.findByRole('option', { name: /Onboarding/ });
+  };
+
+  it('lists configured, localized and custom categories after the system entries', async () => {
+    renderFilter();
+    await openFilter();
+
+    const names = screen.getAllByRole('option').map((o) => o.textContent?.trim());
+    expect(names).toEqual(
+      expect.arrayContaining([
+        'All',
+        'My Prompts',
+        'Shared Prompts',
+        'Human Resources',
+        'Ideas',
+        'Onboarding',
+      ]),
+    );
+  });
+
+  it('renders the configured icon and color for a configured category', async () => {
+    renderFilter();
+    await openFilter();
+
+    const icon = screen.getByRole('option', { name: /Human Resources/ }).querySelector('svg');
+    expect(icon).toHaveClass('lucide-users', 'text-series-7');
+  });
+
+  it('filters by a custom category when it is selected', async () => {
+    renderFilter();
+    fireEvent.click(await openFilter());
+
+    await waitFor(() => expect(screen.getByTestId('category')).toHaveTextContent('Onboarding'));
+  });
+});
diff --git a/client/src/components/Prompts/utils/CategoryIcon.spec.tsx b/client/src/components/Prompts/utils/CategoryIcon.spec.tsx
index 84594373fa1..16fcf121b14 100644
--- a/client/src/components/Prompts/utils/CategoryIcon.spec.tsx
+++ b/client/src/components/Prompts/utils/CategoryIcon.spec.tsx
@@ -1,7 +1,20 @@
 import React from 'react';
 import { render } from '@testing-library/react';
+import { QueryKeys } from 'librechat-data-provider';
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import type { TCategory } from 'librechat-data-provider';
 import CategoryIcon from './CategoryIcon';
 
+const renderIcon = (category: string, configured: TCategory[] = []) => {
+  const queryClient = new QueryClient();
+  queryClient.setQueryData([QueryKeys.categories], configured);
+  return render(
+    <QueryClientProvider client={queryClient}>
+      <CategoryIcon category={category} />
+    </QueryClientProvider>,
+  );
+};
+
 const categoryColors = {
   code: 'text-series-5',
   misc: 'text-series-1',
@@ -24,7 +37,7 @@ describe('CategoryIcon', () => {
   it.each(Object.entries(categoryColors))(
     'uses the semantic series color for %s',
     (category, color) => {
-      const { container } = render(<CategoryIcon category={category} />);
+      const { container } = renderIcon(category);
       const icon = container.querySelector('svg');
 
       expect(icon).toHaveClass(color);
@@ -35,8 +48,29 @@ describe('CategoryIcon', () => {
   );
 
   it('uses secondary text for an unknown category', () => {
-    const { container } = render(<CategoryIcon category="unknown" />);
+    const { container } = renderIcon('unknown');
 
     expect(container.querySelector('svg')).toHaveClass('text-text-secondary');
   });
+
+  it('uses the configured icon and color over the built-in maps', () => {
+    const { container } = renderIcon('hr-team', [
+      { value: 'hr-team', label: 'HR', icon: 'users', color: 'series-7' },
+    ]);
+    const icon = container.querySelector('svg');
+
+    expect(icon).toHaveClass('lucide-users', 'text-series-7');
+  });
+
+  it('falls back to the file icon for an unknown value', () => {
+    const { container } = renderIcon('unknown');
+
+    expect(container.querySelector('svg')).toHaveClass('lucide-file-text', 'text-text-secondary');
+  });
+
+  it('keeps the built-in icon and color when the config has no entry', () => {
+    const { container } = renderIcon('code', [{ value: 'other', label: 'Other' }]);
+
+    expect(container.querySelector('svg')).toHaveClass('lucide-square-terminal', 'text-series-5');
+  });
 });
diff --git a/client/src/components/Prompts/utils/CategoryIcon.tsx b/client/src/components/Prompts/utils/CategoryIcon.tsx
index 4c826123dcf..f167d529df9 100644
--- a/client/src/components/Prompts/utils/CategoryIcon.tsx
+++ b/client/src/components/Prompts/utils/CategoryIcon.tsx
@@ -14,8 +14,37 @@ import {
   Beaker as BeakerIcon,
   Settings as SettingsIcon,
 } from 'lucide-react';
+import type { PromptCategoryColor, PromptCategoryIcon } from 'librechat-data-provider';
+import { useGetCategories } from '~/data-provider';
 import { cn } from '~/utils';
 
+const configIconMap: Record<PromptCategoryIcon, React.ElementType> = {
+  dices: Dices,
+  box: BoxIcon,
+  'file-text': FileText,
+  'pen-line': PenLineIcon,
+  lightbulb: LightbulbIcon,
+  'line-chart': LineChartIcon,
+  'shopping-bag': ShoppingBagIcon,
+  'plane-takeoff': PlaneTakeoffIcon,
+  'graduation-cap': GraduationCapIcon,
+  'terminal-square': TerminalSquareIcon,
+  users: UsersIcon,
+  beaker: BeakerIcon,
+  settings: SettingsIcon,
+};
+
+const configColorMap: Record<PromptCategoryColor, string> = {
+  'series-1': 'text-series-1',
+  'series-2': 'text-series-2',
+  'series-3': 'text-series-3',
+  'series-4': 'text-series-4',
+  'series-5': 'text-series-5',
+  'series-6': 'text-series-6',
+  'series-7': 'text-series-7',
+  'series-8': 'text-series-8',
+};
+
 const categoryIconMap: Record<string, React.ElementType> = {
   misc: BoxIcon,
   roleplay: Dices,
@@ -59,7 +88,13 @@ export default function CategoryIcon({
   category: string;
   className?: string;
 }) {
-  const IconComponent = categoryIconMap[category] ?? FileText;
-  const colorClass = categoryColorMap[category] ?? 'text-text-secondary';
+  const { data: categories } = useGetCategories();
+  const entry = categories?.find((c) => c.value === category);
+  const IconComponent =
+    (entry?.icon && configIconMap[entry.icon]) || categoryIconMap[category] || FileText;
+  const colorClass =
+    (entry?.color && configColorMap[entry.color]) ||
+    categoryColorMap[category] ||
+    'text-text-secondary';
   return <IconComponent className={cn('size-4', colorClass, className)} aria-hidden="true" />;
 }
diff --git a/client/src/components/Skills/forms/__tests__/CategorySelector.spec.tsx b/client/src/components/Skills/forms/__tests__/CategorySelector.spec.tsx
new file mode 100644
index 00000000000..a993f075959
--- /dev/null
+++ b/client/src/components/Skills/forms/__tests__/CategorySelector.spec.tsx
@@ -0,0 +1,64 @@
+import React from 'react';
+import { RecoilRoot } from 'recoil';
+import { useForm, FormProvider } from 'react-hook-form';
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import { render, screen, fireEvent, waitFor } from '@testing-library/react';
+import CategorySelector from '../CategorySelector';
+
+const mockGetCategories = jest.fn();
+
+jest.mock('librechat-data-provider', () => {
+  const actual = jest.requireActual('librechat-data-provider');
+  return {
+    ...actual,
+    dataService: { ...actual.dataService, getCategories: () => mockGetCategories() },
+  };
+});
+
+let currentCategory: string | undefined;
+
+const Harness = () => {
+  const methods = useForm({ defaultValues: { category: '' } });
+  currentCategory = methods.watch('category');
+  return (
+    <FormProvider {...methods}>
+      <CategorySelector />
+    </FormProvider>
+  );
+};
+
+describe('Skills CategorySelector', () => {
+  beforeEach(() => {
+    currentCategory = undefined;
+    mockGetCategories.mockResolvedValue([{ value: 'legal', label: 'Legal Team' }]);
+  });
+
+  afterEach(() => {
+    mockGetCategories.mockReset();
+  });
+
+  const openMenu = async () => {
+    render(
+      <QueryClientProvider client={new QueryClient()}>
+        <RecoilRoot>
+          <Harness />
+        </RecoilRoot>
+      </QueryClientProvider>,
+    );
+    await waitFor(() => expect(mockGetCategories).toHaveBeenCalled());
+    fireEvent.click(screen.getByRole('button', { name: 'Category' }));
+    return screen.findByRole('menuitem', { name: /Legal Team/ });
+  };
+
+  it('lists a configured label verbatim and sets the form category on click', async () => {
+    fireEvent.click(await openMenu());
+
+    await waitFor(() => expect(currentCategory).toBe('legal'));
+  });
+
+  it('offers only the listed categories, with no create option', async () => {
+    await openMenu();
+
+    expect(screen.getAllByRole('menuitem')).toHaveLength(1);
+  });
+});
diff --git a/client/src/data-provider/__tests__/promptCategories.test.tsx b/client/src/data-provider/__tests__/promptCategories.test.tsx
new file mode 100644
index 00000000000..ee7bea5af27
--- /dev/null
+++ b/client/src/data-provider/__tests__/promptCategories.test.tsx
@@ -0,0 +1,79 @@
+import { RecoilRoot } from 'recoil';
+import { dataService, QueryKeys } from 'librechat-data-provider';
+import { act, renderHook, waitFor } from '@testing-library/react';
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import type { ReactNode } from 'react';
+import { useDeletePrompt, useDeletePromptGroup } from '../prompts';
+
+jest.mock('librechat-data-provider', () => {
+  const actual = jest.requireActual('librechat-data-provider');
+  return {
+    ...actual,
+    dataService: {
+      ...actual.dataService,
+      deletePrompt: jest.fn(),
+      deletePromptGroup: jest.fn(),
+    },
+  };
+});
+
+const createWrapper = (queryClient: QueryClient) =>
+  function Wrapper({ children }: { children: ReactNode }) {
+    return (
+      <RecoilRoot>
+        <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
+      </RecoilRoot>
+    );
+  };
+
+describe('prompt category refresh on delete', () => {
+  let queryClient: QueryClient;
+  let invalidate: jest.SpyInstance;
+
+  beforeEach(() => {
+    queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } });
+    invalidate = jest.spyOn(queryClient, 'invalidateQueries');
+  });
+
+  it('invalidates categories after deleting a prompt group', async () => {
+    jest.mocked(dataService.deletePromptGroup).mockResolvedValue({ message: 'deleted' });
+    const { result } = renderHook(() => useDeletePromptGroup(), {
+      wrapper: createWrapper(queryClient),
+    });
+
+    await act(async () => {
+      await result.current.mutateAsync({ id: 'g1' });
+    });
+
+    await waitFor(() => expect(invalidate).toHaveBeenCalledWith([QueryKeys.categories]));
+  });
+
+  it('invalidates categories when deleting the last prompt removes its group', async () => {
+    jest.mocked(dataService.deletePrompt).mockResolvedValue({
+      prompt: 'p1',
+      promptGroup: { id: 'g1', message: 'deleted' },
+    });
+    const { result } = renderHook(() => useDeletePrompt(), {
+      wrapper: createWrapper(queryClient),
+    });
+
+    await act(async () => {
+      await result.current.mutateAsync({ _id: 'p1', groupId: 'g1' });
+    });
+
+    await waitFor(() => expect(invalidate).toHaveBeenCalledWith([QueryKeys.categories]));
+  });
+
+  it('leaves categories alone when only a non-final prompt is deleted', async () => {
+    jest.mocked(dataService.deletePrompt).mockResolvedValue({ prompt: 'p1' });
+    const { result } = renderHook(() => useDeletePrompt(), {
+      wrapper: createWrapper(queryClient),
+    });
+
+    await act(async () => {
+      await result.current.mutateAsync({ _id: 'p1', groupId: 'g1' });
+    });
+
+    expect(invalidate).not.toHaveBeenCalledWith([QueryKeys.categories]);
+  });
+});
diff --git a/client/src/data-provider/prompts.ts b/client/src/data-provider/prompts.ts
index 29efaff61a0..10463b01eec 100644
--- a/client/src/data-provider/prompts.ts
+++ b/client/src/data-provider/prompts.ts
@@ -86,6 +86,7 @@ export const useUpdatePromptGroup = (
     },
     onSuccess: (response, variables, context) => {
       updateGroupInAll(queryClient, { _id: variables.id, ...response });
+      queryClient.invalidateQueries([QueryKeys.categories]);
       if (onSuccess) {
         onSuccess(response, variables, context);
       }
@@ -126,6 +127,7 @@ export const useCreatePrompt = (
         );
 
         addGroupToAll(queryClient, group);
+        queryClient.invalidateQueries([QueryKeys.categories]);
         /** The sidebar reads row permissions from the batch map, which lacks the new group */
         queryClient.invalidateQueries([
           QueryKeys.effectivePermissions,
@@ -198,6 +200,7 @@ export const useDeletePrompt = (
         );
 
         removeGroupFromAll(queryClient, promptGroupId);
+        queryClient.invalidateQueries([QueryKeys.categories]);
       } else {
         queryClient.setQueryData<t.TPrompt[]>(
           [QueryKeys.prompts, variables.groupId],
@@ -257,6 +260,7 @@ export const useDeletePromptGroup = (
       );
 
       removeGroupFromAll(queryClient, variables.id);
+      queryClient.invalidateQueries([QueryKeys.categories]);
       if (onSuccess) {
         onSuccess(response, variables, context);
       }
diff --git a/client/src/hooks/Prompts/__tests__/useCategories.spec.tsx b/client/src/hooks/Prompts/__tests__/useCategories.spec.tsx
new file mode 100644
index 00000000000..7414871fa79
--- /dev/null
+++ b/client/src/hooks/Prompts/__tests__/useCategories.spec.tsx
@@ -0,0 +1,52 @@
+import React from 'react';
+import { dataService } from 'librechat-data-provider';
+import { renderHook, waitFor } from '@testing-library/react';
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import useCategories from '../useCategories';
+
+jest.mock('librechat-data-provider', () => ({
+  ...jest.requireActual('librechat-data-provider'),
+  dataService: { getCategories: jest.fn() },
+}));
+
+const getCategories = dataService.getCategories as jest.Mock;
+
+const renderCategories = () => {
+  const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } });
+  const wrapper = ({ children }: { children: React.ReactNode }) => (
+    <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
+  );
+  return renderHook(() => useCategories({}), { wrapper });
+};
+
+describe('useCategories', () => {
+  afterEach(() => getCategories.mockReset());
+
+  it('localizes com_ keys, keeps literal labels, and falls back to the value', async () => {
+    getCategories.mockResolvedValue([
+      { value: 'idea', label: 'com_ui_idea' },
+      { value: 'hr-team', label: 'Human Resources', custom: true },
+      { value: 'bare' },
+    ] as never);
+    const { result } = renderCategories();
+
+    await waitFor(() => expect(result.current.categories).toHaveLength(3));
+    const [idea, hr, bare] = result.current.categories as {
+      label: string;
+      custom?: boolean;
+    }[];
+    expect(idea.label).toBe('Ideas');
+    expect(hr.label).toBe('Human Resources');
+    expect(hr.custom).toBe(true);
+    expect(bare.label).toBe('bare');
+    expect(idea.custom).toBeUndefined();
+  });
+
+  it('keeps the loading placeholder when the request is rejected', async () => {
+    getCategories.mockRejectedValue(new Error('boom'));
+    const { result } = renderCategories();
+
+    await waitFor(() => expect(getCategories).toHaveBeenCalled());
+    expect(result.current.categories).toEqual([{ label: 'com_ui_loading', value: '' }]);
+  });
+});
diff --git a/client/src/hooks/Prompts/useCategories.tsx b/client/src/hooks/Prompts/useCategories.tsx
index daa4f47e9f9..594aae35e33 100644
--- a/client/src/hooks/Prompts/useCategories.tsx
+++ b/client/src/hooks/Prompts/useCategories.tsx
@@ -27,8 +27,11 @@ const useCategories = ({
     enabled: hasAccess,
     select: (data) =>
       data.map((category) => ({
-        label: localize(category.label as TranslationKeys),
+        label: category.label?.startsWith('com_')
+          ? localize(category.label as TranslationKeys)
+          : category.label || category.value,
         value: category.value,
+        ...(category.custom && { custom: true }),
         icon: category.value ? (
           <CategoryIcon category={category.value} className={className} />
         ) : null,
diff --git a/client/src/locales/en/translation.json b/client/src/locales/en/translation.json
index 1d776fdc72e..2b549d996ed 100644
--- a/client/src/locales/en/translation.json
+++ b/client/src/locales/en/translation.json
@@ -1344,6 +1344,10 @@
   "com_ui_capabilities_count": "{{count}} capabilities",
   "com_ui_capabilities_count_one": "{{count}} capability",
   "com_ui_category": "Category",
+  "com_ui_category_invalid_chars": "Category names cannot contain control characters",
+  "com_ui_category_name": "Category name",
+  "com_ui_category_reserved_prefix": "Category names cannot start with sys__",
+  "com_ui_category_too_long": "Category names are limited to 100 characters",
   "com_ui_change_project": "Change project",
   "com_ui_change_version": "Change Version",
   "com_ui_chat": "Chat",
@@ -1513,6 +1517,7 @@
   "com_ui_create": "Create",
   "com_ui_create_api_key": "Create API Key",
   "com_ui_create_assistant": "Create Assistant",
+  "com_ui_create_category": "Create “{{0}}”",
   "com_ui_create_link": "Create a shared link",
   "com_ui_create_mcp_server": "Create MCP server",
   "com_ui_create_memory": "Create Memory",
@@ -2087,6 +2092,7 @@
   "com_ui_navigate_results": "Navigate results",
   "com_ui_new": "New",
   "com_ui_new_action": "New action",
+  "com_ui_new_category": "New category…",
   "com_ui_new_chat": "New chat",
   "com_ui_new_chat_in_project": "New chat in {{name}}",
   "com_ui_new_conversation_title": "New Conversation Title",
@@ -3237,6 +3243,7 @@
   "com_ui_usage": "Usage",
   "com_ui_use_2fa_code": "Use 2FA Code Instead",
   "com_ui_use_backup_code": "Use Backup Code Instead",
+  "com_ui_use_category": "Use “{{0}}”",
   "com_ui_use_memory": "Use memory",
   "com_ui_use_micrphone": "Use microphone",
   "com_ui_use_prompt": "Use Prompt",
diff --git a/eslint-suppressions.json b/eslint-suppressions.json
index 0c430ac9be4..f2759bf6944 100644
--- a/eslint-suppressions.json
+++ b/eslint-suppressions.json
@@ -2183,4 +2183,4 @@
       "count": 1
     }
   }
-}
\ No newline at end of file
+}
diff --git a/librechat.example.yaml b/librechat.example.yaml
index 28ff6059494..dd192b0a928 100644
--- a/librechat.example.yaml
+++ b/librechat.example.yaml
@@ -414,6 +414,21 @@ interface:
   # retentionMode: "all"; non-agent files still expire.
   # retainAgentFiles: false
 
+# Prompt library categories (optional)
+# Without this section the nine built-in categories are shown, as before.
+# prompts:
+#   categories:
+#     enableDefaultCategories: true # false hides the built-ins; list entries still show
+#     allowCustom: false # true lets authors create categories when saving a prompt
+#     list: # up to 50 entries; values must be unique and cannot start with "sys__"
+#       - value: "hr"
+#         label: "Human Resources" # "com_" labels are translated; others show as written
+#         icon: "users" # dices, box, file-text, pen-line, lightbulb, line-chart, shopping-bag,
+#                       # plane-takeoff, graduation-cap, terminal-square, users, beaker, settings
+#         color: "series-7" # series-1 … series-8
+#       - value: "code" # matching a built-in overrides its label, icon and color in place
+#         label: "Engineering"
+
 # Example Cloudflare turnstile (optional)
 #turnstile:
 #  siteKey: "your-site-key-here"
diff --git a/packages/api/src/prompts/categories.spec.ts b/packages/api/src/prompts/categories.spec.ts
new file mode 100644
index 00000000000..38daae74cb8
--- /dev/null
+++ b/packages/api/src/prompts/categories.spec.ts
@@ -0,0 +1,233 @@
+import { defaultPromptCategories } from 'librechat-data-provider';
+import type { TPromptsConfig } from 'librechat-data-provider';
+import type { Response } from 'express';
+import type { ServerRequest } from '~/types';
+import {
+  resolvePromptCategories,
+  getPromptCategoriesStartupConfig,
+  createGetPromptCategoriesHandler,
+} from './categories';
+
+const cfg = (categories: NonNullable<TPromptsConfig>['categories']): TPromptsConfig => ({
+  categories,
+});
+
+describe('resolvePromptCategories', () => {
+  it('returns exactly the defaults when unconfigured', () => {
+    expect(resolvePromptCategories(undefined, [])).toEqual(defaultPromptCategories);
+    expect(resolvePromptCategories({}, ['x'])).toEqual(defaultPromptCategories);
+    expect(resolvePromptCategories(undefined, [])[0]).not.toBe(defaultPromptCategories[0]);
+  });
+
+  it('replaces defaults with the configured list, labels falling back to value', () => {
+    const result = resolvePromptCategories(
+      cfg({
+        enableDefaultCategories: false,
+        list: [
+          { value: 'hr' },
+          { value: 'legal', label: 'Legal', color: 'series-1' },
+          { value: 'ops' },
+        ],
+      }),
+      [],
+    );
+    expect(result).toEqual([
+      { value: 'hr', label: 'hr' },
+      { value: 'legal', label: 'Legal', color: 'series-1' },
+      { value: 'ops', label: 'ops' },
+    ]);
+  });
+
+  it('overrides a built-in in place and appends new entries', () => {
+    const result = resolvePromptCategories(
+      cfg({ list: [{ value: 'code', label: 'Engineering' }, { value: 'hr' }] }),
+      [],
+    );
+    expect(result).toHaveLength(10);
+    expect(result[5]).toEqual({ value: 'code', label: 'Engineering' });
+    expect(result[9]).toEqual({ value: 'hr', label: 'hr' });
+  });
+
+  it('matches built-ins case-insensitively and keeps the built-in value', () => {
+    const result = resolvePromptCategories(cfg({ list: [{ value: ' CODE ', icon: 'box' }] }), []);
+    expect(result).toHaveLength(9);
+    expect(result[5]).toMatchObject({ value: 'code', label: 'com_ui_code', icon: 'box' });
+  });
+
+  it('returns nothing when defaults are off and the list is empty', () => {
+    expect(resolvePromptCategories(cfg({ enableDefaultCategories: false, list: [] }), [])).toEqual(
+      [],
+    );
+  });
+
+  it('keeps a built-in-valued entry when defaults are off', () => {
+    expect(
+      resolvePromptCategories(
+        cfg({ enableDefaultCategories: false, list: [{ value: 'code' }] }),
+        [],
+      ),
+    ).toEqual([{ value: 'code', label: 'code' }]);
+  });
+
+  it('appends custom values after configured ones, deduping by exact value', () => {
+    const result = resolvePromptCategories(
+      cfg({ allowCustom: true, enableDefaultCategories: false, list: [{ value: 'hr' }] }),
+      ['hr', 'alpha', 'Alpha', 'beta', 'beta'],
+    );
+    expect(result).toEqual([
+      { value: 'hr', label: 'hr' },
+      { value: 'alpha', label: 'alpha', custom: true },
+      { value: 'Alpha', label: 'Alpha', custom: true },
+      { value: 'beta', label: 'beta', custom: true },
+    ]);
+  });
+
+  it('keeps a stored value that only matches a configured label', () => {
+    const result = resolvePromptCategories(
+      cfg({
+        allowCustom: true,
+        enableDefaultCategories: false,
+        list: [{ value: 'hr', label: 'People' }],
+      }),
+      ['People'],
+    );
+    expect(result).toEqual([
+      { value: 'hr', label: 'People' },
+      { value: 'People', label: 'People', custom: true },
+    ]);
+  });
+
+  it('trims configured values and labels', () => {
+    const result = resolvePromptCategories(
+      cfg({ enableDefaultCategories: false, list: [{ value: ' hr ', label: ' People ' }] }),
+      [],
+    );
+    expect(result).toEqual([{ value: 'hr', label: 'People' }]);
+  });
+
+  it('ignores custom values unless allowCustom is true', () => {
+    expect(resolvePromptCategories(cfg({ allowCustom: false }), ['alpha'])).toEqual(
+      defaultPromptCategories,
+    );
+  });
+});
+
+describe('createGetPromptCategoriesHandler', () => {
+  const makeRes = () => {
+    const res = { status: jest.fn(), send: jest.fn() };
+    res.status.mockReturnValue(res);
+    return res;
+  };
+  const makeReq = (prompts?: TPromptsConfig, filters?: unknown) =>
+    ({
+      config: { prompts, filters },
+      user: { id: 'u1', role: 'USER' },
+    }) as unknown as ServerRequest;
+
+  it('makes no reads when custom categories are off', async () => {
+    const getPromptGroupAccessContext = jest.fn();
+    const getDistinctPromptGroupCategories = jest.fn();
+    const res = makeRes();
+    await createGetPromptCategoriesHandler({
+      getPromptGroupAccessContext,
+      getDistinctPromptGroupCategories,
+      canUsePrompts: jest.fn().mockResolvedValue(true),
+    })(makeReq(), res as unknown as Response);
+    expect(getPromptGroupAccessContext).not.toHaveBeenCalled();
+    expect(getDistinctPromptGroupCategories).not.toHaveBeenCalled();
+    expect(res.status).toHaveBeenCalledWith(200);
+    expect(res.send).toHaveBeenCalledWith(defaultPromptCategories);
+  });
+
+  it('reads context then distinct categories once each when custom is on', async () => {
+    const getPromptGroupAccessContext = jest.fn().mockResolvedValue({ accessibleIds: ['a', 'b'] });
+    const getDistinctPromptGroupCategories = jest.fn().mockResolvedValue(['alpha']);
+    const res = makeRes();
+    await createGetPromptCategoriesHandler({
+      getPromptGroupAccessContext,
+      getDistinctPromptGroupCategories,
+      canUsePrompts: jest.fn().mockResolvedValue(true),
+    })(
+      makeReq({ categories: { allowCustom: true, enableDefaultCategories: false } }),
+      res as unknown as Response,
+    );
+    expect(getPromptGroupAccessContext).toHaveBeenCalledTimes(1);
+    expect(getPromptGroupAccessContext).toHaveBeenCalledWith({ userId: 'u1', role: 'USER' });
+    expect(getDistinctPromptGroupCategories).toHaveBeenCalledTimes(1);
+    expect(getDistinctPromptGroupCategories).toHaveBeenCalledWith(['a', 'b']);
+    expect(res.status).toHaveBeenCalledWith(200);
+    expect(res.send).toHaveBeenCalledWith([{ value: 'alpha', label: 'alpha', custom: true }]);
+  });
+
+  it('returns configured categories only, with no stored reads, without prompt-use permission', async () => {
+    const getPromptGroupAccessContext = jest.fn();
+    const getDistinctPromptGroupCategories = jest.fn();
+    const res = makeRes();
+    await createGetPromptCategoriesHandler({
+      getPromptGroupAccessContext,
+      getDistinctPromptGroupCategories,
+      canUsePrompts: jest.fn().mockResolvedValue(false),
+    })(
+      makeReq({
+        categories: {
+          allowCustom: true,
+          enableDefaultCategories: false,
+          list: [{ value: 'hr' }],
+        },
+      }),
+      res as unknown as Response,
+    );
+    expect(getPromptGroupAccessContext).not.toHaveBeenCalled();
+    expect(getDistinctPromptGroupCategories).not.toHaveBeenCalled();
+    expect(res.status).toHaveBeenCalledWith(200);
+    expect(res.send).toHaveBeenCalledWith([{ value: 'hr', label: 'hr' }]);
+  });
+
+  it('omits stored categories blocked by the current prompt content policy', async () => {
+    const res = makeRes();
+    const filters = {
+      prompts: {
+        pii: {
+          starterPatterns: [],
+          customPatterns: [{ id: 'private', label: 'private value', regex: 'PRIVATE-[A-Z]+' }],
+        },
+      },
+    };
+    await createGetPromptCategoriesHandler({
+      getPromptGroupAccessContext: jest.fn().mockResolvedValue({ accessibleIds: ['a'] }),
+      getDistinctPromptGroupCategories: jest.fn().mockResolvedValue(['PRIVATE-TEAM', 'alpha']),
+      canUsePrompts: jest.fn().mockResolvedValue(true),
+    })(
+      makeReq({ categories: { allowCustom: true, enableDefaultCategories: false } }, filters),
+      res as unknown as Response,
+    );
+    expect(res.send).toHaveBeenCalledWith([{ value: 'alpha', label: 'alpha', custom: true }]);
+  });
+
+  it('responds 500 with a fixed message and no error text', async () => {
+    const getPromptGroupAccessContext = jest.fn().mockRejectedValue(new Error('secret db text'));
+    const res = makeRes();
+    await createGetPromptCategoriesHandler({
+      getPromptGroupAccessContext,
+      getDistinctPromptGroupCategories: jest.fn(),
+      canUsePrompts: jest.fn().mockResolvedValue(true),
+    })(makeReq({ categories: { allowCustom: true } }), res as unknown as Response);
+    expect(res.status).toHaveBeenCalledWith(500);
+    expect(res.send).toHaveBeenCalledWith({ message: 'Failed to retrieve categories' });
+  });
+});
+
+describe('getPromptCategoriesStartupConfig', () => {
+  it('is false when unset', () => {
+    expect(getPromptCategoriesStartupConfig(undefined)).toEqual({ allowCustom: false });
+    expect(getPromptCategoriesStartupConfig({ prompts: { categories: {} } })).toEqual({
+      allowCustom: false,
+    });
+  });
+
+  it('is true when allowCustom is set', () => {
+    expect(
+      getPromptCategoriesStartupConfig({ prompts: { categories: { allowCustom: true } } }),
+    ).toEqual({ allowCustom: true });
+  });
+});
diff --git a/packages/api/src/prompts/categories.ts b/packages/api/src/prompts/categories.ts
new file mode 100644
index 00000000000..425e5f4dc62
--- /dev/null
+++ b/packages/api/src/prompts/categories.ts
@@ -0,0 +1,112 @@
+import { logger } from '@librechat/data-schemas';
+import { defaultPromptCategories } from 'librechat-data-provider';
+import type { TCategory, TPromptsConfig } from 'librechat-data-provider';
+import type { Response } from 'express';
+import type { ServerRequest } from '~/types';
+import { projectStoredPromptGroup } from './protection';
+
+type CategoryEntry = {
+  value: string;
+  label?: string;
+  icon?: TCategory['icon'];
+  color?: TCategory['color'];
+};
+
+type CategoryHandlerDeps<TIds> = {
+  getPromptGroupAccessContext: (params: {
+    userId: string;
+    role?: string;
+  }) => Promise<{ accessibleIds: TIds }>;
+  getDistinctPromptGroupCategories: (accessibleIds: TIds) => Promise<string[]>;
+  /** Whether the requester holds the prompt-use permission required to discover stored categories. */
+  canUsePrompts: (req: ServerRequest) => Promise<boolean>;
+};
+
+const normalize = (value: string): string => value.trim().toLowerCase();
+
+const fromEntry = ({ value, label, icon, color }: CategoryEntry): TCategory => ({
+  value,
+  label: label || value,
+  ...(icon && { icon }),
+  ...(color && { color }),
+});
+
+export function resolvePromptCategories(
+  config: TPromptsConfig | undefined,
+  customValues: string[],
+): TCategory[] {
+  const categories = config?.categories;
+  const entries: CategoryEntry[] = (categories?.list ?? []).map((entry) => ({
+    ...entry,
+    value: entry.value.trim(),
+    label: entry.label?.trim(),
+  }));
+  const result: TCategory[] =
+    categories?.enableDefaultCategories === false
+      ? []
+      : defaultPromptCategories.map((category) => ({ ...category }));
+  const builtinCount = result.length;
+
+  for (const entry of entries) {
+    const key = normalize(entry.value);
+    const index = result.findIndex(
+      (category, i) => i < builtinCount && normalize(category.value) === key,
+    );
+    if (index === -1) {
+      result.push(fromEntry(entry));
+      continue;
+    }
+    const { label, icon, color } = entry;
+    result[index] = {
+      ...result[index],
+      ...(label && { label }),
+      ...(icon && { icon }),
+      ...(color && { color }),
+    };
+  }
+
+  if (categories?.allowCustom !== true) {
+    return result;
+  }
+
+  const seen = new Set(result.map((c) => c.value));
+  for (const value of customValues) {
+    if (seen.has(value)) {
+      continue;
+    }
+    seen.add(value);
+    result.push({ value, label: value, custom: true });
+  }
+  return result;
+}
+
+export function createGetPromptCategoriesHandler<TIds>(
+  deps: CategoryHandlerDeps<TIds>,
+): (req: ServerRequest, res: Response) => Promise<void> {
+  return async (req: ServerRequest, res: Response): Promise<void> => {
+    try {
+      const config = req.config?.prompts;
+      let customValues: string[] = [];
+      if (config?.categories?.allowCustom === true && (await deps.canUsePrompts(req))) {
+        const { accessibleIds } = await deps.getPromptGroupAccessContext({
+          userId: req.user?.id ?? '',
+          role: req.user?.role,
+        });
+        const stored = await deps.getDistinctPromptGroupCategories(accessibleIds);
+        customValues = stored.filter(
+          (category) => projectStoredPromptGroup({ category }, req.config?.filters) != null,
+        );
+      }
+      res.status(200).send(resolvePromptCategories(config, customValues));
+    } catch (error) {
+      logger.error('[getPromptCategories] Failed to retrieve categories', error);
+      res.status(500).send({ message: 'Failed to retrieve categories' });
+    }
+  };
+}
+
+export function getPromptCategoriesStartupConfig(
+  appConfig: { prompts?: TPromptsConfig } | undefined,
+): { allowCustom: boolean } {
+  return { allowCustom: appConfig?.prompts?.categories?.allowCustom === true };
+}
diff --git a/packages/api/src/prompts/index.ts b/packages/api/src/prompts/index.ts
index c0215fdd613..398daaa0c9a 100644
--- a/packages/api/src/prompts/index.ts
+++ b/packages/api/src/prompts/index.ts
@@ -1,4 +1,5 @@
 export * from './access';
+export * from './categories';
 export * from './artifacts';
 export * from './errors';
 export * from './format';
diff --git a/packages/api/src/prompts/schemas.spec.ts b/packages/api/src/prompts/schemas.spec.ts
index f4de5af1118..216e6aa954b 100644
--- a/packages/api/src/prompts/schemas.spec.ts
+++ b/packages/api/src/prompts/schemas.spec.ts
@@ -1,5 +1,6 @@
 import {
   updatePromptGroupSchema,
+  safeValidatePromptGroupCategory,
   validatePromptGroupUpdate,
   safeValidatePromptPayload,
   safeValidatePromptGroupUpdate,
@@ -228,3 +229,27 @@ describe('safeValidatePromptGroupUpdate', () => {
     }
   });
 });
+
+describe('safeValidatePromptGroupCategory', () => {
+  it.each([['a'.repeat(101)], ['sys__x'], ['a\u0007b']])('should reject %j', (category) => {
+    expect(safeValidatePromptGroupCategory(category).success).toBe(false);
+  });
+
+  it('should accept an empty string', () => {
+    const result = safeValidatePromptGroupCategory('');
+    expect(result.success && result.data).toBe('');
+  });
+
+  it('should trim surrounding whitespace', () => {
+    const result = safeValidatePromptGroupCategory('  Onboarding  ');
+    expect(result.success && result.data).toBe('Onboarding');
+  });
+
+  it('should accept a 100 character category', () => {
+    expect(safeValidatePromptGroupCategory('a'.repeat(100)).success).toBe(true);
+  });
+
+  it('should reject a sys__ category on update', () => {
+    expect(safeValidatePromptGroupUpdate({ category: 'sys__x' }).success).toBe(false);
+  });
+});
diff --git a/packages/api/src/prompts/schemas.ts b/packages/api/src/prompts/schemas.ts
index 508a4d2dd3d..fd8b6488607 100644
--- a/packages/api/src/prompts/schemas.ts
+++ b/packages/api/src/prompts/schemas.ts
@@ -1,5 +1,12 @@
 import { z } from 'zod';
-import { Constants } from 'librechat-data-provider';
+import { Constants, promptCategoryValueSchema } from 'librechat-data-provider';
+
+type TPromptGroupCategorySchema = z.ZodUnion<[z.ZodLiteral<''>, typeof promptCategoryValueSchema]>;
+
+export const promptGroupCategorySchema: TPromptGroupCategorySchema = z.union([
+  z.literal(''),
+  promptCategoryValueSchema,
+]);
 
 export type TPromptPayloadSchema = {
   prompt: string;
@@ -38,7 +45,7 @@ export const updatePromptGroupSchema: z.ZodObject<
     /** Short description/oneliner for the prompt group */
     oneliner: z.ZodOptional<z.ZodString>;
     /** Category for organizing prompt groups */
-    category: z.ZodOptional<z.ZodString>;
+    category: z.ZodOptional<typeof promptGroupCategorySchema>;
     /** Command shortcut for the prompt group */
     command: z.ZodNullable<z.ZodOptional<z.ZodString>>;
   },
@@ -50,7 +57,7 @@ export const updatePromptGroupSchema: z.ZodObject<
     /** Short description/oneliner for the prompt group */
     oneliner: z.string().max(500).optional(),
     /** Category for organizing prompt groups */
-    category: z.string().max(100).optional(),
+    category: promptGroupCategorySchema.optional(),
     /** Command shortcut for the prompt group */
     command: z
       .string()
@@ -97,3 +104,9 @@ export function safeValidatePromptGroupUpdate(data: unknown): z.SafeParseReturnT
 > {
   return updatePromptGroupSchema.safeParse(data);
 }
+
+export function safeValidatePromptGroupCategory(
+  category: unknown,
+): z.SafeParseReturnType<unknown, string> {
+  return promptGroupCategorySchema.safeParse(category);
+}
diff --git a/packages/api/src/prompts/service.ts b/packages/api/src/prompts/service.ts
index 89f1d66aa35..ef4019d618f 100644
--- a/packages/api/src/prompts/service.ts
+++ b/packages/api/src/prompts/service.ts
@@ -23,6 +23,11 @@ import {
   projectStoredPromptGroup,
   projectStoredPromptGroups,
 } from './protection';
+import {
+  safeValidatePromptPayload,
+  safeValidatePromptGroupUpdate,
+  safeValidatePromptGroupCategory,
+} from './schemas';
 import {
   markPublicPromptGroups,
   buildPromptGroupFilter,
@@ -33,7 +38,6 @@ import {
   createNativePromptAdapter,
   selectionUnavailableReason,
 } from './native';
-import { safeValidatePromptGroupUpdate, safeValidatePromptPayload } from './schemas';
 import { withPromptStage } from './errors';
 
 type WithPromptFilters<T> = T & { readonly filters?: FiltersConfig };
@@ -179,15 +183,23 @@ export function createPromptServiceFromAdapters(adapters: PromptServiceAdapters)
       if (!input.prompt || !input.group || !input.group.name) {
         return invalidInput('Prompt and group name are required');
       }
+      let group = input.group;
+      if (group.category !== undefined) {
+        const category = safeValidatePromptGroupCategory(group.category);
+        if (!category.success) {
+          return invalidInput('Invalid request body', category.error.errors);
+        }
+        group = { ...group, category: category.data };
+      }
       const validation = safeValidatePromptPayload(input.prompt);
       if (!validation.success) {
         return invalidInput(validation.error.issues[0]?.message ?? 'Invalid prompt');
       }
-      const rejection = inspect({ prompt: validation.data, group: input.group }, filters);
+      const rejection = inspect({ prompt: validation.data, group }, filters);
       if (rejection != null) {
         return rejection;
       }
-      const value = await source.createPromptGroup({ ...input, prompt: validation.data });
+      const value = await source.createPromptGroup({ ...input, group, prompt: validation.data });
       const groupId = value.prompt?.groupId;
       if (value.prompt?._id && groupId) {
         try {
diff --git a/packages/data-provider/specs/config.spec.ts b/packages/data-provider/specs/config.spec.ts
new file mode 100644
index 00000000000..f3a2c9e0bd1
--- /dev/null
+++ b/packages/data-provider/specs/config.spec.ts
@@ -0,0 +1,73 @@
+import { promptsConfigSchema, defaultPromptCategories, configSchema } from '../src/config';
+
+const parse = (categories: unknown) => promptsConfigSchema.safeParse({ categories });
+const entries = (n: number) => Array.from({ length: n }, (_, i) => ({ value: `cat${i}` }));
+
+describe('prompts.categories', () => {
+  it('parses a valid full config', () => {
+    const result = parse({
+      enableDefaultCategories: false,
+      allowCustom: true,
+      list: [{ value: 'legal', label: 'Legal', icon: 'settings', color: 'series-3' }],
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it('parses when the section is missing', () => {
+    expect(promptsConfigSchema.safeParse(undefined).success).toBe(true);
+    expect(configSchema.safeParse({ version: '1.0.0' }).success).toBe(true);
+  });
+
+  it('rejects duplicate values differing by case or whitespace at the duplicate entry', () => {
+    const result = parse({ list: [{ value: 'Legal' }, { value: 'other' }, { value: ' legal ' }] });
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error.issues[0].path).toEqual(['categories', 'list', 2, 'value']);
+    }
+  });
+
+  it('rejects values with the reserved system prefix', () => {
+    expect(parse({ list: [{ value: 'sys__x' }] }).success).toBe(false);
+  });
+
+  it('rejects empty values', () => {
+    expect(parse({ list: [{ value: '' }] }).success).toBe(false);
+    expect(parse({ list: [{ value: '   ' }] }).success).toBe(false);
+  });
+
+  it('rejects control characters', () => {
+    expect(parse({ list: [{ value: 'a\u0007b' }] }).success).toBe(false);
+  });
+
+  it('rejects a 101-character value and accepts 100', () => {
+    expect(parse({ list: [{ value: 'a'.repeat(101) }] }).success).toBe(false);
+    expect(parse({ list: [{ value: 'a'.repeat(100) }] }).success).toBe(true);
+  });
+
+  it('rejects more than 50 entries and accepts 50', () => {
+    expect(parse({ list: entries(51) }).success).toBe(false);
+    expect(parse({ list: entries(50) }).success).toBe(true);
+  });
+
+  it('rejects an unknown icon', () => {
+    expect(parse({ list: [{ value: 'a', icon: 'rocket' }] }).success).toBe(false);
+  });
+
+  it('rejects an unknown color', () => {
+    expect(parse({ list: [{ value: 'a', color: 'series-9' }] }).success).toBe(false);
+  });
+
+  it('defaultPromptCategories matches the built-in categories', () => {
+    expect(defaultPromptCategories).toEqual([
+      { label: 'com_ui_idea', value: 'idea' },
+      { label: 'com_ui_travel', value: 'travel' },
+      { label: 'com_ui_teach_or_explain', value: 'teach_or_explain' },
+      { label: 'com_ui_write', value: 'write' },
+      { label: 'com_ui_shop', value: 'shop' },
+      { label: 'com_ui_code', value: 'code' },
+      { label: 'com_ui_misc', value: 'misc' },
+      { label: 'com_ui_roleplay', value: 'roleplay' },
+      { label: 'com_ui_finance', value: 'finance' },
+    ]);
+  });
+});
diff --git a/packages/data-provider/src/config.ts b/packages/data-provider/src/config.ts
index 05d522b8cd5..fbe38d1a6b4 100644
--- a/packages/data-provider/src/config.ts
+++ b/packages/data-provider/src/config.ts
@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import type { ZodError } from 'zod';
-import type { TEndpointsConfig, TModelsConfig, TConfig } from './types';
+import type { TEndpointsConfig, TModelsConfig, TCategory, TConfig } from './types';
 import {
   MAX_SUBAGENTS,
   MAX_SUBAGENTS_CEILING,
@@ -3131,6 +3131,7 @@ export function supportsConversationTitleOwnership(config?: {
 export type TStartupConfig = {
   conversationTitleOwnershipVersion?: typeof CONVERSATION_TITLE_OWNERSHIP_VERSION;
   appTitle: string;
+  promptCategories?: { allowCustom: boolean };
   socialLogins?: string[];
   langfuseFanoutEnabled?: boolean;
   langfuseConnectionAccess?: boolean;
@@ -3804,6 +3805,99 @@ export type TChatProjectsConfig = z.infer<typeof chatProjectsConfigSchema>;
 /** Maximum CAS attempts per ACL document, including the initial attempt. */
 export const permissionWriteAttemptsSchema = z.number().int().min(1).max(100).default(3);
 
+export const SYSTEM_CATEGORY_PREFIX = 'sys__';
+
+export const promptCategoryIcons = [
+  'dices',
+  'box',
+  'file-text',
+  'pen-line',
+  'lightbulb',
+  'line-chart',
+  'shopping-bag',
+  'plane-takeoff',
+  'graduation-cap',
+  'terminal-square',
+  'users',
+  'beaker',
+  'settings',
+] as const;
+export type PromptCategoryIcon = (typeof promptCategoryIcons)[number];
+
+export const promptCategoryColors = [
+  'series-1',
+  'series-2',
+  'series-3',
+  'series-4',
+  'series-5',
+  'series-6',
+  'series-7',
+  'series-8',
+] as const;
+export type PromptCategoryColor = (typeof promptCategoryColors)[number];
+
+export const promptCategoryValueSchema = z
+  .string()
+  .trim()
+  .min(1)
+  .max(100)
+  .refine((value) => !value.startsWith(SYSTEM_CATEGORY_PREFIX), {
+    message: `Category values cannot start with ${SYSTEM_CATEGORY_PREFIX}`,
+  })
+  .refine(
+    (value) =>
+      !value.split('').some((char) => char.charCodeAt(0) < 32 || char.charCodeAt(0) === 127),
+    {
+      message: 'Category values cannot contain control characters',
+    },
+  );
+
+export const promptCategoryEntrySchema = z.object({
+  value: promptCategoryValueSchema,
+  label: z.string().trim().min(1).max(100).optional(),
+  icon: z.enum(promptCategoryIcons).optional(),
+  color: z.enum(promptCategoryColors).optional(),
+});
+
+export const promptsConfigSchema = z
+  .object({
+    categories: z
+      .object({
+        enableDefaultCategories: z.boolean().optional(),
+        allowCustom: z.boolean().optional(),
+        list: z.array(promptCategoryEntrySchema).max(50).optional(),
+      })
+      .optional(),
+  })
+  .superRefine((config, ctx) => {
+    const seen = new Set<string>();
+    config.categories?.list?.forEach((entry, i) => {
+      const key = entry.value.toLowerCase();
+      if (seen.has(key)) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: `Duplicate category value: ${entry.value}`,
+          path: ['categories', 'list', i, 'value'],
+        });
+      }
+      seen.add(key);
+    });
+  })
+  .optional();
+export type TPromptsConfig = z.infer<typeof promptsConfigSchema>;
+
+export const defaultPromptCategories: TCategory[] = [
+  { label: 'com_ui_idea', value: 'idea' },
+  { label: 'com_ui_travel', value: 'travel' },
+  { label: 'com_ui_teach_or_explain', value: 'teach_or_explain' },
+  { label: 'com_ui_write', value: 'write' },
+  { label: 'com_ui_shop', value: 'shop' },
+  { label: 'com_ui_code', value: 'code' },
+  { label: 'com_ui_misc', value: 'misc' },
+  { label: 'com_ui_roleplay', value: 'roleplay' },
+  { label: 'com_ui_finance', value: 'finance' },
+];
+
 /**
  * Validation limits for the conversation list's filter facets. The field defaults are the
  * only definition of these values: `getConfigDefaults()` resolves them for AppService, and
@@ -3840,6 +3934,7 @@ export type TToolCallPreviewsConfig = z.infer<typeof toolCallPreviewsConfigSchem
 
 export const configSchema = z.object({
   version: z.string(),
+  prompts: promptsConfigSchema,
   permissions: z.object({ maxWriteAttempts: permissionWriteAttemptsSchema }).optional(),
   cache: z.boolean().default(true),
   projects: chatProjectsConfigSchema,
diff --git a/packages/data-provider/src/types.ts b/packages/data-provider/src/types.ts
index 0e6db56cf99..f5f58f463e4 100644
--- a/packages/data-provider/src/types.ts
+++ b/packages/data-provider/src/types.ts
@@ -10,17 +10,19 @@ import type {
   ReasoningResponseKey,
   ReasoningParameterFormat,
 } from './schemas';
+import type {
+  CodeEnvironmentUserConfigSchema,
+  CodeEnvironmentUserSettings,
+  PromptCategoryColor,
+  PromptCategoryIcon,
+  TAgentsEndpoint,
+} from './config';
 import type {
   CodeWorkspaceDescriptor,
   CodeEnvironmentMode,
   CodeWorkspaceOperation,
   CodeWorkspaceSelection,
 } from './code/workspace';
-import type {
-  CodeEnvironmentUserConfigSchema,
-  CodeEnvironmentUserSettings,
-  TAgentsEndpoint,
-} from './config';
 import type { BalanceRefillMode, RefillIntervalUnit } from './balance';
 import type { StatefulCodeEnvironment } from './stateful-code';
 import type { CodeApprovalMode } from './code/approval';
@@ -289,6 +291,8 @@ export type TCategory = {
   value: string;
   label: string;
   description?: string;
+  icon?: PromptCategoryIcon;
+  color?: PromptCategoryColor;
   custom?: boolean;
 };
 
diff --git a/packages/data-schemas/src/app/service.spec.ts b/packages/data-schemas/src/app/service.spec.ts
index 7bb03200867..4aafd3045c2 100644
--- a/packages/data-schemas/src/app/service.spec.ts
+++ b/packages/data-schemas/src/app/service.spec.ts
@@ -377,3 +377,24 @@ describe('AppService memory capability', () => {
     );
   });
 });
+
+describe('AppService prompts config', () => {
+  it('loads the prompts section into the app config', async () => {
+    const config = {
+      prompts: {
+        categories: {
+          enableDefaultCategories: false,
+          allowCustom: true,
+          list: [{ value: 'support', label: 'Support' }],
+        },
+      },
+    } as DeepPartial<TCustomConfig>;
+    const result = await AppService({ config });
+    expect(result.prompts).toEqual(config.prompts);
+  });
+
+  it('leaves prompts undefined when the section is absent', async () => {
+    const result = await AppService({ config: {} });
+    expect(result.prompts).toBeUndefined();
+  });
+});
diff --git a/packages/data-schemas/src/app/service.ts b/packages/data-schemas/src/app/service.ts
index 725fd4f644a..76644afa478 100644
--- a/packages/data-schemas/src/app/service.ts
+++ b/packages/data-schemas/src/app/service.ts
@@ -206,6 +206,7 @@ export const AppService = async (params?: {
     paths,
     config,
     memory,
+    prompts: config.prompts as AppConfig['prompts'],
     speech,
     actions,
     balance,
diff --git a/packages/data-schemas/src/methods/categories.ts b/packages/data-schemas/src/methods/categories.ts
index 3fb86929437..416992f14fc 100644
--- a/packages/data-schemas/src/methods/categories.ts
+++ b/packages/data-schemas/src/methods/categories.ts
@@ -1,17 +1,6 @@
+import { defaultPromptCategories } from 'librechat-data-provider';
 import logger from '~/config/winston';
 
-const options = [
-  { label: 'com_ui_idea', value: 'idea' },
-  { label: 'com_ui_travel', value: 'travel' },
-  { label: 'com_ui_teach_or_explain', value: 'teach_or_explain' },
-  { label: 'com_ui_write', value: 'write' },
-  { label: 'com_ui_shop', value: 'shop' },
-  { label: 'com_ui_code', value: 'code' },
-  { label: 'com_ui_misc', value: 'misc' },
-  { label: 'com_ui_roleplay', value: 'roleplay' },
-  { label: 'com_ui_finance', value: 'finance' },
-] as const;
-
 export type CategoryOption = { label: string; value: string };
 
 export function createCategoriesMethods(_mongoose: typeof import('mongoose')): {
@@ -22,7 +11,7 @@ export function createCategoriesMethods(_mongoose: typeof import('mongoose')): {
    */
   async function getCategories(): Promise<CategoryOption[]> {
     try {
-      return [...options];
+      return defaultPromptCategories.map((c) => ({ ...c }));
     } catch (error) {
       logger.error('Error getting categories', error);
       return [];
diff --git a/packages/data-schemas/src/methods/prompt.spec.ts b/packages/data-schemas/src/methods/prompt.spec.ts
index 60e7f36a268..3b8154495b1 100644
--- a/packages/data-schemas/src/methods/prompt.spec.ts
+++ b/packages/data-schemas/src/methods/prompt.spec.ts
@@ -624,6 +624,62 @@ describe('Prompt ACL Permissions', () => {
   });
 });
 
+describe('distinct categories', () => {
+  const seed = async (categories: string[]) => {
+    const docs = await PromptGroup.insertMany(
+      categories.map((category, i) => ({
+        name: `Distinct Group ${i}`,
+        category,
+        author: testUsers.owner._id,
+        authorName: testUsers.owner.name,
+        productionId: new mongoose.Types.ObjectId(),
+      })),
+    );
+    return docs.map((doc) => doc._id as mongoose.Types.ObjectId);
+  };
+
+  afterEach(async () => {
+    await PromptGroup.deleteMany({ name: /^Distinct Group/ });
+  });
+
+  it('reads only groups whose ids are passed', async () => {
+    const [visible] = await seed(['Visible', 'Secret']);
+    expect(await methods.getDistinctPromptGroupCategories([visible])).toEqual(['Visible']);
+  });
+
+  it('excludes empty categories, system-prefixed values and values over 100 characters', async () => {
+    const ids = await seed(['', 'sys__x', 'a'.repeat(101), 'Keep']);
+    expect(await methods.getDistinctPromptGroupCategories(ids)).toEqual(['Keep']);
+  });
+
+  it('trims values and drops duplicates after trimming', async () => {
+    const ids = await seed([' Alpha ', 'Alpha']);
+    expect(await methods.getDistinctPromptGroupCategories(ids)).toEqual(['Alpha']);
+  });
+
+  it('sorts case-insensitively', async () => {
+    const ids = await seed(['beta', 'Alpha', 'gamma']);
+    expect(await methods.getDistinctPromptGroupCategories(ids)).toEqual(['Alpha', 'beta', 'gamma']);
+  });
+
+  it('caps the result at 200 values', async () => {
+    const ids = await seed(
+      Array.from({ length: 250 }, (_, i) => `cat-${String(i).padStart(3, '0')}`),
+    );
+    const result = await methods.getDistinctPromptGroupCategories(ids);
+    expect(result).toHaveLength(200);
+    expect(result[0]).toBe('cat-000');
+    expect(result[199]).toBe('cat-199');
+  });
+
+  it('returns [] without querying when no ids are passed', async () => {
+    const spy = jest.spyOn(PromptGroup, 'distinct');
+    expect(await methods.getDistinctPromptGroupCategories([])).toEqual([]);
+    expect(spy).not.toHaveBeenCalled();
+    spy.mockRestore();
+  });
+});
+
 describe('Prompt method failure contracts', () => {
   const dbError = new Error('database unavailable');
 
diff --git a/packages/data-schemas/src/methods/prompt.ts b/packages/data-schemas/src/methods/prompt.ts
index a7aba67d98b..bebef0746c3 100644
--- a/packages/data-schemas/src/methods/prompt.ts
+++ b/packages/data-schemas/src/methods/prompt.ts
@@ -5,6 +5,7 @@ import {
   ResourceType,
   SystemCategories,
   Time,
+  promptCategoryValueSchema,
 } from 'librechat-data-provider';
 import type { Model, Types } from 'mongoose';
 import type {
@@ -98,6 +99,8 @@ async function readAccessGeneration(cache: CacheStore): Promise<string | undefin
   }
 }
 
+const MAX_CUSTOM_PROMPT_CATEGORIES = 200;
+
 /**
  * Plain listing inputs. `name` is a case-insensitive substring; `category` is the stored
  * category value, where an empty string selects groups without a category.
@@ -132,6 +135,7 @@ export interface PromptMethods {
     has_more: boolean;
     after: string | null;
   }>;
+  getDistinctPromptGroupCategories(accessibleIds: Types.ObjectId[]): Promise<string[]>;
   incrementPromptGroupUsage(groupId: string): Promise<{ numberOfGenerations: number }>;
   createPromptGroup(saveData: {
     prompt: Record<string, unknown>;
@@ -494,6 +498,35 @@ export function createPromptMethods(
     };
   }
 
+  /**
+   * Get the sorted, validated custom category values used by the given prompt groups.
+   */
+  async function getDistinctPromptGroupCategories(
+    accessibleIds: Types.ObjectId[],
+  ): Promise<string[]> {
+    if (accessibleIds.length === 0) {
+      return [];
+    }
+
+    const PromptGroup = mongoose.models.PromptGroup as Model<IPromptGroupDocument>;
+    const stored = await PromptGroup.distinct('category', {
+      _id: { $in: accessibleIds },
+      category: { $nin: ['', null] },
+    });
+
+    const values = new Set<string>();
+    for (const category of stored) {
+      const parsed = promptCategoryValueSchema.safeParse(category);
+      if (parsed.success) {
+        values.add(parsed.data);
+      }
+    }
+
+    return [...values]
+      .sort((a, b) => a.localeCompare(b, undefined, { sensitivity: 'base' }))
+      .slice(0, MAX_CUSTOM_PROMPT_CATEGORIES);
+  }
+
   /**
    * Increment the numberOfGenerations counter for a prompt group.
    */
@@ -1131,6 +1164,7 @@ export function createPromptMethods(
     deletePromptGroup,
     getAllPromptGroups,
     getListPromptGroupsByAccess,
+    getDistinctPromptGroupCategories,
     incrementPromptGroupUsage,
     createPromptGroup,
     savePrompt,
diff --git a/packages/data-schemas/src/types/app.ts b/packages/data-schemas/src/types/app.ts
index 92ab7c996ea..6e54f534f74 100644
--- a/packages/data-schemas/src/types/app.ts
+++ b/packages/data-schemas/src/types/app.ts
@@ -6,6 +6,7 @@ import type {
   TCustomConfig,
   TChatProjectsConfig,
   TMemoryConfig,
+  TPromptsConfig,
   EModelEndpoint,
   TVertexAIConfig,
   TAgentsEndpoint,
@@ -52,6 +53,8 @@ export interface FunctionTool {
 export interface AppConfig {
   /** The main custom configuration */
   config: Partial<TCustomConfig>;
+  /** Prompt library configuration */
+  prompts?: TPromptsConfig;
   /** OCR configuration */
   ocr?: TCustomConfig['ocr'];
   /** File paths configuration */