diff --git a/src/components/configuration/ConfigPage.tsx b/src/components/configuration/ConfigPage.tsx
index 6d30330d..f39447ee 100644
--- a/src/components/configuration/ConfigPage.tsx
+++ b/src/components/configuration/ConfigPage.tsx
@@ -10,6 +10,7 @@ import {
   tombstoneFieldProfileValueFn,
   bulkSaveProfileValuesFn,
   getBatchFieldProfilesFn,
+  getBaseConfigOverridesFn,
   availableScopesOptions,
   resetBaseConfigFieldFn,
   getResolvedConfigFn,
@@ -38,12 +39,15 @@ import {
   buildSavePayload,
   mergeIndexedArrayEdits,
   partitionScopeResetPaths,
+  collectEntryOverrideKeys,
+  executeEntryOverridesReset,
 } from './utils';
 import { validateMcpCrossField } from './sections/McpServersRenderer';
 import { ScopeSelector, ScopeTriggerButton } from './ScopeSelector';
 import { StickyActionBar } from '@/components/shared';
 import { ConfigTableOfContents } from './ConfigTableOfContents';
 import { ResetBaseConfigDialog } from './ResetBaseConfigDialog';
+import { ResetOverridesDialog } from './ResetOverridesDialog';
 import { ConfirmSaveDialog } from './ConfirmSaveDialog';
 import { ConfigTabContent } from './ConfigTabContent';
 import { ImportYamlDialog } from './ImportYamlDialog';
@@ -152,9 +156,15 @@ export function ConfigPage({ initialTab, highlightField, initialScope }: t.Confi
     if (yamlMcpKeys && Array.isArray(yamlMcpKeys)) {
       result.mcpServers = new Set(yamlMcpKeys);
     }
+    const yamlCustomEndpointKeys = baseConfigData?.yamlCustomEndpointKeys;
+    if (yamlCustomEndpointKeys && Array.isArray(yamlCustomEndpointKeys)) {
+      result.endpoints = new Set(yamlCustomEndpointKeys);
+    }
     return result;
   }, [baseConfigData]);
 
+  const dbOverrideKeys = useMemo(() => collectEntryOverrideKeys(dbOverrides), [dbOverrides]);
+
   const hasUnmappedSections = useMemo(
     () =>
       schemaTree.some(
@@ -536,6 +546,39 @@ export function ConfigPage({ initialTab, highlightField, initialScope }: t.Confi
     });
   }, []);
 
+  const [entryResetTarget, setEntryResetTarget] = useState<t.EntryResetTarget | null>(null);
+  const [entryResetting, setEntryResetting] = useState(false);
+  const [entryResetError, setEntryResetError] = useState<string | null>(null);
+
+  const handleEntryOverridesReset = useCallback((target: t.EntryResetTarget) => {
+    setEntryResetError(null);
+    setEntryResetTarget(target);
+  }, []);
+
+  const handleEntryResetConfirm = useCallback(async () => {
+    if (!entryResetTarget || entryResetting) return;
+    setEntryResetting(true);
+    setEntryResetError(null);
+    try {
+      await executeEntryOverridesReset(entryResetTarget, schemaPathSet, {
+        fetchOverrides: () => getBaseConfigOverridesFn().then((r) => r.overrides),
+        resetField: (fieldPath) => resetBaseConfigFieldFn({ data: { fieldPath } }),
+        saveEntries: (entries) => saveBaseConfigFn({ data: { entries } }),
+      });
+      await queryClient.invalidateQueries({ queryKey: ['baseConfig'] });
+      /** Remount session-keyed field state (e.g. a SecretField opened for Replace but left untouched, which no invalidation reaches) so nothing local survives past the reset. */
+      setEditSessionId((id) => id + 1);
+      setEntryResetting(false);
+      setEntryResetTarget(null);
+      notifySuccess(localize('com_config_reset_entry_success', { name: entryResetTarget.label }));
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      setEntryResetting(false);
+      setEntryResetError(message);
+      notifyError(message);
+    }
+  }, [entryResetTarget, entryResetting, schemaPathSet, queryClient, localize]);
+
   const handleConfirmSave = useCallback(async () => {
     if (saving) return;
     const { touched, saves, resets } = buildSavePayload(touchedPaths, editedValues, schemaPathSet);
@@ -1006,6 +1049,8 @@ export function ConfigPage({ initialTab, highlightField, initialScope }: t.Confi
               showConfiguredOnly={showConfiguredOnly}
               isEditingScope={isEditingScope}
               baseRecordKeys={baseRecordKeys}
+              dbOverrideKeys={isEditingScope ? undefined : dbOverrideKeys}
+              onResetEntryOverrides={isEditingScope ? undefined : handleEntryOverridesReset}
               onValidationError={(message) => notifyError(message)}
               editSessionId={editSessionId}
             />
@@ -1068,6 +1113,18 @@ export function ConfigPage({ initialTab, highlightField, initialScope }: t.Confi
           setResetBaseError(null);
         }}
       />
+
+      <ResetOverridesDialog
+        target={entryResetTarget}
+        resetting={entryResetting}
+        error={entryResetError}
+        onConfirm={handleEntryResetConfirm}
+        onCancel={() => {
+          if (entryResetting) return;
+          setEntryResetTarget(null);
+          setEntryResetError(null);
+        }}
+      />
     </div>
   );
 }
diff --git a/src/components/configuration/ConfigTabContent.tsx b/src/components/configuration/ConfigTabContent.tsx
index fa0fcd7e..13940af7 100644
--- a/src/components/configuration/ConfigTabContent.tsx
+++ b/src/components/configuration/ConfigTabContent.tsx
@@ -57,6 +57,8 @@ export function ConfigTabContent({
   showConfiguredOnly,
   isEditingScope,
   baseRecordKeys,
+  dbOverrideKeys,
+  onResetEntryOverrides,
   onValidationError,
   editSessionId,
 }: t.ConfigTabContentProps) {
@@ -188,6 +190,8 @@ export function ConfigTabContent({
       showConfiguredOnly,
       isEditingScope,
       yamlBaseKeys: baseRecordKeys?.[dataKey],
+      dbOverrideKeys: dbOverrideKeys?.[dataKey],
+      onResetEntryOverrides,
       onValidationError,
       editSessionId,
     };
diff --git a/src/components/configuration/ResetOverridesDialog.tsx b/src/components/configuration/ResetOverridesDialog.tsx
new file mode 100644
index 00000000..7198cad9
--- /dev/null
+++ b/src/components/configuration/ResetOverridesDialog.tsx
@@ -0,0 +1,62 @@
+import { Button, Dialog } from '@clickhouse/click-ui';
+import type * as t from '@/types';
+import { useLocalize } from '@/hooks';
+
+export function ResetOverridesDialog({
+  target,
+  resetting,
+  error,
+  onConfirm,
+  onCancel,
+}: t.ResetOverridesDialogProps) {
+  const localize = useLocalize();
+
+  return (
+    <Dialog
+      open={target != null}
+      onOpenChange={(isOpen) => {
+        if (!isOpen) onCancel();
+      }}
+    >
+      <Dialog.Content
+        title={localize('com_config_reset_entry_title')}
+        showClose
+        onClose={onCancel}
+        className="modal-frost"
+      >
+        <div className="flex flex-col gap-4">
+          <p className="text-sm leading-relaxed text-(--cui-color-text-default)">
+            {localize('com_config_reset_entry_confirm', { name: target?.label ?? '' })}
+          </p>
+          {error && (
+            <div
+              className="rounded-lg bg-[rgba(220,38,38,0.1)] px-3 py-2 text-sm font-medium text-(--cui-color-text-danger)"
+              role="alert"
+            >
+              {error}
+            </div>
+          )}
+          <div className="flex items-center justify-end gap-2">
+            <Button
+              type="secondary"
+              label={localize('com_ui_cancel')}
+              onClick={onCancel}
+              disabled={resetting}
+            />
+            <Button
+              type="danger"
+              label={
+                resetting
+                  ? localize('com_config_reset_base_resetting')
+                  : localize('com_config_reset_entry_action')
+              }
+              iconLeft={resetting ? 'loading-animated' : undefined}
+              onClick={onConfirm}
+              disabled={resetting}
+            />
+          </div>
+        </div>
+      </Dialog.Content>
+    </Dialog>
+  );
+}
diff --git a/src/components/configuration/fields/ArrayObjectField.tsx b/src/components/configuration/fields/ArrayObjectField.tsx
index 52b807cb..fd3cb11b 100644
--- a/src/components/configuration/fields/ArrayObjectField.tsx
+++ b/src/components/configuration/fields/ArrayObjectField.tsx
@@ -25,6 +25,7 @@ export function ArrayObjectField({
   addTriggerRef,
   renderFields,
   entryIdPrefix,
+  entryControls,
   editSessionId,
 }: t.ArrayObjectFieldProps) {
   const localize = useLocalize();
@@ -104,21 +105,29 @@ export function ArrayObjectField({
           onClick={handleAdd}
         />
       )}
-      {items.map((item, index) => (
-        <ObjectEntryCard
-          key={keys[index] ?? index}
-          id={entryIdPrefix ? `${entryIdPrefix}-${index}` : undefined}
-          entryKey={getEntryLabel(item) ?? localize('com_config_entry_n', { n: String(index + 1) })}
-          fields={fields}
-          value={item}
-          onValueChange={(v) => handleEntryChange(index, v)}
-          onRemove={disabled ? undefined : () => handleRemove(index)}
-          disabled={disabled}
-          defaultExpanded={keys[index] === expandedKeyRef.current}
-          renderFields={renderFields}
-          editSessionId={editSessionId}
-        />
-      ))}
+      {items.map((item, index) => {
+        const controls = entryControls?.(index, item);
+        return (
+          <ObjectEntryCard
+            key={keys[index] ?? index}
+            id={entryIdPrefix ? `${entryIdPrefix}-${index}` : undefined}
+            entryKey={
+              getEntryLabel(item) ?? localize('com_config_entry_n', { n: String(index + 1) })
+            }
+            fields={fields}
+            value={item}
+            onValueChange={(v) => handleEntryChange(index, v)}
+            onRemove={
+              disabled || controls?.canRemove === false ? undefined : () => handleRemove(index)
+            }
+            resetOverrides={controls?.resetOverrides}
+            disabled={disabled}
+            defaultExpanded={keys[index] === expandedKeyRef.current}
+            renderFields={renderFields}
+            editSessionId={editSessionId}
+          />
+        );
+      })}
       {items.length === 0 && !hideAddButton && (
         <p className="py-2 text-sm text-(--cui-color-text-muted)">
           {localize('com_config_no_entries')}
diff --git a/src/components/configuration/fields/ObjectEntryCard.tsx b/src/components/configuration/fields/ObjectEntryCard.tsx
index 4e4a3121..aae99154 100644
--- a/src/components/configuration/fields/ObjectEntryCard.tsx
+++ b/src/components/configuration/fields/ObjectEntryCard.tsx
@@ -1,4 +1,4 @@
-import { Icon } from '@clickhouse/click-ui';
+import { Icon, IconButton } from '@clickhouse/click-ui';
 import { useState, useCallback, useRef, useEffect } from 'react';
 import type * as t from '@/types';
 import { TrashButton } from '@/components/shared';
@@ -14,6 +14,7 @@ export function ObjectEntryCard({
   onValueChange,
   onRemove,
   onRename,
+  resetOverrides,
   disabled,
   defaultExpanded = false,
   renderFields,
@@ -191,6 +192,24 @@ export function ObjectEntryCard({
             <span>{localize('com_config_add_field')}</span>
           </button>
         )}
+        {!disabled && resetOverrides && (
+          <span
+            className="opacity-0 transition-opacity group-focus-within:opacity-100 group-hover:opacity-100"
+            onClick={(e) => e.stopPropagation()}
+            title={resetOverrides.title}
+          >
+            <IconButton
+              icon="refresh"
+              size="sm"
+              onClick={(e) => {
+                e.preventDefault();
+                resetOverrides.onClick();
+              }}
+              disabled={resetOverrides.disabled}
+              aria-label={localize('com_a11y_reset_entry_overrides', { name: entryKey })}
+            />
+          </span>
+        )}
         {!disabled && onRemove && (
           <span
             className="opacity-0 transition-opacity group-focus-within:opacity-100 group-hover:opacity-100"
diff --git a/src/components/configuration/sections/EndpointsRenderer.tsx b/src/components/configuration/sections/EndpointsRenderer.tsx
index d18c1806..414059dd 100644
--- a/src/components/configuration/sections/EndpointsRenderer.tsx
+++ b/src/components/configuration/sections/EndpointsRenderer.tsx
@@ -14,7 +14,7 @@
  * relevant subset. New fields added to the schema surface automatically.
  */
 
-import { useMemo, useState } from 'react';
+import { useMemo, useState, useCallback } from 'react';
 import { Icon, MultiAccordion } from '@clickhouse/click-ui';
 import type { ReactNode } from 'react';
 import type * as t from '@/types';
@@ -94,6 +94,15 @@ const FIELD_GROUPS: Record<string, FieldGroupDef[]> = {
  */
 const REQUIRED_ENDPOINT_KEYS = new Set(['name', 'apiKey', 'baseURL']);
 
+/**
+ * LibreChat merges the `endpoints.custom` override array into the YAML array
+ * by item `name`, so `name` is the entry's identity across config layers.
+ * Renaming a YAML-defined endpoint can never work: the renamed override item
+ * no longer matches its YAML counterpart, which survives unchanged while the
+ * override is appended as a duplicate entry.
+ */
+const YAML_LOCKED_ENDPOINT_FIELDS = new Set(['name']);
+
 function withRequired(field: t.SchemaField): t.SchemaField {
   if (REQUIRED_ENDPOINT_KEYS.has(field.key)) {
     return { ...field, isOptional: false };
@@ -129,6 +138,7 @@ function flattenGroupFields(
   disabled?: boolean,
   collectionRenderOverrides?: Record<string, t.CollectionRenderFields>,
   editSessionId?: number,
+  lockedKeys?: Set<string>,
 ): ReactNode[] {
   const values =
     typeof parentValue === 'object' && parentValue !== null && !Array.isArray(parentValue)
@@ -137,6 +147,7 @@ function flattenGroupFields(
 
   const nodes: ReactNode[] = [];
   for (const field of fields) {
+    const fieldDisabled = disabled || (lockedKeys?.has(field.key) ?? false);
     if (field.children && field.children.length > 0 && !field.isArray && field.type !== 'record') {
       const nested = values[field.key];
       const nestedObj =
@@ -153,7 +164,7 @@ function flattenGroupFields(
               onChange(field.key, { ...nestedObj, [childKey]: childValue });
             },
             localize,
-            disabled,
+            fieldDisabled,
             collectionRenderOverrides,
             true,
             editSessionId,
@@ -168,7 +179,7 @@ function flattenGroupFields(
           parentPath,
           onChange,
           localize,
-          disabled,
+          fieldDisabled,
           collectionRenderOverrides,
           true,
           editSessionId,
@@ -189,6 +200,7 @@ function FieldGroup({
   defaultExpanded,
   collectionRenderOverrides,
   editSessionId,
+  lockedKeys,
 }: {
   labelKey: string;
   fields: t.SchemaField[];
@@ -199,6 +211,7 @@ function FieldGroup({
   defaultExpanded: boolean;
   collectionRenderOverrides?: Record<string, t.CollectionRenderFields>;
   editSessionId?: number;
+  lockedKeys?: Set<string>;
 }) {
   const localize = useLocalize();
   const { isExpanded, hasEverExpanded, sectionRef, toggle } = useCollapsibleSection({
@@ -242,6 +255,7 @@ function FieldGroup({
             disabled,
             collectionRenderOverrides,
             editSessionId,
+            lockedKeys,
           )}
         </div>,
       )}
@@ -258,6 +272,7 @@ function GroupedFieldRenderer({
   disabled,
   collectionRenderOverrides,
   editSessionId,
+  lockedKeys,
 }: {
   groupKey: string;
   fields: t.SchemaField[];
@@ -267,6 +282,7 @@ function GroupedFieldRenderer({
   disabled?: boolean;
   collectionRenderOverrides?: Record<string, t.CollectionRenderFields>;
   editSessionId?: number;
+  lockedKeys?: Set<string>;
 }) {
   const groups = FIELD_GROUPS[groupKey];
   if (!groups) return null;
@@ -293,6 +309,7 @@ function GroupedFieldRenderer({
             defaultExpanded={group.defaultExpanded}
             collectionRenderOverrides={collectionRenderOverrides}
             editSessionId={editSessionId}
+            lockedKeys={lockedKeys}
           />
         );
       })}
@@ -307,6 +324,7 @@ function GroupedFieldRenderer({
           defaultExpanded={false}
           collectionRenderOverrides={collectionRenderOverrides}
           editSessionId={editSessionId}
+          lockedKeys={lockedKeys}
         />
       )}
     </div>
@@ -466,7 +484,10 @@ const COLLECTION_RENDER_OVERRIDES: Record<string, t.CollectionRenderFields> = {
  * Matches the `CollectionRenderFields` signature so it can be injected
  * into `ArrayObjectField` and `ObjectEntryCard`.
  */
-function makeGroupedEndpointFields(disabled?: boolean): t.CollectionRenderFields {
+function makeGroupedEndpointFields(
+  disabled?: boolean,
+  isEntryNameLocked?: (entry: t.ConfigValue) => boolean,
+): t.CollectionRenderFields {
   return (fields, parentValue, parentPath, onChange, _addFieldTriggerRef, editSessionId) => (
     <GroupedFieldRenderer
       groupKey="custom"
@@ -477,6 +498,7 @@ function makeGroupedEndpointFields(disabled?: boolean): t.CollectionRenderFields
       disabled={disabled}
       collectionRenderOverrides={COLLECTION_RENDER_OVERRIDES}
       editSessionId={editSessionId}
+      lockedKeys={isEntryNameLocked?.(parentValue) ? YAML_LOCKED_ENDPOINT_FIELDS : undefined}
     />
   );
 }
@@ -611,12 +633,86 @@ function ProviderSection({
 // ---------------------------------------------------------------------------
 
 export function CustomEndpointsRenderer(props: t.FieldRendererProps) {
-  const { fields, parentPath, parentValue, getValue, onChange, disabled, editSessionId } = props;
+  const {
+    fields,
+    parentPath,
+    parentValue,
+    getValue,
+    onChange,
+    disabled,
+    editedValues,
+    yamlBaseKeys,
+    dbOverrideKeys,
+    isEditingScope,
+    onResetEntryOverrides,
+    editSessionId,
+  } = props;
   const localize = useLocalize();
   const [createOpen, setCreateOpen] = useState(false);
+
+  /** `yamlBaseKeys` is undefined only when the YAML provenance (baseOnly) fetch failed. Fail closed: with unknown provenance any entry could be YAML-defined, and a staged delete or rename would both fail (the name-based merge restores the YAML entry) and freeze the whole array into the override document. */
+  const provenanceUnknown = !isEditingScope && yamlBaseKeys === undefined;
+
+  /** YAML identity locks apply in base mode only; scope overrides layer on top of the resolved base and keep their own affordances. */
+  const yamlNames = useMemo(
+    () => (isEditingScope ? new Set<string>() : (yamlBaseKeys ?? new Set<string>())),
+    [isEditingScope, yamlBaseKeys],
+  );
+
+  const isEntryNameLocked = useCallback(
+    (entry: t.ConfigValue) => {
+      if (provenanceUnknown) return true;
+      if (!entry || typeof entry !== 'object' || Array.isArray(entry)) return false;
+      const name = (entry as Record<string, t.ConfigValue>).name;
+      return typeof name === 'string' && yamlNames.has(name);
+    },
+    [provenanceUnknown, yamlNames],
+  );
+
   const renderGroupedEndpointFields = useMemo(
-    () => makeGroupedEndpointFields(disabled),
-    [disabled],
+    () => makeGroupedEndpointFields(disabled, isEntryNameLocked),
+    [disabled, isEntryNameLocked],
+  );
+
+  const renderCreateEndpointFields = useMemo(() => makeGroupedEndpointFields(disabled), [disabled]);
+
+  const hasPendingEdits = !!editedValues && Object.keys(editedValues).length > 0;
+
+  const entryControls = useCallback(
+    (_index: number, item: t.ConfigValue): t.EntryCardControls => {
+      if (provenanceUnknown) return { canRemove: false };
+      const obj =
+        item && typeof item === 'object' && !Array.isArray(item)
+          ? (item as Record<string, t.ConfigValue>)
+          : {};
+      const name = typeof obj.name === 'string' ? obj.name : '';
+      const isYamlSource = name !== '' && yamlNames.has(name);
+      if (!isYamlSource) return {};
+      /** YAML-defined endpoints cannot be deleted from the admin panel: the merge preserves unmatched YAML items, so the entry would reappear on the next load. Offer clearing the override layer instead. */
+      const resetOverrides: t.EntryResetAction | undefined =
+        onResetEntryOverrides && dbOverrideKeys?.has(name)
+          ? {
+              onClick: () =>
+                onResetEntryOverrides({
+                  fieldPath: `${parentPath}.custom`,
+                  itemName: name,
+                  label: name,
+                }),
+              disabled: hasPendingEdits,
+              title: hasPendingEdits ? localize('com_config_reset_base_dirty') : undefined,
+            }
+          : undefined;
+      return { canRemove: false, resetOverrides };
+    },
+    [
+      provenanceUnknown,
+      yamlNames,
+      dbOverrideKeys,
+      onResetEntryOverrides,
+      parentPath,
+      hasPendingEdits,
+      localize,
+    ],
   );
 
   const customField = fields.find((f) => f.key === 'custom');
@@ -661,6 +757,7 @@ export function CustomEndpointsRenderer(props: t.FieldRendererProps) {
           hideAddButton
           renderFields={renderGroupedEndpointFields}
           entryIdPrefix={`section-${path.split('.')[0]}-custom`}
+          entryControls={entryControls}
           editSessionId={editSessionId}
         />
       )}
@@ -669,7 +766,7 @@ export function CustomEndpointsRenderer(props: t.FieldRendererProps) {
         onClose={() => setCreateOpen(false)}
         onSave={handleCreate}
         fields={customField.children ?? []}
-        renderFields={renderGroupedEndpointFields}
+        renderFields={renderCreateEndpointFields}
       />
     </div>
   );
diff --git a/src/components/configuration/sections/McpServersRenderer.tsx b/src/components/configuration/sections/McpServersRenderer.tsx
index 5eb0f985..659e20eb 100644
--- a/src/components/configuration/sections/McpServersRenderer.tsx
+++ b/src/components/configuration/sections/McpServersRenderer.tsx
@@ -43,6 +43,9 @@ const TRANSPORT_TYPE_OPTIONS: { label: string; value: string }[] = [
 
 const ALWAYS_REQUIRED = new Set(['type']);
 
+/** Segments `safeFieldPath` rejects server-side; a server key matching one can never round-trip through the field-path API. */
+const UNADDRESSABLE_SEGMENTS = new Set(['__proto__', 'constructor', 'prototype']);
+
 /** Stable empty record used as the fallback for `baseRecord`/`parentValue` when no data is available, so the downstream `useMemo` chain on `editsByEntry`/`record` does not re-fire on every render with a fresh `{}` literal. */
 const EMPTY_RECORD: Record<string, t.ConfigValue> = Object.freeze({}) as Record<
   string,
@@ -212,6 +215,7 @@ function flattenGroupFields(
   disabled?: boolean,
   collectionRenderOverrides?: Record<string, t.CollectionRenderFields>,
   lockedKeys?: Set<string>,
+  editSessionId?: number,
 ): ReactNode[] {
   const values = isPlainObject(parentValue) ? parentValue : {};
 
@@ -264,6 +268,7 @@ function flattenGroupFields(
             fieldDisabled,
             collectionRenderOverrides,
             true,
+            editSessionId,
           ),
         );
       }
@@ -278,6 +283,7 @@ function flattenGroupFields(
           fieldDisabled,
           collectionRenderOverrides,
           true,
+          editSessionId,
         ),
       );
     }
@@ -340,6 +346,7 @@ function FieldGroup({
   defaultExpanded,
   transportType,
   lockedKeys,
+  editSessionId,
 }: {
   labelKey: string;
   fields: t.SchemaField[];
@@ -350,6 +357,7 @@ function FieldGroup({
   defaultExpanded: boolean;
   transportType: string;
   lockedKeys?: Set<string>;
+  editSessionId?: number;
 }) {
   const localize = useLocalize();
   const { isExpanded, hasEverExpanded, sectionRef, toggle } = useCollapsibleSection({
@@ -394,6 +402,7 @@ function FieldGroup({
             disabled,
             undefined,
             lockedKeys,
+            editSessionId,
           )}
         </div>,
       )}
@@ -408,6 +417,7 @@ function McpEntryFields({
   onChange,
   disabled,
   lockedKeys,
+  editSessionId,
 }: {
   fields: t.SchemaField[];
   parentValue: t.ConfigValue;
@@ -415,6 +425,7 @@ function McpEntryFields({
   onChange: (path: string, value: t.ConfigValue) => void;
   disabled?: boolean;
   lockedKeys?: Set<string>;
+  editSessionId?: number;
 }) {
   const localize = useLocalize();
   const values = isPlainObject(parentValue) ? parentValue : {};
@@ -479,6 +490,7 @@ function McpEntryFields({
                 disabled,
                 undefined,
                 lockedKeys,
+                editSessionId,
               )}
             </div>
           )}
@@ -494,6 +506,7 @@ function McpEntryFields({
               defaultExpanded={child.defaultExpanded}
               transportType={currentType}
               lockedKeys={lockedKeys}
+              editSessionId={editSessionId}
             />
           ))}
         </FieldGroupSection>
@@ -512,6 +525,7 @@ function McpEntryFields({
         defaultExpanded={group.defaultExpanded}
         transportType={currentType}
         lockedKeys={lockedKeys}
+        editSessionId={editSessionId}
       />
     );
   };
@@ -530,6 +544,7 @@ function McpEntryFields({
           defaultExpanded={false}
           transportType={currentType}
           lockedKeys={lockedKeys}
+          editSessionId={editSessionId}
         />
       )}
     </div>
@@ -662,8 +677,11 @@ export function McpServersRenderer(props: t.FieldRendererProps) {
     disabled,
     editedValues,
     yamlBaseKeys,
+    dbOverrideKeys,
     isEditingScope,
+    onResetEntryOverrides,
     onValidationError,
+    editSessionId,
   } = props;
   const localize = useLocalize();
   const [createOpen, setCreateOpen] = useState(false);
@@ -786,6 +804,21 @@ export function McpServersRenderer(props: t.FieldRendererProps) {
     localizeRef.current = localize;
   }, [localize]);
 
+  const onResetEntryOverridesRef = useRef(onResetEntryOverrides);
+  useEffect(() => {
+    onResetEntryOverridesRef.current = onResetEntryOverrides;
+  }, [onResetEntryOverrides]);
+
+  const handleResetOverrides = useCallback(
+    (key: string) => {
+      onResetEntryOverridesRef.current?.({ fieldPath: `${path}.${key}`, label: key });
+    },
+    [path],
+  );
+
+  /** Immediate reset would interleave with staged edits, so it stays locked until they are saved or discarded (same rule as the global reset button). */
+  const hasPendingEdits = !!editedValues && Object.keys(editedValues).length > 0;
+
   const handleCreate = useCallback(
     (serverName: string, entry: Record<string, t.ConfigValue>) => {
       if (serverName.includes('.')) {
@@ -942,10 +975,16 @@ export function McpServersRenderer(props: t.FieldRendererProps) {
           disabled={disabled}
           isEditingScope={!!isEditingScope}
           isYamlSource={yamlSourceKeys.has(key)}
+          canResetOverrides={
+            !isEditingScope && yamlSourceKeys.has(key) && (dbOverrideKeys?.has(key) ?? false)
+          }
+          resetDisabled={hasPendingEdits}
           onChange={onChange}
           onRemove={handleRemove}
           onRename={handleRename}
+          onResetOverrides={onResetEntryOverrides ? handleResetOverrides : undefined}
           justAdded={key === justAddedKey}
+          editSessionId={editSessionId}
         />
       ))}
       {!disabled && entries.length === 0 && (
@@ -981,10 +1020,14 @@ const McpEntryRow = memo(function McpEntryRowImpl({
   disabled,
   isEditingScope,
   isYamlSource,
+  canResetOverrides,
+  resetDisabled,
   onChange,
   onRemove,
   onRename,
+  onResetOverrides,
   justAdded,
+  editSessionId,
 }: {
   entryKey: string;
   entryValue: t.ConfigValue;
@@ -993,11 +1036,16 @@ const McpEntryRow = memo(function McpEntryRowImpl({
   disabled?: boolean;
   isEditingScope: boolean;
   isYamlSource: boolean;
+  canResetOverrides: boolean;
+  resetDisabled: boolean;
   onChange: (path: string, value: t.ConfigValue) => void;
   onRemove: (key: string) => void;
   onRename: (oldKey: string, newKey: string) => void;
+  onResetOverrides?: (key: string) => void;
   justAdded: boolean;
+  editSessionId?: number;
 }) {
+  const localize = useLocalize();
   const entryObj = isPlainObject(entryValue) ? entryValue : {};
   const rawType = typeof entryObj.type === 'string' ? entryObj.type : '';
   const inferred = rawType || inferTransportType(entryObj);
@@ -1006,18 +1054,18 @@ const McpEntryRow = memo(function McpEntryRowImpl({
     effectiveType !== rawType ? { ...entryObj, type: effectiveType } : entryValue;
 
   const entryPathBase = `${path}.${entryKey}`;
-  /** Dotted entry names predate the dot-rejecting create/rename validators; the save endpoint parses fieldPath as dot-delimited so any per-leaf write under such a key collides with a parallel "legacy" → "dotted" nested-object interpretation. Render them read-only so they stay visible in the list but never round-trip through the per-field save API. */
-  const isDottedLegacy = entryKey.includes('.');
-  const isReadOnly = !!disabled || isDottedLegacy;
-  const isLockedIdentity = (!isEditingScope && isYamlSource) || isDottedLegacy;
-  const lockedKeys = isYamlSource && !isDottedLegacy ? YAML_LOCKED_FIELDS : undefined;
+  /** Dotted entry names predate the dot-rejecting create/rename validators; the save endpoint parses fieldPath as dot-delimited so any per-leaf write under such a key collides with a parallel "legacy" → "dotted" nested-object interpretation. Keys matching `safeFieldPath`'s rejected segments are equally unaddressable: every field-path write or unset for them fails server-side validation. Render both read-only so they stay visible in the list but never round-trip through the per-field save API. */
+  const isUnaddressableKey = entryKey.includes('.') || UNADDRESSABLE_SEGMENTS.has(entryKey);
+  const isReadOnly = !!disabled || isUnaddressableKey;
+  const isLockedIdentity = (!isEditingScope && isYamlSource) || isUnaddressableKey;
+  const lockedKeys = isYamlSource && !isUnaddressableKey ? YAML_LOCKED_FIELDS : undefined;
 
   const entryOnChange = useCallback(
     (leafKey: string, leafValue: t.ConfigValue) => {
-      if (isDottedLegacy) return;
+      if (isUnaddressableKey) return;
       onChange(`${entryPathBase}.${leafKey}`, leafValue);
     },
-    [onChange, entryPathBase, isDottedLegacy],
+    [onChange, entryPathBase, isUnaddressableKey],
   );
 
   const renderEntryFields: t.CollectionRenderFields = useCallback(
@@ -1029,20 +1077,30 @@ const McpEntryRow = memo(function McpEntryRowImpl({
         onChange={entryOnChange}
         disabled={isReadOnly}
         lockedKeys={lockedKeys}
+        editSessionId={editSessionId}
       />
     ),
-    [entryOnChange, isReadOnly, lockedKeys],
+    [entryOnChange, isReadOnly, lockedKeys, editSessionId],
   );
 
   /** Required by ObjectEntryCard's onValueChange contract; unused on leaf edits. */
   const handleWholeEntryChange = useCallback(
     (v: t.ConfigValue) => {
-      if (isDottedLegacy) return;
+      if (isUnaddressableKey) return;
       onChange(entryPathBase, v);
     },
-    [onChange, entryPathBase, isDottedLegacy],
+    [onChange, entryPathBase, isUnaddressableKey],
   );
 
+  const resetOverrides: t.EntryResetAction | undefined =
+    !isReadOnly && canResetOverrides && onResetOverrides
+      ? {
+          onClick: () => onResetOverrides(entryKey),
+          disabled: resetDisabled,
+          title: resetDisabled ? localize('com_config_reset_base_dirty') : undefined,
+        }
+      : undefined;
+
   return (
     <ObjectEntryCard
       id={`section-mcpServers-${encodeURIComponent(entryKey)}`}
@@ -1054,6 +1112,7 @@ const McpEntryRow = memo(function McpEntryRowImpl({
       onRename={
         isReadOnly || isLockedIdentity ? undefined : (renamed) => onRename(entryKey, renamed)
       }
+      resetOverrides={resetOverrides}
       disabled={isReadOnly}
       defaultExpanded={justAdded}
       renderFields={renderEntryFields}
diff --git a/src/components/configuration/sections/__tests__/EndpointsRenderer.test.tsx b/src/components/configuration/sections/__tests__/EndpointsRenderer.test.tsx
index 76d63adf..544f95e3 100644
--- a/src/components/configuration/sections/__tests__/EndpointsRenderer.test.tsx
+++ b/src/components/configuration/sections/__tests__/EndpointsRenderer.test.tsx
@@ -1,7 +1,7 @@
 import { describe, it, expect, vi } from 'vitest';
-import { render, screen } from '@testing-library/react';
+import { render, screen, fireEvent } from '@testing-library/react';
 import type * as t from '@/types';
-import { ProvidersRenderer } from '../EndpointsRenderer';
+import { ProvidersRenderer, CustomEndpointsRenderer } from '../EndpointsRenderer';
 import { createField } from '@/test/fixtures';
 
 vi.mock('@/hooks/useLocalize', () => ({
@@ -17,6 +17,13 @@ interface MockTextFieldProps {
   'aria-label'?: string;
 }
 
+interface MockIconButtonProps {
+  icon: string;
+  onClick?: () => void;
+  disabled?: boolean;
+  'aria-label'?: string;
+}
+
 vi.mock('@clickhouse/click-ui', () => ({
   Icon: () => <span />,
   MultiAccordion: Object.assign(
@@ -25,6 +32,14 @@ vi.mock('@clickhouse/click-ui', () => ({
       Item: ({ children }: { children: React.ReactNode }) => <div>{children}</div>,
     },
   ),
+  IconButton: ({ icon, onClick, disabled, ...rest }: MockIconButtonProps) => (
+    <button
+      onClick={onClick}
+      disabled={disabled}
+      aria-label={rest['aria-label'] ?? icon}
+      data-testid={`icon-button-${icon}`}
+    />
+  ),
   TextField: ({ id, value, onChange, disabled, ...rest }: MockTextFieldProps) => (
     <input
       id={id}
@@ -36,9 +51,180 @@ vi.mock('@clickhouse/click-ui', () => ({
   ),
 }));
 
+vi.mock('@/components/shared', async () => {
+  const actual = await vi.importActual<typeof import('@/components/shared')>('@/components/shared');
+  return {
+    ...actual,
+    FormDialog: ({ open, children }: { open: boolean; children: React.ReactNode }) =>
+      open ? <div data-testid="form-dialog">{children}</div> : null,
+  };
+});
+
 const noop = () => {};
 const getValue = (_path: string, fallback: t.ConfigValue) => fallback;
 
+function customEndpointFields(): t.SchemaField[] {
+  return [
+    createField({
+      key: 'custom',
+      type: 'array<object>',
+      isArray: true,
+      children: [
+        createField({ key: 'name', type: 'string' }),
+        createField({ key: 'baseURL', type: 'string' }),
+      ],
+    }),
+  ];
+}
+
+function renderCustomEndpoints({
+  items,
+  editedValues = {},
+  yamlBaseKeys,
+  dbOverrideKeys,
+  isEditingScope,
+  onChange = vi.fn(),
+  onResetEntryOverrides,
+}: {
+  items: t.ConfigValue[];
+  editedValues?: t.FlatConfigMap;
+  yamlBaseKeys?: Set<string>;
+  dbOverrideKeys?: Set<string>;
+  isEditingScope?: boolean;
+  onChange?: (path: string, value: t.ConfigValue) => void;
+  onResetEntryOverrides?: (target: t.EntryResetTarget) => void;
+}) {
+  const props: t.FieldRendererProps = {
+    fields: customEndpointFields(),
+    parentValue: { custom: items },
+    parentPath: 'endpoints',
+    getValue,
+    onChange,
+    editedValues,
+    yamlBaseKeys,
+    dbOverrideKeys,
+    isEditingScope,
+    onResetEntryOverrides,
+  };
+  return { ...render(<CustomEndpointsRenderer {...props} />), onChange };
+}
+
+describe('CustomEndpointsRenderer — YAML-defined endpoints (issue #108)', () => {
+  const yamlEp = { name: 'yamlEp', baseURL: 'https://yaml.example' };
+  const adminEp = { name: 'adminEp', baseURL: 'https://admin.example' };
+
+  it('hides the trash for YAML-defined endpoints but keeps it for admin-created ones', () => {
+    const { container } = renderCustomEndpoints({
+      items: [yamlEp, adminEp],
+      yamlBaseKeys: new Set(['yamlEp']),
+    });
+    expect(container.querySelector('button[aria-label="com_ui_delete yamlEp"]')).toBeNull();
+    expect(container.querySelector('button[aria-label="com_ui_delete adminEp"]')).not.toBeNull();
+  });
+
+  it('shows a reset-to-YAML action on an overridden YAML endpoint and reports the array item target', () => {
+    const onResetEntryOverrides = vi.fn();
+    renderCustomEndpoints({
+      items: [yamlEp, adminEp],
+      yamlBaseKeys: new Set(['yamlEp']),
+      dbOverrideKeys: new Set(['yamlEp']),
+      onResetEntryOverrides,
+    });
+    const resetBtn = screen.getByTestId('icon-button-refresh');
+    fireEvent.click(resetBtn);
+    expect(onResetEntryOverrides).toHaveBeenCalledWith({
+      fieldPath: 'endpoints.custom',
+      itemName: 'yamlEp',
+      label: 'yamlEp',
+    });
+  });
+
+  it('hides the reset action when the YAML endpoint has no stored override', () => {
+    renderCustomEndpoints({
+      items: [yamlEp],
+      yamlBaseKeys: new Set(['yamlEp']),
+      dbOverrideKeys: new Set<string>(),
+      onResetEntryOverrides: vi.fn(),
+    });
+    expect(screen.queryByTestId('icon-button-refresh')).toBeNull();
+  });
+
+  it('disables the reset action while edits are pending', () => {
+    renderCustomEndpoints({
+      items: [yamlEp],
+      editedValues: { 'endpoints.custom.0': { ...yamlEp, baseURL: 'https://staged.example' } },
+      yamlBaseKeys: new Set(['yamlEp']),
+      dbOverrideKeys: new Set(['yamlEp']),
+      onResetEntryOverrides: vi.fn(),
+    });
+    expect(screen.getByTestId('icon-button-refresh').hasAttribute('disabled')).toBe(true);
+  });
+
+  it('locks the name field on YAML-defined endpoints (merge identity) but not on admin-created ones', () => {
+    const { container } = renderCustomEndpoints({
+      items: [yamlEp, adminEp],
+      yamlBaseKeys: new Set(['yamlEp']),
+    });
+
+    fireEvent.click(screen.getByText('yamlEp'));
+    const yamlName = container.querySelector('input#yamlEp-name') as HTMLInputElement | null;
+    expect(yamlName).not.toBeNull();
+    expect(yamlName!.hasAttribute('disabled')).toBe(true);
+    const yamlBaseURL = container.querySelector('input#yamlEp-baseURL') as HTMLInputElement | null;
+    expect(yamlBaseURL).not.toBeNull();
+    expect(yamlBaseURL!.hasAttribute('disabled')).toBe(false);
+
+    fireEvent.click(screen.getByText('adminEp'));
+    const adminName = container.querySelector('input#adminEp-name') as HTMLInputElement | null;
+    expect(adminName).not.toBeNull();
+    expect(adminName!.hasAttribute('disabled')).toBe(false);
+  });
+
+  it('fails closed when YAML provenance is unavailable: trash hidden, name locked, reset hidden', () => {
+    /** yamlBaseKeys is undefined only when the baseOnly provenance fetch failed; any entry could be YAML-defined, so identity actions lock for all of them. */
+    const { container } = renderCustomEndpoints({
+      items: [yamlEp, adminEp],
+      yamlBaseKeys: undefined,
+      dbOverrideKeys: new Set(['yamlEp', 'adminEp']),
+      onResetEntryOverrides: vi.fn(),
+    });
+    expect(container.querySelector('button[aria-label^="com_ui_delete"]')).toBeNull();
+    expect(screen.queryByTestId('icon-button-refresh')).toBeNull();
+    fireEvent.click(screen.getByText('adminEp'));
+    const adminName = container.querySelector('input#adminEp-name') as HTMLInputElement | null;
+    expect(adminName).not.toBeNull();
+    expect(adminName!.hasAttribute('disabled')).toBe(true);
+  });
+
+  it('keeps entries fully editable when provenance is known and empty (no YAML endpoints)', () => {
+    const { container } = renderCustomEndpoints({
+      items: [adminEp],
+      yamlBaseKeys: new Set<string>(),
+    });
+    expect(container.querySelector('button[aria-label="com_ui_delete adminEp"]')).not.toBeNull();
+    fireEvent.click(screen.getByText('adminEp'));
+    const adminName = container.querySelector('input#adminEp-name') as HTMLInputElement | null;
+    expect(adminName).not.toBeNull();
+    expect(adminName!.hasAttribute('disabled')).toBe(false);
+  });
+
+  it('keeps scope mode unaffected: trash stays and name stays editable for YAML endpoints', () => {
+    const { container } = renderCustomEndpoints({
+      items: [yamlEp],
+      yamlBaseKeys: new Set(['yamlEp']),
+      dbOverrideKeys: new Set(['yamlEp']),
+      isEditingScope: true,
+      onResetEntryOverrides: vi.fn(),
+    });
+    expect(container.querySelector('button[aria-label="com_ui_delete yamlEp"]')).not.toBeNull();
+    expect(screen.queryByTestId('icon-button-refresh')).toBeNull();
+    fireEvent.click(screen.getByText('yamlEp'));
+    const nameInput = container.querySelector('input#yamlEp-name') as HTMLInputElement | null;
+    expect(nameInput).not.toBeNull();
+    expect(nameInput!.hasAttribute('disabled')).toBe(false);
+  });
+});
+
 describe('ProvidersRenderer', () => {
   const providerFields: t.SchemaField[] = [
     createField({
diff --git a/src/components/configuration/sections/__tests__/McpServersRenderer.test.tsx b/src/components/configuration/sections/__tests__/McpServersRenderer.test.tsx
index 4fd36638..3ee0af7c 100644
--- a/src/components/configuration/sections/__tests__/McpServersRenderer.test.tsx
+++ b/src/components/configuration/sections/__tests__/McpServersRenderer.test.tsx
@@ -59,6 +59,7 @@ interface NumberFieldProps {
 interface IconButtonProps {
   icon: string;
   onClick?: () => void;
+  disabled?: boolean;
   'aria-label'?: string;
 }
 
@@ -89,9 +90,10 @@ vi.mock('@clickhouse/click-ui', () => ({
   Button: ({ label, onClick, children }: ButtonProps) => (
     <button onClick={onClick}>{label ?? children}</button>
   ),
-  IconButton: ({ icon, onClick, ...props }: IconButtonProps) => (
+  IconButton: ({ icon, onClick, disabled, ...props }: IconButtonProps) => (
     <button
       onClick={onClick}
+      disabled={disabled}
       aria-label={props['aria-label'] ?? icon}
       data-testid={`icon-button-${icon}`}
     />
@@ -163,6 +165,7 @@ function fieldsForMcp(): t.SchemaField[] {
     createField({ key: 'command', type: 'string', isOptional: true }),
     createField({ key: 'title', type: 'string', isOptional: true }),
     createField({ key: 'description', type: 'string', isOptional: true }),
+    createField({ key: 'apiKey', type: 'string', isOptional: true }),
     createField({ key: 'tools', type: 'array<string>', isOptional: true, isArray: true }),
     createField({ key: 'source', type: 'string', isOptional: true }),
   ];
@@ -173,16 +176,22 @@ function renderRenderer({
   editedValues = {},
   dbOverridePaths,
   yamlBaseKeys,
+  dbOverrideKeys,
   isEditingScope,
+  editSessionId,
   onChange = vi.fn(),
+  onResetEntryOverrides,
   onValidationError = vi.fn(),
 }: {
   baseRecord: Record<string, t.ConfigValue>;
   editedValues?: t.FlatConfigMap;
   dbOverridePaths?: Set<string>;
   yamlBaseKeys?: Set<string>;
+  dbOverrideKeys?: Set<string>;
   isEditingScope?: boolean;
+  editSessionId?: number;
   onChange?: (path: string, value: t.ConfigValue) => void;
+  onResetEntryOverrides?: (target: t.EntryResetTarget) => void;
   onValidationError?: (message: string) => void;
 }) {
   const fields = fieldsForMcp();
@@ -199,11 +208,17 @@ function renderRenderer({
     editedValues,
     dbOverridePaths,
     yamlBaseKeys,
+    dbOverrideKeys,
     isEditingScope,
+    editSessionId,
+    onResetEntryOverrides,
     onValidationError,
   };
+  const result = render(<McpServersRenderer {...props} />);
   return {
-    ...render(<McpServersRenderer {...props} />),
+    ...result,
+    rerenderWithSession: (sessionId: number) =>
+      result.rerender(<McpServersRenderer {...props} editSessionId={sessionId} />),
     onChange,
     onValidationError,
     fields,
@@ -344,6 +359,129 @@ describe('McpServersRenderer — YAML source detection', () => {
   });
 });
 
+describe('McpServersRenderer — per-entry clear overrides (issue #73)', () => {
+  it('shows a reset-to-YAML action on a YAML server with DB overrides and reports the entry target', () => {
+    const onResetEntryOverrides = vi.fn();
+    const baseRecord = {
+      kapa: { type: 'sse', url: 'https://example.com', title: 'Overridden title' },
+    };
+    const { container } = renderRenderer({
+      baseRecord,
+      yamlBaseKeys: new Set(['kapa']),
+      dbOverrideKeys: new Set(['kapa']),
+      onResetEntryOverrides,
+    });
+
+    expect(container.querySelector('button[aria-label^="com_ui_delete"]')).toBeNull();
+    const resetBtn = screen.getByTestId('icon-button-refresh');
+    fireEvent.click(resetBtn);
+    expect(onResetEntryOverrides).toHaveBeenCalledWith({
+      fieldPath: 'mcpServers.kapa',
+      label: 'kapa',
+    });
+  });
+
+  it('hides the reset action when the YAML server has no DB overrides', () => {
+    const baseRecord = {
+      kapa: { type: 'sse', url: 'https://example.com' },
+    };
+    renderRenderer({
+      baseRecord,
+      yamlBaseKeys: new Set(['kapa']),
+      dbOverrideKeys: new Set<string>(),
+      onResetEntryOverrides: vi.fn(),
+    });
+    expect(screen.queryByTestId('icon-button-refresh')).toBeNull();
+  });
+
+  it('hides the reset action for keys the field-path validator rejects', () => {
+    const baseRecord = {
+      constructor: { type: 'sse', url: 'https://example.com', title: 'Overridden' },
+    };
+    renderRenderer({
+      baseRecord,
+      yamlBaseKeys: new Set(['constructor']),
+      dbOverrideKeys: new Set(['constructor']),
+      onResetEntryOverrides: vi.fn(),
+    });
+    expect(screen.queryByTestId('icon-button-refresh')).toBeNull();
+    expect(screen.queryByRole('button', { name: /com_ui_delete/ })).toBeNull();
+  });
+
+  it('hides the reset action for admin-only servers (they have delete instead)', () => {
+    const baseRecord = {
+      adminOnly: { type: 'sse', url: 'https://admin.example.com' },
+    };
+    const { container } = renderRenderer({
+      baseRecord,
+      yamlBaseKeys: new Set<string>(),
+      dbOverrideKeys: new Set(['adminOnly']),
+      onResetEntryOverrides: vi.fn(),
+    });
+    expect(screen.queryByTestId('icon-button-refresh')).toBeNull();
+    expect(container.querySelector('button[aria-label^="com_ui_delete"]')).not.toBeNull();
+  });
+
+  it('hides the reset action in scope mode (scope overrides are not the base override layer)', () => {
+    const baseRecord = {
+      kapa: { type: 'sse', url: 'https://example.com' },
+    };
+    renderRenderer({
+      baseRecord,
+      yamlBaseKeys: new Set(['kapa']),
+      dbOverrideKeys: new Set(['kapa']),
+      isEditingScope: true,
+      onResetEntryOverrides: vi.fn(),
+    });
+    expect(screen.queryByTestId('icon-button-refresh')).toBeNull();
+  });
+
+  it('disables the reset action while edits are pending', () => {
+    const baseRecord = {
+      kapa: { type: 'sse', url: 'https://example.com' },
+    };
+    renderRenderer({
+      baseRecord,
+      editedValues: { 'mcpServers.kapa.title': 'staged' },
+      yamlBaseKeys: new Set(['kapa']),
+      dbOverrideKeys: new Set(['kapa']),
+      onResetEntryOverrides: vi.fn(),
+    });
+    const resetBtn = screen.getByTestId('icon-button-refresh');
+    expect(resetBtn.hasAttribute('disabled')).toBe(true);
+  });
+});
+
+describe('McpServersRenderer — editSessionId remounts secret replacement state', () => {
+  it('abandons an open untouched Replace input when the edit session changes (e.g. after an entry reset)', () => {
+    const baseRecord = {
+      kapa: { type: 'sse', url: 'https://x.com', apiKeyPreview: 'sk-test...1234' },
+    };
+    const { container, rerenderWithSession } = renderRenderer({
+      baseRecord,
+      yamlBaseKeys: new Set<string>(),
+      editSessionId: 0,
+    });
+
+    fireEvent.click(screen.getByText('kapa'));
+    fireEvent.click(screen.getByText('com_config_group_authentication'));
+    const replaceBtn = container.querySelector(
+      'button[aria-label^="com_a11y_secret_replace"]',
+    ) as HTMLButtonElement | null;
+    expect(replaceBtn).not.toBeNull();
+    fireEvent.click(replaceBtn!);
+    expect(
+      container.querySelector('button[aria-label^="com_a11y_secret_cancel_replace"]'),
+    ).not.toBeNull();
+
+    rerenderWithSession(1);
+    expect(
+      container.querySelector('button[aria-label^="com_a11y_secret_cancel_replace"]'),
+    ).toBeNull();
+    expect(container.querySelector('button[aria-label^="com_a11y_secret_replace"]')).not.toBeNull();
+  });
+});
+
 describe('McpServersRenderer — lock matrix and inspector hide', () => {
   it('does not render inspector-derived fields like source/tools in the card', () => {
     const baseRecord = {
diff --git a/src/components/configuration/utils.test.ts b/src/components/configuration/utils.test.ts
index 469644d4..93fab3e9 100644
--- a/src/components/configuration/utils.test.ts
+++ b/src/components/configuration/utils.test.ts
@@ -1,4 +1,4 @@
-import { describe, it, expect } from 'vitest';
+import { describe, it, expect, vi } from 'vitest';
 import type * as t from '@/types';
 import {
   getControlType,
@@ -9,6 +9,9 @@ import {
   mergeIndexedArrayEdits,
   buildSavePayload,
   applyConfigEdit,
+  buildEntryOverridesResetPlan,
+  executeEntryOverridesReset,
+  collectEntryOverrideKeys,
 } from './utils';
 import { createField } from '@/test/fixtures';
 import { flattenObject } from '@/utils';
@@ -543,3 +546,295 @@ describe('buildSavePayload — masked secrets never reach the backend', () => {
     expect(resets).toEqual(['ocr.apiKey']);
   });
 });
+
+describe('buildEntryOverridesResetPlan', () => {
+  const schemaPaths = new Set(['endpoints.custom.apiKey', 'endpoints.custom.name']);
+
+  it('resets the whole override subtree for a record entry (MCP server)', () => {
+    const dbOverrides = {
+      mcpServers: { kapa: { title: 'Overridden', timeout: 5000 } },
+    };
+    expect(
+      buildEntryOverridesResetPlan({ fieldPath: 'mcpServers.kapa' }, dbOverrides, schemaPaths),
+    ).toEqual({ resetPaths: ['mcpServers.kapa'], saves: [] });
+  });
+
+  it('rewrites the override array without the named item when other overrides remain', () => {
+    const dbOverrides = {
+      endpoints: {
+        custom: [
+          { name: 'yamlEp', baseURL: 'https://overridden.example' },
+          { name: 'adminEp', baseURL: 'https://admin.example' },
+        ],
+      },
+    };
+    expect(
+      buildEntryOverridesResetPlan(
+        { fieldPath: 'endpoints.custom', itemName: 'yamlEp' },
+        dbOverrides,
+        schemaPaths,
+      ),
+    ).toEqual({
+      resetPaths: [],
+      saves: [
+        {
+          fieldPath: 'endpoints.custom',
+          value: [{ name: 'adminEp', baseURL: 'https://admin.example' }],
+        },
+      ],
+    });
+  });
+
+  it('resets the array path outright when the named item was the only override', () => {
+    const dbOverrides = {
+      endpoints: { custom: [{ name: 'yamlEp', baseURL: 'https://overridden.example' }] },
+    };
+    expect(
+      buildEntryOverridesResetPlan(
+        { fieldPath: 'endpoints.custom', itemName: 'yamlEp' },
+        dbOverrides,
+        schemaPaths,
+      ),
+    ).toEqual({ resetPaths: ['endpoints.custom'], saves: [] });
+  });
+
+  it('produces a no-op plan when the named item has no stored override', () => {
+    const dbOverrides = {
+      endpoints: { custom: [{ name: 'adminEp', baseURL: 'https://admin.example' }] },
+    };
+    expect(
+      buildEntryOverridesResetPlan(
+        { fieldPath: 'endpoints.custom', itemName: 'missing' },
+        dbOverrides,
+        schemaPaths,
+      ),
+    ).toEqual({ resetPaths: [], saves: [] });
+  });
+
+  it('produces a no-op plan when there is no override array at all', () => {
+    expect(
+      buildEntryOverridesResetPlan(
+        { fieldPath: 'endpoints.custom', itemName: 'yamlEp' },
+        undefined,
+        schemaPaths,
+      ),
+    ).toEqual({ resetPaths: [], saves: [] });
+  });
+
+  it('emits sibling items in the omit shape the backend secret preservation expects', () => {
+    /** LibreChat's PATCH handler restores secrets omitted from same-name items (preserveArraySecrets omit-to-keep), so the rewritten array must carry NO apiKey or apiKeyPreview key on redacted siblings. Passthrough references like env placeholders come back readable from the redacted GET and round-trip verbatim. */
+    const dbOverrides = {
+      endpoints: {
+        custom: [
+          { name: 'yamlEp', apiKeyPreview: 'sk-yaml...1111' },
+          { name: 'adminEp', apiKeyPreview: 'sk-admi...2222', baseURL: 'https://a.example' },
+          { name: 'envEp', apiKey: '${MY_KEY}' },
+        ],
+      },
+    };
+    const plan = buildEntryOverridesResetPlan(
+      { fieldPath: 'endpoints.custom', itemName: 'yamlEp' },
+      dbOverrides,
+      schemaPaths,
+    );
+    expect(plan.saves).toEqual([
+      {
+        fieldPath: 'endpoints.custom',
+        value: [
+          { name: 'adminEp', baseURL: 'https://a.example' },
+          { name: 'envEp', apiKey: '${MY_KEY}' },
+        ],
+      },
+    ]);
+  });
+
+  it('strips masked secret previews from the rewritten override array', () => {
+    const dbOverrides = {
+      endpoints: {
+        custom: [
+          { name: 'yamlEp', apiKeyPreview: 'sk-yaml...1111' },
+          { name: 'adminEp', apiKeyPreview: 'sk-admi...2222' },
+        ],
+      },
+    };
+    const plan = buildEntryOverridesResetPlan(
+      { fieldPath: 'endpoints.custom', itemName: 'yamlEp' },
+      dbOverrides,
+      schemaPaths,
+    );
+    expect(plan.saves).toEqual([{ fieldPath: 'endpoints.custom', value: [{ name: 'adminEp' }] }]);
+  });
+});
+
+describe('executeEntryOverridesReset — builds the rewrite from a fresh override document', () => {
+  const schemaPaths = new Set(['endpoints.custom.apiKey', 'endpoints.custom.name']);
+  const target: t.EntryResetTarget = {
+    fieldPath: 'endpoints.custom',
+    itemName: 'yamlEp',
+    label: 'yamlEp',
+  };
+
+  it('preserves an item another admin added after this page cached its snapshot', async () => {
+    /** The stale client cache only knew about yamlEp; the fresh document also holds adminEp, added concurrently. The rewrite must come from the fresh document so adminEp survives the reset. */
+    const freshOverrides = {
+      endpoints: {
+        custom: [
+          { name: 'yamlEp', baseURL: 'https://overridden.example' },
+          { name: 'adminEp', baseURL: 'https://concurrent.example' },
+        ],
+      },
+    };
+    const fetchOverrides = vi.fn().mockResolvedValue(freshOverrides);
+    const resetField = vi.fn().mockResolvedValue(undefined);
+    const saveEntries = vi.fn().mockResolvedValue(undefined);
+
+    await executeEntryOverridesReset(target, schemaPaths, {
+      fetchOverrides,
+      resetField,
+      saveEntries,
+    });
+
+    expect(fetchOverrides).toHaveBeenCalledTimes(1);
+    expect(resetField).not.toHaveBeenCalled();
+    expect(saveEntries).toHaveBeenCalledWith([
+      {
+        fieldPath: 'endpoints.custom',
+        value: [{ name: 'adminEp', baseURL: 'https://concurrent.example' }],
+      },
+    ]);
+  });
+
+  it('is a no-op when another admin already removed the item from the fresh document', async () => {
+    const freshOverrides = {
+      endpoints: { custom: [{ name: 'adminEp', baseURL: 'https://concurrent.example' }] },
+    };
+    const fetchOverrides = vi.fn().mockResolvedValue(freshOverrides);
+    const resetField = vi.fn().mockResolvedValue(undefined);
+    const saveEntries = vi.fn().mockResolvedValue(undefined);
+
+    await executeEntryOverridesReset(target, schemaPaths, {
+      fetchOverrides,
+      resetField,
+      saveEntries,
+    });
+
+    expect(resetField).not.toHaveBeenCalled();
+    expect(saveEntries).not.toHaveBeenCalled();
+  });
+
+  it('unsets the array path when the fresh document holds only the named item', async () => {
+    const freshOverrides = {
+      endpoints: { custom: [{ name: 'yamlEp', baseURL: 'https://overridden.example' }] },
+    };
+    const fetchOverrides = vi.fn().mockResolvedValue(freshOverrides);
+    const resetField = vi.fn().mockResolvedValue(undefined);
+    const saveEntries = vi.fn().mockResolvedValue(undefined);
+
+    await executeEntryOverridesReset(target, schemaPaths, {
+      fetchOverrides,
+      resetField,
+      saveEntries,
+    });
+
+    expect(resetField).toHaveBeenCalledWith('endpoints.custom');
+    expect(saveEntries).not.toHaveBeenCalled();
+  });
+
+  it('unsets the record path for MCP targets regardless of the fetched document', async () => {
+    const fetchOverrides = vi.fn().mockResolvedValue(undefined);
+    const resetField = vi.fn().mockResolvedValue(undefined);
+    const saveEntries = vi.fn().mockResolvedValue(undefined);
+
+    await executeEntryOverridesReset({ fieldPath: 'mcpServers.kapa', label: 'kapa' }, schemaPaths, {
+      fetchOverrides,
+      resetField,
+      saveEntries,
+    });
+
+    expect(resetField).toHaveBeenCalledWith('mcpServers.kapa');
+    expect(saveEntries).not.toHaveBeenCalled();
+  });
+});
+
+describe('buildEntryOverridesResetPlan — legacy numeric-key object storage', () => {
+  const schemaPaths = new Set(['endpoints.custom.apiKey', 'endpoints.custom.name']);
+
+  /** Panels prior to #92 PATCHed indexed field paths (endpoints.custom.2) directly; Mongo's $set on a missing parent stores those as a numeric-key object rather than an array. */
+  it('rewrites a numeric-key object override as a dense array without the named item', () => {
+    const dbOverrides = {
+      endpoints: {
+        custom: {
+          '0': { name: 'yamlEp', baseURL: 'https://overridden.example' },
+          '2': { name: 'adminEp', baseURL: 'https://admin.example' },
+        },
+      },
+    };
+    expect(
+      buildEntryOverridesResetPlan(
+        { fieldPath: 'endpoints.custom', itemName: 'yamlEp' },
+        dbOverrides,
+        schemaPaths,
+      ),
+    ).toEqual({
+      resetPaths: [],
+      saves: [
+        {
+          fieldPath: 'endpoints.custom',
+          value: [{ name: 'adminEp', baseURL: 'https://admin.example' }],
+        },
+      ],
+    });
+  });
+
+  it('resets the array path when the numeric-key object held only the named item', () => {
+    const dbOverrides = {
+      endpoints: { custom: { '1': { name: 'yamlEp', baseURL: 'https://overridden.example' } } },
+    };
+    expect(
+      buildEntryOverridesResetPlan(
+        { fieldPath: 'endpoints.custom', itemName: 'yamlEp' },
+        dbOverrides,
+        schemaPaths,
+      ),
+    ).toEqual({ resetPaths: ['endpoints.custom'], saves: [] });
+  });
+
+  it('is a no-op for an object whose keys are not array indices', () => {
+    const dbOverrides = {
+      endpoints: { custom: { yamlEp: { name: 'yamlEp' } } },
+    };
+    expect(
+      buildEntryOverridesResetPlan(
+        { fieldPath: 'endpoints.custom', itemName: 'yamlEp' },
+        dbOverrides,
+        schemaPaths,
+      ),
+    ).toEqual({ resetPaths: [], saves: [] });
+  });
+});
+
+describe('collectEntryOverrideKeys', () => {
+  it('collects MCP record keys and endpoint names from an array override', () => {
+    const dbOverrides = {
+      mcpServers: { kapa: { title: 'X' }, other: { timeout: 1 } },
+      endpoints: { custom: [{ name: 'yamlEp' }, { name: 'adminEp' }, { baseURL: 'nameless' }] },
+    };
+    expect(collectEntryOverrideKeys(dbOverrides)).toEqual({
+      mcpServers: new Set(['kapa', 'other']),
+      endpoints: new Set(['yamlEp', 'adminEp']),
+    });
+  });
+
+  it('collects endpoint names from a legacy numeric-key object override', () => {
+    const dbOverrides = {
+      endpoints: { custom: { '0': { name: 'yamlEp' }, '3': { name: 'adminEp' } } },
+    };
+    expect(collectEntryOverrideKeys(dbOverrides)).toEqual({
+      endpoints: new Set(['yamlEp', 'adminEp']),
+    });
+  });
+
+  it('returns an empty map when there is no override document', () => {
+    expect(collectEntryOverrideKeys(undefined)).toEqual({});
+  });
+});
diff --git a/src/components/configuration/utils.ts b/src/components/configuration/utils.ts
index d858cecc..6a5e184a 100644
--- a/src/components/configuration/utils.ts
+++ b/src/components/configuration/utils.ts
@@ -27,6 +27,132 @@ export function buildSavePayload(
   return { touched, saves, resets };
 }
 
+/**
+ * Builds the server calls that clear the admin-override layer for one entry,
+ * reverting it to the YAML config. Record entries (`mcpServers.<key>`) unset
+ * the whole override subtree. Array entries merged by name
+ * (`endpoints.custom` + `itemName`) rewrite the stored override array without
+ * the named item; when that item was the only one, the array path is unset
+ * instead so no empty override lingers.
+ */
+export function buildEntryOverridesResetPlan(
+  target: Pick<t.EntryResetTarget, 'fieldPath' | 'itemName'>,
+  dbOverrides: Record<string, t.ConfigValue> | undefined,
+  schemaPaths: ReadonlySet<string>,
+): t.EntryResetPlan {
+  if (target.itemName == null) {
+    return { resetPaths: [target.fieldPath], saves: [] };
+  }
+  const overrideArray = toOverrideArraySource(lookupPath(dbOverrides, target.fieldPath));
+  if (!overrideArray) {
+    return { resetPaths: [], saves: [] };
+  }
+  const remaining = overrideArray.filter((item) => {
+    if (!item || typeof item !== 'object' || Array.isArray(item)) return true;
+    return (item as Record<string, t.ConfigValue>).name !== target.itemName;
+  });
+  if (remaining.length === overrideArray.length) {
+    return { resetPaths: [], saves: [] };
+  }
+  if (remaining.length === 0) {
+    return { resetPaths: [target.fieldPath], saves: [] };
+  }
+  return {
+    resetPaths: [],
+    saves: [
+      {
+        fieldPath: target.fieldPath,
+        value: stripSecretPreviewValues(remaining, target.fieldPath, schemaPaths),
+      },
+    ],
+  };
+}
+
+const ARRAY_INDEX_KEY_RE = /^(0|[1-9]\d*)$/;
+
+/**
+ * Normalizes a stored array override into a dense array. Panels prior to #92
+ * PATCHed indexed field paths (`endpoints.custom.2`) directly, and Mongo's
+ * `$set` on a missing parent materializes those as a numeric-key object
+ * (`{ '0': {...}, '2': {...} }`) rather than an array, so legacy override
+ * documents can hold either shape. Holes from sparse indices are dropped.
+ */
+export function toOverrideArraySource(value: t.ConfigValue | undefined): t.ConfigValue[] | null {
+  if (Array.isArray(value)) return [...value];
+  if (!value || typeof value !== 'object') return null;
+  const sparse: t.ConfigValue[] = [];
+  for (const [key, entry] of Object.entries(value as Record<string, t.ConfigValue>)) {
+    if (!ARRAY_INDEX_KEY_RE.test(key)) return null;
+    sparse[Number(key)] = entry;
+  }
+  return sparse.filter((entry) => entry !== undefined);
+}
+
+/**
+ * Derives the entry identities stored in the base override document, keyed by
+ * section, so per-entry "reset to YAML" affordances only appear where
+ * overrides actually exist. MCP servers key by record key; custom endpoints
+ * key by item `name` (the merge identity), accepting both the array and
+ * legacy numeric-key object storage shapes.
+ */
+export function collectEntryOverrideKeys(
+  dbOverrides: Record<string, t.ConfigValue> | undefined,
+): Record<string, Set<string>> {
+  const result: Record<string, Set<string>> = {};
+  if (!dbOverrides) return result;
+  const mcp = dbOverrides.mcpServers;
+  if (mcp && typeof mcp === 'object' && !Array.isArray(mcp)) {
+    result.mcpServers = new Set(Object.keys(mcp as Record<string, t.ConfigValue>));
+  }
+  const custom = toOverrideArraySource(lookupPath(dbOverrides, 'endpoints.custom'));
+  if (custom) {
+    const names = new Set<string>();
+    for (const item of custom) {
+      if (!item || typeof item !== 'object' || Array.isArray(item)) continue;
+      const name = (item as Record<string, t.ConfigValue>).name;
+      if (typeof name === 'string' && name) names.add(name);
+    }
+    result.endpoints = names;
+  }
+  return result;
+}
+
+/**
+ * Runs a per-entry overrides reset against a freshly fetched override
+ * document instead of the client cache. Another admin may have changed the
+ * override array since this page loaded, and rewriting it from a stale
+ * snapshot would silently discard their change (or resurrect a deleted
+ * item); fetching immediately before building the plan shrinks the
+ * read-modify-write window to the request itself. A target whose item no
+ * longer exists in the fresh document resolves as a no-op success.
+ */
+export async function executeEntryOverridesReset(
+  target: t.EntryResetTarget,
+  schemaPaths: ReadonlySet<string>,
+  deps: t.EntryResetDeps,
+): Promise<void> {
+  const overrides = await deps.fetchOverrides();
+  const plan = buildEntryOverridesResetPlan(target, overrides, schemaPaths);
+  if (plan.resetPaths.length > 0) {
+    await Promise.all(plan.resetPaths.map((fieldPath) => deps.resetField(fieldPath)));
+  }
+  if (plan.saves.length > 0) {
+    await deps.saveEntries(plan.saves);
+  }
+}
+
+function lookupPath(
+  obj: Record<string, t.ConfigValue> | undefined,
+  path: string,
+): t.ConfigValue | undefined {
+  let cursor: t.ConfigValue | undefined = obj;
+  for (const segment of path.split('.')) {
+    if (!cursor || typeof cursor !== 'object' || Array.isArray(cursor)) return undefined;
+    cursor = (cursor as Record<string, t.ConfigValue>)[segment];
+  }
+  return cursor;
+}
+
 export function inferKVType(v: t.ConfigValue): t.KVValueType {
   if (typeof v === 'boolean') return 'boolean';
   if (typeof v === 'number') return 'number';
diff --git a/src/locales/en/translation.json b/src/locales/en/translation.json
index a00cd996..c01cfb65 100644
--- a/src/locales/en/translation.json
+++ b/src/locales/en/translation.json
@@ -110,6 +110,10 @@
   "com_config_reset_base_resetting": "Resetting...",
   "com_config_reset_base_success": "Base configuration reset to librechat.yaml",
   "com_config_reset_base_dirty": "Save or discard your changes before resetting",
+  "com_config_reset_entry_title": "Reset entry to YAML",
+  "com_config_reset_entry_confirm": "This removes every admin panel override stored for \"{{name}}\", reverting it to what librechat.yaml defines. This can't be undone.",
+  "com_config_reset_entry_action": "Reset entry",
+  "com_config_reset_entry_success": "{{name}} reset to librechat.yaml",
   "com_config_section_configured_count": "{{count}} of {{total}} configured",
   "com_config_default_hint": "(default: {{value}})",
   "com_config_entry_n": "Entry {{n}}",
@@ -1071,6 +1075,7 @@
   "com_a11y_page_n": "Page {{page}}",
   "com_a11y_rename_entry": "Rename {{name}}",
   "com_a11y_remove_override": "Remove override for {{name}}",
+  "com_a11y_reset_entry_overrides": "Reset {{name}} to the YAML configuration",
   "com_a11y_reset_to_default": "Reset {{name}} to default",
   "com_a11y_add_item": "Add {{name}}",
   "com_access_tab_capabilities": "Capabilities",
diff --git a/src/server/config.test.ts b/src/server/config.test.ts
index 931bc7a5..fc5a0a95 100644
--- a/src/server/config.test.ts
+++ b/src/server/config.test.ts
@@ -18,6 +18,7 @@ import {
   toConfigArraySource,
   normalizeAppServiceKeys,
   mergeConfigArraySources,
+  extractCustomEndpointNames,
   mergeIndexedArrayEntriesIntoBase,
 } from './config';
 
@@ -1283,3 +1284,20 @@ describe('validateFieldValue for endpoints', () => {
     expect(result).toEqual({ success: true });
   });
 });
+
+describe('extractCustomEndpointNames', () => {
+  it('collects named custom endpoints from a baseOnly endpoints section', () => {
+    const endpoints = {
+      custom: [{ name: 'yamlEp' }, { baseURL: 'https://nameless.example' }, { name: 'other' }],
+    };
+    expect(extractCustomEndpointNames(endpoints)).toEqual(['yamlEp', 'other']);
+  });
+
+  /** A successfully fetched baseOnly config without endpoints.custom means known-empty provenance, never undefined. The client reserves undefined yamlCustomEndpointKeys for a failed provenance fetch and fails closed on identity actions. */
+  it('returns an empty array when endpoints.custom is absent or malformed', () => {
+    expect(extractCustomEndpointNames(undefined)).toEqual([]);
+    expect(extractCustomEndpointNames({})).toEqual([]);
+    expect(extractCustomEndpointNames({ custom: 'not-an-array' })).toEqual([]);
+    expect(extractCustomEndpointNames([{ name: 'x' }])).toEqual([]);
+  });
+});
diff --git a/src/server/config.ts b/src/server/config.ts
index 32635157..307848a9 100644
--- a/src/server/config.ts
+++ b/src/server/config.ts
@@ -902,6 +902,7 @@ export const getBaseConfigFn = createServerFn({ method: 'GET' }).handler(async (
 
   let yamlMcpKeys: string[] | undefined;
   let yamlMcpServers: Record<string, t.ConfigValue> | undefined;
+  let yamlCustomEndpointKeys: string[] | undefined;
   if (baseOnlyResponse.ok) {
     const { config: baseOnlyRaw } = (await baseOnlyResponse.json()) as {
       config: Record<string, t.ConfigValue>;
@@ -913,6 +914,7 @@ export const getBaseConfigFn = createServerFn({ method: 'GET' }).handler(async (
       yamlMcpServers = mcp as Record<string, t.ConfigValue>;
       yamlMcpKeys = Object.keys(yamlMcpServers);
     }
+    yamlCustomEndpointKeys = extractCustomEndpointNames(baseOnly.endpoints);
   }
 
   return {
@@ -922,15 +924,58 @@ export const getBaseConfigFn = createServerFn({ method: 'GET' }).handler(async (
     schemaDefaults: flatDefaults,
     yamlMcpKeys,
     yamlMcpServers,
+    yamlCustomEndpointKeys,
   };
 });
 
+/**
+ * LibreChat merges `endpoints.custom` override arrays into the YAML array by
+ * item `name`, so names are the stable entry identity across layers. Always
+ * returns an array: a missing or malformed `endpoints.custom` in a
+ * successfully fetched baseOnly config means "no YAML-defined endpoints"
+ * (known-empty provenance). `yamlCustomEndpointKeys` is only ever `undefined`
+ * when the baseOnly fetch itself failed, which the client treats as
+ * provenance-unavailable and fails closed on identity actions.
+ */
+export function extractCustomEndpointNames(endpoints: t.ConfigValue): string[] {
+  if (!endpoints || typeof endpoints !== 'object' || Array.isArray(endpoints)) return [];
+  const custom = (endpoints as Record<string, t.ConfigValue>).custom;
+  if (!Array.isArray(custom)) return [];
+  const names: string[] = [];
+  for (const item of custom) {
+    if (!item || typeof item !== 'object' || Array.isArray(item)) continue;
+    const name = (item as Record<string, t.ConfigValue>).name;
+    if (typeof name === 'string' && name) names.push(name);
+  }
+  return names;
+}
+
 export const baseConfigOptions = queryOptions({
   queryKey: ['baseConfig'],
   queryFn: () => getBaseConfigFn(),
   staleTime: 30_000,
 });
 
+/**
+ * Fetches only the current base override document, bypassing the client
+ * cache. Read-modify-write flows (per-entry overrides reset) must build
+ * their replacement value from a fresh copy: `baseConfigOptions` keeps data
+ * for 30 seconds and an open tab keeps it far longer, so rewriting
+ * `endpoints.custom` from the cached snapshot could silently discard a
+ * concurrent admin's change. A 404 means no override document exists.
+ */
+export const getBaseConfigOverridesFn = createServerFn({ method: 'GET' }).handler(async () => {
+  const response = await apiFetch(`/api/admin/config/role/${BASE_CONFIG_PRINCIPAL_ID}`);
+  if (response.status === 404) {
+    return { overrides: undefined };
+  }
+  if (!response.ok) {
+    throw new Error(`Failed to fetch base config overrides: ${response.status}`);
+  }
+  const { config: dbConfig } = (await response.json()) as AdminConfigResponse;
+  return { overrides: dbConfig.overrides as Record<string, t.ConfigValue> | undefined };
+});
+
 let cachedSchemaPathSet: Set<string> | undefined;
 
 /**
diff --git a/src/types/config-ui.ts b/src/types/config-ui.ts
index acf9de13..e51b59ce 100644
--- a/src/types/config-ui.ts
+++ b/src/types/config-ui.ts
@@ -83,6 +83,9 @@ export interface ConfigTabContentProps {
   isEditingScope?: boolean;
   /** YAML-defined entry keys per section, keyed by parent path. */
   baseRecordKeys?: Record<string, Set<string>>;
+  /** Entry identities present in the base DB override document, keyed by parent path. */
+  dbOverrideKeys?: Record<string, Set<string>>;
+  onResetEntryOverrides?: (target: EntryResetTarget) => void;
   onValidationError?: (message: string) => void;
   /** See `SingleFieldRendererProps.editSessionId`. */
   editSessionId?: number;
@@ -168,6 +171,38 @@ export interface ResetBaseConfigDialogProps {
   onCancel: () => void;
 }
 
+/**
+ * Identifies the admin-override layer to clear for a single collection entry.
+ * `fieldPath` is the override document path to unset (`mcpServers.<key>`), or
+ * the array container path (`endpoints.custom`) when `itemName` identifies the
+ * item to drop from the override array (LibreChat merges that array by `name`).
+ */
+export interface EntryResetTarget {
+  fieldPath: string;
+  itemName?: string;
+  label: string;
+}
+
+export interface EntryResetPlan {
+  resetPaths: string[];
+  saves: Array<{ fieldPath: string; value: ConfigValue }>;
+}
+
+/** Server-call seams for `executeEntryOverridesReset`, injected so the flow is unit-testable. */
+export interface EntryResetDeps {
+  fetchOverrides: () => Promise<Record<string, ConfigValue> | undefined>;
+  resetField: (fieldPath: string) => Promise<unknown>;
+  saveEntries: (entries: Array<{ fieldPath: string; value: ConfigValue }>) => Promise<unknown>;
+}
+
+export interface ResetOverridesDialogProps {
+  target: EntryResetTarget | null;
+  resetting: boolean;
+  error?: string | null;
+  onConfirm: () => void;
+  onCancel: () => void;
+}
+
 export interface FieldProfilePopoverProps {
   fieldPath: string;
   fieldLabel: string;
@@ -265,6 +300,9 @@ export interface FieldRendererProps {
   isEditingScope?: boolean;
   /** YAML-defined entry keys for the section being rendered. */
   yamlBaseKeys?: Set<string>;
+  /** Entry identities present in the base DB override document for the section being rendered. */
+  dbOverrideKeys?: Set<string>;
+  onResetEntryOverrides?: (target: EntryResetTarget) => void;
   onValidationError?: (message: string) => void;
   /** See `SingleFieldRendererProps.editSessionId`. */
   editSessionId?: number;
diff --git a/src/types/fields.ts b/src/types/fields.ts
index 38bf9ea2..e8f5dc87 100644
--- a/src/types/fields.ts
+++ b/src/types/fields.ts
@@ -132,6 +132,8 @@ export interface ArrayObjectFieldProps {
   renderFields: CollectionRenderFields;
   /** When set, each entry card gets an id of `{entryIdPrefix}-{index}` for TOC scroll targets. */
   entryIdPrefix?: string;
+  /** Per-entry header control overrides, resolved from the entry's identity. */
+  entryControls?: (index: number, item: ConfigValue) => EntryCardControls;
   /** See `SingleFieldRendererProps.editSessionId`. Forwarded to `renderFields`. */
   editSessionId?: number;
 }
@@ -161,6 +163,19 @@ export type CollectionRenderFields = (
   editSessionId?: number,
 ) => React.ReactNode;
 
+/** Header action that clears an entry's admin overrides so it reverts to the YAML config. */
+export interface EntryResetAction {
+  onClick: () => void;
+  disabled?: boolean;
+  title?: string;
+}
+
+/** Per-entry header controls for collection entries (YAML-defined entries hide the trash and may expose a reset-overrides action). */
+export interface EntryCardControls {
+  canRemove?: boolean;
+  resetOverrides?: EntryResetAction;
+}
+
 export interface ObjectEntryCardProps {
   id?: string;
   entryKey: string;
@@ -169,6 +184,7 @@ export interface ObjectEntryCardProps {
   onValueChange: (value: ConfigValue) => void;
   onRemove?: () => void;
   onRename?: (newKey: string) => void;
+  resetOverrides?: EntryResetAction;
   disabled?: boolean;
   defaultExpanded?: boolean;
   renderFields: CollectionRenderFields;