From d5cccb5f18e8b776d0f07ec6e635080760c5700d Mon Sep 17 00:00:00 2001
From: Marco Beretta <81851188+berry-13@users.noreply.github.com>
Date: Fri, 3 Jul 2026 01:12:31 +0200
Subject: [PATCH] feat: add favorites for marketplace tools, MCP servers, and
 skills

Reintroduce the favorite star from the old skill picker, generalized to
every marketplace item kind except per-agent actions. Cards in the Tool
Library and Skills dialogs get a hover-revealed star (always visible once
favorited), and the existing Favorites views in both dialogs now filter to
starred items.

Favorites persist in a dedicated ToolFavorite collection, one document per
(user, itemType, itemId) with a unique compound index, exposed through
atomic per-item PUT/DELETE endpoints under /api/user/settings/favorites/
tools. Per-item writes are idempotent and race-free across tabs/devices
(the unique index backstops concurrent toggles), reads are a single
index-backed query capped at 100 favorites per user, and the client keeps
React Query as the source of truth with optimistic updates. Handlers live
in @librechat/api with a thin route wrapper; methods follow the
data-schemas factory pattern with tenant isolation.

The favorites filter now matches on compound kind:id keys instead of bare
ids, closing a cross-kind collision where a tool and a skill sharing an id
would both match. The skill-favorites data-service stubs and the reserved
TUserFavorite.skillId field are replaced by the new tool-favorites service.
---
 api/server/routes/settings.js                 |  15 ++
 .../Agents/Tools/MarketplaceCatalog.tsx       |   7 +
 .../SidePanel/Agents/Tools/SkillsDialog.tsx   |  38 ++--
 .../SidePanel/Agents/Tools/ToolCard.tsx       |  75 ++++++--
 .../Agents/Tools/ToolsMarketplaceDialog.tsx   |  26 +--
 .../Agents/Tools/__tests__/ToolCard.spec.tsx  |  71 +++++++
 .../__tests__/ToolsMarketplaceDialog.spec.tsx |  36 +++-
 .../Tools/items/__tests__/filtering.spec.ts   |  48 ++++-
 .../SidePanel/Agents/Tools/items/filtering.ts |   9 +-
 client/src/data-provider/Favorites.ts         |  66 ++++---
 .../hooks/__tests__/useToolFavorites.spec.tsx | 117 ++++++++++++
 client/src/hooks/index.ts                     |   1 +
 client/src/hooks/useToolFavorites.ts          |  90 +++++++++
 client/src/locales/en/translation.json        |   1 +
 client/src/utils/favoritesError.ts            |  10 +-
 packages/api/src/favorites/handlers.spec.ts   | 178 ++++++++++++++++++
 packages/api/src/favorites/handlers.ts        | 126 +++++++++++++
 packages/api/src/favorites/index.ts           |   1 +
 packages/api/src/index.ts                     |   1 +
 packages/data-provider/src/api-endpoints.ts   |   5 +
 packages/data-provider/src/data-service.ts    |  18 +-
 packages/data-provider/src/keys.ts            |   4 +-
 packages/data-provider/src/types/queries.ts   |  14 +-
 packages/data-schemas/src/index.ts            |   2 +
 .../data-schemas/src/methods/favorite.spec.ts | 153 +++++++++++++++
 packages/data-schemas/src/methods/favorite.ts |  90 +++++++++
 packages/data-schemas/src/methods/index.ts    |  10 +
 packages/data-schemas/src/models/favorite.ts  |  12 ++
 packages/data-schemas/src/models/index.ts     |   3 +
 packages/data-schemas/src/schema/favorite.ts  |  40 ++++
 packages/data-schemas/src/schema/index.ts     |   1 +
 packages/data-schemas/src/types/favorite.ts   |  35 ++++
 packages/data-schemas/src/types/index.ts      |   1 +
 33 files changed, 1190 insertions(+), 114 deletions(-)
 create mode 100644 client/src/hooks/__tests__/useToolFavorites.spec.tsx
 create mode 100644 client/src/hooks/useToolFavorites.ts
 create mode 100644 packages/api/src/favorites/handlers.spec.ts
 create mode 100644 packages/api/src/favorites/handlers.ts
 create mode 100644 packages/api/src/favorites/index.ts
 create mode 100644 packages/data-schemas/src/methods/favorite.spec.ts
 create mode 100644 packages/data-schemas/src/methods/favorite.ts
 create mode 100644 packages/data-schemas/src/models/favorite.ts
 create mode 100644 packages/data-schemas/src/schema/favorite.ts
 create mode 100644 packages/data-schemas/src/types/favorite.ts

diff --git a/api/server/routes/settings.js b/api/server/routes/settings.js
index c6b7c84b2c..38b353d560 100644
--- a/api/server/routes/settings.js
+++ b/api/server/routes/settings.js
@@ -1,4 +1,5 @@
 const express = require('express');
+const { createToolFavoritesHandlers } = require('@librechat/api');
 const {
   updateFavoritesController,
   getFavoritesController,
@@ -8,9 +9,23 @@ const {
   updateSkillStatesController,
 } = require('~/server/controllers/SkillStatesController');
 const { requireJwtAuth } = require('~/server/middleware');
+const { getToolFavorites, addToolFavorite, removeToolFavorite } = require('~/models');
 
 const router = express.Router();
 
+const toolFavorites = createToolFavoritesHandlers({
+  getToolFavorites,
+  addToolFavorite,
+  removeToolFavorite,
+});
+
+router.get('/favorites/tools', requireJwtAuth, toolFavorites.listToolFavorites);
+router.put('/favorites/tools/:itemType/:itemId', requireJwtAuth, toolFavorites.addToolFavorite);
+router.delete(
+  '/favorites/tools/:itemType/:itemId',
+  requireJwtAuth,
+  toolFavorites.removeToolFavorite,
+);
 router.get('/favorites', requireJwtAuth, getFavoritesController);
 router.post('/favorites', requireJwtAuth, updateFavoritesController);
 router.get('/skills/active', requireJwtAuth, getSkillStatesController);
diff --git a/client/src/components/SidePanel/Agents/Tools/MarketplaceCatalog.tsx b/client/src/components/SidePanel/Agents/Tools/MarketplaceCatalog.tsx
index 8fbd4ab6ac..5d719984e1 100644
--- a/client/src/components/SidePanel/Agents/Tools/MarketplaceCatalog.tsx
+++ b/client/src/components/SidePanel/Agents/Tools/MarketplaceCatalog.tsx
@@ -16,6 +16,9 @@ interface MarketplaceCatalogProps {
   view?: View;
   isLoadingSkills?: boolean;
   skillsInView?: boolean;
+  /** Compound `kind:id` keys of the user's favorited items. */
+  favoriteKeys?: Set<string>;
+  onToggleFavorite?: (item: AgentItem) => void;
   /** Overrides the default per-view empty message (e.g. "No skills found"). */
   emptyKey?: TranslationKeys;
   /** Accessible label for the grid; defaults to the marketplace label. */
@@ -54,6 +57,8 @@ export default function MarketplaceCatalog({
   view = 'marketplace',
   isLoadingSkills = false,
   skillsInView = false,
+  favoriteKeys,
+  onToggleFavorite,
   emptyKey,
   ariaLabel,
 }: MarketplaceCatalogProps) {
@@ -84,6 +89,8 @@ export default function MarketplaceCatalog({
             selected={selectedIds.has(itemKey(item))}
             onToggle={onToggle}
             onConfigure={onConfigure}
+            isFavorited={favoriteKeys?.has(itemKey(item)) ?? false}
+            onToggleFavorite={onToggleFavorite}
           />
         </li>
       ))}
diff --git a/client/src/components/SidePanel/Agents/Tools/SkillsDialog.tsx b/client/src/components/SidePanel/Agents/Tools/SkillsDialog.tsx
index 9c425fa05c..03b16d4e36 100644
--- a/client/src/components/SidePanel/Agents/Tools/SkillsDialog.tsx
+++ b/client/src/components/SidePanel/Agents/Tools/SkillsDialog.tsx
@@ -16,14 +16,10 @@ import type { TranslationKeys } from '~/hooks/useLocalize';
 import type { CategoryOption } from './CategoryFilter';
 import type { AgentItem } from './items/types';
 import type { AgentForm } from '~/common';
-import {
-  useListSkillsQuery,
-  useGetFavoritesQuery,
-  useGetSkillFavoritesQuery,
-} from '~/data-provider';
-import { useLocalize, useHasAccess, useAuthContext } from '~/hooks';
+import { useLocalize, useHasAccess, useAuthContext, useToolFavorites } from '~/hooks';
 import { CreateSkillDialog } from '~/components/Skills/dialogs';
 import MarketplaceCatalog from './MarketplaceCatalog';
+import { useListSkillsQuery } from '~/data-provider';
 import { CategoryIcon } from '~/components/Prompts';
 import { buildSkillItems } from './items/catalog';
 import ItemDialog from './ItemDialog/ItemDialog';
@@ -62,24 +58,7 @@ export default function SkillsDialog({ open, onOpenChange, agentId }: SkillsDial
     { limit: 100 },
     { enabled: hasSkillsAccess },
   );
-  const { data: favorites } = useGetFavoritesQuery();
-  const { data: skillFavorites } = useGetSkillFavoritesQuery();
-
-  /** Phase 2 (favorites backend): skill favorites resolve from a stubbed
-   * data-service route and no UI toggles them yet, so the "Favorites" view
-   * stays empty until the backend route and a star affordance land. */
-  const favoritedIds = useMemo(() => {
-    const ids = new Set<string>();
-    for (const favorite of favorites ?? []) {
-      if (favorite.skillId != null) {
-        ids.add(favorite.skillId);
-      }
-    }
-    for (const skillId of skillFavorites ?? []) {
-      ids.add(skillId);
-    }
-    return ids;
-  }, [favorites, skillFavorites]);
+  const { favoriteKeys, toggle: toggleFavorite } = useToolFavorites();
 
   const skillsField = useWatch({ control, name: 'skills' });
   const selectedIds = useMemo(
@@ -120,8 +99,13 @@ export default function SkillsDialog({ open, onOpenChange, agentId }: SkillsDial
   }, [catalog]);
 
   const filtered = useMemo(
-    () => applyFilter(catalog, { search, kind: 'skill', category, view }, { favoritedIds }),
-    [catalog, search, category, view, favoritedIds],
+    () =>
+      applyFilter(
+        catalog,
+        { search, kind: 'skill', category, view },
+        { favoritedIds: favoriteKeys },
+      ),
+    [catalog, search, category, view, favoriteKeys],
   );
 
   const handleSkillCreated = useCallback(
@@ -226,6 +210,8 @@ export default function SkillsDialog({ open, onOpenChange, agentId }: SkillsDial
               view={view}
               isLoadingSkills={isLoadingSkills}
               skillsInView={view !== 'mine'}
+              favoriteKeys={favoriteKeys}
+              onToggleFavorite={toggleFavorite}
               emptyKey={emptyKey}
               ariaLabel={localize('com_ui_skills')}
             />
diff --git a/client/src/components/SidePanel/Agents/Tools/ToolCard.tsx b/client/src/components/SidePanel/Agents/Tools/ToolCard.tsx
index 0244fffe33..f5864ec733 100644
--- a/client/src/components/SidePanel/Agents/Tools/ToolCard.tsx
+++ b/client/src/components/SidePanel/Agents/Tools/ToolCard.tsx
@@ -1,5 +1,5 @@
 import { memo, useState } from 'react';
-import { BadgeCheck, Check, Globe, Info, Settings, User } from 'lucide-react';
+import { BadgeCheck, Check, Globe, Info, Settings, Star, User } from 'lucide-react';
 import type { TranslationKeys } from '~/hooks/useLocalize';
 import type { AgentItem } from './items/types';
 import { hasConfigurableSettings } from './items/configurable';
@@ -12,6 +12,8 @@ interface ToolCardProps {
   selected: boolean;
   onToggle: (item: AgentItem) => void;
   onConfigure?: (item: AgentItem) => void;
+  isFavorited?: boolean;
+  onToggleFavorite?: (item: AgentItem) => void;
 }
 
 function useDisplayStrings(item: AgentItem): { name: string; description: string } {
@@ -76,12 +78,20 @@ function ItemIconView({ item, size }: ItemIconProps) {
   );
 }
 
-function ToolCardImpl({ item, selected, onToggle, onConfigure }: ToolCardProps) {
+function ToolCardImpl({
+  item,
+  selected,
+  onToggle,
+  onConfigure,
+  isFavorited = false,
+  onToggleFavorite,
+}: ToolCardProps) {
   const localize = useLocalize();
   const { name, description } = useDisplayStrings(item);
   const { user } = useAuthContext();
   const isNative = item.kind === 'builtin';
   const kindLabel = localize(KIND_LABEL_KEYS[item.kind]);
+  const canFavorite = onToggleFavorite !== undefined && item.kind !== 'action';
   const canConfigure = hasConfigurableSettings(item) && onConfigure !== undefined;
   const skill = item.kind === 'skill' ? item.skill : undefined;
   const isPublicSkill = skill?.isPublic === true;
@@ -180,25 +190,50 @@ function ToolCardImpl({ item, selected, onToggle, onConfigure }: ToolCardProps)
           </div>
         ) : null}
       </button>
-      {(canConfigure || showInfoOnly) && (
-        <button
-          type="button"
-          onClick={(e) => {
-            e.stopPropagation();
-            onConfigure?.(item);
-          }}
-          aria-label={
-            canConfigure ? localize('com_ui_tools_configure') : localize('com_ui_tools_info')
-          }
-          className={cn(
-            'absolute bottom-2 right-2 flex size-7 items-center justify-center rounded-lg text-text-secondary',
-            'opacity-0 transition duration-150 hover:bg-surface-hover hover:text-text-primary',
-            'group-focus-within:opacity-100 group-hover:opacity-100',
-            'focus:outline-none focus-visible:opacity-100 focus-visible:ring-2 focus-visible:ring-ring-primary',
+      {(canFavorite || canConfigure || showInfoOnly) && (
+        <div className="absolute bottom-2 right-2 flex items-center gap-1">
+          {canFavorite && (
+            <button
+              type="button"
+              onClick={(e) => {
+                e.stopPropagation();
+                onToggleFavorite?.(item);
+              }}
+              aria-pressed={isFavorited}
+              aria-label={localize(isFavorited ? 'com_ui_unfavorite' : 'com_ui_favorite')}
+              className={cn(
+                'flex size-7 items-center justify-center rounded-lg text-text-secondary',
+                'opacity-0 transition duration-150 hover:bg-surface-hover hover:text-text-primary',
+                'group-focus-within:opacity-100 group-hover:opacity-100',
+                'focus:outline-none focus-visible:opacity-100 focus-visible:ring-2 focus-visible:ring-ring-primary',
+                isFavorited &&
+                  'text-amber-600 opacity-100 hover:text-amber-500 dark:text-amber-500 dark:hover:text-amber-400',
+              )}
+            >
+              <Star className={cn('size-4', isFavorited && 'fill-current')} aria-hidden="true" />
+            </button>
           )}
-        >
-          <DetailIcon className="size-4" aria-hidden="true" />
-        </button>
+          {(canConfigure || showInfoOnly) && (
+            <button
+              type="button"
+              onClick={(e) => {
+                e.stopPropagation();
+                onConfigure?.(item);
+              }}
+              aria-label={
+                canConfigure ? localize('com_ui_tools_configure') : localize('com_ui_tools_info')
+              }
+              className={cn(
+                'flex size-7 items-center justify-center rounded-lg text-text-secondary',
+                'opacity-0 transition duration-150 hover:bg-surface-hover hover:text-text-primary',
+                'group-focus-within:opacity-100 group-hover:opacity-100',
+                'focus:outline-none focus-visible:opacity-100 focus-visible:ring-2 focus-visible:ring-ring-primary',
+              )}
+            >
+              <DetailIcon className="size-4" aria-hidden="true" />
+            </button>
+          )}
+        </div>
       )}
     </div>
   );
diff --git a/client/src/components/SidePanel/Agents/Tools/ToolsMarketplaceDialog.tsx b/client/src/components/SidePanel/Agents/Tools/ToolsMarketplaceDialog.tsx
index 9d9d578bd9..efaaa90967 100644
--- a/client/src/components/SidePanel/Agents/Tools/ToolsMarketplaceDialog.tsx
+++ b/client/src/components/SidePanel/Agents/Tools/ToolsMarketplaceDialog.tsx
@@ -14,13 +14,12 @@ import { useAgentItems, useUninstallToolCredentials } from './hooks';
 import AddMcpServerDialog from './ItemDialog/AddMcpServerDialog';
 import { itemKey, mcpServerToken } from './items/selectors';
 import { computeToggleAction } from './items/mutations';
-import { useGetFavoritesQuery } from '~/data-provider';
+import { useLocalize, useToolFavorites } from '~/hooks';
 import MarketplaceSidebar from './MarketplaceSidebar';
 import MarketplaceCatalog from './MarketplaceCatalog';
 import ItemDialog from './ItemDialog/ItemDialog';
 import { applyFilter } from './items/filtering';
 import { NEW_ACTION_ID } from './items/types';
-import { useLocalize } from '~/hooks';
 
 interface ToolsMarketplaceDialogProps {
   open: boolean;
@@ -43,21 +42,7 @@ export default function ToolsMarketplaceDialog({
   /** Skills are excluded here — they have their own picker (`SkillsDialog`). */
   const { catalog, selected: selectedItems } = useAgentItems({ agentId });
 
-  const { data: favorites } = useGetFavoritesQuery();
-
-  /** Phase 2 (favorites backend): the favorites API only stores agent favorites
-   * today, so nothing here ever matches a catalog item id and the sidebar's
-   * "Favorites" view stays empty — same for "Made by you", which only skills
-   * populate (and this dialog excludes skills). Both views are kept visible as
-   * scaffolding until tool favoriting/ownership lands server-side. */
-  const favoritedIds = useMemo(() => {
-    const ids = new Set<string>();
-    for (const favorite of favorites ?? []) {
-      if (favorite.agentId != null) ids.add(favorite.agentId);
-      if (favorite.spec != null) ids.add(favorite.spec);
-    }
-    return ids;
-  }, [favorites]);
+  const { favoriteKeys, toggle: toggleFavorite } = useToolFavorites();
 
   const [view, setView] = useState<View>('marketplace');
   const [kind, setKind] = useState<Kind>('all');
@@ -97,8 +82,9 @@ export default function ToolsMarketplaceDialog({
   );
 
   const filtered = useMemo(
-    () => applyFilter(catalog, { search, kind, category: 'all', view }, { favoritedIds }),
-    [catalog, search, kind, view, favoritedIds],
+    () =>
+      applyFilter(catalog, { search, kind, category: 'all', view }, { favoritedIds: favoriteKeys }),
+    [catalog, search, kind, view, favoriteKeys],
   );
 
   const handleToggle = useCallback(
@@ -225,6 +211,8 @@ export default function ToolsMarketplaceDialog({
                 onToggle={handleCardClick}
                 onConfigure={handleConfigure}
                 view={view}
+                favoriteKeys={favoriteKeys}
+                onToggleFavorite={toggleFavorite}
               />
             </div>
           </div>
diff --git a/client/src/components/SidePanel/Agents/Tools/__tests__/ToolCard.spec.tsx b/client/src/components/SidePanel/Agents/Tools/__tests__/ToolCard.spec.tsx
index 74eb0be9ad..3c45b1abfa 100644
--- a/client/src/components/SidePanel/Agents/Tools/__tests__/ToolCard.spec.tsx
+++ b/client/src/components/SidePanel/Agents/Tools/__tests__/ToolCard.spec.tsx
@@ -103,4 +103,75 @@ describe('ToolCard', () => {
     render(<ToolCard item={own} selected={false} onToggle={jest.fn()} />);
     expect(screen.queryByText('Me')).not.toBeInTheDocument();
   });
+
+  describe('favorite star', () => {
+    test('renders with add label and aria-pressed=false when not favorited', () => {
+      render(
+        <ToolCard
+          item={skill}
+          selected={false}
+          onToggle={jest.fn()}
+          onToggleFavorite={jest.fn()}
+        />,
+      );
+      const star = screen.getByRole('button', { name: 'com_ui_favorite' });
+      expect(star).toHaveAttribute('aria-pressed', 'false');
+    });
+
+    test('clicking the star calls onToggleFavorite without toggling the card', () => {
+      const onToggle = jest.fn();
+      const onToggleFavorite = jest.fn();
+      render(
+        <ToolCard
+          item={skill}
+          selected={false}
+          onToggle={onToggle}
+          onToggleFavorite={onToggleFavorite}
+        />,
+      );
+      fireEvent.click(screen.getByRole('button', { name: 'com_ui_favorite' }));
+      expect(onToggleFavorite).toHaveBeenCalledWith(skill);
+      expect(onToggle).not.toHaveBeenCalled();
+    });
+
+    test('a favorited card keeps the star visible with the remove label', () => {
+      render(
+        <ToolCard
+          item={skill}
+          selected={false}
+          onToggle={jest.fn()}
+          isFavorited
+          onToggleFavorite={jest.fn()}
+        />,
+      );
+      const star = screen.getByRole('button', { name: 'com_ui_unfavorite' });
+      expect(star).toHaveAttribute('aria-pressed', 'true');
+      expect(star).toHaveClass('opacity-100');
+    });
+
+    test('renders no star without an onToggleFavorite handler', () => {
+      render(<ToolCard item={skill} selected={false} onToggle={jest.fn()} />);
+      expect(screen.queryByRole('button', { name: 'com_ui_favorite' })).not.toBeInTheDocument();
+    });
+
+    test('renders no star for action items', () => {
+      const action: AgentItem = {
+        kind: 'action',
+        id: 'a1',
+        name: 'My Action',
+        description: '',
+        iconKey: 'action',
+        endpointCount: 0,
+      };
+      render(
+        <ToolCard
+          item={action}
+          selected={false}
+          onToggle={jest.fn()}
+          onToggleFavorite={jest.fn()}
+        />,
+      );
+      expect(screen.queryByRole('button', { name: 'com_ui_favorite' })).not.toBeInTheDocument();
+    });
+  });
 });
diff --git a/client/src/components/SidePanel/Agents/Tools/__tests__/ToolsMarketplaceDialog.spec.tsx b/client/src/components/SidePanel/Agents/Tools/__tests__/ToolsMarketplaceDialog.spec.tsx
index d51e7412fe..f9a9aee91a 100644
--- a/client/src/components/SidePanel/Agents/Tools/__tests__/ToolsMarketplaceDialog.spec.tsx
+++ b/client/src/components/SidePanel/Agents/Tools/__tests__/ToolsMarketplaceDialog.spec.tsx
@@ -36,11 +36,21 @@ jest.mock('~/Providers', () => ({
   }),
 }));
 
+const mockToggleFavorite = jest.fn();
+let mockFavoriteKeys = new Set<string>();
+
 jest.mock('~/hooks', () => ({
   useLocalize: () => (key: string) => key,
   useHasAccess: () => true,
   useCategories: () => ({ categories: [] }),
   useAuthContext: () => ({ user: { id: 'u1' } }),
+  useToolFavorites: () => ({
+    favoriteKeys: mockFavoriteKeys,
+    toggle: mockToggleFavorite,
+    isFavorite: (item: { kind: string; id: string }) =>
+      mockFavoriteKeys.has(`${item.kind}:${item.id}`),
+    isLoading: false,
+  }),
 }));
 
 jest.mock('@ariakit/react/menu', () => ({
@@ -49,8 +59,7 @@ jest.mock('@ariakit/react/menu', () => ({
 
 jest.mock('~/data-provider', () => ({
   useListSkillsQuery: () => ({ data: { skills: [] }, isLoading: false }),
-  useGetFavoritesQuery: () => ({ data: [] }),
-  useGetSkillFavoritesQuery: () => ({ data: [] }),
+  useGetToolFavoritesQuery: () => ({ data: [] }),
 }));
 
 jest.mock('react-router-dom', () => ({
@@ -144,6 +153,8 @@ describe('ToolsMarketplaceDialog', () => {
     mockSetValue.mockClear();
     mockGetValues.mockClear();
     mockGetValues.mockReturnValue([]);
+    mockToggleFavorite.mockClear();
+    mockFavoriteKeys = new Set<string>();
   });
 
   test('renders cards from catalog when open', () => {
@@ -186,4 +197,25 @@ describe('ToolsMarketplaceDialog', () => {
       expect.objectContaining({ shouldDirty: true }),
     );
   });
+
+  test('clicking a card star toggles the favorite without selecting the tool', () => {
+    render(<ToolsMarketplaceDialog open onOpenChange={jest.fn()} agentId="a1" />);
+    fireEvent.click(screen.getAllByRole('button', { name: 'com_ui_favorite' })[0]);
+    expect(mockToggleFavorite).toHaveBeenCalledTimes(1);
+    expect(mockSetValue).not.toHaveBeenCalled();
+  });
+
+  test('the Favorites view shows only favorited items', () => {
+    mockFavoriteKeys = new Set(['tool:dalle']);
+    render(<ToolsMarketplaceDialog open onOpenChange={jest.fn()} agentId="a1" />);
+    fireEvent.click(screen.getByRole('button', { name: /com_ui_tools_view_favorites/ }));
+    expect(screen.getByText('DALL-E')).toBeInTheDocument();
+    expect(screen.queryByText('com_ui_run_code')).not.toBeInTheDocument();
+  });
+
+  test('the Favorites view is empty without favorites', () => {
+    render(<ToolsMarketplaceDialog open onOpenChange={jest.fn()} agentId="a1" />);
+    fireEvent.click(screen.getByRole('button', { name: /com_ui_tools_view_favorites/ }));
+    expect(screen.getByText('com_ui_tools_view_favorites_empty')).toBeInTheDocument();
+  });
 });
diff --git a/client/src/components/SidePanel/Agents/Tools/items/__tests__/filtering.spec.ts b/client/src/components/SidePanel/Agents/Tools/items/__tests__/filtering.spec.ts
index 812f392fd8..7e87b3653a 100644
--- a/client/src/components/SidePanel/Agents/Tools/items/__tests__/filtering.spec.ts
+++ b/client/src/components/SidePanel/Agents/Tools/items/__tests__/filtering.spec.ts
@@ -1,6 +1,6 @@
-import { applyFilter, matchesView } from '../filtering';
-import { makePlugin, makeSkill } from 'test/itemFactories';
 import type { AgentItem } from '../types';
+import { makePlugin, makeSkill } from 'test/itemFactories';
+import { applyFilter, matchesView } from '../filtering';
 
 const items: AgentItem[] = [
   {
@@ -81,11 +81,47 @@ describe('applyFilter', () => {
     expect(result.map((i) => i.id)).toEqual(['s1']);
   });
 
-  test('"favorites" view returns only favorited ids', () => {
-    const result = applyFilter(items, { view: 'favorites' }, { favoritedIds: new Set(['dalle']) });
+  test('"favorites" view returns only items matching compound kind:id keys', () => {
+    const result = applyFilter(
+      items,
+      { view: 'favorites' },
+      { favoritedIds: new Set(['tool:dalle']) },
+    );
     expect(result.map((i) => i.id)).toEqual(['dalle']);
   });
 
+  test('"favorites" view does not match bare ids (cross-kind collision guard)', () => {
+    const result = applyFilter(items, { view: 'favorites' }, { favoritedIds: new Set(['dalle']) });
+    expect(result.length).toBe(0);
+  });
+
+  test('"favorites" view distinguishes the same id across kinds', () => {
+    const collision: AgentItem[] = [
+      {
+        kind: 'tool',
+        id: 'shared-id',
+        name: 'Tool',
+        description: '',
+        iconKey: 'tool',
+        plugin: makePlugin({ pluginKey: 'shared-id' }),
+      },
+      {
+        kind: 'skill',
+        id: 'shared-id',
+        name: 'Skill',
+        description: '',
+        iconKey: 'skill',
+        skill: makeSkill({ _id: 'shared-id' }),
+      },
+    ];
+    const result = applyFilter(
+      collision,
+      { view: 'favorites' },
+      { favoritedIds: new Set(['skill:shared-id']) },
+    );
+    expect(result.map((i) => i.kind)).toEqual(['skill']);
+  });
+
   test('"favorites" view with no favorited set returns nothing', () => {
     expect(applyFilter(items, { view: 'favorites' }).length).toBe(0);
   });
@@ -116,8 +152,8 @@ describe('matchesView', () => {
     expect(matchesView(tool, 'mine', {})).toBe(false);
   });
 
-  test('"favorites" matches only ids in the favorited set', () => {
-    const context = { favoritedIds: new Set(['s1']) };
+  test('"favorites" matches only compound keys in the favorited set', () => {
+    const context = { favoritedIds: new Set(['skill:s1']) };
     expect(matchesView(ownedSkill, 'favorites', context)).toBe(true);
     expect(matchesView(unownedSkill, 'favorites', context)).toBe(false);
   });
diff --git a/client/src/components/SidePanel/Agents/Tools/items/filtering.ts b/client/src/components/SidePanel/Agents/Tools/items/filtering.ts
index bccea3ef45..ede1e4e374 100644
--- a/client/src/components/SidePanel/Agents/Tools/items/filtering.ts
+++ b/client/src/components/SidePanel/Agents/Tools/items/filtering.ts
@@ -1,4 +1,5 @@
 import type { AgentItem, ItemFilter } from './types';
+import { itemKey } from './selectors';
 
 /**
  * Extra, non-serializable inputs the view filter needs. Kept out of
@@ -6,7 +7,11 @@ import type { AgentItem, ItemFilter } from './types';
  * — like the set of favorited ids — can be threaded in by callers.
  */
 export interface FilterContext {
-  /** Ids of items the user has favorited; required for the `favorites` view. */
+  /**
+   * Compound `kind:id` keys (the `itemKey` format) of the user's favorited
+   * items; required for the `favorites` view. Compound keys prevent an item
+   * of one kind from matching a favorite of another kind with the same id.
+   */
   favoritedIds?: Set<string>;
 }
 
@@ -42,7 +47,7 @@ export function matchesView(
     case 'mine':
       return item.ownedByUser === true;
     case 'favorites':
-      return context.favoritedIds?.has(item.id) === true;
+      return context.favoritedIds?.has(itemKey(item)) === true;
     default:
       return true;
   }
diff --git a/client/src/data-provider/Favorites.ts b/client/src/data-provider/Favorites.ts
index 19571a1887..4bac514ab5 100644
--- a/client/src/data-provider/Favorites.ts
+++ b/client/src/data-provider/Favorites.ts
@@ -1,8 +1,12 @@
 import { dataService, QueryKeys } from 'librechat-data-provider';
 import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
 import type { UseQueryOptions } from '@tanstack/react-query';
+import type { TToolFavorite } from 'librechat-data-provider';
 import type { FavoritesState } from '~/store/favorites';
 
+const sameFavorite = (a: TToolFavorite, b: TToolFavorite) =>
+  a.itemType === b.itemType && a.itemId === b.itemId;
+
 export const useGetFavoritesQuery = (
   config?: Omit<UseQueryOptions<FavoritesState, Error>, 'queryKey' | 'queryFn'>,
 ) => {
@@ -40,12 +44,12 @@ export const useUpdateFavoritesMutation = () => {
   );
 };
 
-export const useGetSkillFavoritesQuery = (
-  config?: Omit<UseQueryOptions<string[], Error>, 'queryKey' | 'queryFn'>,
+export const useGetToolFavoritesQuery = (
+  config?: Omit<UseQueryOptions<TToolFavorite[], Error>, 'queryKey' | 'queryFn'>,
 ) => {
-  return useQuery<string[], Error>(
-    [QueryKeys.skillFavorites],
-    () => dataService.getSkillFavorites() as Promise<string[]>,
+  return useQuery<TToolFavorite[], Error>(
+    [QueryKeys.toolFavorites],
+    () => dataService.getToolFavorites(),
     {
       refetchOnWindowFocus: false,
       refetchOnReconnect: false,
@@ -55,23 +59,41 @@ export const useGetSkillFavoritesQuery = (
   );
 };
 
-export const useUpdateSkillFavoritesMutation = () => {
+export const useAddToolFavoriteMutation = () => {
   const queryClient = useQueryClient();
-  return useMutation(
-    (skillFavorites: string[]) =>
-      dataService.updateSkillFavorites(skillFavorites) as Promise<string[]>,
-    {
-      onMutate: async (newFavorites) => {
-        await queryClient.cancelQueries([QueryKeys.skillFavorites]);
-        const previous = queryClient.getQueryData<string[]>([QueryKeys.skillFavorites]);
-        queryClient.setQueryData([QueryKeys.skillFavorites], newFavorites);
-        return { previous };
-      },
-      onError: (_err, _newFavorites, context) => {
-        if (context?.previous !== undefined) {
-          queryClient.setQueryData([QueryKeys.skillFavorites], context.previous);
-        }
-      },
+  return useMutation((favorite: TToolFavorite) => dataService.addToolFavorite(favorite), {
+    onMutate: async (favorite) => {
+      await queryClient.cancelQueries([QueryKeys.toolFavorites]);
+      const previous = queryClient.getQueryData<TToolFavorite[]>([QueryKeys.toolFavorites]);
+      queryClient.setQueryData<TToolFavorite[]>([QueryKeys.toolFavorites], (current) => {
+        const list = current ?? [];
+        return list.some((f) => sameFavorite(f, favorite)) ? list : [...list, favorite];
+      });
+      return { previous };
     },
-  );
+    onError: (_err, _favorite, context) => {
+      if (context?.previous !== undefined) {
+        queryClient.setQueryData([QueryKeys.toolFavorites], context.previous);
+      }
+    },
+  });
+};
+
+export const useRemoveToolFavoriteMutation = () => {
+  const queryClient = useQueryClient();
+  return useMutation((favorite: TToolFavorite) => dataService.removeToolFavorite(favorite), {
+    onMutate: async (favorite) => {
+      await queryClient.cancelQueries([QueryKeys.toolFavorites]);
+      const previous = queryClient.getQueryData<TToolFavorite[]>([QueryKeys.toolFavorites]);
+      queryClient.setQueryData<TToolFavorite[]>([QueryKeys.toolFavorites], (current) =>
+        (current ?? []).filter((f) => !sameFavorite(f, favorite)),
+      );
+      return { previous };
+    },
+    onError: (_err, _favorite, context) => {
+      if (context?.previous !== undefined) {
+        queryClient.setQueryData([QueryKeys.toolFavorites], context.previous);
+      }
+    },
+  });
 };
diff --git a/client/src/hooks/__tests__/useToolFavorites.spec.tsx b/client/src/hooks/__tests__/useToolFavorites.spec.tsx
new file mode 100644
index 0000000000..d2672bf2df
--- /dev/null
+++ b/client/src/hooks/__tests__/useToolFavorites.spec.tsx
@@ -0,0 +1,117 @@
+import React from 'react';
+import { renderHook, act, waitFor } from '@testing-library/react';
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import type { TToolFavorite } from 'librechat-data-provider';
+import useToolFavorites from '../useToolFavorites';
+
+const mockShowToast = jest.fn();
+const mockGetToolFavorites = jest.fn();
+const mockAddToolFavorite = jest.fn();
+const mockRemoveToolFavorite = jest.fn();
+
+jest.mock('librechat-data-provider', () => {
+  const actual = jest.requireActual('librechat-data-provider');
+  return {
+    ...actual,
+    dataService: {
+      ...actual.dataService,
+      getToolFavorites: (...args: unknown[]) => mockGetToolFavorites(...args),
+      addToolFavorite: (...args: unknown[]) => mockAddToolFavorite(...args),
+      removeToolFavorite: (...args: unknown[]) => mockRemoveToolFavorite(...args),
+    },
+  };
+});
+
+jest.mock('@librechat/client', () => ({
+  useToastContext: () => ({ showToast: mockShowToast }),
+}));
+
+jest.mock('../useLocalize', () => ({
+  __esModule: true,
+  default:
+    () =>
+    (key: string, options?: Record<string, unknown>): string =>
+      options ? `${key}[${Object.values(options).join(',')}]` : key,
+}));
+
+function createWrapper() {
+  const queryClient = new QueryClient({
+    defaultOptions: {
+      queries: { retry: false },
+      mutations: { retry: false },
+    },
+    logger: { log: () => {}, warn: () => {}, error: () => {} },
+  });
+  return function Wrapper({ children }: { children: React.ReactNode }) {
+    return <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>;
+  };
+}
+
+const seeded: TToolFavorite[] = [
+  { itemType: 'tool', itemId: 'dalle' },
+  { itemType: 'mcp', itemId: 'everything' },
+];
+
+beforeEach(() => {
+  jest.clearAllMocks();
+  mockGetToolFavorites.mockResolvedValue(seeded);
+  mockAddToolFavorite.mockImplementation((favorite) => Promise.resolve(favorite));
+  mockRemoveToolFavorite.mockResolvedValue({ ok: true });
+});
+
+describe('useToolFavorites', () => {
+  test('exposes favorites as compound kind:id keys', async () => {
+    const { result } = renderHook(() => useToolFavorites(), { wrapper: createWrapper() });
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(result.current.favoriteKeys).toEqual(new Set(['tool:dalle', 'mcp:everything']));
+    expect(result.current.isFavorite({ kind: 'tool', id: 'dalle' })).toBe(true);
+    expect(result.current.isFavorite({ kind: 'skill', id: 'dalle' })).toBe(false);
+  });
+
+  test('toggle adds an unfavorited item and removes a favorited one', async () => {
+    const { result } = renderHook(() => useToolFavorites(), { wrapper: createWrapper() });
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+    await act(async () => {
+      await result.current.toggle({ kind: 'skill', id: 's1' });
+    });
+    expect(mockAddToolFavorite).toHaveBeenCalledWith({ itemType: 'skill', itemId: 's1' });
+    await waitFor(() => expect(result.current.isFavorite({ kind: 'skill', id: 's1' })).toBe(true));
+
+    await act(async () => {
+      await result.current.toggle({ kind: 'tool', id: 'dalle' });
+    });
+    expect(mockRemoveToolFavorite).toHaveBeenCalledWith({ itemType: 'tool', itemId: 'dalle' });
+    await waitFor(() =>
+      expect(result.current.isFavorite({ kind: 'tool', id: 'dalle' })).toBe(false),
+    );
+  });
+
+  test('never favorites actions', async () => {
+    const { result } = renderHook(() => useToolFavorites(), { wrapper: createWrapper() });
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+    await act(async () => {
+      await result.current.toggle({ kind: 'action', id: 'a1' });
+    });
+    expect(mockAddToolFavorite).not.toHaveBeenCalled();
+    expect(result.current.isFavorite({ kind: 'action', id: 'a1' })).toBe(false);
+  });
+
+  test('shows the item-worded cap toast and rolls back on rejection', async () => {
+    mockAddToolFavorite.mockRejectedValue({
+      response: { data: { code: 'MAX_FAVORITES_EXCEEDED', limit: 100 } },
+    });
+    const { result } = renderHook(() => useToolFavorites(), { wrapper: createWrapper() });
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+    await act(async () => {
+      await result.current.toggle({ kind: 'skill', id: 's1' });
+    });
+    expect(mockShowToast).toHaveBeenCalledWith({
+      message: 'com_ui_max_favorites_reached_items[100]',
+      status: 'error',
+    });
+    await waitFor(() => expect(result.current.isFavorite({ kind: 'skill', id: 's1' })).toBe(false));
+  });
+});
diff --git a/client/src/hooks/index.ts b/client/src/hooks/index.ts
index 645330b7bd..b24e3a6aac 100644
--- a/client/src/hooks/index.ts
+++ b/client/src/hooks/index.ts
@@ -29,6 +29,7 @@ export { default as useNewConvo } from './useNewConvo';
 export { default as useLocalize } from './useLocalize';
 export { default as useFocusTrap } from './useFocusTrap';
 export { default as useFavorites } from './useFavorites';
+export { default as useToolFavorites } from './useToolFavorites';
 export { default as useChatBadges } from './useChatBadges';
 export { default as useScrollToRef } from './useScrollToRef';
 export { default as useIsActiveItem } from './useIsActiveItem';
diff --git a/client/src/hooks/useToolFavorites.ts b/client/src/hooks/useToolFavorites.ts
new file mode 100644
index 0000000000..f84dcb63a3
--- /dev/null
+++ b/client/src/hooks/useToolFavorites.ts
@@ -0,0 +1,90 @@
+import { useMemo, useCallback } from 'react';
+import { useToastContext } from '@librechat/client';
+import type { TToolFavorite, TToolFavoriteType } from 'librechat-data-provider';
+import {
+  useGetToolFavoritesQuery,
+  useAddToolFavoriteMutation,
+  useRemoveToolFavoriteMutation,
+} from '~/data-provider';
+import { getFavoritesErrorMessage, logger } from '~/utils';
+import useLocalize from './useLocalize';
+
+export const MAX_TOOL_FAVORITES = 100;
+
+const EMPTY_FAVORITES: TToolFavorite[] = [];
+
+interface FavoritableItem {
+  kind: string;
+  id: string;
+}
+
+const toFavorite = (item: FavoritableItem): TToolFavorite => ({
+  itemType: item.kind as TToolFavoriteType,
+  itemId: item.id,
+});
+
+/**
+ * Favorites for marketplace items (built-in capabilities, plugin tools, MCP
+ * servers, skills), persisted per user server-side. React Query is the source
+ * of truth; `favoriteKeys` uses the marketplace `itemKey` format
+ * (`kind:id`), so it plugs directly into the catalog filter context. Actions
+ * are per-agent and not favoritable — `isFavorite`/`toggle` guard them.
+ */
+export default function useToolFavorites() {
+  const localize = useLocalize();
+  const { showToast } = useToastContext();
+  const getQuery = useGetToolFavoritesQuery();
+  const addMutation = useAddToolFavoriteMutation();
+  const removeMutation = useRemoveToolFavoriteMutation();
+
+  const favorites = useMemo(
+    () => (Array.isArray(getQuery.data) ? getQuery.data : EMPTY_FAVORITES),
+    [getQuery.data],
+  );
+
+  const favoriteKeys = useMemo(
+    () => new Set(favorites.map((f) => `${f.itemType}:${f.itemId}`)),
+    [favorites],
+  );
+
+  const isFavorite = useCallback(
+    (item: FavoritableItem): boolean =>
+      item.kind !== 'action' && favoriteKeys.has(`${item.kind}:${item.id}`),
+    [favoriteKeys],
+  );
+
+  const toggle = useCallback(
+    async (item: FavoritableItem) => {
+      if (item.kind === 'action') {
+        return;
+      }
+      const favorite = toFavorite(item);
+      const mutation = favoriteKeys.has(`${item.kind}:${item.id}`) ? removeMutation : addMutation;
+      try {
+        await mutation.mutateAsync(favorite);
+      } catch (error) {
+        logger.error('Error updating tool favorites:', error);
+        showToast({
+          message: getFavoritesErrorMessage(
+            error,
+            localize,
+            MAX_TOOL_FAVORITES,
+            'com_ui_max_favorites_reached_items',
+          ),
+          status: 'error',
+        });
+      }
+    },
+    [favoriteKeys, addMutation, removeMutation, showToast, localize],
+  );
+
+  return {
+    favorites,
+    favoriteKeys,
+    isFavorite,
+    toggle,
+    isLoading: getQuery.isLoading,
+    isError: getQuery.isError,
+    isUpdating: addMutation.isLoading || removeMutation.isLoading,
+  };
+}
diff --git a/client/src/locales/en/translation.json b/client/src/locales/en/translation.json
index 0054d4dc56..f6e93000f1 100644
--- a/client/src/locales/en/translation.json
+++ b/client/src/locales/en/translation.json
@@ -1304,6 +1304,7 @@
   "com_ui_marketplace_allow_use": "Allow using Marketplace",
   "com_ui_max": "Max",
   "com_ui_max_favorites_reached": "Maximum pinned items reached ({{0}}). Unpin an item to add more.",
+  "com_ui_max_favorites_reached_items": "Maximum favorites reached ({{0}}). Remove a favorite to add more.",
   "com_ui_max_file_size": "PNG, JPG or JPEG (max {{0}})",
   "com_ui_max_tags": "Maximum number allowed is {{0}}, using latest values.",
   "com_ui_mcp_authenticated_success": "MCP server '{{0}}' authenticated successfully",
diff --git a/client/src/utils/favoritesError.ts b/client/src/utils/favoritesError.ts
index b9dcb279d1..ac19fccf35 100644
--- a/client/src/utils/favoritesError.ts
+++ b/client/src/utils/favoritesError.ts
@@ -10,19 +10,21 @@ const isApiError = (error: unknown): error is ApiErrorShape =>
   typeof error === 'object' && error !== null && 'response' in error;
 
 /**
- * Builds a localized error message from an axios-shaped favorites/skill-favorites
- * mutation rejection. Recognizes the `MAX_*_EXCEEDED` codes the backend emits and
- * falls back to the generic error string otherwise.
+ * Builds a localized error message from an axios-shaped favorites mutation
+ * rejection. Recognizes the `MAX_*_EXCEEDED` codes the backend emits and falls
+ * back to the generic error string otherwise. `messageKey` lets callers pick
+ * wording that fits their surface (pinned items vs. starred marketplace items).
  */
 export function getFavoritesErrorMessage(
   error: unknown,
   localize: LocalizeFn,
   defaultLimit: number,
+  messageKey: TranslationKeys = 'com_ui_max_favorites_reached',
 ): string {
   if (isApiError(error)) {
     const { code, limit } = error.response?.data ?? {};
     if (code === 'MAX_FAVORITES_EXCEEDED' || code === 'MAX_SKILL_FAVORITES_EXCEEDED') {
-      return localize('com_ui_max_favorites_reached', {
+      return localize(messageKey, {
         0: String(limit ?? defaultLimit),
       });
     }
diff --git a/packages/api/src/favorites/handlers.spec.ts b/packages/api/src/favorites/handlers.spec.ts
new file mode 100644
index 0000000000..487ab939d0
--- /dev/null
+++ b/packages/api/src/favorites/handlers.spec.ts
@@ -0,0 +1,178 @@
+import type { Response } from 'express';
+import type { ServerRequest } from '~/types';
+import { createToolFavoritesHandlers } from './handlers';
+
+function mockReq(overrides = {}) {
+  return {
+    user: { id: 'u1' },
+    params: {},
+    body: {},
+    query: {},
+    ...overrides,
+  } as Partial<ServerRequest> as ServerRequest;
+}
+
+interface MockRes {
+  statusCode: number;
+  body: undefined | Record<string, unknown> | unknown[];
+  status: jest.Mock;
+  json: jest.Mock;
+}
+
+function mockRes() {
+  const res: MockRes = {
+    statusCode: 200,
+    body: undefined,
+    status: jest.fn((code: number) => {
+      res.statusCode = code;
+      return res;
+    }),
+    json: jest.fn((data: MockRes['body']) => {
+      res.body = data;
+      return res;
+    }),
+  };
+  return res as Partial<Response> as Response & MockRes;
+}
+
+function createHandlers(overrides = {}) {
+  const deps = {
+    getToolFavorites: jest.fn().mockResolvedValue([{ itemType: 'tool', itemId: 'dalle' }]),
+    addToolFavorite: jest.fn().mockResolvedValue({ ok: true, added: true }),
+    removeToolFavorite: jest.fn().mockResolvedValue({ ok: true, removed: true }),
+    ...overrides,
+  };
+  const handlers = createToolFavoritesHandlers(deps);
+  return { handlers, deps };
+}
+
+describe('createToolFavoritesHandlers', () => {
+  describe('listToolFavorites', () => {
+    it('returns the favorites for the authenticated user', async () => {
+      const { handlers, deps } = createHandlers();
+      const res = mockRes();
+      await handlers.listToolFavorites(mockReq(), res);
+      expect(deps.getToolFavorites).toHaveBeenCalledWith('u1');
+      expect(res.statusCode).toBe(200);
+      expect(res.body).toEqual([{ itemType: 'tool', itemId: 'dalle' }]);
+    });
+
+    it('returns 401 without an authenticated user', async () => {
+      const { handlers, deps } = createHandlers();
+      const res = mockRes();
+      await handlers.listToolFavorites(mockReq({ user: undefined }), res);
+      expect(res.statusCode).toBe(401);
+      expect(deps.getToolFavorites).not.toHaveBeenCalled();
+    });
+
+    it('returns 500 when the dep throws', async () => {
+      const { handlers } = createHandlers({
+        getToolFavorites: jest.fn().mockRejectedValue(new Error('boom')),
+      });
+      const res = mockRes();
+      await handlers.listToolFavorites(mockReq(), res);
+      expect(res.statusCode).toBe(500);
+    });
+  });
+
+  describe('addToolFavorite', () => {
+    it('adds a favorite from validated params', async () => {
+      const { handlers, deps } = createHandlers();
+      const res = mockRes();
+      await handlers.addToolFavorite(
+        mockReq({ params: { itemType: 'mcp', itemId: 'everything' } }),
+        res,
+      );
+      expect(deps.addToolFavorite).toHaveBeenCalledWith({
+        userId: 'u1',
+        itemType: 'mcp',
+        itemId: 'everything',
+      });
+      expect(res.statusCode).toBe(200);
+      expect(res.body).toEqual({ itemType: 'mcp', itemId: 'everything' });
+    });
+
+    it('rejects an unknown itemType with 400 before calling deps', async () => {
+      const { handlers, deps } = createHandlers();
+      const res = mockRes();
+      await handlers.addToolFavorite(mockReq({ params: { itemType: 'agent', itemId: 'x' } }), res);
+      expect(res.statusCode).toBe(400);
+      expect((res.body as Record<string, unknown>).code).toBe('INVALID_ITEM_TYPE');
+      expect(deps.addToolFavorite).not.toHaveBeenCalled();
+    });
+
+    it.each([
+      ['empty', ''],
+      ['oversized', 'x'.repeat(257)],
+    ])('rejects an %s itemId with 400', async (_label, itemId) => {
+      const { handlers, deps } = createHandlers();
+      const res = mockRes();
+      await handlers.addToolFavorite(mockReq({ params: { itemType: 'tool', itemId } }), res);
+      expect(res.statusCode).toBe(400);
+      expect((res.body as Record<string, unknown>).code).toBe('INVALID_ITEM_ID');
+      expect(deps.addToolFavorite).not.toHaveBeenCalled();
+    });
+
+    it('propagates the cap error code and limit as 400', async () => {
+      const capError = Object.assign(new Error('Maximum of 100 favorites reached'), {
+        code: 'MAX_FAVORITES_EXCEEDED',
+        limit: 100,
+      });
+      const { handlers } = createHandlers({
+        addToolFavorite: jest.fn().mockRejectedValue(capError),
+      });
+      const res = mockRes();
+      await handlers.addToolFavorite(
+        mockReq({ params: { itemType: 'skill', itemId: 'abc' } }),
+        res,
+      );
+      expect(res.statusCode).toBe(400);
+      expect(res.body).toEqual({
+        code: 'MAX_FAVORITES_EXCEEDED',
+        message: 'Maximum of 100 favorites reached',
+        limit: 100,
+      });
+    });
+
+    it('returns 500 on unexpected dep failure', async () => {
+      const { handlers } = createHandlers({
+        addToolFavorite: jest.fn().mockRejectedValue(new Error('boom')),
+      });
+      const res = mockRes();
+      await handlers.addToolFavorite(
+        mockReq({ params: { itemType: 'builtin', itemId: 'web_search' } }),
+        res,
+      );
+      expect(res.statusCode).toBe(500);
+    });
+  });
+
+  describe('removeToolFavorite', () => {
+    it('removes a favorite from validated params', async () => {
+      const { handlers, deps } = createHandlers();
+      const res = mockRes();
+      await handlers.removeToolFavorite(
+        mockReq({ params: { itemType: 'tool', itemId: 'dalle' } }),
+        res,
+      );
+      expect(deps.removeToolFavorite).toHaveBeenCalledWith({
+        userId: 'u1',
+        itemType: 'tool',
+        itemId: 'dalle',
+      });
+      expect(res.statusCode).toBe(200);
+      expect(res.body).toEqual({ ok: true });
+    });
+
+    it('rejects an unknown itemType with 400', async () => {
+      const { handlers, deps } = createHandlers();
+      const res = mockRes();
+      await handlers.removeToolFavorite(
+        mockReq({ params: { itemType: 'nope', itemId: 'x' } }),
+        res,
+      );
+      expect(res.statusCode).toBe(400);
+      expect(deps.removeToolFavorite).not.toHaveBeenCalled();
+    });
+  });
+});
diff --git a/packages/api/src/favorites/handlers.ts b/packages/api/src/favorites/handlers.ts
new file mode 100644
index 0000000000..378d4fa645
--- /dev/null
+++ b/packages/api/src/favorites/handlers.ts
@@ -0,0 +1,126 @@
+import { logger, FAVORITE_ITEM_TYPES } from '@librechat/data-schemas';
+import type {
+  FavoriteItemType,
+  IToolFavoriteLean,
+  AddToolFavoriteResult,
+  RemoveToolFavoriteResult,
+} from '@librechat/data-schemas';
+import type { Response } from 'express';
+import type { ServerRequest } from '~/types';
+
+const MAX_ITEM_ID_LENGTH = 256;
+
+/** Thin error shape `addToolFavorite` throws when the per-user cap is reached. */
+type FavoriteCapError = Error & { code?: string; limit?: number };
+
+export interface ToolFavoritesHandlersDeps {
+  /** Tool favorite CRUD — from `@librechat/data-schemas` `createMethods` output. */
+  getToolFavorites: (userId: string) => Promise<IToolFavoriteLean[]>;
+  addToolFavorite: (params: {
+    userId: string;
+    itemType: FavoriteItemType;
+    itemId: string;
+  }) => Promise<AddToolFavoriteResult>;
+  removeToolFavorite: (params: {
+    userId: string;
+    itemType: FavoriteItemType;
+    itemId: string;
+  }) => Promise<RemoveToolFavoriteResult>;
+}
+
+interface ValidatedParams {
+  itemType: FavoriteItemType;
+  itemId: string;
+}
+
+function validateParams(req: ServerRequest, res: Response): ValidatedParams | null {
+  const { itemType, itemId } = req.params as { itemType?: string; itemId?: string };
+
+  if (!FAVORITE_ITEM_TYPES.includes(itemType as FavoriteItemType)) {
+    res.status(400).json({
+      code: 'INVALID_ITEM_TYPE',
+      message: `itemType must be one of: ${FAVORITE_ITEM_TYPES.join(', ')}`,
+    });
+    return null;
+  }
+
+  if (typeof itemId !== 'string' || itemId.length === 0 || itemId.length > MAX_ITEM_ID_LENGTH) {
+    res.status(400).json({
+      code: 'INVALID_ITEM_ID',
+      message: `itemId must be a non-empty string of at most ${MAX_ITEM_ID_LENGTH} characters`,
+    });
+    return null;
+  }
+
+  return { itemType: itemType as FavoriteItemType, itemId };
+}
+
+export function createToolFavoritesHandlers(deps: ToolFavoritesHandlersDeps): {
+  listToolFavorites: (req: ServerRequest, res: Response) => Promise<Response>;
+  addToolFavorite: (req: ServerRequest, res: Response) => Promise<Response>;
+  removeToolFavorite: (req: ServerRequest, res: Response) => Promise<Response>;
+} {
+  async function listToolFavorites(req: ServerRequest, res: Response): Promise<Response> {
+    const userId = req.user?.id;
+    if (!userId) {
+      return res.status(401).json({ message: 'Unauthorized' });
+    }
+    try {
+      const favorites = await deps.getToolFavorites(userId);
+      return res.status(200).json(favorites);
+    } catch (error) {
+      logger.error('[ToolFavorites] Error listing favorites:', error);
+      return res.status(500).json({ message: 'Failed to retrieve favorites' });
+    }
+  }
+
+  async function addToolFavorite(req: ServerRequest, res: Response): Promise<Response> {
+    const userId = req.user?.id;
+    if (!userId) {
+      return res.status(401).json({ message: 'Unauthorized' });
+    }
+    const params = validateParams(req, res);
+    if (params == null) {
+      return res;
+    }
+    try {
+      await deps.addToolFavorite({ userId, ...params });
+      return res.status(200).json(params);
+    } catch (error) {
+      const capError = error as FavoriteCapError;
+      if (capError.code === 'MAX_FAVORITES_EXCEEDED') {
+        return res.status(400).json({
+          code: capError.code,
+          message: capError.message,
+          limit: capError.limit,
+        });
+      }
+      logger.error('[ToolFavorites] Error adding favorite:', error);
+      return res.status(500).json({ message: 'Failed to add favorite' });
+    }
+  }
+
+  async function removeToolFavorite(req: ServerRequest, res: Response): Promise<Response> {
+    const userId = req.user?.id;
+    if (!userId) {
+      return res.status(401).json({ message: 'Unauthorized' });
+    }
+    const params = validateParams(req, res);
+    if (params == null) {
+      return res;
+    }
+    try {
+      await deps.removeToolFavorite({ userId, ...params });
+      return res.status(200).json({ ok: true });
+    } catch (error) {
+      logger.error('[ToolFavorites] Error removing favorite:', error);
+      return res.status(500).json({ message: 'Failed to remove favorite' });
+    }
+  }
+
+  return {
+    listToolFavorites,
+    addToolFavorite,
+    removeToolFavorite,
+  };
+}
diff --git a/packages/api/src/favorites/index.ts b/packages/api/src/favorites/index.ts
new file mode 100644
index 0000000000..6c6f862d01
--- /dev/null
+++ b/packages/api/src/favorites/index.ts
@@ -0,0 +1 @@
+export * from './handlers';
diff --git a/packages/api/src/index.ts b/packages/api/src/index.ts
index ead04e0b87..fff580d06f 100644
--- a/packages/api/src/index.ts
+++ b/packages/api/src/index.ts
@@ -51,6 +51,7 @@ export * from './prompts';
 export * from './projects';
 /* Skills */
 export * from './skills';
+export * from './favorites';
 /* Endpoints */
 export * from './endpoints';
 /* Files */
diff --git a/packages/data-provider/src/api-endpoints.ts b/packages/data-provider/src/api-endpoints.ts
index 4cc2fd1c47..b08e9c5106 100644
--- a/packages/data-provider/src/api-endpoints.ts
+++ b/packages/data-provider/src/api-endpoints.ts
@@ -438,6 +438,11 @@ export const skillTree = ({ skillId, path = '' }: { skillId: string; path?: stri
 /* Skill active states (per-user overrides) */
 export const skillStates = () => `${BASE_URL}/api/user/settings/skills/active`;
 
+/* Tool favorites (starred marketplace items) */
+export const toolFavorites = () => `${BASE_URL}/api/user/settings/favorites/tools`;
+export const toolFavorite = (itemType: string, itemId: string) =>
+  `${toolFavorites()}/${itemType}/${encodeURIComponent(itemId)}`;
+
 /* Roles */
 export const roles = () => `${BASE_URL}/api/roles`;
 export const adminRoles = () => `${BASE_URL}/api/admin/roles`;
diff --git a/packages/data-provider/src/data-service.ts b/packages/data-provider/src/data-service.ts
index 87d216e27f..d06c138e0d 100644
--- a/packages/data-provider/src/data-service.ts
+++ b/packages/data-provider/src/data-service.ts
@@ -35,17 +35,17 @@ export function updateFavorites(favorites: q.TUserFavorite[]): Promise<q.TUserFa
   return request.post(`${endpoints.apiBaseUrl()}/api/user/settings/favorites`, { favorites });
 }
 
-/**
- * Skill favorites (star-a-skill). The backend route is phase 2 — see the
- * original UI PR for the client surface. Until then, these resolve with
- * an empty list so the UI hooks compile and the Star button is a no-op.
- */
-export function getSkillFavorites(): Promise<string[]> {
-  return Promise.resolve([] as string[]);
+/** Tool favorites — starred marketplace items (builtins, tools, MCP servers, skills). */
+export function getToolFavorites(): Promise<q.TToolFavorite[]> {
+  return request.get(endpoints.toolFavorites());
 }
 
-export function updateSkillFavorites(skillFavorites: string[]): Promise<string[]> {
-  return Promise.resolve(skillFavorites);
+export function addToolFavorite(favorite: q.TToolFavorite): Promise<q.TToolFavorite> {
+  return request.put(endpoints.toolFavorite(favorite.itemType, favorite.itemId));
+}
+
+export function removeToolFavorite(favorite: q.TToolFavorite): Promise<{ ok: boolean }> {
+  return request.delete(endpoints.toolFavorite(favorite.itemType, favorite.itemId));
 }
 
 /** Per-user skill active/inactive overrides. */
diff --git a/packages/data-provider/src/keys.ts b/packages/data-provider/src/keys.ts
index 26eed7462a..22b9ee959a 100644
--- a/packages/data-provider/src/keys.ts
+++ b/packages/data-provider/src/keys.ts
@@ -79,8 +79,8 @@ export enum QueryKeys {
   /* Skill tree (phase 2 — filesystem-style node view) */
   skillTree = 'skillTree',
   skillNodeContent = 'skillNodeContent',
-  /* Skill favorites (star a skill in the sidebar) */
-  skillFavorites = 'skillFavorites',
+  /* Tool favorites (starred marketplace items) */
+  toolFavorites = 'toolFavorites',
   /* Per-user skill active/inactive overrides */
   skillStates = 'skillStates',
   /* General user favorites */
diff --git a/packages/data-provider/src/types/queries.ts b/packages/data-provider/src/types/queries.ts
index abe773fce2..f763632d81 100644
--- a/packages/data-provider/src/types/queries.ts
+++ b/packages/data-provider/src/types/queries.ts
@@ -228,8 +228,18 @@ export type TUserFavorite = {
   model?: string;
   endpoint?: string;
   spec?: string;
-  /** Phase 2 — skill favoriting isn't persisted yet, but the shape is reserved. */
-  skillId?: string;
+};
+
+/**
+ * Tool favorites — starred marketplace items (built-in capabilities, plugin
+ * tools, MCP servers, skills). Identity is the compound (itemType, itemId)
+ * pair, matching the marketplace `itemKey` format `itemType:itemId`.
+ */
+export type TToolFavoriteType = 'builtin' | 'tool' | 'mcp' | 'skill';
+
+export type TToolFavorite = {
+  itemType: TToolFavoriteType;
+  itemId: string;
 };
 
 /* SharePoint Graph API Token */
diff --git a/packages/data-schemas/src/index.ts b/packages/data-schemas/src/index.ts
index ee393b2de4..85ff1b86fc 100644
--- a/packages/data-schemas/src/index.ts
+++ b/packages/data-schemas/src/index.ts
@@ -28,7 +28,9 @@ export {
   MAX_AUDIT_EXPORT_ROWS,
   MAX_AUDIT_LOG_LIMIT,
   MAX_AUDIT_VERIFY_ROWS,
+  MAX_TOOL_FAVORITES,
 } from './methods';
+export { FAVORITE_ITEM_TYPES } from './types/favorite';
 export type * from './types';
 export type * from './methods';
 export {
diff --git a/packages/data-schemas/src/methods/favorite.spec.ts b/packages/data-schemas/src/methods/favorite.spec.ts
new file mode 100644
index 0000000000..e4306ac3e4
--- /dev/null
+++ b/packages/data-schemas/src/methods/favorite.spec.ts
@@ -0,0 +1,153 @@
+import mongoose from 'mongoose';
+import { logger, createModels } from '..';
+import { MongoMemoryServer } from 'mongodb-memory-server';
+import { createToolFavoriteMethods, MAX_TOOL_FAVORITES } from './favorite';
+
+logger.silent = true;
+
+let ToolFavorite: mongoose.Model<unknown>;
+let methods: ReturnType<typeof createToolFavoriteMethods>;
+let mongoServer: MongoMemoryServer;
+
+const userA = new mongoose.Types.ObjectId().toString();
+const userB = new mongoose.Types.ObjectId().toString();
+
+beforeAll(async () => {
+  mongoServer = await MongoMemoryServer.create();
+  await mongoose.connect(mongoServer.getUri());
+  createModels(mongoose);
+  ToolFavorite = mongoose.models.ToolFavorite;
+  await ToolFavorite.syncIndexes();
+  methods = createToolFavoriteMethods(mongoose);
+});
+
+afterAll(async () => {
+  await mongoose.disconnect();
+  await mongoServer.stop();
+});
+
+beforeEach(async () => {
+  await ToolFavorite.deleteMany({});
+});
+
+describe('addToolFavorite', () => {
+  test('persists a favorite and getToolFavorites returns the lean projection', async () => {
+    const result = await methods.addToolFavorite({
+      userId: userA,
+      itemType: 'mcp',
+      itemId: 'everything',
+    });
+    expect(result).toEqual({ ok: true, added: true });
+
+    const favorites = await methods.getToolFavorites(userA);
+    expect(favorites).toEqual([{ itemType: 'mcp', itemId: 'everything' }]);
+  });
+
+  test('is idempotent: double-add keeps one doc and reports added: false', async () => {
+    await methods.addToolFavorite({ userId: userA, itemType: 'tool', itemId: 'dalle' });
+    const second = await methods.addToolFavorite({
+      userId: userA,
+      itemType: 'tool',
+      itemId: 'dalle',
+    });
+    expect(second).toEqual({ ok: true, added: false });
+    expect(await ToolFavorite.countDocuments({ user: userA })).toBe(1);
+  });
+
+  test('rejects an itemType outside the enum', async () => {
+    await expect(
+      methods.addToolFavorite({
+        userId: userA,
+        itemType: 'agent' as never,
+        itemId: 'x',
+      }),
+    ).rejects.toThrow();
+  });
+
+  test('rejects an itemId longer than 256 characters', async () => {
+    await expect(
+      methods.addToolFavorite({ userId: userA, itemType: 'tool', itemId: 'x'.repeat(257) }),
+    ).rejects.toThrow();
+  });
+
+  test('throws a coded error at the cap, but re-adding an existing favorite still succeeds', async () => {
+    const docs = Array.from({ length: MAX_TOOL_FAVORITES }, (_, i) => ({
+      user: userA,
+      itemType: 'tool',
+      itemId: `tool-${i}`,
+    }));
+    await ToolFavorite.insertMany(docs);
+
+    const rejection = methods.addToolFavorite({
+      userId: userA,
+      itemType: 'tool',
+      itemId: 'one-too-many',
+    });
+    await expect(rejection).rejects.toMatchObject({
+      code: 'MAX_FAVORITES_EXCEEDED',
+      limit: MAX_TOOL_FAVORITES,
+    });
+
+    const existing = await methods.addToolFavorite({
+      userId: userA,
+      itemType: 'tool',
+      itemId: 'tool-0',
+    });
+    expect(existing).toEqual({ ok: true, added: false });
+  });
+
+  test('concurrent duplicate adds do not throw (unique index backstop)', async () => {
+    const params = { userId: userA, itemType: 'skill', itemId: 'abc123' } as const;
+    const results = await Promise.all([
+      methods.addToolFavorite(params),
+      methods.addToolFavorite(params),
+      methods.addToolFavorite(params),
+    ]);
+    expect(results.every((r) => r.ok)).toBe(true);
+    expect(await ToolFavorite.countDocuments({ user: userA })).toBe(1);
+  });
+});
+
+describe('removeToolFavorite', () => {
+  test('removes a favorite and is idempotent', async () => {
+    await methods.addToolFavorite({ userId: userA, itemType: 'builtin', itemId: 'web_search' });
+
+    const removed = await methods.removeToolFavorite({
+      userId: userA,
+      itemType: 'builtin',
+      itemId: 'web_search',
+    });
+    expect(removed).toEqual({ ok: true, removed: true });
+
+    const again = await methods.removeToolFavorite({
+      userId: userA,
+      itemType: 'builtin',
+      itemId: 'web_search',
+    });
+    expect(again).toEqual({ ok: true, removed: false });
+    expect(await methods.getToolFavorites(userA)).toEqual([]);
+  });
+});
+
+describe('getToolFavorites', () => {
+  test('is isolated per user', async () => {
+    await methods.addToolFavorite({ userId: userA, itemType: 'tool', itemId: 'dalle' });
+    await methods.addToolFavorite({ userId: userB, itemType: 'mcp', itemId: 'everything' });
+
+    expect(await methods.getToolFavorites(userA)).toEqual([{ itemType: 'tool', itemId: 'dalle' }]);
+    expect(await methods.getToolFavorites(userB)).toEqual([
+      { itemType: 'mcp', itemId: 'everything' },
+    ]);
+  });
+
+  test('does not distinguish same itemId across kinds (compound identity)', async () => {
+    await methods.addToolFavorite({ userId: userA, itemType: 'tool', itemId: 'shared-id' });
+    await methods.addToolFavorite({ userId: userA, itemType: 'skill', itemId: 'shared-id' });
+
+    const favorites = await methods.getToolFavorites(userA);
+    expect(favorites).toHaveLength(2);
+    expect(new Set(favorites.map((f) => `${f.itemType}:${f.itemId}`))).toEqual(
+      new Set(['tool:shared-id', 'skill:shared-id']),
+    );
+  });
+});
diff --git a/packages/data-schemas/src/methods/favorite.ts b/packages/data-schemas/src/methods/favorite.ts
new file mode 100644
index 0000000000..10e1544f20
--- /dev/null
+++ b/packages/data-schemas/src/methods/favorite.ts
@@ -0,0 +1,90 @@
+import type * as t from '~/types';
+
+export const MAX_TOOL_FAVORITES = 100;
+
+const DUPLICATE_KEY_ERROR = 11000;
+
+function isDuplicateKeyError(error: unknown): boolean {
+  return (
+    typeof error === 'object' &&
+    error !== null &&
+    (error as { code?: number }).code === DUPLICATE_KEY_ERROR
+  );
+}
+
+function capError(): Error {
+  const error = new Error(`Maximum of ${MAX_TOOL_FAVORITES} favorites reached`);
+  (error as Error & { code: string; limit: number }).code = 'MAX_FAVORITES_EXCEEDED';
+  (error as Error & { code: string; limit: number }).limit = MAX_TOOL_FAVORITES;
+  return error;
+}
+
+export function createToolFavoriteMethods(mongoose: typeof import('mongoose')): {
+  getToolFavorites: (userId: string) => Promise<t.IToolFavoriteLean[]>;
+  addToolFavorite: (params: t.ToolFavoriteParams) => Promise<t.AddToolFavoriteResult>;
+  removeToolFavorite: (params: t.ToolFavoriteParams) => Promise<t.RemoveToolFavoriteResult>;
+} {
+  async function getToolFavorites(userId: string): Promise<t.IToolFavoriteLean[]> {
+    const ToolFavorite = mongoose.models.ToolFavorite;
+    return ToolFavorite.find({ user: userId })
+      .select('itemType itemId -_id')
+      .sort({ createdAt: 1 })
+      .lean<t.IToolFavoriteLean[]>();
+  }
+
+  /**
+   * Idempotent add. The unique `{ user, itemType, itemId }` index is the
+   * concurrency backstop: a duplicate-key rejection from a racing insert is
+   * treated as success. The cap check is read-then-write and may transiently
+   * overshoot by one or two under concurrency — acceptable for a soft UX cap.
+   */
+  async function addToolFavorite({
+    userId,
+    itemType,
+    itemId,
+  }: t.ToolFavoriteParams): Promise<t.AddToolFavoriteResult> {
+    const ToolFavorite = mongoose.models.ToolFavorite;
+    const filter = { user: userId, itemType, itemId };
+
+    const existing = await ToolFavorite.exists(filter);
+    if (existing != null) {
+      return { ok: true, added: false };
+    }
+
+    const count = await ToolFavorite.countDocuments({ user: userId });
+    if (count >= MAX_TOOL_FAVORITES) {
+      throw capError();
+    }
+
+    try {
+      await ToolFavorite.updateOne(
+        filter,
+        { $setOnInsert: filter },
+        { upsert: true, runValidators: true },
+      );
+    } catch (error) {
+      if (!isDuplicateKeyError(error)) {
+        throw error;
+      }
+    }
+    return { ok: true, added: true };
+  }
+
+  async function removeToolFavorite({
+    userId,
+    itemType,
+    itemId,
+  }: t.ToolFavoriteParams): Promise<t.RemoveToolFavoriteResult> {
+    const ToolFavorite = mongoose.models.ToolFavorite;
+    const result = await ToolFavorite.deleteOne({ user: userId, itemType, itemId });
+    return { ok: true, removed: result.deletedCount > 0 };
+  }
+
+  return {
+    getToolFavorites,
+    addToolFavorite,
+    removeToolFavorite,
+  };
+}
+
+export type ToolFavoriteMethods = ReturnType<typeof createToolFavoriteMethods>;
diff --git a/packages/data-schemas/src/methods/index.ts b/packages/data-schemas/src/methods/index.ts
index 5eee6c4db5..2d1dcaf146 100644
--- a/packages/data-schemas/src/methods/index.ts
+++ b/packages/data-schemas/src/methods/index.ts
@@ -7,6 +7,12 @@ import { createRoleMethods, RoleConflictError } from './role';
 import { createKeyMethods, type KeyMethods } from './key';
 /* Memories */
 import { createMemoryMethods, type MemoryMethods } from './memory';
+/* Tool Favorites */
+import {
+  createToolFavoriteMethods,
+  MAX_TOOL_FAVORITES,
+  type ToolFavoriteMethods,
+} from './favorite';
 /* Agent Categories */
 import { createAgentCategoryMethods, type AgentCategoryMethods } from './agentCategory';
 /* Agent API Keys */
@@ -110,6 +116,7 @@ export {
   inferSkillFileCategory,
 };
 export { AUDIT_SCHEMA_VERSION, MAX_AUDIT_EXPORT_ROWS, MAX_AUDIT_LOG_LIMIT, MAX_AUDIT_VERIFY_ROWS };
+export { MAX_TOOL_FAVORITES };
 
 export type AllMethods = UserMethods &
   SessionMethods &
@@ -118,6 +125,7 @@ export type AllMethods = UserMethods &
   KeyMethods &
   FileMethods &
   MemoryMethods &
+  ToolFavoriteMethods &
   AgentCategoryMethods &
   AgentApiKeyMethods &
   MCPServerMethods &
@@ -245,6 +253,7 @@ export function createMethods(
     ...createKeyMethods(mongoose),
     ...createFileMethods(mongoose),
     ...createMemoryMethods(mongoose),
+    ...createToolFavoriteMethods(mongoose),
     ...createAgentCategoryMethods(mongoose),
     ...createAgentApiKeyMethods(mongoose),
     ...createMCPServerMethods(mongoose),
@@ -290,6 +299,7 @@ export type {
   FileMethods,
   FileOwnerScope,
   MemoryMethods,
+  ToolFavoriteMethods,
   AgentCategoryMethods,
   AgentApiKeyMethods,
   MCPServerMethods,
diff --git a/packages/data-schemas/src/models/favorite.ts b/packages/data-schemas/src/models/favorite.ts
new file mode 100644
index 0000000000..0b3b4369f4
--- /dev/null
+++ b/packages/data-schemas/src/models/favorite.ts
@@ -0,0 +1,12 @@
+import { Model } from 'mongoose';
+import type { IToolFavorite } from '~/types/favorite';
+import { applyTenantIsolation } from '~/models/plugins/tenantIsolation';
+import toolFavoriteSchema from '~/schema/favorite';
+
+export function createToolFavoriteModel(mongoose: typeof import('mongoose')): Model<IToolFavorite> {
+  applyTenantIsolation(toolFavoriteSchema);
+  return (
+    mongoose.models.ToolFavorite ||
+    mongoose.model<IToolFavorite>('ToolFavorite', toolFavoriteSchema)
+  );
+}
diff --git a/packages/data-schemas/src/models/index.ts b/packages/data-schemas/src/models/index.ts
index 6493013f2c..440106f2e0 100644
--- a/packages/data-schemas/src/models/index.ts
+++ b/packages/data-schemas/src/models/index.ts
@@ -10,6 +10,7 @@ import { createSystemGrantModel } from './systemGrant';
 import { createPluginAuthModel } from './pluginAuth';
 import { createSharedLinkModel } from './sharedLink';
 import { createAccessRoleModel } from './accessRole';
+import { createToolFavoriteModel } from './favorite';
 import { createMCPServerModel } from './mcpServer';
 import { createAssistantModel } from './assistant';
 import { createSkillFileModel } from './skillFile';
@@ -69,6 +70,7 @@ export function createModels(mongoose: typeof import('mongoose')): {
   SharedLink: ReturnType<typeof createSharedLinkModel>;
   ToolCall: ReturnType<typeof createToolCallModel>;
   MemoryEntry: ReturnType<typeof createMemoryModel>;
+  ToolFavorite: ReturnType<typeof createToolFavoriteModel>;
   AccessRole: ReturnType<typeof createAccessRoleModel>;
   AclEntry: ReturnType<typeof createAclEntryModel>;
   SystemGrant: ReturnType<typeof createSystemGrantModel>;
@@ -107,6 +109,7 @@ export function createModels(mongoose: typeof import('mongoose')): {
     SharedLink: createSharedLinkModel(mongoose),
     ToolCall: createToolCallModel(mongoose),
     MemoryEntry: createMemoryModel(mongoose),
+    ToolFavorite: createToolFavoriteModel(mongoose),
     AccessRole: createAccessRoleModel(mongoose),
     AclEntry: createAclEntryModel(mongoose),
     SystemGrant: createSystemGrantModel(mongoose),
diff --git a/packages/data-schemas/src/schema/favorite.ts b/packages/data-schemas/src/schema/favorite.ts
new file mode 100644
index 0000000000..7efafec438
--- /dev/null
+++ b/packages/data-schemas/src/schema/favorite.ts
@@ -0,0 +1,40 @@
+import { Schema } from 'mongoose';
+import type { IToolFavorite } from '~/types/favorite';
+import { FAVORITE_ITEM_TYPES } from '~/types/favorite';
+
+const toolFavoriteSchema: Schema<IToolFavorite> = new Schema(
+  {
+    user: {
+      type: Schema.Types.ObjectId,
+      ref: 'User',
+      required: true,
+      index: true,
+    },
+    itemType: {
+      type: String,
+      required: true,
+      enum: FAVORITE_ITEM_TYPES,
+    },
+    itemId: {
+      type: String,
+      required: true,
+      maxlength: 256,
+    },
+    tenantId: {
+      type: String,
+      index: true,
+    },
+  },
+  { timestamps: true },
+);
+
+/**
+ * One doc per (user, itemType, itemId): the unique index makes favorite/unfavorite
+ * idempotent and race-free under concurrent toggles. It deliberately excludes
+ * `tenantId` — user ObjectIds are globally unique, so the triple can never
+ * legitimately collide across tenants, and tenant-scoped reads are still served
+ * by this user-prefixed index.
+ */
+toolFavoriteSchema.index({ user: 1, itemType: 1, itemId: 1 }, { unique: true });
+
+export default toolFavoriteSchema;
diff --git a/packages/data-schemas/src/schema/index.ts b/packages/data-schemas/src/schema/index.ts
index a71591844f..e6ac941d00 100644
--- a/packages/data-schemas/src/schema/index.ts
+++ b/packages/data-schemas/src/schema/index.ts
@@ -27,6 +27,7 @@ export { default as toolCallSchema } from './toolCall';
 export { default as transactionSchema } from './transaction';
 export { default as userSchema } from './user';
 export { default as memorySchema } from './memory';
+export { default as toolFavoriteSchema } from './favorite';
 export { default as groupSchema } from './group';
 export { default as systemGrantSchema } from './systemGrant';
 export { default as auditLogSchema } from './auditLog';
diff --git a/packages/data-schemas/src/types/favorite.ts b/packages/data-schemas/src/types/favorite.ts
new file mode 100644
index 0000000000..ca8a01ebda
--- /dev/null
+++ b/packages/data-schemas/src/types/favorite.ts
@@ -0,0 +1,35 @@
+import type { Types, Document } from 'mongoose';
+
+export const FAVORITE_ITEM_TYPES = ['builtin', 'tool', 'mcp', 'skill'] as const;
+
+export type FavoriteItemType = (typeof FAVORITE_ITEM_TYPES)[number];
+
+export interface IToolFavorite extends Document {
+  user: Types.ObjectId;
+  itemType: FavoriteItemType;
+  itemId: string;
+  tenantId?: string;
+  createdAt?: Date;
+  updatedAt?: Date;
+}
+
+export interface IToolFavoriteLean {
+  itemType: FavoriteItemType;
+  itemId: string;
+}
+
+export interface ToolFavoriteParams {
+  userId: string | Types.ObjectId;
+  itemType: FavoriteItemType;
+  itemId: string;
+}
+
+export interface AddToolFavoriteResult {
+  ok: boolean;
+  added: boolean;
+}
+
+export interface RemoveToolFavoriteResult {
+  ok: boolean;
+  removed: boolean;
+}
diff --git a/packages/data-schemas/src/types/index.ts b/packages/data-schemas/src/types/index.ts
index 3dc5228532..f0348f332c 100644
--- a/packages/data-schemas/src/types/index.ts
+++ b/packages/data-schemas/src/types/index.ts
@@ -22,6 +22,7 @@ export * from './share';
 export * from './pluginAuth';
 /* Memories */
 export * from './memory';
+export * from './favorite';
 /* Prompts */
 export * from './prompts';
 /* Skills */