diff --git a/frontend/package.json.md5 b/frontend/package.json.md5
index 50f303f7..72cd1564 100755
--- a/frontend/package.json.md5
+++ b/frontend/package.json.md5
@@ -1 +1 @@
-84ec3a6d42105c92f224232f0d83a33b
\ No newline at end of file
+1d8f9adbde8018f90d013cc740e0405b
\ No newline at end of file
diff --git a/frontend/src/App.css b/frontend/src/App.css
index 51cc7c71..ae9b9451 100644
--- a/frontend/src/App.css
+++ b/frontend/src/App.css
@@ -715,6 +715,29 @@ body[data-theme='dark'] .gonavi-query-editor-db-token {
   color: #c4b5fd;
 }
 
+.gonavi-query-editor-ai-inline-ghost {
+  color: rgba(100, 116, 139, 0.7);
+  font-style: italic;
+  pointer-events: none;
+}
+
+.gonavi-query-editor-ai-inline-ghost-overlay {
+  color: rgba(100, 116, 139, 0.7);
+  font-style: italic;
+  pointer-events: none;
+  position: absolute;
+  white-space: pre;
+  z-index: 6;
+}
+
+body[data-theme='dark'] .gonavi-query-editor-ai-inline-ghost {
+  color: rgba(203, 213, 225, 0.56);
+}
+
+body[data-theme='dark'] .gonavi-query-editor-ai-inline-ghost-overlay {
+  color: rgba(203, 213, 225, 0.56);
+}
+
 /* Legacy sidebar resize bounds — mirror v2 .gn-v2-app-sider so Ant Design inline width locks do not collapse drag range. */
 body[data-ui-version="legacy"] .ant-layout-sider {
   min-width: 232px !important;
diff --git a/frontend/src/components/AISettingsModal.tsx b/frontend/src/components/AISettingsModal.tsx
index 888bf208..be0a6b2e 100644
--- a/frontend/src/components/AISettingsModal.tsx
+++ b/frontend/src/components/AISettingsModal.tsx
@@ -374,6 +374,7 @@ const AISettingsModal: React.FC<AISettingsModalProps> = ({ open, onClose, darkMo
                 valuesModel: values.model,
                 customModels: values.models,
             });
+            const inlineCompletionModel = String(values.inlineCompletionModel || '').trim();
             // 内置供应商自动使用 preset label 作为名称
             const finalName = isCustomLike ? (values.name || localizedPreset.label) : localizedPreset.label;
             
@@ -398,6 +399,7 @@ const AISettingsModal: React.FC<AISettingsModalProps> = ({ open, onClose, darkMo
                 apiKey: secretDraft.apiKey,
                 hasSecret: secretDraft.hasSecret,
                 model: finalModel,
+                inlineCompletionModel,
                 models: resolvedModels,
                 baseUrl: finalBaseUrl,
                 apiFormat: resolvedTransport.apiFormat,
@@ -669,6 +671,7 @@ const AISettingsModal: React.FC<AISettingsModalProps> = ({ open, onClose, darkMo
                 hasSecret: secretDraft.hasSecret,
                 baseUrl: finalBaseUrl,
                 model: finalModel,
+                inlineCompletionModel: String(values.inlineCompletionModel || '').trim(),
                 models: resolvedModels,
                 maxTokens: Number(values.maxTokens) || 4096,
                 temperature: Number(values.temperature) ?? 0.7,
@@ -687,12 +690,20 @@ const AISettingsModal: React.FC<AISettingsModalProps> = ({ open, onClose, darkMo
             presetFixedApiFormat: preset.fixedApiFormat,
             valuesApiFormat: form.getFieldValue('apiFormat'),
         });
+        const { model: presetModel, models: presetModels } = resolvePresetModelSelection({
+            presetKey,
+            presetDefaultModel: preset.defaultModel,
+            presetModels: preset.models,
+            customModels: preset.models,
+        });
         form.setFieldsValue({
             presetKey,
             type: resolvedTransport.type,
             apiFormat: resolvedTransport.apiFormat || 'openai',
             baseUrl: preset.defaultBaseUrl,
-            model: preset.defaultModel,
+            model: presetModel,
+            models: presetModels,
+            inlineCompletionModel: '',
         });
     };
 
diff --git a/frontend/src/components/QueryEditor.external-sql-save.test.tsx b/frontend/src/components/QueryEditor.external-sql-save.test.tsx
index 2f9dbd35..9df1edbd 100644
--- a/frontend/src/components/QueryEditor.external-sql-save.test.tsx
+++ b/frontend/src/components/QueryEditor.external-sql-save.test.tsx
@@ -186,7 +186,13 @@ const editorState = vi.hoisted(() => {
   const state = {
     value: '',
     editor: null as any,
-    domNode: { style: { cursor: '' }, addEventListener: vi.fn(), removeEventListener: vi.fn() },
+    domNode: {
+      style: { cursor: '' },
+      addEventListener: vi.fn(),
+      removeEventListener: vi.fn(),
+      appendChild: vi.fn(),
+      removeChild: vi.fn(),
+    },
     position: { lineNumber: 1, column: 1 },
     selection: null as any,
     providers: [] as any[],
@@ -194,6 +200,7 @@ const editorState = vi.hoisted(() => {
     contentChangeListeners: [] as Array<() => void>,
     cursorPositionListeners: [] as Array<(event: any) => void>,
     modelContentListeners: [] as Array<(event: any) => void>,
+    keyDownListeners: [] as Array<(event: any) => void>,
     mouseMoveListeners: [] as Array<(event: any) => void>,
     mouseDownListeners: [] as Array<(event: any) => void>,
     mouseLeaveListeners: [] as Array<() => void>,
@@ -277,6 +284,7 @@ const editorState = vi.hoisted(() => {
       });
     }),
     addAction: vi.fn(),
+    addCommand: vi.fn(),
     onDidChangeModelContent: vi.fn((listener: (event?: any) => void) => {
       state.contentChangeListeners.push(listener);
       state.modelContentListeners.push(listener);
@@ -286,6 +294,10 @@ const editorState = vi.hoisted(() => {
       state.cursorPositionListeners.push(listener);
       return { dispose: vi.fn() };
     }),
+    onKeyDown: vi.fn((listener: (event: any) => void) => {
+      state.keyDownListeners.push(listener);
+      return { dispose: vi.fn() };
+    }),
     onMouseMove: vi.fn((listener: (event: any) => void) => {
       state.mouseMoveListeners.push(listener);
       return { dispose: vi.fn() };
@@ -298,6 +310,8 @@ const editorState = vi.hoisted(() => {
       state.mouseLeaveListeners.push(listener);
       return { dispose: vi.fn() };
     }),
+    onDidScrollChange: vi.fn(() => ({ dispose: vi.fn() })),
+    onDidLayoutChange: vi.fn(() => ({ dispose: vi.fn() })),
     deltaDecorations: vi.fn((oldDecorations: string[], newDecorations: any[]) => {
       state.decorationIds = newDecorations.map((_: any, index: number) => `decoration-${index + 1}`);
       return state.decorationIds;
@@ -311,6 +325,13 @@ const editorState = vi.hoisted(() => {
     layout: vi.fn(),
     focus: vi.fn(),
     trigger: vi.fn(),
+    createContextKey: vi.fn((_key: string, initialValue: boolean) => ({
+      set: vi.fn(),
+      get: vi.fn(() => initialValue),
+      reset: vi.fn(),
+    })),
+    getScrolledVisiblePosition: vi.fn(() => ({ left: 0, top: 0, height: 20 })),
+    getOption: vi.fn(() => null),
   };
   return state;
 });
@@ -348,7 +369,7 @@ vi.mock('@monaco-editor/react', () => ({
       const mountEditor = () => onMount?.(editorState.editor, {
         editor: { setTheme: vi.fn() },
         KeyMod: { CtrlCmd: 2048, WinCtrl: 256, Alt: 512, Shift: 1024 },
-        KeyCode: { KeyD: 68, KeyE: 69, KeyF: 70, KeyM: 77, KeyQ: 81, KeyS: 83 },
+        KeyCode: { KeyD: 68, KeyE: 69, KeyF: 70, KeyM: 77, KeyQ: 81, KeyS: 83, RightArrow: 39 },
         languages: {
           CompletionItemKind: { Keyword: 1, Function: 2, Field: 3 },
           CompletionItemInsertTextRule: { InsertAsSnippet: 1 },
@@ -443,6 +464,7 @@ vi.mock('@ant-design/icons', () => {
     RobotOutlined: Icon,
     SearchOutlined: Icon,
     DatabaseOutlined: Icon,
+    DownOutlined: Icon,
     EyeOutlined: Icon,
     EyeInvisibleOutlined: Icon,
   };
@@ -478,6 +500,10 @@ vi.mock('antd', () => {
   );
   const Empty = ({ description }: { description?: React.ReactNode }) => <div>{description}</div>;
   (Empty as any).PRESENTED_IMAGE_SIMPLE = 'simple';
+  const Input: any = ({ value, onChange, placeholder }: any) => <input value={value} onChange={onChange} placeholder={placeholder} />;
+  Input.TextArea = ({ value, onChange, placeholder, disabled }: any) => (
+    <textarea value={value} onChange={onChange} placeholder={placeholder} disabled={disabled} />
+  );
 
   return {
     Button,
@@ -492,7 +518,7 @@ vi.mock('antd', () => {
         <button type="button" onClick={onOk}>{okText}</button>
       </section>
     ) : null),
-    Input: ({ value, onChange, placeholder }: any) => <input value={value} onChange={onChange} placeholder={placeholder} />,
+    Input,
     Form,
     Dropdown: ({ children, menu }: any) => (
       <>
@@ -506,6 +532,24 @@ vi.mock('antd', () => {
     ),
     Tooltip: ({ children }: any) => <>{children}</>,
     Select: () => null,
+    Segmented: ({ value, onChange, options }: any) => (
+      <div>
+        {(options || []).map((option: any) => {
+          const optionValue = typeof option === 'object' ? option.value : option;
+          const label = typeof option === 'object' ? option.label : option;
+          return (
+            <button
+              key={String(optionValue)}
+              type="button"
+              aria-pressed={value === optionValue}
+              onClick={() => onChange?.(optionValue)}
+            >
+              {label}
+            </button>
+          );
+        })}
+      </div>
+    ),
     Tabs: ({ activeKey, items, onChange, tabBarExtraContent }: any) => {
       const resolvedActiveKey = tabsState.activeKey ?? activeKey ?? items?.[0]?.key;
       const activeItem = items?.find((item: any) => item.key === resolvedActiveKey) || items?.[0];
@@ -694,13 +738,12 @@ describe('QueryEditor external SQL save', () => {
         remove: vi.fn(),
       })),
     });
-    const currentNavigator = globalThis.navigator as any;
     vi.stubGlobal('navigator', {
       clipboard: {
         writeText: vi.fn().mockResolvedValue(undefined),
       },
-      platform: currentNavigator?.platform || 'MacIntel',
-      userAgent: currentNavigator?.userAgent || 'Vitest',
+      platform: 'MacIntel',
+      userAgent: 'Vitest',
     });
     setCurrentLanguage('zh-CN');
     storeState.languagePreference = 'zh-CN';
@@ -813,6 +856,7 @@ describe('QueryEditor external SQL save', () => {
     editorState.contentChangeListeners = [];
     editorState.cursorPositionListeners = [];
     editorState.modelContentListeners = [];
+    editorState.keyDownListeners = [];
     editorState.mouseMoveListeners = [];
     editorState.mouseDownListeners = [];
     editorState.mouseLeaveListeners = [];
@@ -829,6 +873,7 @@ describe('QueryEditor external SQL save', () => {
     editorState.editor.updateOptions.mockClear();
     editorState.editor.pushUndoStop.mockClear();
     editorState.editor.addAction.mockClear();
+    editorState.editor.onKeyDown.mockClear();
     editorState.editor.getContribution.mockReset();
     editorState.editor.getContribution.mockImplementation(defaultEditorContributionResolver(editorState));
     storeState.updateQueryTabDraft.mockReset();
@@ -1061,6 +1106,920 @@ describe('QueryEditor external SQL save', () => {
     expect(textContent(renderer.toJSON())).not.toContain('等待执行 SQL');
   });
 
+  it('captures the manual SQL AI completion shortcut before Monaco inserts a backslash', async () => {
+    const windowListeners: Record<string, ((event?: any) => void)[]> = {};
+    vi.stubGlobal('window', {
+      addEventListener: vi.fn((type: string, listener: (event?: any) => void) => {
+        windowListeners[type] ||= [];
+        windowListeners[type].push(listener);
+      }),
+      removeEventListener: vi.fn(),
+      dispatchEvent: vi.fn(),
+      setTimeout,
+      clearTimeout,
+      requestAnimationFrame: vi.fn((callback: FrameRequestCallback) => {
+        callback(0);
+        return 1;
+      }),
+      cancelAnimationFrame: vi.fn(),
+      innerHeight: 900,
+    });
+
+    await act(async () => {
+      create(<QueryEditor tab={createTab({ query: 'SELECT * FROM ' })} />);
+    });
+
+    editorState.editor.focus.mockClear();
+    const shortcutEvent = {
+      ctrlKey: false,
+      metaKey: false,
+      altKey: true,
+      shiftKey: false,
+      key: 'Process',
+      code: 'Backslash',
+      keyCode: 220,
+      which: 220,
+      isComposing: false,
+      nativeEvent: {
+        code: 'Backslash',
+        keyCode: 220,
+        which: 220,
+        isComposing: false,
+      },
+      target: null,
+      preventDefault: vi.fn(),
+      stopPropagation: vi.fn(),
+    };
+    const monacoShortcutEvent = {
+      browserEvent: shortcutEvent,
+      preventDefault: vi.fn(),
+      stopPropagation: vi.fn(),
+    };
+
+    await act(async () => {
+      editorState.keyDownListeners.forEach((listener) => listener(monacoShortcutEvent));
+    });
+
+    await act(async () => {
+      windowListeners.keydown?.forEach((listener) => listener(shortcutEvent));
+    });
+
+    expect(monacoShortcutEvent.preventDefault).toHaveBeenCalled();
+    expect(monacoShortcutEvent.stopPropagation).toHaveBeenCalled();
+    expect(shortcutEvent.preventDefault).toHaveBeenCalled();
+    expect(shortcutEvent.stopPropagation).toHaveBeenCalled();
+    expect(editorState.editor.focus).toHaveBeenCalled();
+    expect(editorState.value).toBe('SELECT * FROM ');
+  });
+
+  it('treats a sticky Alt modifier plus Backslash as the manual SQL AI completion shortcut', async () => {
+    const windowListeners: Record<string, ((event?: any) => void)[]> = {};
+    vi.stubGlobal('window', {
+      addEventListener: vi.fn((type: string, listener: (event?: any) => void) => {
+        windowListeners[type] ||= [];
+        windowListeners[type].push(listener);
+      }),
+      removeEventListener: vi.fn(),
+      dispatchEvent: vi.fn(),
+      setTimeout,
+      clearTimeout,
+      requestAnimationFrame: vi.fn((callback: FrameRequestCallback) => {
+        callback(0);
+        return 1;
+      }),
+      cancelAnimationFrame: vi.fn(),
+      innerHeight: 900,
+    });
+
+    await act(async () => {
+      create(<QueryEditor tab={createTab({ query: 'SELECT * FROM ' })} />);
+    });
+
+    const altDownEvent = {
+      type: 'keydown',
+      ctrlKey: false,
+      metaKey: false,
+      altKey: true,
+      shiftKey: false,
+      key: 'Alt',
+      code: 'AltLeft',
+      preventDefault: vi.fn(),
+      stopPropagation: vi.fn(),
+    };
+    const backslashEvent = {
+      type: 'keydown',
+      ctrlKey: false,
+      metaKey: false,
+      altKey: false,
+      shiftKey: false,
+      key: '\\',
+      code: 'Backslash',
+      keyCode: 220,
+      which: 220,
+      nativeEvent: {
+        code: 'Backslash',
+        keyCode: 220,
+        which: 220,
+      },
+      target: null,
+      preventDefault: vi.fn(),
+      stopPropagation: vi.fn(),
+    };
+
+    await act(async () => {
+      windowListeners.keydown?.forEach((listener) => listener(altDownEvent));
+      windowListeners.keydown?.forEach((listener) => listener(backslashEvent));
+    });
+
+    expect(backslashEvent.preventDefault).toHaveBeenCalled();
+    expect(backslashEvent.stopPropagation).toHaveBeenCalled();
+    expect(editorState.value).toBe('SELECT * FROM ');
+  });
+
+  it('treats a sticky Alt modifier plus IntlBackslash layout event as the manual SQL AI completion shortcut', async () => {
+    const windowListeners: Record<string, ((event?: any) => void)[]> = {};
+    vi.stubGlobal('window', {
+      addEventListener: vi.fn((type: string, listener: (event?: any) => void) => {
+        windowListeners[type] ||= [];
+        windowListeners[type].push(listener);
+      }),
+      removeEventListener: vi.fn(),
+      dispatchEvent: vi.fn(),
+      setTimeout,
+      clearTimeout,
+      requestAnimationFrame: vi.fn((callback: FrameRequestCallback) => {
+        callback(0);
+        return 1;
+      }),
+      cancelAnimationFrame: vi.fn(),
+      innerHeight: 900,
+    });
+
+    await act(async () => {
+      create(<QueryEditor tab={createTab({ query: 'SELECT * FROM ' })} />);
+    });
+
+    const altDownEvent = {
+      type: 'keydown',
+      ctrlKey: false,
+      metaKey: false,
+      altKey: true,
+      shiftKey: false,
+      key: 'Alt',
+      code: 'AltLeft',
+      preventDefault: vi.fn(),
+      stopPropagation: vi.fn(),
+    };
+    const backslashEvent = {
+      type: 'keydown',
+      ctrlKey: false,
+      metaKey: false,
+      altKey: false,
+      shiftKey: false,
+      key: 'Process',
+      code: 'IntlBackslash',
+      keyCode: 226,
+      which: 226,
+      nativeEvent: {
+        code: 'IntlBackslash',
+        keyCode: 226,
+        which: 226,
+      },
+      target: null,
+      preventDefault: vi.fn(),
+      stopPropagation: vi.fn(),
+    };
+
+    await act(async () => {
+      windowListeners.keydown?.forEach((listener) => listener(altDownEvent));
+      windowListeners.keydown?.forEach((listener) => listener(backslashEvent));
+    });
+
+    expect(backslashEvent.preventDefault).toHaveBeenCalled();
+    expect(backslashEvent.stopPropagation).toHaveBeenCalled();
+    expect(editorState.value).toBe('SELECT * FROM ');
+  });
+
+  it('recovers a missed manual SQL AI completion keystroke by removing the inserted backslash', async () => {
+    const windowListeners: Record<string, ((event?: any) => void)[]> = {};
+    vi.stubGlobal('window', {
+      addEventListener: vi.fn((type: string, listener: (event?: any) => void) => {
+        windowListeners[type] ||= [];
+        windowListeners[type].push(listener);
+      }),
+      removeEventListener: vi.fn(),
+      dispatchEvent: vi.fn(),
+      setTimeout,
+      clearTimeout,
+      requestAnimationFrame: vi.fn((callback: FrameRequestCallback) => {
+        callback(0);
+        return 1;
+      }),
+      cancelAnimationFrame: vi.fn(),
+      innerHeight: 900,
+    });
+
+    await act(async () => {
+      create(<QueryEditor tab={createTab({ query: 'SELECT * FROM ' })} />);
+    });
+
+    editorState.editor.focus.mockClear();
+    editorState.editor.executeEdits.mockClear();
+
+    const altDownEvent = {
+      type: 'keydown',
+      ctrlKey: false,
+      metaKey: false,
+      altKey: true,
+      shiftKey: false,
+      key: 'Alt',
+      code: 'AltLeft',
+      preventDefault: vi.fn(),
+      stopPropagation: vi.fn(),
+    };
+    const unmatchedMonacoShortcutEvent = {
+      browserEvent: {
+        ctrlKey: false,
+        metaKey: false,
+        altKey: false,
+        shiftKey: false,
+        key: 'Process',
+        code: '',
+        keyCode: 0,
+        which: 0,
+        isComposing: false,
+        nativeEvent: {
+          code: '',
+          keyCode: 0,
+          which: 0,
+          isComposing: false,
+        },
+        target: null,
+        preventDefault: vi.fn(),
+        stopPropagation: vi.fn(),
+      },
+      preventDefault: vi.fn(),
+      stopPropagation: vi.fn(),
+    };
+
+    await act(async () => {
+      windowListeners.keydown?.forEach((listener) => listener(altDownEvent));
+      editorState.keyDownListeners.forEach((listener) => listener(unmatchedMonacoShortcutEvent));
+    });
+
+    editorState.value = 'SELECT * FROM \\';
+    editorState.position = { lineNumber: 1, column: 'SELECT * FROM \\'.length + 1 };
+
+    await act(async () => {
+      editorState.modelContentListeners.forEach((listener) => listener({
+        changes: [{
+          text: '\\',
+        }],
+      }));
+      for (let i = 0; i < 4; i += 1) {
+        await Promise.resolve();
+      }
+    });
+
+    expect(editorState.editor.executeEdits).toHaveBeenCalledWith(
+      'gonavi-trigger-sql-ai-completion-fallback',
+      [expect.objectContaining({
+        text: '',
+      })],
+    );
+    expect(editorState.value).toBe('SELECT * FROM ');
+    expect(editorState.editor.focus).toHaveBeenCalled();
+  });
+
+  it('recovers a stray backslash in table completion context even when the desktop keydown is not observable', async () => {
+    const windowListeners: Record<string, ((event?: any) => void)[]> = {};
+    vi.stubGlobal('window', {
+      addEventListener: vi.fn((type: string, listener: (event?: any) => void) => {
+        windowListeners[type] ||= [];
+        windowListeners[type].push(listener);
+      }),
+      removeEventListener: vi.fn(),
+      dispatchEvent: vi.fn(),
+      setTimeout,
+      clearTimeout,
+      requestAnimationFrame: vi.fn((callback: FrameRequestCallback) => {
+        callback(0);
+        return 1;
+      }),
+      cancelAnimationFrame: vi.fn(),
+      innerHeight: 900,
+    });
+
+    await act(async () => {
+      create(<QueryEditor tab={createTab({ query: 'SELECT * FROM ' })} />);
+    });
+
+    editorState.editor.executeEdits.mockClear();
+    editorState.editor.focus.mockClear();
+
+    editorState.value = 'SELECT * FROM \\';
+    editorState.position = { lineNumber: 1, column: 'SELECT * FROM \\'.length + 1 };
+
+    await act(async () => {
+      editorState.modelContentListeners.forEach((listener) => listener({
+        changes: [{
+          text: '\\',
+          rangeOffset: 'SELECT * FROM '.length,
+          rangeLength: 0,
+        }],
+      }));
+      for (let i = 0; i < 4; i += 1) {
+        await Promise.resolve();
+      }
+    });
+
+    expect(editorState.editor.executeEdits).toHaveBeenCalledWith(
+      'gonavi-trigger-sql-ai-completion-fallback',
+      [expect.objectContaining({
+        text: '',
+      })],
+    );
+    expect(editorState.value).toBe('SELECT * FROM ');
+    expect(editorState.editor.focus).toHaveBeenCalled();
+  });
+
+  it('recovers a stray backslash from content-change range data even when the cursor is still stale', async () => {
+    const windowListeners: Record<string, ((event?: any) => void)[]> = {};
+    vi.stubGlobal('window', {
+      addEventListener: vi.fn((type: string, listener: (event?: any) => void) => {
+        windowListeners[type] ||= [];
+        windowListeners[type].push(listener);
+      }),
+      removeEventListener: vi.fn(),
+      dispatchEvent: vi.fn(),
+      setTimeout,
+      clearTimeout,
+      requestAnimationFrame: vi.fn((callback: FrameRequestCallback) => {
+        callback(0);
+        return 1;
+      }),
+      cancelAnimationFrame: vi.fn(),
+      innerHeight: 900,
+    });
+
+    await act(async () => {
+      create(<QueryEditor tab={createTab({ query: 'SELECT * FROM ' })} />);
+    });
+
+    editorState.editor.executeEdits.mockClear();
+    editorState.editor.focus.mockClear();
+
+    editorState.value = 'SELECT * FROM \\';
+    editorState.position = { lineNumber: 1, column: 'SELECT * FROM '.length + 1 };
+
+    await act(async () => {
+      editorState.modelContentListeners.forEach((listener) => listener({
+        changes: [{
+          text: '\\',
+          range: {
+            startLineNumber: 1,
+            startColumn: 'SELECT * FROM '.length + 1,
+            endLineNumber: 1,
+            endColumn: 'SELECT * FROM '.length + 1,
+          },
+        }],
+      }));
+      for (let i = 0; i < 4; i += 1) {
+        await Promise.resolve();
+      }
+    });
+
+    expect(editorState.editor.executeEdits).toHaveBeenCalledWith(
+      'gonavi-trigger-sql-ai-completion-fallback',
+      [expect.objectContaining({
+        text: '',
+      })],
+    );
+    expect(editorState.value).toBe('SELECT * FROM ');
+  });
+
+  it('uses structured SQL suggestions instead of freeform AI when manual completion is triggered in table-name context', async () => {
+    backendApp.DBGetTables.mockResolvedValueOnce({
+      success: true,
+      data: [
+        { TABLE_NAME: 'videos' },
+        { TABLE_NAME: 'visits' },
+      ],
+    });
+
+    const windowListeners: Record<string, ((event?: any) => void)[]> = {};
+    vi.stubGlobal('window', {
+      addEventListener: vi.fn((type: string, listener: (event?: any) => void) => {
+        windowListeners[type] ||= [];
+        windowListeners[type].push(listener);
+      }),
+      removeEventListener: vi.fn(),
+      dispatchEvent: vi.fn(),
+      setTimeout,
+      clearTimeout,
+      requestAnimationFrame: vi.fn((callback: FrameRequestCallback) => {
+        callback(0);
+        return 1;
+      }),
+      cancelAnimationFrame: vi.fn(),
+      innerHeight: 900,
+    });
+
+    await act(async () => {
+      create(<QueryEditor tab={createTab({ query: 'SELECT * FROM ', dbName: 'main' })} />);
+    });
+
+    editorState.value = 'SELECT * FROM ';
+    editorState.position = { lineNumber: 1, column: 'SELECT * FROM '.length + 1 };
+    editorState.editor.trigger.mockClear();
+
+    const shortcutEvent = {
+      ctrlKey: false,
+      metaKey: false,
+      altKey: true,
+      shiftKey: false,
+      key: 'Process',
+      code: 'Backslash',
+      keyCode: 220,
+      which: 220,
+      isComposing: false,
+      nativeEvent: {
+        code: 'Backslash',
+        keyCode: 220,
+        which: 220,
+        isComposing: false,
+      },
+      target: null,
+      preventDefault: vi.fn(),
+      stopPropagation: vi.fn(),
+    };
+    const monacoShortcutEvent = {
+      browserEvent: shortcutEvent,
+      preventDefault: vi.fn(),
+      stopPropagation: vi.fn(),
+    };
+
+    await act(async () => {
+      editorState.keyDownListeners.forEach((listener) => listener(monacoShortcutEvent));
+      for (let i = 0; i < 8; i += 1) {
+        await Promise.resolve();
+      }
+    });
+
+    expect(editorState.editor.trigger).toHaveBeenCalledWith(
+      'gonavi-ai-inline-manual',
+      'editor.action.triggerSuggest',
+      undefined,
+    );
+  });
+
+  it('uses grounded AI inline ghost when manual completion is triggered in table-name context and inline AI is available', async () => {
+    const inlineAiService = {
+      AIGetProviders: vi.fn(async () => [{
+        id: 'openai-main',
+        type: 'openai',
+        name: 'OpenAI',
+        apiKey: '',
+        hasSecret: true,
+        baseUrl: 'https://api.openai.com/v1',
+        model: 'gpt-5-mini',
+        maxTokens: 2048,
+        temperature: 0.2,
+      }]),
+      AIGetActiveProvider: vi.fn(async () => 'openai-main'),
+      AIGetUserPromptSettings: vi.fn(async () => ({
+        global: '',
+        database: '',
+        jvm: '',
+        jvmDiagnostic: '',
+      })),
+      AIChatSend: vi.fn(async () => ({ success: true, content: 'videos' })),
+    };
+    backendApp.DBGetTables.mockResolvedValueOnce({
+      success: true,
+      data: [
+        { TABLE_NAME: 'videos' },
+        { TABLE_NAME: 'visits' },
+      ],
+    });
+
+    const windowListeners: Record<string, ((event?: any) => void)[]> = {};
+    vi.stubGlobal('window', {
+      addEventListener: vi.fn((type: string, listener: (event?: any) => void) => {
+        windowListeners[type] ||= [];
+        windowListeners[type].push(listener);
+      }),
+      removeEventListener: vi.fn(),
+      dispatchEvent: vi.fn(),
+      setTimeout,
+      clearTimeout,
+      requestAnimationFrame: vi.fn((callback: FrameRequestCallback) => {
+        callback(0);
+        return 1;
+      }),
+      cancelAnimationFrame: vi.fn(),
+      innerHeight: 900,
+      go: {
+        aiservice: {
+          Service: inlineAiService,
+        },
+      },
+    });
+
+    await act(async () => {
+      create(<QueryEditor tab={createTab({ query: 'SELECT * FROM ', dbName: 'main' })} />);
+    });
+
+    editorState.value = 'SELECT * FROM ';
+    editorState.position = { lineNumber: 1, column: 'SELECT * FROM '.length + 1 };
+    editorState.editor.trigger.mockClear();
+    editorState.domNode.appendChild.mockClear();
+
+    const shortcutEvent = {
+      ctrlKey: false,
+      metaKey: false,
+      altKey: true,
+      shiftKey: false,
+      key: 'Process',
+      code: 'Backslash',
+      keyCode: 220,
+      which: 220,
+      isComposing: false,
+      nativeEvent: {
+        code: 'Backslash',
+        keyCode: 220,
+        which: 220,
+        isComposing: false,
+      },
+      target: null,
+      preventDefault: vi.fn(),
+      stopPropagation: vi.fn(),
+    };
+    const monacoShortcutEvent = {
+      browserEvent: shortcutEvent,
+      preventDefault: vi.fn(),
+      stopPropagation: vi.fn(),
+    };
+
+    await act(async () => {
+      editorState.keyDownListeners.forEach((listener) => listener(monacoShortcutEvent));
+      for (let i = 0; i < 8; i += 1) {
+        await Promise.resolve();
+      }
+    });
+
+    expect(inlineAiService.AIChatSend).toHaveBeenCalledTimes(1);
+    expect(editorState.domNode.appendChild).toHaveBeenCalled();
+    const ghostOverlay = editorState.domNode.appendChild.mock.calls[
+      editorState.domNode.appendChild.mock.calls.length - 1
+    ]?.[0];
+    expect(ghostOverlay?.className).toBe('gonavi-query-editor-ai-inline-ghost-overlay');
+    expect(ghostOverlay?.textContent).toBe('videos');
+    expect(editorState.editor.trigger).not.toHaveBeenCalledWith(
+      'gonavi-ai-inline-manual',
+      'editor.action.triggerSuggest',
+      undefined,
+    );
+  });
+
+  it('uses local SQL memory for manual inline completion in an empty editor', async () => {
+    storeState.sqlLogs = [{
+      id: 'sql-log-1',
+      timestamp: Date.now(),
+      sql: 'SELECT * FROM videos WHERE code = ?;',
+      status: 'success',
+      duration: 12,
+      dbName: 'main',
+    } as any];
+
+    const windowListeners: Record<string, ((event?: any) => void)[]> = {};
+    vi.stubGlobal('window', {
+      addEventListener: vi.fn((type: string, listener: (event?: any) => void) => {
+        windowListeners[type] ||= [];
+        windowListeners[type].push(listener);
+      }),
+      removeEventListener: vi.fn(),
+      dispatchEvent: vi.fn(),
+      setTimeout,
+      clearTimeout,
+      requestAnimationFrame: vi.fn((callback: FrameRequestCallback) => {
+        callback(0);
+        return 1;
+      }),
+      cancelAnimationFrame: vi.fn(),
+      innerHeight: 900,
+    });
+
+    await act(async () => {
+      create(<QueryEditor tab={createTab({ query: '', dbName: 'main' })} />);
+    });
+
+    editorState.value = '';
+    editorState.position = { lineNumber: 1, column: 1 };
+    editorState.editor.trigger.mockClear();
+    editorState.domNode.appendChild.mockClear();
+
+    const shortcutEvent = {
+      ctrlKey: false,
+      metaKey: false,
+      altKey: true,
+      shiftKey: false,
+      key: 'Process',
+      code: 'Backslash',
+      keyCode: 220,
+      which: 220,
+      isComposing: false,
+      nativeEvent: {
+        code: 'Backslash',
+        keyCode: 220,
+        which: 220,
+        isComposing: false,
+      },
+      target: null,
+      preventDefault: vi.fn(),
+      stopPropagation: vi.fn(),
+    };
+    const monacoShortcutEvent = {
+      browserEvent: shortcutEvent,
+      preventDefault: vi.fn(),
+      stopPropagation: vi.fn(),
+    };
+
+    await act(async () => {
+      editorState.keyDownListeners.forEach((listener) => listener(monacoShortcutEvent));
+      for (let i = 0; i < 4; i += 1) {
+        await Promise.resolve();
+      }
+    });
+
+    expect(editorState.value).toBe('');
+    expect(editorState.domNode.appendChild).toHaveBeenCalled();
+    const ghostOverlay = editorState.domNode.appendChild.mock.calls[
+      editorState.domNode.appendChild.mock.calls.length - 1
+    ]?.[0];
+    expect(ghostOverlay?.className).toBe('gonavi-query-editor-ai-inline-ghost-overlay');
+    expect(ghostOverlay?.textContent).toBe('SELECT * FROM videos WHERE code = ?;');
+    expect(editorState.editor.trigger).not.toHaveBeenCalledWith(
+      'gonavi-ai-inline-manual',
+      'editor.action.triggerSuggest',
+      undefined,
+    );
+  });
+
+  it('uses local SQL memory for automatic inline completion in update table context', async () => {
+    vi.useFakeTimers();
+    try {
+      storeState.sqlLogs = [{
+        id: 'sql-log-2',
+        timestamp: Date.now(),
+        sql: 'UPDATE videos SET status = 1 WHERE id = ?;',
+        status: 'success',
+        duration: 9,
+        dbName: 'main',
+      } as any];
+
+      const windowListeners: Record<string, ((event?: any) => void)[]> = {};
+      vi.stubGlobal('window', {
+        addEventListener: vi.fn((type: string, listener: (event?: any) => void) => {
+          windowListeners[type] ||= [];
+          windowListeners[type].push(listener);
+        }),
+        removeEventListener: vi.fn(),
+        dispatchEvent: vi.fn(),
+        setTimeout,
+        clearTimeout,
+        requestAnimationFrame: vi.fn((callback: FrameRequestCallback) => {
+          callback(0);
+          return 1;
+        }),
+        cancelAnimationFrame: vi.fn(),
+        innerHeight: 900,
+      });
+
+      await act(async () => {
+        create(<QueryEditor tab={createTab({ query: 'UPDAT', dbName: 'main' })} />);
+      });
+
+      editorState.value = 'UPDATE';
+      editorState.position = { lineNumber: 1, column: 'UPDATE'.length + 1 };
+      editorState.editor.trigger.mockClear();
+      editorState.domNode.appendChild.mockClear();
+
+      await act(async () => {
+        editorState.latestOnChange?.('UPDATE');
+        editorState.modelContentListeners.forEach((listener) => listener({
+          changes: [{ text: 'E' }],
+        }));
+        vi.advanceTimersByTime(120);
+        for (let i = 0; i < 8; i += 1) {
+          await Promise.resolve();
+        }
+      });
+
+      expect(editorState.domNode.appendChild).toHaveBeenCalled();
+      const ghostOverlay = editorState.domNode.appendChild.mock.calls[
+        editorState.domNode.appendChild.mock.calls.length - 1
+      ]?.[0];
+      expect(ghostOverlay?.className).toBe('gonavi-query-editor-ai-inline-ghost-overlay');
+      expect(ghostOverlay?.textContent).toBe(' videos SET status = 1 WHERE id = ?;');
+      expect(editorState.editor.trigger).not.toHaveBeenCalled();
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  it('continues accepted inline SQL ghost with grounded table AI completion', async () => {
+    vi.useFakeTimers();
+    try {
+      const inlineAiService = {
+        AIGetProviders: vi.fn(async () => [{
+          id: 'openai-main',
+          type: 'openai',
+          name: 'OpenAI',
+          apiKey: '',
+          hasSecret: true,
+          baseUrl: 'https://api.openai.com/v1',
+          model: 'gpt-5-mini',
+          maxTokens: 2048,
+          temperature: 0.2,
+        }]),
+        AIGetActiveProvider: vi.fn(async () => 'openai-main'),
+        AIGetUserPromptSettings: vi.fn(async () => ({
+          global: '',
+          database: '',
+          jvm: '',
+          jvmDiagnostic: '',
+        })),
+        AIChatSend: vi.fn(async () => ({ success: true, content: 'videos' })),
+      };
+      backendApp.DBGetTables.mockResolvedValueOnce({
+        success: true,
+        data: [
+          { TABLE_NAME: 'videos' },
+          { TABLE_NAME: 'visits' },
+        ],
+      });
+
+      const windowListeners: Record<string, ((event?: any) => void)[]> = {};
+      vi.stubGlobal('window', {
+        addEventListener: vi.fn((type: string, listener: (event?: any) => void) => {
+          windowListeners[type] ||= [];
+          windowListeners[type].push(listener);
+        }),
+        removeEventListener: vi.fn(),
+        dispatchEvent: vi.fn(),
+        setTimeout,
+        clearTimeout,
+        requestAnimationFrame: vi.fn((callback: FrameRequestCallback) => {
+          callback(0);
+          return 1;
+        }),
+        cancelAnimationFrame: vi.fn(),
+        innerHeight: 900,
+        go: {
+          aiservice: {
+            Service: inlineAiService,
+          },
+        },
+      });
+
+      await act(async () => {
+        create(<QueryEditor tab={createTab({ query: 'SELECT', dbName: 'main' })} />);
+      });
+
+      editorState.value = 'SELECT';
+      editorState.position = { lineNumber: 1, column: 'SELECT'.length + 1 };
+      editorState.editor.executeEdits.mockClear();
+      editorState.editor.trigger.mockClear();
+      editorState.domNode.appendChild.mockClear();
+
+      await act(async () => {
+        editorState.latestOnChange?.('SELECT');
+        editorState.modelContentListeners.forEach((listener) => listener({
+          changes: [{ text: 'T' }],
+        }));
+        vi.advanceTimersByTime(120);
+        for (let i = 0; i < 8; i += 1) {
+          await Promise.resolve();
+        }
+      });
+
+      const acceptInlineGhostCall = editorState.editor.addCommand.mock.calls.find(
+        (call: any[]) => call[2] === 'gonaviAiInlineSuggestionVisible',
+      );
+      expect(acceptInlineGhostCall).toBeTruthy();
+
+      await act(async () => {
+        acceptInlineGhostCall?.[1]?.();
+        vi.advanceTimersByTime(1);
+        for (let i = 0; i < 8; i += 1) {
+          await Promise.resolve();
+        }
+      });
+
+      expect(editorState.editor.executeEdits).toHaveBeenCalledWith(
+        'gonavi-ai-inline-sql-completion',
+        [expect.objectContaining({
+          text: ' * FROM ',
+        })],
+      );
+      expect(editorState.value).toBe('SELECT * FROM ');
+      expect(inlineAiService.AIChatSend).toHaveBeenCalledTimes(1);
+      expect(editorState.domNode.appendChild).toHaveBeenCalled();
+      const ghostOverlay = editorState.domNode.appendChild.mock.calls[
+        editorState.domNode.appendChild.mock.calls.length - 1
+      ]?.[0];
+      expect(ghostOverlay?.className).toBe('gonavi-query-editor-ai-inline-ghost-overlay');
+      expect(ghostOverlay?.textContent).toBe('videos');
+      expect(editorState.editor.trigger).not.toHaveBeenCalledWith(
+        'gonavi-ai-inline-auto',
+        'editor.action.triggerSuggest',
+        undefined,
+      );
+
+      editorState.editor.executeEdits.mockClear();
+      editorState.editor.trigger.mockClear();
+
+      await act(async () => {
+        acceptInlineGhostCall?.[1]?.();
+        vi.advanceTimersByTime(1);
+        for (let i = 0; i < 8; i += 1) {
+          await Promise.resolve();
+        }
+      });
+
+      expect(editorState.editor.executeEdits).toHaveBeenCalledWith(
+        'gonavi-ai-inline-sql-completion',
+        [expect.objectContaining({
+          text: 'videos',
+        })],
+      );
+      expect(editorState.value).toBe('SELECT * FROM videos');
+      expect(inlineAiService.AIChatSend).toHaveBeenCalledTimes(1);
+      expect(editorState.editor.trigger).not.toHaveBeenCalled();
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  it('strips a stray backslash before opening manual table suggestions from the toolbar AI button', async () => {
+    backendApp.DBGetTables.mockResolvedValueOnce({
+      success: true,
+      data: [
+        { TABLE_NAME: 'videos' },
+        { TABLE_NAME: 'visits' },
+      ],
+    });
+
+    const windowListeners: Record<string, ((event?: any) => void)[]> = {};
+    vi.stubGlobal('window', {
+      addEventListener: vi.fn((type: string, listener: (event?: any) => void) => {
+        windowListeners[type] ||= [];
+        windowListeners[type].push(listener);
+      }),
+      removeEventListener: vi.fn(),
+      dispatchEvent: vi.fn(),
+      setTimeout,
+      clearTimeout,
+      requestAnimationFrame: vi.fn((callback: FrameRequestCallback) => {
+        callback(0);
+        return 1;
+      }),
+      cancelAnimationFrame: vi.fn(),
+      innerHeight: 900,
+    });
+
+    let renderer: ReactTestRenderer;
+    await act(async () => {
+      renderer = create(<QueryEditor tab={createTab({ query: 'SELECT * FROM \\', dbName: 'main' })} />);
+    });
+
+    editorState.value = 'SELECT * FROM \\';
+    editorState.position = { lineNumber: 1, column: 'SELECT * FROM \\'.length + 1 };
+    editorState.editor.executeEdits.mockClear();
+    editorState.editor.trigger.mockClear();
+
+    await act(async () => {
+      findButton(renderer!, 'AI').props.onClick();
+      for (let i = 0; i < 8; i += 1) {
+        await Promise.resolve();
+      }
+    });
+
+    expect(editorState.editor.executeEdits).toHaveBeenCalledWith(
+      'gonavi-manual-sql-ai-strip-marker',
+      [expect.objectContaining({
+        text: '',
+      })],
+    );
+    expect(editorState.value).toBe('SELECT * FROM ');
+    expect(editorState.editor.trigger).toHaveBeenCalledWith(
+      'gonavi-ai-inline-manual',
+      'editor.action.triggerSuggest',
+      undefined,
+    );
+  });
+
   it('shows the query results panel with the shortcut after manually hiding it', async () => {
     storeState.appearance.uiVersion = 'v2';
 
@@ -3173,6 +4132,8 @@ describe('QueryEditor external SQL save', () => {
 
     await act(async () => {
       create(<QueryEditor tab={createTab()} />);
+    });
+    await act(async () => {
       await new Promise((resolve) => setTimeout(resolve, 0));
     });
 
diff --git a/frontend/src/components/QueryEditor.tsx b/frontend/src/components/QueryEditor.tsx
index f78874af..17aa7509 100644
--- a/frontend/src/components/QueryEditor.tsx
+++ b/frontend/src/components/QueryEditor.tsx
@@ -4,8 +4,8 @@ import Editor, { type OnMount } from './MonacoEditor';
 import { message, Input, Form, MenuProps, Button, Segmented } from 'antd';
 import { format } from 'sql-formatter';
 import { v4 as uuidv4 } from 'uuid';
-import { TabData, ColumnDefinition, type SqlSnippet } from '../types';
-import { useStore } from '../store';
+import { TabData, ColumnDefinition, type SavedQuery, type SqlSnippet } from '../types';
+import { type SqlLog, useStore } from '../store';
 import { DBQuery, DBQueryWithCancel, DBQueryMulti, DBQueryMultiInTransaction, DBQueryMultiTransactional, DBGetTables, DBGetAllColumns, DBGetDatabases, DBGetColumns, CancelQuery, GenerateQueryID, WriteSQLFile, ExportSQLFile } from '../../wailsjs/go/app/App';
 import { GONAVI_ROW_KEY } from './DataGrid';
 import { EventsOn } from '../../wailsjs/runtime';
@@ -143,9 +143,14 @@ import {
     stripCompletionIdentifierQuotes,
 } from './queryEditor/QueryEditorHelpers';
 import {
+    buildQueryEditorAiInlineSuggestOptions,
     getQueryEditorAiService,
     requestQueryEditorInlineCompletion,
     requestQueryEditorTextToSql,
+    resolveInlineSqlGhostPreviewText,
+    resolveQueryEditorInlineMemoryInsertText,
+    resolveQueryEditorInlineCompletionIntentDetails,
+    shouldTriggerQueryEditorInlineObjectSuggestFallback,
     shouldRequestQueryEditorInlineCompletion,
     type QueryEditorAiApplyMode,
     type QueryEditorAiContext,
@@ -164,6 +169,88 @@ const QUERY_EDITOR_MONACO_FIND_OPTIONS = {
     addExtraSpaceOnTop: true,
 } as const;
 const QUERY_EDITOR_NATIVE_SELECT_CURRENT_LINE_EVENT = 'gonavi:native-select-current-line';
+const QUERY_EDITOR_AI_INLINE_DEBOUNCE_MS = 90;
+const QUERY_EDITOR_AI_INLINE_CONTEXT_KEY = 'gonaviAiInlineSuggestionVisible';
+
+const normalizeQueryEditorInlineMemorySqlKey = (sql: string): string => (
+    String(sql || '')
+        .replace(/\r\n?/g, '\n')
+        .replace(/\s+/g, ' ')
+        .trim()
+        .toLowerCase()
+);
+
+const matchesQueryEditorInlineMemoryDb = (currentDb: string, candidateDb?: string): boolean => {
+    const normalizedCurrentDb = String(currentDb || '').trim().toLowerCase();
+    const normalizedCandidateDb = String(candidateDb || '').trim().toLowerCase();
+    if (!normalizedCurrentDb || !normalizedCandidateDb) {
+        return true;
+    }
+    return normalizedCurrentDb === normalizedCandidateDb;
+};
+
+const buildQueryEditorInlineMemoryEntries = ({
+    currentConnectionId,
+    currentDb,
+    savedQueries,
+    sqlLogs,
+}: {
+    currentConnectionId: string;
+    currentDb: string;
+    savedQueries: SavedQuery[];
+    sqlLogs: SqlLog[];
+}): Array<{ sql: string }> => {
+    const ranked = new Map<string, { sql: string; score: number; latestAt: number }>();
+    const addCandidate = (sql: string, score: number, latestAt: number) => {
+        const text = String(sql || '').trim();
+        if (!text) {
+            return;
+        }
+        const key = normalizeQueryEditorInlineMemorySqlKey(text);
+        if (!key) {
+            return;
+        }
+        const existing = ranked.get(key);
+        if (!existing) {
+            ranked.set(key, { sql: text, score, latestAt });
+            return;
+        }
+        existing.score += score;
+        if (latestAt >= existing.latestAt) {
+            existing.latestAt = latestAt;
+            existing.sql = text;
+        }
+    };
+
+    savedQueries.forEach((query) => {
+        if (currentConnectionId && String(query.connectionId || '').trim() !== currentConnectionId) {
+            return;
+        }
+        if (!matchesQueryEditorInlineMemoryDb(currentDb, query.dbName)) {
+            return;
+        }
+        addCandidate(query.sql, 600, Number(query.createdAt || 0));
+    });
+
+    sqlLogs.forEach((log) => {
+        if (log.status !== 'success') {
+            return;
+        }
+        if (!matchesQueryEditorInlineMemoryDb(currentDb, log.dbName)) {
+            return;
+        }
+        addCandidate(log.sql, 80, Number(log.timestamp || 0));
+    });
+
+    return [...ranked.values()]
+        .sort((left, right) => (
+            right.score - left.score
+            || right.latestAt - left.latestAt
+            || left.sql.length - right.sql.length
+        ))
+        .slice(0, 16)
+        .map((entry) => ({ sql: entry.sql }));
+};
 
 const buildQueryEditorMonacoOptions = (isObjectEditQueryTab: boolean) => ({
     minimap: { enabled: false },
@@ -178,13 +265,7 @@ const buildQueryEditorMonacoOptions = (isObjectEditQueryTab: boolean) => ({
     scrollBeyondLastLine: false,
     quickSuggestions: { other: true, comments: false, strings: false },
     suggestOnTriggerCharacters: true,
-    inlineSuggest: {
-        enabled: true,
-        mode: 'prefix' as const,
-        showToolbar: 'onHover' as const,
-        suppressSuggestions: false,
-        minShowDelay: 160,
-    },
+    inlineSuggest: buildQueryEditorAiInlineSuggestOptions(),
     ...(isObjectEditQueryTab
         ? {
             fontSize: 14,
@@ -745,6 +826,19 @@ const buildQueryEditorAiContextPrompt = (connection: any, database: string): str
     });
 };
 
+const resolveQueryEditorAiConnectionHost = (connection: any): string => {
+    const config = connection?.config || {};
+    if (Array.isArray(config.hosts)) {
+        const hosts = config.hosts
+            .map((item: any) => String(typeof item === 'string' ? item : item?.host || item?.hostname || item?.address || '').trim())
+            .filter(Boolean);
+        if (hosts.length > 0) {
+            return hosts.join(', ');
+        }
+    }
+    return String(config.host || config.hostname || config.server || config.address || '').trim();
+};
+
 // HMR 重载时释放旧注册避免补全和 hover 内容重复
 const _g = globalThis as any;
 const SQL_COMPLETION_PROVIDER_VERSION = '20260702-ai-inline-sql-v1';
@@ -773,7 +867,6 @@ let sharedSequencesData: CompletionSequenceMeta[] = [];
 let sharedPackagesData: CompletionPackageMeta[] = [];
 let sharedColumnsCacheData: Record<string, any[]> = {};
 let sharedActiveEditorModelUri = '';
-let sharedAiInlineCompletionRequestSeq = 0;
 const sharedLazyTablesCache: Record<string, CompletionTableMeta[] | undefined> = {};
 const sharedLazyTablesInFlight: Record<string, Promise<CompletionTableMeta[]> | undefined> = {};
 const createEmptySqlCompletionResult = () => ({ suggestions: [] as any[] });
@@ -969,6 +1062,8 @@ const QueryEditor: React.FC<{ tab: TabData; isActive?: boolean }> = ({ tab, isAc
   const saveQueryActionRef = useRef<any>(null);
   const findInEditorActionRef = useRef<any>(null);
   const formatSqlActionRef = useRef<any>(null);
+  const triggerSqlAiCompletionActionRef = useRef<any>(null);
+  const triggerSqlAiCompletionKeydownDisposableRef = useRef<any>(null);
   const insertSqlSnippetActionRef = useRef<any>(null);
   const aiContextMenuActionDisposablesRef = useRef<any[]>([]);
   const toggleQueryResultsPanelActionRef = useRef<any>(null);
@@ -988,6 +1083,24 @@ const QueryEditor: React.FC<{ tab: TabData; isActive?: boolean }> = ({ tab, isAc
   const linkDecorationIdsRef = useRef<string[]>([]);
   const ctrlMetaPressedRef = useRef(false);
   const objectDecorationIdsRef = useRef<string[]>([]);
+  const aiInlineGhostDecorationIdsRef = useRef<string[]>([]);
+  const aiInlineGhostOverlayRef = useRef<HTMLSpanElement | null>(null);
+  const aiInlineGhostVisibleContextKeyRef = useRef<any>(null);
+  const aiInlineGhostTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+  const aiInlineGhostRequestSeqRef = useRef(0);
+  const triggerAiInlineCompletionRef = useRef<(() => void) | null>(null);
+  const aiContextMetadataWarmupRef = useRef<Record<string, Promise<void> | undefined>>({});
+  const triggerSqlAiCompletionAltPressedRef = useRef(false);
+  const triggerSqlAiCompletionAltGestureAtRef = useRef(0);
+  const triggerSqlAiCompletionFallbackRef = useRef<{ observedAt: number } | null>(null);
+  const triggerSqlAiCompletionFallbackApplyingRef = useRef(false);
+  const aiInlineGhostRef = useRef<{
+      insertText: string;
+      modelUri: string;
+      position: { lineNumber: number; column: number };
+      snapshot: QueryEditorAiEditorSnapshot;
+  } | null>(null);
+  const aiInlineGhostAcceptingRef = useRef(false);
   const objectHoverActionRef = useRef<any>(null);
   const dragRef = useRef<{ startY: number, startHeight: number, currentHeight: number } | null>(null);
   const pendingEditorHeightRef = useRef(editorHeight);
@@ -1014,6 +1127,7 @@ const QueryEditor: React.FC<{ tab: TabData; isActive?: boolean }> = ({ tab, isAc
 
   const addSqlLog = useStore(state => state.addSqlLog);
   const sqlLogCount = useStore(state => state.sqlLogs.length);
+  const sqlLogs = useStore(state => state.sqlLogs);
   const addTab = useStore(state => state.addTab);
   const setActiveContext = useStore(state => state.setActiveContext);
   const updateQueryTabDraft = useStore(state => state.updateQueryTabDraft);
@@ -1022,6 +1136,12 @@ const QueryEditor: React.FC<{ tab: TabData; isActive?: boolean }> = ({ tab, isAc
   const sqlSnippets = useStore(state => state.sqlSnippets);
   const currentConnectionIdRef = useRef(currentConnectionId);
   const currentDbRef = useRef(currentDb);
+  const inlineSqlMemoryEntries = useMemo(() => buildQueryEditorInlineMemoryEntries({
+      currentConnectionId,
+      currentDb,
+      savedQueries,
+      sqlLogs,
+  }), [currentConnectionId, currentDb, savedQueries, sqlLogs]);
   const draftSnapshotTab = useMemo(() => ({
       id: tab.id,
       title: tab.title,
@@ -1180,6 +1300,10 @@ const QueryEditor: React.FC<{ tab: TabData; isActive?: boolean }> = ({ tab, isAc
       () => resolveShortcutBinding(shortcutOptions, 'formatSql', activeShortcutPlatform),
       [activeShortcutPlatform, shortcutOptions],
   );
+  const triggerSqlAiCompletionShortcutBinding = useMemo(
+      () => resolveShortcutBinding(shortcutOptions, 'triggerSqlAiCompletion', activeShortcutPlatform),
+      [activeShortcutPlatform, shortcutOptions],
+  );
   const toggleQueryResultsPanelShortcutBinding = useMemo(
       () => resolveShortcutBinding(shortcutOptions, 'toggleQueryResultsPanel', activeShortcutPlatform),
       [activeShortcutPlatform, shortcutOptions],
@@ -1192,6 +1316,111 @@ const QueryEditor: React.FC<{ tab: TabData; isActive?: boolean }> = ({ tab, isAc
       () => getShortcutPrimaryModifierDisplayLabel(activeShortcutPlatform),
       [activeShortcutPlatform],
   );
+  const isTriggerSqlAiCompletionShortcutEvent = useCallback((event: any): boolean => {
+      const binding = triggerSqlAiCompletionShortcutBinding;
+      if (!binding?.enabled || !binding.combo) {
+          return false;
+      }
+      if (isShortcutMatch(event, binding.combo)) {
+          return true;
+      }
+      if (normalizeShortcutCombo(binding.combo) !== 'Alt+\\') {
+          return false;
+      }
+
+      const key = String(
+          event?.key
+          || event?.nativeEvent?.key
+          || event?.browserEvent?.key
+          || '',
+      ).trim();
+      const code = String(
+          event?.code
+          || event?.nativeEvent?.code
+          || event?.browserEvent?.code
+          || '',
+      ).trim();
+      const keyCode = Number(
+          event?.keyCode
+          ?? event?.which
+          ?? event?.nativeEvent?.keyCode
+          ?? event?.nativeEvent?.which
+          ?? event?.browserEvent?.keyCode
+          ?? event?.browserEvent?.which
+          ?? 0,
+      );
+      const isBackslashKey = key === '\\'
+          || code === 'Backslash'
+          || code === 'IntlBackslash'
+          || keyCode === 220
+          || keyCode === 226;
+      return isBackslashKey && triggerSqlAiCompletionAltPressedRef.current;
+  }, [triggerSqlAiCompletionShortcutBinding]);
+  const isPossibleTriggerSqlAiCompletionFallbackEvent = useCallback((event: any): boolean => {
+      const binding = triggerSqlAiCompletionShortcutBinding;
+      if (!binding?.enabled || normalizeShortcutCombo(binding.combo) !== 'Alt+\\') {
+          return false;
+      }
+
+      const key = String(
+          event?.key
+          || event?.nativeEvent?.key
+          || event?.browserEvent?.key
+          || '',
+      ).trim();
+      const code = String(
+          event?.code
+          || event?.nativeEvent?.code
+          || event?.browserEvent?.code
+          || '',
+      ).trim();
+      const keyCode = Number(
+          event?.keyCode
+          ?? event?.which
+          ?? event?.nativeEvent?.keyCode
+          ?? event?.nativeEvent?.which
+          ?? event?.browserEvent?.keyCode
+          ?? event?.browserEvent?.which
+          ?? 0,
+      );
+      const isLikelyBackslashKey = key === '\\'
+          || key === 'Process'
+          || code === 'Backslash'
+          || code === 'IntlBackslash'
+          || keyCode === 220
+          || keyCode === 226;
+      const hasAltIntent = Boolean(
+          event?.altKey
+          || event?.nativeEvent?.altKey
+          || event?.browserEvent?.altKey
+          || triggerSqlAiCompletionAltPressedRef.current
+      );
+      return isLikelyBackslashKey && hasAltIntent;
+  }, [triggerSqlAiCompletionShortcutBinding]);
+  const registerTriggerSqlAiCompletionAction = useCallback((editor: any, monaco: any) => {
+      if (triggerSqlAiCompletionActionRef.current) {
+          triggerSqlAiCompletionActionRef.current.dispose();
+          triggerSqlAiCompletionActionRef.current = null;
+      }
+      if (!editor || !monaco) {
+          return;
+      }
+
+      const binding = triggerSqlAiCompletionShortcutBinding;
+      const keyBinding = binding?.enabled && binding.combo
+          ? comboToMonacoKeyBinding(binding.combo, monaco.KeyMod, monaco.KeyCode)
+          : null;
+      triggerSqlAiCompletionActionRef.current = editor.addAction({
+          id: 'gonavi.triggerSqlAiCompletion',
+          label: buildQueryEditorMonacoActionLabel('app.shortcuts.action.triggerSqlAiCompletion.label'),
+          keybindings: keyBinding ? [keyBinding.keyMod | keyBinding.keyCode] : [],
+          contextMenuGroupId: '7_ai',
+          contextMenuOrder: 0,
+          run: () => {
+              triggerAiInlineCompletionRef.current?.();
+          },
+      });
+  }, [triggerSqlAiCompletionShortcutBinding]);
   useEffect(() => {
       setIsResultPanelVisible(tab.resultPanelVisible === true);
   }, [tab.id, tab.resultPanelVisible]);
@@ -1464,16 +1693,174 @@ const QueryEditor: React.FC<{ tab: TabData; isActive?: boolean }> = ({ tab, isAc
   }, [getCurrentQuery]);
 
   const buildQueryEditorAiContext = useCallback((): QueryEditorAiContext => {
-      const conn = connectionsRef.current.find(c => c.id === currentConnectionIdRef.current);
+      const resolvedConnectionId = String(
+          currentConnectionIdRef.current
+          || currentConnectionId
+          || tab.connectionId
+          || '',
+      ).trim();
+      const conn = connectionsRef.current.find(c => c.id === resolvedConnectionId);
+      const currentDbName = String(
+          currentDbRef.current
+          || currentDb
+          || tab.dbName
+          || '',
+      ).trim();
+      const lazyTables = sharedLazyTablesCache[`${resolvedConnectionId}|${currentDbName}`] || [];
+      const mergedTablesByKey = new Map<string, CompletionTableMeta>();
+      [...sharedTablesData, ...tablesRef.current, ...lazyTables].forEach((table) => {
+          const tableKey = `${String(table?.dbName || '').trim().toLowerCase()}\u0000${String(table?.tableName || '').trim().toLowerCase()}`;
+          if (!tableKey.trim()) {
+              return;
+          }
+          mergedTablesByKey.set(tableKey, table);
+      });
+      const mergedColumnsByKey = new Map<string, CompletionColumnMeta>();
+      [...sharedAllColumnsData, ...allColumnsRef.current].forEach((column) => {
+          const columnKey = `${String(column?.dbName || '').trim().toLowerCase()}\u0000${String(column?.tableName || '').trim().toLowerCase()}\u0000${String(column?.name || '').trim().toLowerCase()}`;
+          if (!columnKey.trim()) {
+              return;
+          }
+          mergedColumnsByKey.set(columnKey, column);
+      });
       return {
           connectionName: conn?.name,
+          host: resolveQueryEditorAiConnectionHost(conn),
+          port: conn?.config?.port,
           sourceType: conn?.config?.type,
-          currentDb: currentDbRef.current,
+          currentDb: currentDbName,
           visibleDbs: visibleDbsRef.current,
-          tables: tablesRef.current,
-          columns: allColumnsRef.current,
+          tables: [...mergedTablesByKey.values()],
+          columns: [...mergedColumnsByKey.values()],
       };
-  }, []);
+  }, [currentConnectionId, currentDb, tab.connectionId, tab.dbName]);
+
+  const ensureQueryEditorAiContextMetadata = useCallback(async (
+      editorSnapshot: QueryEditorAiEditorSnapshot,
+  ): Promise<void> => {
+      const connectionId = String(
+          currentConnectionIdRef.current
+          || currentConnectionId
+          || tab.connectionId
+          || '',
+      ).trim();
+      const dbName = String(
+          currentDbRef.current
+          || currentDb
+          || tab.dbName
+          || '',
+      ).trim();
+      if (!connectionId || !dbName) {
+          return;
+      }
+
+      const intent = resolveQueryEditorInlineCompletionIntentDetails(editorSnapshot);
+      const normalizedDbName = dbName.toLowerCase();
+      const needsTables = intent.intent === 'table_name'
+          || !tablesRef.current.some((table) => String(table.dbName || '').trim().toLowerCase() === normalizedDbName);
+      const needsColumns = intent.intent === 'column_name'
+          && !allColumnsRef.current.some((column) => String(column.dbName || '').trim().toLowerCase() === normalizedDbName);
+      if (!needsTables && !needsColumns) {
+          return;
+      }
+
+      const warmupKey = `${connectionId}\u0000${normalizedDbName}\u0000${needsTables ? 'tables' : ''}\u0000${needsColumns ? 'columns' : ''}`;
+      const existingWarmup = aiContextMetadataWarmupRef.current[warmupKey];
+      if (existingWarmup) {
+          await existingWarmup;
+          return;
+      }
+
+      const warmupPromise = (async () => {
+          const conn = connectionsRef.current.find((item) => item.id === connectionId);
+          if (!conn) {
+              return;
+          }
+
+          const config = {
+              ...conn.config,
+              port: Number(conn.config.port),
+              password: conn.config.password || '',
+              database: conn.config.database || '',
+              useSSH: conn.config.useSSH || false,
+              ssh: conn.config.ssh || { host: '', port: 22, user: '', password: '', keyPath: '' },
+          };
+
+          if (needsTables) {
+              try {
+                  const metadataDialect = normalizeMetadataDialect(conn);
+                  const [tableComments, resTables] = await Promise.all([
+                      fetchCompletionTableCommentMap(config, dbName, metadataDialect).catch(() => new Map<string, string>()),
+                      DBGetTables(buildRpcConnectionConfig(config) as any, dbName),
+                  ]);
+                  if (resTables?.success && Array.isArray(resTables.data)) {
+                      const fetchedTables = resTables.data
+                          .map((row: any) => buildCompletionTableMeta(dbName, row, tableComments))
+                          .filter((table): table is CompletionTableMeta => !!table);
+                      if (fetchedTables.length > 0) {
+                          const nextTableByKey = new Map(
+                              tablesRef.current.map((table) => [
+                                  `${String(table.dbName || '').trim().toLowerCase()}\u0000${String(table.tableName || '').trim().toLowerCase()}`,
+                                  table,
+                              ]),
+                          );
+                          fetchedTables.forEach((table) => {
+                              nextTableByKey.set(
+                                  `${String(table.dbName || '').trim().toLowerCase()}\u0000${String(table.tableName || '').trim().toLowerCase()}`,
+                                  table,
+                              );
+                          });
+                          tablesRef.current = [...nextTableByKey.values()];
+                          sharedTablesData = tablesRef.current;
+                          sharedLazyTablesCache[`${connectionId}|${dbName}`] = fetchedTables;
+                      }
+                  }
+              } catch (error) {
+                  console.warn('GoNavi AI inline table metadata warmup failed', error);
+              }
+          }
+
+          if (needsColumns) {
+              try {
+                  const resCols = await DBGetAllColumns(buildRpcConnectionConfig(config) as any, dbName);
+                  if (resCols?.success && Array.isArray(resCols.data)) {
+                      const fetchedColumns = resCols.data.map((col: any) => ({
+                          dbName,
+                          tableName: col.tableName,
+                          name: col.name,
+                          type: col.type,
+                          comment: normalizeCommentText(col.comment ?? col.Comment ?? col.COLUMN_COMMENT ?? col.column_comment ?? ''),
+                      }));
+                      if (fetchedColumns.length > 0) {
+                          const nextColumnByKey = new Map(
+                              allColumnsRef.current.map((column) => [
+                                  `${String(column.dbName || '').trim().toLowerCase()}\u0000${String(column.tableName || '').trim().toLowerCase()}\u0000${String(column.name || '').trim().toLowerCase()}`,
+                                  column,
+                              ]),
+                          );
+                          fetchedColumns.forEach((column) => {
+                              nextColumnByKey.set(
+                                  `${String(column.dbName || '').trim().toLowerCase()}\u0000${String(column.tableName || '').trim().toLowerCase()}\u0000${String(column.name || '').trim().toLowerCase()}`,
+                                  column,
+                              );
+                          });
+                          allColumnsRef.current = [...nextColumnByKey.values()];
+                          sharedAllColumnsData = allColumnsRef.current;
+                      }
+                  }
+              } catch (error) {
+                  console.warn('GoNavi AI inline column metadata warmup failed', error);
+              }
+          }
+      })();
+
+      aiContextMetadataWarmupRef.current[warmupKey] = warmupPromise;
+      try {
+          await warmupPromise;
+      } finally {
+          delete aiContextMetadataWarmupRef.current[warmupKey];
+      }
+  }, [currentConnectionId, currentDb, tab.connectionId, tab.dbName]);
 
   useEffect(() => {
       if (!isExternalSQLFileTab) return;
@@ -2873,8 +3260,389 @@ const QueryEditor: React.FC<{ tab: TabData; isActive?: boolean }> = ({ tab, isAc
           sharedActiveEditorModelUri = String(editor.getModel?.()?.uri?.toString?.() || '');
       }
 
+      const mountedModel = editor.getModel?.();
+      if (mountedModel && typeof monaco?.editor?.setModelLanguage === 'function') {
+          monaco.editor.setModelLanguage(mountedModel, 'sql');
+      }
       editor.updateOptions?.(buildQueryEditorMonacoOptions(isObjectEditQueryTab));
+
+      aiInlineGhostVisibleContextKeyRef.current = editor.createContextKey?.(
+          QUERY_EDITOR_AI_INLINE_CONTEXT_KEY,
+          false,
+      ) || null;
+
+      const clearAiInlineGhostTimer = () => {
+          if (aiInlineGhostTimerRef.current !== null) {
+              clearTimeout(aiInlineGhostTimerRef.current);
+              aiInlineGhostTimerRef.current = null;
+          }
+      };
+
+      const clearAiInlineGhostDecorations = () => {
+          if (aiInlineGhostDecorationIdsRef.current.length === 0) {
+              return;
+          }
+          const nextDecorationIds = editor.deltaDecorations?.(
+              aiInlineGhostDecorationIdsRef.current,
+              [],
+          );
+          aiInlineGhostDecorationIdsRef.current = Array.isArray(nextDecorationIds) ? nextDecorationIds : [];
+      };
+
+      const clearAiInlineGhost = (cancelRequest = true) => {
+          clearAiInlineGhostTimer();
+          if (cancelRequest) {
+              aiInlineGhostRequestSeqRef.current += 1;
+          }
+          aiInlineGhostRef.current = null;
+          aiInlineGhostVisibleContextKeyRef.current?.set?.(false);
+          if (aiInlineGhostOverlayRef.current) {
+              aiInlineGhostOverlayRef.current.remove();
+              aiInlineGhostOverlayRef.current = null;
+          }
+          clearAiInlineGhostDecorations();
+      };
+
+      const triggerStructuredSqlSuggest = (source: string, defer = false) => {
+          const run = () => {
+              if (editorRef.current !== editor) {
+                  return;
+              }
+              editor.trigger?.(source, 'editor.action.triggerSuggest', undefined);
+          };
+          if (defer) {
+              window.setTimeout(run, 0);
+              return;
+          }
+          run();
+      };
+
+      const didModelContentAcceptCurrentAiInlineGhost = (event: any): boolean => {
+          const ghost = aiInlineGhostRef.current;
+          if (!ghost?.insertText) {
+              return false;
+          }
+          const changes = Array.isArray(event?.changes) ? event.changes : [];
+          return changes.some((change: any) => String(change?.text ?? '') === ghost.insertText);
+      };
+
+      const buildInlineGhostEditorSnapshot = (model: any, position: { lineNumber: number; column: number }): QueryEditorAiEditorSnapshot => {
+          const lineContent = String(model.getLineContent?.(position.lineNumber) || '');
+          const lineColumnIndex = Math.max(0, Math.min(Number(position.column || 1) - 1, lineContent.length));
+          const lineCount = Number(model.getLineCount?.() || position.lineNumber || 1);
+          return {
+              prefix: String(model.getValueInRange?.(new monaco.Range(1, 1, position.lineNumber, position.column)) || ''),
+              suffix: String(model.getValueInRange?.(new monaco.Range(
+                  position.lineNumber,
+                  position.column,
+                  lineCount,
+                  Number(model.getLineMaxColumn?.(lineCount) || position.column),
+              )) || ''),
+              currentLineBeforeCursor: lineContent.slice(0, lineColumnIndex),
+              currentLineAfterCursor: lineContent.slice(lineColumnIndex),
+          };
+      };
+
+      const buildInlineGhostEditorSnapshotFromInsertedTextRemoval = (
+          modelText: string,
+          rangeOffset: number,
+          removedTextLength: number,
+      ): QueryEditorAiEditorSnapshot | null => {
+          if (!Number.isFinite(rangeOffset)) {
+              return null;
+          }
+          const safeStart = Math.max(0, Math.min(Math.trunc(rangeOffset), modelText.length));
+          const safeEnd = Math.max(safeStart, Math.min(safeStart + Math.max(0, removedTextLength), modelText.length));
+          const textBeforeInsertion = `${modelText.slice(0, safeStart)}${modelText.slice(safeEnd)}`;
+          const prefix = textBeforeInsertion.slice(0, safeStart);
+          const suffix = textBeforeInsertion.slice(safeStart);
+          const lineStart = Math.max(0, prefix.lastIndexOf('\n') + 1);
+          const nextLineBreak = textBeforeInsertion.indexOf('\n', safeStart);
+          const lineEnd = nextLineBreak === -1 ? textBeforeInsertion.length : nextLineBreak;
+          return {
+              prefix,
+              suffix,
+              currentLineBeforeCursor: prefix.slice(lineStart).replace(/\r/g, ''),
+              currentLineAfterCursor: textBeforeInsertion.slice(safeStart, lineEnd).replace(/\r/g, ''),
+          };
+      };
+
+      const recoverStrayManualSqlCompletionMarker = (
+          model: any,
+          position: { lineNumber: number; column: number },
+          snapshot: QueryEditorAiEditorSnapshot,
+      ): {
+          position: { lineNumber: number; column: number };
+          snapshot: QueryEditorAiEditorSnapshot;
+          recovered: boolean;
+      } => {
+          const prefix = String(snapshot.prefix || '');
+          const lineBeforeCursor = String(snapshot.currentLineBeforeCursor || '');
+          if (!prefix.endsWith('\\') || !lineBeforeCursor.endsWith('\\')) {
+              return { position, snapshot, recovered: false };
+          }
+
+          const sanitizedSnapshot: QueryEditorAiEditorSnapshot = {
+              prefix: prefix.slice(0, -1),
+              suffix: String(snapshot.suffix || ''),
+              currentLineBeforeCursor: lineBeforeCursor.slice(0, -1),
+              currentLineAfterCursor: String(snapshot.currentLineAfterCursor || ''),
+          };
+          const intent = resolveQueryEditorInlineCompletionIntentDetails(sanitizedSnapshot);
+          if (intent.intent !== 'table_name' && intent.intent !== 'column_name') {
+              return { position, snapshot, recovered: false };
+          }
+
+          const startColumn = Math.max(1, position.column - 1);
+          const startPosition = { lineNumber: position.lineNumber, column: startColumn };
+          editor.executeEdits?.('gonavi-manual-sql-ai-strip-marker', [{
+              range: new monaco.Range(
+                  position.lineNumber,
+                  startColumn,
+                  position.lineNumber,
+                  position.column,
+              ),
+              text: '',
+              forceMoveMarkers: true,
+          }]);
+          editor.setPosition?.(startPosition);
+          syncQueryDraft(getEditorText());
+
+          return {
+              position: startPosition,
+              snapshot: buildInlineGhostEditorSnapshot(model, startPosition),
+              recovered: true,
+          };
+      };
+
+      const isInlineGhostSnapshotCurrent = (
+          model: any,
+          position: { lineNumber: number; column: number },
+          snapshot: QueryEditorAiEditorSnapshot,
+      ): boolean => {
+          const currentSnapshot = buildInlineGhostEditorSnapshot(model, position);
+          return currentSnapshot.prefix === snapshot.prefix
+              && currentSnapshot.suffix === snapshot.suffix
+              && currentSnapshot.currentLineBeforeCursor === snapshot.currentLineBeforeCursor
+              && currentSnapshot.currentLineAfterCursor === snapshot.currentLineAfterCursor;
+      };
+
+      const renderAiInlineGhost = (
+          model: any,
+          position: { lineNumber: number; column: number },
+          insertText: string,
+          snapshot: QueryEditorAiEditorSnapshot,
+      ) => {
+          const previewText = resolveInlineSqlGhostPreviewText(insertText);
+          if (!previewText) {
+              clearAiInlineGhost(false);
+              return;
+          }
+
+          const modelUri = String(model?.uri?.toString?.() || '');
+          aiInlineGhostRef.current = {
+              insertText,
+              modelUri,
+              position,
+              snapshot,
+          };
+          clearAiInlineGhostDecorations();
+          const visiblePosition = editor.getScrolledVisiblePosition?.(position);
+          const editorDomNode = editor.getDomNode?.();
+          if (!visiblePosition || !editorDomNode) {
+              clearAiInlineGhost(false);
+              return;
+          }
+
+          const overlay = aiInlineGhostOverlayRef.current || document.createElement('span');
+          if (!aiInlineGhostOverlayRef.current) {
+              overlay.className = 'gonavi-query-editor-ai-inline-ghost-overlay';
+              editorDomNode.appendChild(overlay);
+              aiInlineGhostOverlayRef.current = overlay;
+          }
+
+          const fontInfoOption = monaco.editor?.EditorOption?.fontInfo;
+          const fontInfo = fontInfoOption !== undefined ? editor.getOption?.(fontInfoOption) : null;
+          overlay.textContent = previewText;
+          overlay.style.left = `${Math.max(0, visiblePosition.left)}px`;
+          overlay.style.top = `${Math.max(0, visiblePosition.top)}px`;
+          overlay.style.height = `${Math.max(1, visiblePosition.height || fontInfo?.lineHeight || 20)}px`;
+          overlay.style.lineHeight = `${Math.max(1, visiblePosition.height || fontInfo?.lineHeight || 20)}px`;
+          if (fontInfo) {
+              overlay.style.fontFamily = String(fontInfo.fontFamily || '');
+              overlay.style.fontSize = `${Number(fontInfo.fontSize || 14)}px`;
+              overlay.style.fontWeight = String(fontInfo.fontWeight || 'normal');
+          }
+          aiInlineGhostVisibleContextKeyRef.current?.set?.(true);
+      };
+
+      const acceptAiInlineGhost = (): boolean => {
+          const ghost = aiInlineGhostRef.current;
+          const model = editor.getModel?.();
+          const position = normalizeEditorPosition(editor.getPosition?.());
+          if (!ghost || !model || !position) {
+              return false;
+          }
+          const modelUri = String(model?.uri?.toString?.() || '');
+          if (
+              ghost.modelUri !== modelUri
+              || ghost.position.lineNumber !== position.lineNumber
+              || ghost.position.column !== position.column
+              || !isInlineGhostSnapshotCurrent(model, position, ghost.snapshot)
+          ) {
+              clearAiInlineGhost();
+              return false;
+          }
+
+          aiInlineGhostAcceptingRef.current = true;
+          try {
+              editor.pushUndoStop?.();
+              const startOffset = typeof model.getOffsetAt === 'function'
+                  ? Number(model.getOffsetAt(position))
+                  : Number.NaN;
+              editor.executeEdits?.('gonavi-ai-inline-sql-completion', [{
+                  range: new monaco.Range(
+                      position.lineNumber,
+                      position.column,
+                      position.lineNumber,
+                      position.column,
+                  ),
+                  text: ghost.insertText,
+                  forceMoveMarkers: true,
+              }]);
+              editor.pushUndoStop?.();
+              syncQueryDraft(String(editor.getValue?.() ?? model.getValue?.() ?? ''));
+              if (Number.isFinite(startOffset) && typeof model.getPositionAt === 'function') {
+                  const nextPosition = normalizeEditorPosition(model.getPositionAt(startOffset + ghost.insertText.length));
+                  if (nextPosition) {
+                      editor.setPosition?.(nextPosition);
+                  }
+              }
+          } finally {
+              aiInlineGhostAcceptingRef.current = false;
+              clearAiInlineGhost();
+          }
+          requestAiInlineGhost(0);
+          return true;
+      };
+
+      const requestAiInlineGhost = (delayMs: number, focusEditor = false, manualTrigger = false) => {
+          clearAiInlineGhost();
+          if (aiInlineGhostAcceptingRef.current || editorRef.current !== editor) {
+              return;
+          }
+          if (focusEditor) {
+              editor.focus?.();
+          }
+
+          const model = editor.getModel?.();
+          let position = normalizeEditorPosition(editor.getPosition?.());
+          if (!model || !position) {
+              return;
+          }
+
+          const modelUri = String(model?.uri?.toString?.() || '');
+          if (modelUri && sharedActiveEditorModelUri && modelUri !== sharedActiveEditorModelUri) {
+              return;
+          }
+
+          let editorSnapshot = buildInlineGhostEditorSnapshot(model, position);
+          if (manualTrigger) {
+              const normalizedState = recoverStrayManualSqlCompletionMarker(model, position, editorSnapshot);
+              position = normalizedState.position;
+              editorSnapshot = normalizedState.snapshot;
+          }
+          const intent = resolveQueryEditorInlineCompletionIntentDetails(editorSnapshot);
+          const shouldUseInlineMemory = manualTrigger || intent.intent !== 'general_sql';
+          if (shouldUseInlineMemory) {
+              const memoryInsertText = resolveQueryEditorInlineMemoryInsertText({
+                  editorSnapshot,
+                  memoryEntries: inlineSqlMemoryEntries,
+              });
+              if (memoryInsertText.trim()) {
+                  renderAiInlineGhost(model, position, memoryInsertText, editorSnapshot);
+                  return;
+              }
+          }
+          if (!shouldRequestQueryEditorInlineCompletion(editorSnapshot)) {
+              return;
+          }
+
+          const requestId = ++aiInlineGhostRequestSeqRef.current;
+          const runRequest = () => {
+              if (aiInlineGhostTimerRef.current !== null) {
+                  aiInlineGhostTimerRef.current = null;
+              }
+          void (async () => {
+                  if (
+                      requestId !== aiInlineGhostRequestSeqRef.current
+                      || editorRef.current !== editor
+                  ) {
+                      return;
+                  }
+                  try {
+                      await ensureQueryEditorAiContextMetadata(editorSnapshot);
+                      const insertText = await requestQueryEditorInlineCompletion({
+                          service: getQueryEditorAiService(),
+                          aiContext: buildQueryEditorAiContext(),
+                          editorSnapshot,
+                      });
+                      const currentPosition = normalizeEditorPosition(editor.getPosition?.());
+                      if (
+                          requestId !== aiInlineGhostRequestSeqRef.current
+                          || !currentPosition
+                          || currentPosition.lineNumber !== position.lineNumber
+                          || currentPosition.column !== position.column
+                          || !isInlineGhostSnapshotCurrent(model, currentPosition, editorSnapshot)
+                          ) {
+                          return;
+                      }
+                      if (!insertText.trim()) {
+                          if (intent.intent === 'table_name' || intent.intent === 'column_name') {
+                              const shouldTriggerStructuredSuggest = manualTrigger
+                                  || shouldTriggerQueryEditorInlineObjectSuggestFallback({
+                                      aiContext: buildQueryEditorAiContext(),
+                                      editorSnapshot,
+                                  });
+                              if (shouldTriggerStructuredSuggest) {
+                                  triggerStructuredSqlSuggest(
+                                      manualTrigger ? 'gonavi-ai-inline-manual' : 'gonavi-ai-inline-auto',
+                                      !manualTrigger,
+                                  );
+                              }
+                          }
+                          return;
+                      }
+                      renderAiInlineGhost(model, position, insertText, editorSnapshot);
+                  } catch (error) {
+                      console.warn('GoNavi AI inline SQL ghost failed', error);
+                  }
+              })();
+          };
+
+          if (delayMs > 0) {
+              aiInlineGhostTimerRef.current = setTimeout(runRequest, delayMs);
+              return;
+          }
+          runRequest();
+      };
+
+      const scheduleAiInlineGhost = () => {
+          requestAiInlineGhost(QUERY_EDITOR_AI_INLINE_DEBOUNCE_MS);
+      };
+
+      triggerAiInlineCompletionRef.current = () => {
+          requestAiInlineGhost(0, true, true);
+      };
+
       if (monaco?.KeyCode?.RightArrow) {
+          editor.addCommand?.(
+              monaco.KeyCode.RightArrow,
+              () => {
+                  acceptAiInlineGhost();
+              },
+              QUERY_EDITOR_AI_INLINE_CONTEXT_KEY,
+          );
           editor.addCommand?.(
               monaco.KeyCode.RightArrow,
               () => {
@@ -2884,6 +3652,20 @@ const QueryEditor: React.FC<{ tab: TabData; isActive?: boolean }> = ({ tab, isAc
           );
       }
 
+      const repositionAiInlineGhost = () => {
+          const ghost = aiInlineGhostRef.current;
+          const model = editor.getModel?.();
+          if (!ghost || !model) {
+              return;
+          }
+          const modelUri = String(model?.uri?.toString?.() || '');
+          if (ghost.modelUri !== modelUri) {
+              clearAiInlineGhost();
+              return;
+          }
+          renderAiInlineGhost(model, ghost.position, ghost.insertText, ghost.snapshot);
+      };
+
       const applyNavigationHoverStateAtPosition = (targetPosition: { lineNumber: number; column: number } | null) => {
           if (!ctrlMetaPressedRef.current) {
               clearQueryEditorLinkDecorations(editor, linkDecorationIdsRef);
@@ -3131,13 +3913,152 @@ const QueryEditor: React.FC<{ tab: TabData; isActive?: boolean }> = ({ tab, isAc
           if (position) {
               lastEditorCursorPositionRef.current = position;
           }
+          const ghost = aiInlineGhostRef.current;
+          if (
+              ghost
+              && (!position
+                  || ghost.position.lineNumber !== position.lineNumber
+                  || ghost.position.column !== position.column)
+          ) {
+              clearAiInlineGhost();
+          }
       });
 
+      const recoverTriggerSqlAiCompletionFallback = (event: any): boolean => {
+          if (triggerSqlAiCompletionFallbackApplyingRef.current) {
+              return true;
+          }
+
+          const pending = triggerSqlAiCompletionFallbackRef.current;
+          const altGestureAge = Date.now() - Number(triggerSqlAiCompletionAltGestureAtRef.current || 0);
+          const hasRecentAltGesture = altGestureAge >= 0 && altGestureAge <= 1200;
+          const changes = Array.isArray(event?.changes) ? event.changes : [];
+          const backslashChange = changes.find((change: any) => String(change?.text ?? '') === '\\');
+          if (!backslashChange) {
+              if (pending && (Date.now() - pending.observedAt) > 1200) {
+                  triggerSqlAiCompletionFallbackRef.current = null;
+              }
+              return false;
+          }
+
+          const model = editor.getModel?.();
+          if (!model || typeof model.getOffsetAt !== 'function' || typeof model.getValue !== 'function') {
+              return false;
+          }
+
+          let markerOffset = Number.NaN;
+          let startPosition = normalizeEditorPosition(backslashChange?.range
+              ? {
+                  lineNumber: Number(backslashChange.range.startLineNumber || 1),
+                  column: Number(backslashChange.range.startColumn || 1),
+              }
+              : null);
+          let endPosition = normalizeEditorPosition(backslashChange?.range
+              ? {
+                  lineNumber: Number(backslashChange.range.endLineNumber || 1),
+                  column: Number(backslashChange.range.endColumn || 1),
+              }
+              : null);
+
+          const rangeOffset = Number(backslashChange?.rangeOffset);
+          if (Number.isFinite(rangeOffset)) {
+              markerOffset = rangeOffset;
+          } else if (startPosition) {
+              markerOffset = Number(model.getOffsetAt(startPosition));
+          } else {
+              const currentPosition = normalizeEditorPosition(editor.getPosition?.());
+              const currentOffset = currentPosition ? Number(model.getOffsetAt(currentPosition)) : Number.NaN;
+              if (Number.isFinite(currentOffset) && currentOffset > 0) {
+                  markerOffset = currentOffset - 1;
+              }
+          }
+
+          if (!Number.isFinite(markerOffset) || markerOffset < 0) {
+              return false;
+          }
+          const currentModelText = String(model?.getValue?.() ?? '');
+          if (currentModelText.slice(markerOffset, markerOffset + 1) !== '\\') {
+              return false;
+          }
+          startPosition = normalizeEditorPosition(model?.getPositionAt?.(markerOffset));
+          endPosition = normalizeEditorPosition(model?.getPositionAt?.(markerOffset + 1));
+          const fallbackSnapshot = buildInlineGhostEditorSnapshotFromInsertedTextRemoval(
+              currentModelText,
+              markerOffset,
+              1,
+          );
+          const fallbackIntent = fallbackSnapshot
+              ? resolveQueryEditorInlineCompletionIntentDetails(fallbackSnapshot)
+              : null;
+          const hasStructuredSqlCompletionContext = fallbackIntent?.intent === 'table_name'
+              || fallbackIntent?.intent === 'column_name';
+          if (!pending && !hasRecentAltGesture && !hasStructuredSqlCompletionContext) {
+              return false;
+          }
+          if (pending && (Date.now() - pending.observedAt) > 1200) {
+              triggerSqlAiCompletionFallbackRef.current = null;
+              if (!hasRecentAltGesture && !hasStructuredSqlCompletionContext) {
+                  return false;
+              }
+          }
+
+          if (!startPosition || !endPosition) {
+              return false;
+          }
+
+          triggerSqlAiCompletionFallbackRef.current = null;
+          triggerSqlAiCompletionFallbackApplyingRef.current = true;
+          try {
+              editor.executeEdits?.('gonavi-trigger-sql-ai-completion-fallback', [{
+                  range: new monaco.Range(
+                      startPosition.lineNumber,
+                      startPosition.column,
+                      endPosition.lineNumber,
+                      endPosition.column,
+                  ),
+                  text: '',
+                  forceMoveMarkers: true,
+              }]);
+              editor.setPosition?.(startPosition);
+              syncQueryDraft(getEditorText());
+          } finally {
+              triggerSqlAiCompletionFallbackApplyingRef.current = false;
+          }
+          triggerAiInlineCompletionRef.current?.();
+          return true;
+      };
+
       editor.onDidChangeModelContent?.((event: any) => {
+          if (recoverTriggerSqlAiCompletionFallback(event)) {
+              return;
+          }
           const hasSlashCommandMarker = Array.isArray(event?.changes)
               && event.changes.some((change: any) => /__AI_\w+__/.test(String(change?.text || '')));
-          if (!hasSlashCommandMarker) return;
-          refreshObjectDecorations(QUERY_EDITOR_LIVE_DECORATION_MAX_TEXT_LENGTH);
+          if (hasSlashCommandMarker) {
+              refreshObjectDecorations(QUERY_EDITOR_LIVE_DECORATION_MAX_TEXT_LENGTH);
+          }
+          const acceptedCurrentAiGhost = !aiInlineGhostAcceptingRef.current
+              && didModelContentAcceptCurrentAiInlineGhost(event);
+          if (acceptedCurrentAiGhost) {
+              clearAiInlineGhost(false);
+              window.setTimeout(() => {
+                  if (editorRef.current !== editor) {
+                      return;
+                  }
+                  requestAiInlineGhost(0);
+              }, 0);
+              return;
+          }
+          if (!aiInlineGhostAcceptingRef.current) {
+              scheduleAiInlineGhost();
+          }
+      });
+
+      editor.onDidScrollChange?.(() => {
+          repositionAiInlineGhost();
+      });
+      editor.onDidLayoutChange?.(() => {
+          repositionAiInlineGhost();
       });
 
       editor.onMouseMove?.((event: any) => {
@@ -3263,6 +4184,11 @@ const QueryEditor: React.FC<{ tab: TabData; isActive?: boolean }> = ({ tab, isAc
           setQueryEditorMouseCursor(editor, '');
           objectHoverActionRef.current?.dispose?.();
           objectHoverActionRef.current = null;
+          triggerSqlAiCompletionActionRef.current?.dispose?.();
+          triggerSqlAiCompletionActionRef.current = null;
+          triggerSqlAiCompletionKeydownDisposableRef.current?.dispose?.();
+          triggerSqlAiCompletionKeydownDisposableRef.current = null;
+          triggerAiInlineCompletionRef.current = null;
           const disposedModelUri = String(editor.getModel?.()?.uri?.toString?.() || '');
           if (disposedModelUri && sharedActiveEditorModelUri === disposedModelUri) {
               sharedActiveEditorModelUri = '';
@@ -3284,6 +4210,7 @@ const QueryEditor: React.FC<{ tab: TabData; isActive?: boolean }> = ({ tab, isAc
       // 注册 AI 右键菜单操作
       registerQueryEditorAiContextMenuActions(editor);
       registerInsertSqlSnippetContextMenuAction(editor);
+      registerTriggerSqlAiCompletionAction(editor, monaco);
 
       // Register runQuery shortcut inside Monaco so it overrides Monaco's default keybinding
       const runBinding = runQueryShortcutBinding;
@@ -4226,87 +5153,6 @@ const QueryEditor: React.FC<{ tab: TabData; isActive?: boolean }> = ({ tab, isAc
           },
       }));
 
-      if (typeof monaco.languages.registerInlineCompletionsProvider === 'function') {
-          sqlCompletionDisposables.push(monaco.languages.registerInlineCompletionsProvider('sql', {
-              groupId: 'gonavi-query-editor-ai',
-              displayName: 'GoNavi AI SQL',
-              debounceDelayMs: 650,
-              provideInlineCompletions: async (model: any, position: any, context: any, token: any) => {
-                  if (context?.includeInlineCompletions === false || token?.isCancellationRequested) {
-                      return { items: [] };
-                  }
-
-                  const modelUri = String(model?.uri?.toString?.() || '');
-                  if (!modelUri || modelUri !== sharedActiveEditorModelUri) {
-                      return { items: [] };
-                  }
-
-                  const lineContent = String(model.getLineContent?.(position.lineNumber) || '');
-                  const lineColumnIndex = Math.max(0, Math.min(Number(position.column || 1) - 1, lineContent.length));
-                  const lineCount = Number(model.getLineCount?.() || position.lineNumber || 1);
-                  const prefixRange = new monaco.Range(1, 1, position.lineNumber, position.column);
-                  const suffixRange = new monaco.Range(
-                      position.lineNumber,
-                      position.column,
-                      lineCount,
-                      Number(model.getLineMaxColumn?.(lineCount) || position.column),
-                  );
-                  const editorSnapshot = {
-                      prefix: String(model.getValueInRange?.(prefixRange) || ''),
-                      suffix: String(model.getValueInRange?.(suffixRange) || ''),
-                      currentLineBeforeCursor: lineContent.slice(0, lineColumnIndex),
-                      currentLineAfterCursor: lineContent.slice(lineColumnIndex),
-                  };
-                  if (!shouldRequestQueryEditorInlineCompletion(editorSnapshot)) {
-                      return { items: [] };
-                  }
-
-                  const versionId = Number(model.getVersionId?.() || 0);
-                  const requestId = ++sharedAiInlineCompletionRequestSeq;
-                  try {
-                      const insertText = await requestQueryEditorInlineCompletion({
-                          service: getQueryEditorAiService(),
-                          aiContext: {
-                              connectionName: sharedConnections.find(c => c.id === sharedCurrentConnectionId)?.name,
-                              sourceType: sharedConnections.find(c => c.id === sharedCurrentConnectionId)?.config?.type,
-                              currentDb: sharedCurrentDb,
-                              visibleDbs: sharedVisibleDbs,
-                              tables: sharedTablesData,
-                              columns: sharedAllColumnsData,
-                          },
-                          editorSnapshot,
-                      });
-                      if (
-                          token?.isCancellationRequested
-                          || requestId !== sharedAiInlineCompletionRequestSeq
-                          || (versionId && Number(model.getVersionId?.() || 0) !== versionId)
-                          || !insertText.trim()
-                      ) {
-                          return { items: [] };
-                      }
-
-                      return {
-                          items: [{
-                              insertText,
-                              range: new monaco.Range(
-                                  position.lineNumber,
-                                  position.column,
-                                  position.lineNumber,
-                                  position.column,
-                              ),
-                          }],
-                          suppressSuggestions: false,
-                          enableForwardStability: true,
-                      };
-                  } catch (error) {
-                      console.warn('GoNavi AI inline SQL completion failed', error);
-                      return { items: [] };
-                  }
-              },
-              disposeInlineCompletions: () => {},
-          }));
-      }
-
       } // end sqlCompletionRegistered guard
 
       // 每个编辑器实例都注册内容变化监听（检测斜杠命令标记）
@@ -5666,6 +6512,61 @@ const QueryEditor: React.FC<{ tab: TabData; isActive?: boolean }> = ({ tab, isAc
       };
   }, [languagePreference, registerInsertSqlSnippetContextMenuAction]);
 
+  useEffect(() => {
+      const editor = editorRef.current;
+      const monaco = monacoRef.current;
+      if (!editor || !monaco) return;
+
+      registerTriggerSqlAiCompletionAction(editor, monaco);
+
+      return () => {
+          if (triggerSqlAiCompletionActionRef.current) {
+              triggerSqlAiCompletionActionRef.current.dispose();
+              triggerSqlAiCompletionActionRef.current = null;
+          }
+      };
+  }, [languagePreference, registerTriggerSqlAiCompletionAction]);
+
+  useEffect(() => {
+      triggerSqlAiCompletionKeydownDisposableRef.current?.dispose?.();
+      triggerSqlAiCompletionKeydownDisposableRef.current = null;
+
+      const editor = editorRef.current;
+      const binding = triggerSqlAiCompletionShortcutBinding;
+      if (!editor?.onKeyDown || !binding?.enabled || !binding.combo) {
+          return;
+      }
+
+      triggerSqlAiCompletionKeydownDisposableRef.current = editor.onKeyDown((event: any) => {
+          if (!isActive) {
+              return;
+          }
+
+          const browserEvent = event?.browserEvent || event?.event || event;
+          if (!browserEvent) {
+              return;
+          }
+          if (!isTriggerSqlAiCompletionShortcutEvent(browserEvent)) {
+              if (isPossibleTriggerSqlAiCompletionFallbackEvent(browserEvent)) {
+                  triggerSqlAiCompletionFallbackRef.current = { observedAt: Date.now() };
+              }
+              return;
+          }
+
+          triggerSqlAiCompletionFallbackRef.current = null;
+          event?.preventDefault?.();
+          event?.stopPropagation?.();
+          browserEvent.preventDefault?.();
+          browserEvent.stopPropagation?.();
+          triggerAiInlineCompletionRef.current?.();
+      });
+
+      return () => {
+          triggerSqlAiCompletionKeydownDisposableRef.current?.dispose?.();
+          triggerSqlAiCompletionKeydownDisposableRef.current = null;
+      };
+  }, [isActive, isPossibleTriggerSqlAiCompletionFallbackEvent, isTriggerSqlAiCompletionShortcutEvent, triggerSqlAiCompletionShortcutBinding]);
+
   useEffect(() => {
       if (runQueryActionRef.current) {
           runQueryActionRef.current.dispose();
@@ -6371,6 +7272,74 @@ const QueryEditor: React.FC<{ tab: TabData; isActive?: boolean }> = ({ tab, isAc
       };
   }, [isActive, formatSqlShortcutBinding]);
 
+  useEffect(() => {
+      const updateAltState = (event: KeyboardEvent) => {
+          const key = String(event.key || '').trim().toLowerCase();
+          const code = String(event.code || '').trim().toLowerCase();
+          const isAltKey = key === 'alt'
+              || code === 'altleft'
+              || code === 'altright';
+          if (isAltKey) {
+              if (event.type === 'keydown') {
+                  triggerSqlAiCompletionAltGestureAtRef.current = Date.now();
+              }
+              triggerSqlAiCompletionAltPressedRef.current = event.type !== 'keyup';
+          } else if (event.type === 'keyup' && !event.altKey) {
+              triggerSqlAiCompletionAltPressedRef.current = false;
+          }
+      };
+      const clearAltState = () => {
+          triggerSqlAiCompletionAltPressedRef.current = false;
+          triggerSqlAiCompletionAltGestureAtRef.current = 0;
+          triggerSqlAiCompletionFallbackRef.current = null;
+      };
+
+      window.addEventListener('keydown', updateAltState, true);
+      window.addEventListener('keyup', updateAltState, true);
+      window.addEventListener('blur', clearAltState);
+      return () => {
+          window.removeEventListener('keydown', updateAltState, true);
+          window.removeEventListener('keyup', updateAltState, true);
+          window.removeEventListener('blur', clearAltState);
+      };
+  }, []);
+
+  useEffect(() => {
+      const binding = triggerSqlAiCompletionShortcutBinding;
+      if (!binding?.enabled || !binding.combo) {
+          return;
+      }
+
+      const handleTriggerSqlAiCompletionShortcut = (event: KeyboardEvent) => {
+          if (!isActive) {
+              return;
+          }
+          const editor = editorRef.current;
+          const targetNode = resolveEventTargetNode(event.target);
+          const editorHasFocus = !!editor?.hasTextFocus?.();
+          const inQueryEditor = !!(targetNode && queryEditorRootRef.current?.contains(targetNode));
+          if (!editorHasFocus && !inQueryEditor && !isDocumentLevelShortcutTarget(targetNode)) {
+              return;
+          }
+          if (!isTriggerSqlAiCompletionShortcutEvent(event)) {
+              if (isPossibleTriggerSqlAiCompletionFallbackEvent(event)) {
+                  triggerSqlAiCompletionFallbackRef.current = { observedAt: Date.now() };
+              }
+              return;
+          }
+
+          triggerSqlAiCompletionFallbackRef.current = null;
+          event.preventDefault();
+          event.stopPropagation();
+          triggerAiInlineCompletionRef.current?.();
+      };
+
+      window.addEventListener('keydown', handleTriggerSqlAiCompletionShortcut, true);
+      return () => {
+          window.removeEventListener('keydown', handleTriggerSqlAiCompletionShortcut, true);
+      };
+  }, [isActive, isPossibleTriggerSqlAiCompletionFallbackEvent, isTriggerSqlAiCompletionShortcutEvent, triggerSqlAiCompletionShortcutBinding]);
+
   useEffect(() => {
       const binding = toggleQueryResultsPanelShortcutBinding;
       if (!binding?.enabled || !binding.combo) {
@@ -6563,6 +7532,7 @@ const QueryEditor: React.FC<{ tab: TabData; isActive?: boolean }> = ({ tab, isAc
         runQueryShortcutBinding={runQueryShortcutBinding}
         saveQueryShortcutBinding={saveQueryShortcutBinding}
         formatSqlShortcutBinding={formatSqlShortcutBinding}
+        triggerSqlAiCompletionShortcutBinding={triggerSqlAiCompletionShortcutBinding}
         toggleQueryResultsPanelShortcutBinding={toggleQueryResultsPanelShortcutBinding}
         activeShortcutPlatform={activeShortcutPlatform}
         isResultPanelVisible={isResultPanelVisible}
@@ -6587,6 +7557,7 @@ const QueryEditor: React.FC<{ tab: TabData; isActive?: boolean }> = ({ tab, isAc
         onQuickSave={handleQuickSave}
         onFindInEditor={handleOpenEditorFind}
         onFormat={handleFormat}
+        onTriggerSqlAiCompletion={() => triggerAiInlineCompletionRef.current?.()}
         onToggleResultPanelVisibility={toggleResultPanelVisibility}
         onAIAction={handleAIAction}
       />
diff --git a/frontend/src/components/QueryEditorToolbar.ai-trigger.test.tsx b/frontend/src/components/QueryEditorToolbar.ai-trigger.test.tsx
new file mode 100644
index 00000000..af4bc60f
--- /dev/null
+++ b/frontend/src/components/QueryEditorToolbar.ai-trigger.test.tsx
@@ -0,0 +1,17 @@
+import { readFileSync } from 'node:fs';
+import { describe, expect, it } from 'vitest';
+
+const source = readFileSync(new URL('./QueryEditorToolbar.tsx', import.meta.url), 'utf8');
+
+describe('QueryEditorToolbar AI trigger affordance', () => {
+  it('keeps a direct toolbar trigger for inline AI completion', () => {
+    expect(source).toContain('onMouseDown={onCaptureEditorCursorPosition}');
+    expect(source).toContain('onClick={onTriggerSqlAiCompletion}');
+    expect(source).toContain('triggerSqlAiCompletionLabel');
+  });
+
+  it('keeps the secondary AI dropdown for other actions', () => {
+    expect(source).toContain('icon={<DownOutlined />}');
+    expect(source).toContain('menu={{ items: aiMenuItems }}');
+  });
+});
diff --git a/frontend/src/components/QueryEditorToolbar.tsx b/frontend/src/components/QueryEditorToolbar.tsx
index b62a1d66..382fccf0 100644
--- a/frontend/src/components/QueryEditorToolbar.tsx
+++ b/frontend/src/components/QueryEditorToolbar.tsx
@@ -1,6 +1,7 @@
 import React from "react";
 import { Button, Dropdown, Select, Tooltip, type MenuProps } from "antd";
 import {
+  DownOutlined,
   EyeInvisibleOutlined,
   EyeOutlined,
   FormatPainterOutlined,
@@ -37,6 +38,7 @@ type QueryEditorToolbarProps = {
   runQueryShortcutBinding: ShortcutPlatformBinding;
   saveQueryShortcutBinding: ShortcutPlatformBinding;
   formatSqlShortcutBinding: ShortcutPlatformBinding;
+  triggerSqlAiCompletionShortcutBinding: ShortcutPlatformBinding;
   toggleQueryResultsPanelShortcutBinding: ShortcutPlatformBinding;
   activeShortcutPlatform: ShortcutPlatform;
   isResultPanelVisible: boolean;
@@ -54,6 +56,7 @@ type QueryEditorToolbarProps = {
   onQuickSave: () => void;
   onFindInEditor: () => void;
   onFormat: () => void;
+  onTriggerSqlAiCompletion: () => void;
   onToggleResultPanelVisibility: () => void;
   onAIAction: (action: "generate" | "explain" | "optimize" | "schema") => void;
 };
@@ -99,6 +102,7 @@ const QueryEditorToolbar: React.FC<QueryEditorToolbarProps> = ({
   runQueryShortcutBinding,
   saveQueryShortcutBinding,
   formatSqlShortcutBinding,
+  triggerSqlAiCompletionShortcutBinding,
   toggleQueryResultsPanelShortcutBinding,
   activeShortcutPlatform,
   isResultPanelVisible,
@@ -116,6 +120,7 @@ const QueryEditorToolbar: React.FC<QueryEditorToolbarProps> = ({
   onQuickSave,
   onFindInEditor,
   onFormat,
+  onTriggerSqlAiCompletion,
   onToggleResultPanelVisibility,
   onAIAction,
 }) => {
@@ -175,7 +180,22 @@ const QueryEditorToolbar: React.FC<QueryEditorToolbarProps> = ({
       ),
     },
   );
+  const triggerSqlAiCompletionLabel =
+    triggerSqlAiCompletionShortcutBinding.enabled &&
+    triggerSqlAiCompletionShortcutBinding.combo
+      ? `${t("app.shortcuts.action.triggerSqlAiCompletion.label")} · ${getShortcutDisplayLabel(
+          triggerSqlAiCompletionShortcutBinding.combo,
+          activeShortcutPlatform,
+        )}`
+      : t("app.shortcuts.action.triggerSqlAiCompletion.label");
   const aiMenuItems: MenuProps["items"] = [
+    {
+      key: "ai-inline-completion",
+      label: triggerSqlAiCompletionLabel,
+      icon: <RobotOutlined />,
+      onClick: onTriggerSqlAiCompletion,
+    },
+    { type: "divider" as const },
     {
       key: "ai-generate",
       label: t("query_editor.action.ai_text_to_sql_menu"),
@@ -359,19 +379,30 @@ const QueryEditorToolbar: React.FC<QueryEditorToolbarProps> = ({
             {t("query_editor.action.save")}
           </Button>
         </Tooltip>
-        <Dropdown
-          menu={{ items: aiMenuItems }}
-          placement="bottomRight"
-          trigger={["click"]}
-        >
-          <Button
-            className={isV2Ui ? "gn-v2-query-toolbar-ai-action" : undefined}
-            icon={<RobotOutlined />}
-            style={{ color: "#818cf8" }}
+        <div style={{ display: "flex", gap: "4px", alignItems: "center" }}>
+          <Tooltip title={triggerSqlAiCompletionLabel}>
+            <Button
+              className={isV2Ui ? "gn-v2-query-toolbar-ai-action" : undefined}
+              icon={<RobotOutlined />}
+              style={{ color: "#818cf8" }}
+              onMouseDown={onCaptureEditorCursorPosition}
+              onClick={onTriggerSqlAiCompletion}
+            >
+              AI
+            </Button>
+          </Tooltip>
+          <Dropdown
+            menu={{ items: aiMenuItems }}
+            placement="bottomRight"
+            trigger={["click"]}
           >
-            AI
-          </Button>
-        </Dropdown>
+            <Button
+              className={isV2Ui ? "gn-v2-query-toolbar-icon-action" : undefined}
+              icon={<DownOutlined />}
+              aria-label="AI more actions"
+            />
+          </Dropdown>
+        </div>
         <Dropdown
           menu={{ items: moreMenuItems }}
           placement="bottomRight"
diff --git a/frontend/src/components/ai/AISettingsProvidersSection.test.tsx b/frontend/src/components/ai/AISettingsProvidersSection.test.tsx
index d1242296..f8b1f1fd 100644
--- a/frontend/src/components/ai/AISettingsProvidersSection.test.tsx
+++ b/frontend/src/components/ai/AISettingsProvidersSection.test.tsx
@@ -38,6 +38,10 @@ const REQUIRED_PROVIDER_FORM_KEYS = [
   'ai_settings.form.model_list_placeholder',
   'ai_settings.form.model_list_placeholder.codebuddy',
   'ai_settings.form.model_list_placeholder.cursor',
+  'ai_settings.form.section.inline_completion',
+  'ai_settings.form.inline_completion_model',
+  'ai_settings.form.inline_completion_model_hint',
+  'ai_settings.form.inline_completion_model_placeholder',
   'ai_settings.form.api_key',
   'ai_settings.form.api_key.codebuddy_optional',
   'ai_settings.form.api_key.codebuddy_hint',
@@ -158,6 +162,8 @@ describe('AISettingsProvidersSection', () => {
     const markup = renderToStaticMarkup(<Wrap />);
     expect(markup).toContain('Edit model provider');
     expect(markup).toContain('Provider name');
+    expect(markup).toContain('SQL auto-completion');
+    expect(markup).toContain('Auto-completion model');
     expect(markup).toContain('API Endpoint (URL)');
     expect(markup).toContain('Test connection');
   });
diff --git a/frontend/src/components/ai/AISettingsProvidersSection.tsx b/frontend/src/components/ai/AISettingsProvidersSection.tsx
index a0a20c73..4a70f517 100644
--- a/frontend/src/components/ai/AISettingsProvidersSection.tsx
+++ b/frontend/src/components/ai/AISettingsProvidersSection.tsx
@@ -21,6 +21,8 @@ export interface AISettingsProviderPresetOption {
   icon: React.ReactNode;
   desc: string;
   defaultBaseUrl: string;
+  defaultModel?: string;
+  models?: string[];
 }
 
 interface MatchedProviderPreset {
@@ -116,6 +118,31 @@ const AISettingsProvidersSection: React.FC<AISettingsProvidersSectionProps> = ({
   const sectionLabelColor = darkMode ? 'rgba(255,255,255,0.5)' : 'rgba(0,0,0,0.4)';
   const currentFieldGroupStyle = fieldGroupStyle(cardBorder, cardBg);
   const currentFieldLabelStyle = fieldLabelStyle(sectionLabelColor);
+  const watchedModel = Form.useWatch('model', form);
+  const watchedModels = Form.useWatch('models', form);
+  const watchedInlineCompletionModel = Form.useWatch('inlineCompletionModel', form);
+  const presetFromForm = providerPresets.find((preset) => preset.key === presetKeyFromForm);
+  const inlineCompletionModelOptions = React.useMemo(() => {
+    const values = [
+      watchedModel,
+      presetFromForm?.defaultModel,
+      ...(Array.isArray(presetFromForm?.models) ? presetFromForm.models : []),
+      ...(Array.isArray(watchedModels) ? watchedModels : []),
+      editingProvider?.inlineCompletionModel,
+      watchedInlineCompletionModel,
+    ];
+    const deduped = new Set<string>();
+    values.forEach((value) => {
+      const normalized = String(value || '').trim();
+      if (normalized) {
+        deduped.add(normalized);
+      }
+    });
+    return Array.from(deduped).map((value) => ({
+      label: value,
+      value,
+    }));
+  }, [editingProvider?.inlineCompletionModel, presetFromForm?.defaultModel, presetFromForm?.models, watchedInlineCompletionModel, watchedModel, watchedModels]);
 
   if (!isEditing) {
     return (
@@ -343,6 +370,28 @@ const AISettingsProvidersSection: React.FC<AISettingsProvidersSectionProps> = ({
         <Form.Item name="model" hidden><Input /></Form.Item>
         <Form.Item name="name" hidden><Input /></Form.Item>
 
+        <div style={{ ...currentFieldGroupStyle, marginTop: 16 }}>
+          <div style={currentFieldLabelStyle}>
+            <RobotOutlined style={{ fontSize: 14 }} /> {copy('ai_settings.form.section.inline_completion')}
+          </div>
+          <Form.Item
+            label={<span style={{ fontWeight: 500, color: overlayTheme.titleText }}>{copy('ai_settings.form.inline_completion_model')}</span>}
+            name="inlineCompletionModel"
+            extra={copy('ai_settings.form.inline_completion_model_hint')}
+            style={{ marginBottom: 0 }}
+          >
+            <Select
+              allowClear
+              showSearch
+              optionFilterProp="label"
+              size="middle"
+              placeholder={copy('ai_settings.form.inline_completion_model_placeholder')}
+              options={inlineCompletionModelOptions}
+              style={{ width: '100%' }}
+            />
+          </Form.Item>
+        </div>
+
         <div style={{ ...currentFieldGroupStyle, marginTop: 16 }}>
           <div style={currentFieldLabelStyle}>
             <KeyOutlined style={{ fontSize: 14 }} /> {copy('ai_settings.form.section.auth_connection')}
diff --git a/frontend/src/components/queryEditor/QueryEditorAiAssist.test.ts b/frontend/src/components/queryEditor/QueryEditorAiAssist.test.ts
index 65d4ae1c..8f35fd08 100644
--- a/frontend/src/components/queryEditor/QueryEditorAiAssist.test.ts
+++ b/frontend/src/components/queryEditor/QueryEditorAiAssist.test.ts
@@ -1,12 +1,20 @@
 import { describe, expect, it, vi } from 'vitest';
 
 import {
+    buildQueryEditorAiInlineSuggestOptions,
     buildQueryEditorInlineCompletionMessages,
+    buildQueryEditorInlineCompletionContext,
     buildQueryEditorTextToSqlMessages,
     requestQueryEditorInlineCompletion,
+    resolveInlineSqlGhostPreviewText,
     resolveInlineSqlInsertText,
     resolveQueryEditorAiRuntimeReadiness,
+    resolveQueryEditorInlineMemoryInsertText,
+    resolveQueryEditorInlineCompletionModel,
+    resolveQueryEditorInlineCompletionIntentDetails,
     sanitizeSqlAssistantResponse,
+    shouldAllowQueryEditorInlineMemoryCompletion,
+    shouldTriggerQueryEditorInlineObjectSuggestFallback,
     shouldRequestQueryEditorInlineCompletion,
     type QueryEditorAiService,
 } from './QueryEditorAiAssist';
@@ -32,6 +40,17 @@ const readyService = (content = 'SELECT * FROM users;'): QueryEditorAiService =>
 });
 
 describe('QueryEditorAiAssist', () => {
+    it('keeps AI inline suggestions visible when normal SQL suggestions are open', () => {
+        expect(buildQueryEditorAiInlineSuggestOptions()).toMatchObject({
+            enabled: true,
+            mode: 'prefix',
+            suppressSuggestions: true,
+            experimental: {
+                showOnSuggestConflict: 'always',
+            },
+        });
+    });
+
     it('only requests inline completion in editable SQL context', () => {
         expect(shouldRequestQueryEditorInlineCompletion({
             prefix: 'select',
@@ -62,6 +81,41 @@ describe('QueryEditorAiAssist', () => {
         })).toBe(false);
     });
 
+    it('allows inline memory completion in empty or prefix-only editable SQL context', () => {
+        expect(shouldAllowQueryEditorInlineMemoryCompletion({
+            prefix: '',
+            suffix: '',
+            currentLineBeforeCursor: '',
+            currentLineAfterCursor: '',
+        })).toBe(true);
+
+        expect(resolveQueryEditorInlineMemoryInsertText({
+            editorSnapshot: {
+                prefix: '',
+                suffix: '',
+                currentLineBeforeCursor: '',
+                currentLineAfterCursor: '',
+            },
+            memoryEntries: [
+                { sql: 'SELECT * FROM videos WHERE code = ?;' },
+                { sql: 'UPDATE videos SET status = 1 WHERE id = ?;' },
+            ],
+        })).toBe('SELECT * FROM videos WHERE code = ?;');
+
+        expect(resolveQueryEditorInlineMemoryInsertText({
+            editorSnapshot: {
+                prefix: 'UPDATE',
+                suffix: '',
+                currentLineBeforeCursor: 'UPDATE',
+                currentLineAfterCursor: '',
+            },
+            memoryEntries: [
+                { sql: 'SELECT * FROM videos WHERE code = ?;' },
+                { sql: 'UPDATE videos SET status = 1 WHERE id = ?;' },
+            ],
+        })).toBe(' videos SET status = 1 WHERE id = ?;');
+    });
+
     it('sanitizes fenced SQL and removes duplicated typed prefixes', () => {
         expect(sanitizeSqlAssistantResponse('```sql\nselect * from users;\n```')).toBe('select * from users;');
         expect(sanitizeSqlAssistantResponse('SQL: select count(*) from orders;')).toBe('select count(*) from orders;');
@@ -69,18 +123,243 @@ describe('QueryEditorAiAssist', () => {
         expect(resolveInlineSqlInsertText('SELECT * FROM users;', 'select')).toBe(' * FROM users;');
         expect(resolveInlineSqlInsertText('from users;', 'select ')).toBe('from users;');
         expect(resolveInlineSqlInsertText('orders', 'select * from')).toBe(' orders');
+
+        expect(resolveInlineSqlGhostPreviewText(' * FROM users\nWHERE id = 1;')).toBe(' * FROM users WHERE id = 1;');
+    });
+
+    it('treats stray non-identifier markers in object-name positions as an empty fragment', () => {
+        expect(resolveQueryEditorInlineCompletionIntentDetails({
+            prefix: 'SELECT * FROM \\',
+            suffix: '',
+            currentLineBeforeCursor: 'SELECT * FROM \\',
+            currentLineAfterCursor: '',
+        })).toEqual({
+            intent: 'table_name',
+            fragment: '',
+            qualifier: '',
+        });
+
+        expect(resolveQueryEditorInlineCompletionIntentDetails({
+            prefix: 'SELECT * FROM videos v WHERE v.\\',
+            suffix: '',
+            currentLineBeforeCursor: 'SELECT * FROM videos v WHERE v.\\',
+            currentLineAfterCursor: '',
+        })).toEqual({
+            intent: 'column_name',
+            fragment: '',
+            qualifier: 'v',
+        });
+
+        expect(resolveQueryEditorInlineCompletionIntentDetails({
+            prefix: 'ALTER TABLE \\',
+            suffix: '',
+            currentLineBeforeCursor: 'ALTER TABLE \\',
+            currentLineAfterCursor: '',
+        })).toEqual({
+            intent: 'table_name',
+            fragment: '',
+            qualifier: '',
+        });
+    });
+
+    it('only keeps object-name suggest fallback for unresolved inline object positions', () => {
+        expect(shouldTriggerQueryEditorInlineObjectSuggestFallback({
+            aiContext: {
+                connectionName: 'Local MySQL',
+                sourceType: 'mysql',
+                currentDb: 'shop',
+                tables: [
+                    { dbName: 'shop', tableName: 'videos' },
+                    { dbName: 'shop', tableName: 'visits' },
+                ],
+                columns: [],
+            },
+            editorSnapshot: {
+                prefix: 'SELECT * FROM ',
+                suffix: '',
+                currentLineBeforeCursor: 'SELECT * FROM ',
+                currentLineAfterCursor: '',
+            },
+        })).toBe(true);
+
+        expect(shouldTriggerQueryEditorInlineObjectSuggestFallback({
+            aiContext: {
+                connectionName: 'Local MySQL',
+                sourceType: 'mysql',
+                currentDb: 'shop',
+                tables: [
+                    { dbName: 'shop', tableName: 'videos' },
+                    { dbName: 'shop', tableName: 'visits' },
+                ],
+                columns: [],
+            },
+            editorSnapshot: {
+                prefix: 'SELECT * FROM videos',
+                suffix: '',
+                currentLineBeforeCursor: 'SELECT * FROM videos',
+                currentLineAfterCursor: '',
+            },
+        })).toBe(false);
+    });
+
+    it('uses deterministic SQL skeletons for weak keyword-only contexts and skips AI', async () => {
+        const service = readyService('select * from users;');
+
+        await expect(requestQueryEditorInlineCompletion({
+            service,
+            aiContext: {
+                connectionName: 'Local MySQL',
+                sourceType: 'mysql',
+                currentDb: 'shop',
+                tables: [{ dbName: 'shop', tableName: 'users' }],
+                columns: [{ dbName: 'shop', tableName: 'users', name: 'id', type: 'bigint' }],
+            },
+            editorSnapshot: {
+                prefix: 'SELECT',
+                suffix: '',
+                currentLineBeforeCursor: 'SELECT',
+                currentLineAfterCursor: '',
+            },
+        })).resolves.toBe(' * FROM ');
+
+        await expect(requestQueryEditorInlineCompletion({
+            service,
+            aiContext: {
+                connectionName: 'Local MySQL',
+                sourceType: 'mysql',
+                currentDb: 'shop',
+                tables: [{ dbName: 'shop', tableName: 'users' }],
+                columns: [{ dbName: 'shop', tableName: 'users', name: 'id', type: 'bigint' }],
+            },
+            editorSnapshot: {
+                prefix: 'DELETE',
+                suffix: '',
+                currentLineBeforeCursor: 'DELETE',
+                currentLineAfterCursor: '',
+            },
+        })).resolves.toBe(' FROM ');
+
+        await expect(requestQueryEditorInlineCompletion({
+            service,
+            aiContext: {
+                connectionName: 'Local MySQL',
+                sourceType: 'mysql',
+                currentDb: 'shop',
+                tables: [{ dbName: 'shop', tableName: 'users' }],
+                columns: [{ dbName: 'shop', tableName: 'users', name: 'id', type: 'bigint' }],
+            },
+            editorSnapshot: {
+                prefix: 'MERGE',
+                suffix: '',
+                currentLineBeforeCursor: 'MERGE',
+                currentLineAfterCursor: '',
+            },
+        })).resolves.toBe(' INTO ');
+
+        await expect(requestQueryEditorInlineCompletion({
+            service,
+            aiContext: {
+                connectionName: 'Local MySQL',
+                sourceType: 'mysql',
+                currentDb: 'shop',
+                tables: [{ dbName: 'shop', tableName: 'users' }],
+                columns: [{ dbName: 'shop', tableName: 'users', name: 'id', type: 'bigint' }],
+            },
+            editorSnapshot: {
+                prefix: 'REPLACE',
+                suffix: '',
+                currentLineBeforeCursor: 'REPLACE',
+                currentLineAfterCursor: '',
+            },
+        })).resolves.toBe(' INTO ');
+
+        await expect(requestQueryEditorInlineCompletion({
+            service,
+            aiContext: {
+                connectionName: 'Local MySQL',
+                sourceType: 'mysql',
+                currentDb: 'shop',
+                tables: [{ dbName: 'shop', tableName: 'users' }],
+                columns: [{ dbName: 'shop', tableName: 'users', name: 'id', type: 'bigint' }],
+            },
+            editorSnapshot: {
+                prefix: 'ALTER',
+                suffix: '',
+                currentLineBeforeCursor: 'ALTER',
+                currentLineAfterCursor: '',
+            },
+        })).resolves.toBe(' TABLE ');
+
+        await expect(requestQueryEditorInlineCompletion({
+            service,
+            aiContext: {
+                connectionName: 'Local MySQL',
+                sourceType: 'mysql',
+                currentDb: 'shop',
+                tables: [{ dbName: 'shop', tableName: 'users' }],
+                columns: [{ dbName: 'shop', tableName: 'users', name: 'id', type: 'bigint' }],
+            },
+            editorSnapshot: {
+                prefix: 'CREATE',
+                suffix: '',
+                currentLineBeforeCursor: 'CREATE',
+                currentLineAfterCursor: '',
+            },
+        })).resolves.toBe(' TABLE ');
+
+        await expect(requestQueryEditorInlineCompletion({
+            service,
+            aiContext: {
+                connectionName: 'Local MySQL',
+                sourceType: 'mysql',
+                currentDb: 'shop',
+                tables: [{ dbName: 'shop', tableName: 'users' }],
+                columns: [{ dbName: 'shop', tableName: 'users', name: 'id', type: 'bigint' }],
+            },
+            editorSnapshot: {
+                prefix: 'DROP',
+                suffix: '',
+                currentLineBeforeCursor: 'DROP',
+                currentLineAfterCursor: '',
+            },
+        })).resolves.toBe(' TABLE ');
+
+        await expect(requestQueryEditorInlineCompletion({
+            service,
+            aiContext: {
+                connectionName: 'Local MySQL',
+                sourceType: 'mysql',
+                currentDb: 'shop',
+                tables: [{ dbName: 'shop', tableName: 'users' }],
+                columns: [{ dbName: 'shop', tableName: 'users', name: 'id', type: 'bigint' }],
+            },
+            editorSnapshot: {
+                prefix: 'TRUNCATE',
+                suffix: '',
+                currentLineBeforeCursor: 'TRUNCATE',
+                currentLineAfterCursor: '',
+            },
+        })).resolves.toBe(' TABLE ');
+
+        expect(service.AIChatSend).not.toHaveBeenCalled();
     });
 
     it('builds inline and text-to-sql prompts with custom instructions and schema hints', () => {
         const aiContext = {
             connectionName: 'Local MySQL',
+            host: '127.0.0.1',
+            port: 3306,
             sourceType: 'mysql',
             currentDb: 'shop',
             visibleDbs: ['shop'],
-            tables: [{ dbName: 'shop', tableName: 'orders', comment: 'sales orders' }],
+            tables: [
+                { dbName: 'shop', tableName: 'orders', comment: 'sales orders' },
+                { dbName: 'shop', tableName: 'videos', comment: 'media table' },
+            ],
             columns: [
                 { dbName: 'shop', tableName: 'orders', name: 'id', type: 'bigint' },
                 { dbName: 'shop', tableName: 'orders', name: 'amount', type: 'decimal' },
+                { dbName: 'shop', tableName: 'videos', name: 'code', type: 'varchar' },
             ],
         };
         const userPromptSettings = {
@@ -93,16 +372,21 @@ describe('QueryEditorAiAssist', () => {
         const inlineMessages = buildQueryEditorInlineCompletionMessages({
             aiContext,
             editorSnapshot: {
-                prefix: 'select',
+                prefix: 'select * from videos v where v.',
                 suffix: '',
-                currentLineBeforeCursor: 'select',
+                currentLineBeforeCursor: 'select * from videos v where v.',
                 currentLineAfterCursor: '',
             },
             userPromptSettings,
         });
         const inlineJoined = inlineMessages.map((message) => message.content).join('\n');
         expect(inlineJoined).toContain('Always use explicit column names.');
-        expect(inlineJoined).toContain('shop.orders -- sales orders; columns: id bigint, amount decimal');
+        expect(inlineJoined).toContain('- host: 127.0.0.1:3306');
+        expect(inlineJoined).toContain('- current_statement_tables: shop.videos AS v');
+        expect(inlineJoined).toContain('- inline_completion_intent: column_name');
+        expect(inlineJoined).toContain('- inline_completion_qualifier: v');
+        expect(inlineJoined).toContain('shop.videos -- media table; columns: code varchar');
+        expect(inlineJoined).not.toContain('shop.orders -- sales orders');
         expect(inlineJoined).toContain('<prefix_before_cursor>');
 
         const textToSqlMessages = buildQueryEditorTextToSqlMessages({
@@ -119,8 +403,42 @@ describe('QueryEditorAiAssist', () => {
         expect(textToSqlMessages.map((message) => message.content).join('\n')).toContain('total order amount by day');
     });
 
+    it('focuses inline schema hints on referenced tables or the current database', () => {
+        const focused = buildQueryEditorInlineCompletionContext({
+            connectionName: 'Local MySQL',
+            sourceType: 'mysql',
+            currentDb: 'shop',
+            visibleDbs: ['shop'],
+            tables: [
+                { dbName: 'shop', tableName: 'orders' },
+                { dbName: 'shop', tableName: 'videos' },
+                { dbName: 'archive', tableName: 'videos' },
+            ],
+            columns: [
+                { dbName: 'shop', tableName: 'orders', name: 'id', type: 'bigint' },
+                { dbName: 'shop', tableName: 'videos', name: 'code', type: 'varchar' },
+                { dbName: 'archive', tableName: 'videos', name: 'legacy_code', type: 'varchar' },
+            ],
+        }, {
+            prefix: 'select * from videos v where',
+            suffix: '',
+            currentLineBeforeCursor: 'select * from videos v where',
+            currentLineAfterCursor: '',
+        });
+
+        expect(focused.inlineSchemaScope).toBe('referenced_tables');
+        expect(focused.inlineReferencedTables).toEqual([{
+            dbName: 'shop',
+            tableName: 'videos',
+            alias: 'v',
+            raw: 'videos',
+        }]);
+        expect(focused.tables).toEqual([{ dbName: 'shop', tableName: 'videos' }]);
+        expect(focused.columns).toEqual([{ dbName: 'shop', tableName: 'videos', name: 'code', type: 'varchar' }]);
+    });
+
     it('checks active provider readiness before inline AI requests', async () => {
-        const service = readyService('select * from users;');
+        const service = readyService('select * from users where id > 1;');
         const readiness = await resolveQueryEditorAiRuntimeReadiness(service);
         expect(readiness.ready).toBe(true);
         expect(readiness.provider?.model).toBe('gpt-5');
@@ -131,17 +449,17 @@ describe('QueryEditorAiAssist', () => {
                 connectionName: 'Local MySQL',
                 sourceType: 'mysql',
                 currentDb: 'shop',
-                tables: [],
-                columns: [],
+                tables: [{ dbName: 'shop', tableName: 'users' }],
+                columns: [{ dbName: 'shop', tableName: 'users', name: 'id', type: 'bigint' }],
             },
             editorSnapshot: {
-                prefix: 'select',
+                prefix: 'select * from users ',
                 suffix: '',
-                currentLineBeforeCursor: 'select',
+                currentLineBeforeCursor: 'select * from users ',
                 currentLineAfterCursor: '',
             },
         });
-        expect(insertText).toBe(' * from users;');
+        expect(insertText).toBe('where id > 1;');
         expect(service.AIChatSend).toHaveBeenCalledTimes(1);
 
         const missingProvider = await resolveQueryEditorAiRuntimeReadiness({
@@ -152,4 +470,322 @@ describe('QueryEditorAiAssist', () => {
         expect(missingProvider.ready).toBe(false);
         expect(missingProvider.reason).toBe('provider_missing');
     });
+
+    it('uses deterministic schema metadata for table-name inline completion and skips AI', async () => {
+        const service = readyService('SELECT * FROM orders;');
+
+        const insertText = await requestQueryEditorInlineCompletion({
+            service,
+            aiContext: {
+                connectionName: 'Local MySQL',
+                sourceType: 'mysql',
+                currentDb: 'shop',
+                tables: [
+                    { dbName: 'shop', tableName: 'videos' },
+                    { dbName: 'shop', tableName: 'orders' },
+                ],
+                columns: [],
+            },
+            editorSnapshot: {
+                prefix: 'SELECT * FROM vid',
+                suffix: '',
+                currentLineBeforeCursor: 'SELECT * FROM vid',
+                currentLineAfterCursor: '',
+            },
+        });
+
+        expect(insertText).toBe('eos');
+        expect(service.AIChatSend).not.toHaveBeenCalled();
+    });
+
+    it('uses deterministic schema metadata for alter-table inline completion and skips AI', async () => {
+        const service = readyService('ALTER TABLE orders ADD COLUMN status INT;');
+
+        const insertText = await requestQueryEditorInlineCompletion({
+            service,
+            aiContext: {
+                connectionName: 'Local MySQL',
+                sourceType: 'mysql',
+                currentDb: 'shop',
+                tables: [
+                    { dbName: 'shop', tableName: 'videos' },
+                    { dbName: 'shop', tableName: 'orders' },
+                ],
+                columns: [],
+            },
+            editorSnapshot: {
+                prefix: 'ALTER TABLE ord',
+                suffix: '',
+                currentLineBeforeCursor: 'ALTER TABLE ord',
+                currentLineAfterCursor: '',
+            },
+        });
+
+        expect(insertText).toBe('ers');
+        expect(service.AIChatSend).not.toHaveBeenCalled();
+    });
+
+    it('uses grounded AI for ambiguous table-name inline completion when the suggestion matches schema metadata', async () => {
+        const service = readyService('videos');
+
+        const insertText = await requestQueryEditorInlineCompletion({
+            service,
+            aiContext: {
+                connectionName: 'Local MySQL',
+                sourceType: 'mysql',
+                currentDb: 'shop',
+                tables: [
+                    { dbName: 'shop', tableName: 'videos' },
+                    { dbName: 'shop', tableName: 'visits' },
+                ],
+                columns: [],
+            },
+            editorSnapshot: {
+                prefix: 'SELECT * FROM vi',
+                suffix: '',
+                currentLineBeforeCursor: 'SELECT * FROM vi',
+                currentLineAfterCursor: '',
+            },
+        });
+
+        expect(insertText).toBe('deos');
+        expect(service.AIChatSend).toHaveBeenCalledTimes(1);
+    });
+
+    it('rejects ungrounded AI table-name inline completion when the suggestion is outside schema metadata', async () => {
+        const service = readyService('Japgolly');
+
+        const insertText = await requestQueryEditorInlineCompletion({
+            service,
+            aiContext: {
+                connectionName: 'Local MySQL',
+                sourceType: 'mysql',
+                currentDb: 'shop',
+                tables: [
+                    { dbName: 'shop', tableName: 'videos' },
+                    { dbName: 'shop', tableName: 'visits' },
+                ],
+                columns: [],
+            },
+            editorSnapshot: {
+                prefix: 'SELECT * FROM \\',
+                suffix: '',
+                currentLineBeforeCursor: 'SELECT * FROM \\',
+                currentLineAfterCursor: '',
+            },
+        });
+
+        expect(insertText).toBe('');
+        expect(service.AIChatSend).toHaveBeenCalledTimes(1);
+    });
+
+    it('uses deterministic schema metadata for alias column inline completion and skips AI', async () => {
+        const service = readyService('SELECT * FROM videos;');
+
+        const insertText = await requestQueryEditorInlineCompletion({
+            service,
+            aiContext: {
+                connectionName: 'Local MySQL',
+                sourceType: 'mysql',
+                currentDb: 'shop',
+                tables: [{ dbName: 'shop', tableName: 'videos' }],
+                columns: [
+                    { dbName: 'shop', tableName: 'videos', name: 'code', type: 'varchar' },
+                    { dbName: 'shop', tableName: 'videos', name: 'created_at', type: 'datetime' },
+                ],
+            },
+            editorSnapshot: {
+                prefix: 'SELECT v.co FROM videos v WHERE v.co',
+                suffix: '',
+                currentLineBeforeCursor: 'SELECT v.co FROM videos v WHERE v.co',
+                currentLineAfterCursor: '',
+            },
+        });
+
+        expect(insertText).toBe('de');
+        expect(service.AIChatSend).not.toHaveBeenCalled();
+    });
+
+    it('uses grounded AI for ambiguous column-name inline completion when the suggestion matches table metadata', async () => {
+        const service = readyService('code');
+
+        const insertText = await requestQueryEditorInlineCompletion({
+            service,
+            aiContext: {
+                connectionName: 'Local MySQL',
+                sourceType: 'mysql',
+                currentDb: 'shop',
+                tables: [{ dbName: 'shop', tableName: 'videos' }],
+                columns: [
+                    { dbName: 'shop', tableName: 'videos', name: 'code', type: 'varchar' },
+                    { dbName: 'shop', tableName: 'videos', name: 'created_at', type: 'datetime' },
+                ],
+            },
+            editorSnapshot: {
+                prefix: 'SELECT * FROM videos v WHERE v.c',
+                suffix: '',
+                currentLineBeforeCursor: 'SELECT * FROM videos v WHERE v.c',
+                currentLineAfterCursor: '',
+            },
+        });
+
+        expect(insertText).toBe('ode');
+        expect(service.AIChatSend).toHaveBeenCalledTimes(1);
+    });
+
+    it('rejects ungrounded AI column-name inline completion when the suggestion is outside table metadata', async () => {
+        const service = readyService('checksum');
+
+        const insertText = await requestQueryEditorInlineCompletion({
+            service,
+            aiContext: {
+                connectionName: 'Local MySQL',
+                sourceType: 'mysql',
+                currentDb: 'shop',
+                tables: [{ dbName: 'shop', tableName: 'videos' }],
+                columns: [
+                    { dbName: 'shop', tableName: 'videos', name: 'code', type: 'varchar' },
+                    { dbName: 'shop', tableName: 'videos', name: 'created_at', type: 'datetime' },
+                ],
+            },
+            editorSnapshot: {
+                prefix: 'SELECT * FROM videos v WHERE v.c',
+                suffix: '',
+                currentLineBeforeCursor: 'SELECT * FROM videos v WHERE v.c',
+                currentLineAfterCursor: '',
+            },
+        });
+
+        expect(insertText).toBe('');
+        expect(service.AIChatSend).toHaveBeenCalledTimes(1);
+    });
+
+    it('uses the dedicated inline completion model when configured', async () => {
+        const service = {
+            ...readyService('select * from users;'),
+            AIGetProviders: vi.fn(async () => [{
+                id: 'openai-main',
+                type: 'openai' as const,
+                name: 'OpenAI',
+                apiKey: '',
+                hasSecret: true,
+                baseUrl: 'https://api.openai.com/v1',
+                model: 'gpt-5',
+                inlineCompletionModel: 'gpt-5-mini',
+                maxTokens: 2048,
+                temperature: 0.2,
+            }]),
+            AIChatSendWithOptions: vi.fn(async () => ({ success: true, content: 'select * from users where id = 1;' })),
+        };
+
+        const insertText = await requestQueryEditorInlineCompletion({
+            service,
+            aiContext: {
+                connectionName: 'Local MySQL',
+                sourceType: 'mysql',
+                currentDb: 'shop',
+                tables: [{ dbName: 'shop', tableName: 'users' }],
+                columns: [{ dbName: 'shop', tableName: 'users', name: 'id', type: 'bigint' }],
+            },
+            editorSnapshot: {
+                prefix: 'select * from users ',
+                suffix: '',
+                currentLineBeforeCursor: 'select * from users ',
+                currentLineAfterCursor: '',
+            },
+        });
+
+        expect(resolveQueryEditorInlineCompletionModel((await service.AIGetProviders())[0])).toBe('gpt-5-mini');
+        expect(insertText).toBe('where id = 1;');
+        expect(service.AIChatSend).not.toHaveBeenCalled();
+        expect(service.AIChatSendWithOptions).toHaveBeenCalledWith(expect.any(Array), [], {
+            model: 'gpt-5-mini',
+            maxTokens: 192,
+            temperature: 0.1,
+        });
+    });
+
+    it('falls back to the chat model for inline completion when no dedicated model is configured', async () => {
+        const service = {
+            ...readyService('select * from users;'),
+            AIChatSendWithOptions: vi.fn(async () => ({ success: true, content: 'select * from users where id = 1;' })),
+        };
+
+        await requestQueryEditorInlineCompletion({
+            service,
+            aiContext: {
+                connectionName: 'Local MySQL',
+                sourceType: 'mysql',
+                currentDb: 'shop',
+                tables: [{ dbName: 'shop', tableName: 'users' }],
+                columns: [{ dbName: 'shop', tableName: 'users', name: 'id', type: 'bigint' }],
+            },
+            editorSnapshot: {
+                prefix: 'select * from users ',
+                suffix: '',
+                currentLineBeforeCursor: 'select * from users ',
+                currentLineAfterCursor: '',
+            },
+        });
+
+        expect(service.AIChatSendWithOptions).toHaveBeenCalledWith(expect.any(Array), [], expect.objectContaining({
+            model: 'gpt-5',
+        }));
+    });
+
+    it('uses reasoning content as a fallback for inline completion responses', async () => {
+        const service = {
+            ...readyService(''),
+            AIChatSend: vi.fn(async () => ({
+                success: true,
+                content: '',
+                reasoning_content: 'SELECT * FROM videos WHERE code IS NOT NULL;',
+            })),
+        };
+
+        const insertText = await requestQueryEditorInlineCompletion({
+            service,
+            aiContext: {
+                connectionName: 'Local MySQL',
+                sourceType: 'mysql',
+                currentDb: 'shop',
+                tables: [{ dbName: 'shop', tableName: 'videos' }],
+                columns: [{ dbName: 'shop', tableName: 'videos', name: 'code', type: 'varchar' }],
+            },
+            editorSnapshot: {
+                prefix: 'select * from videos ',
+                suffix: '',
+                currentLineBeforeCursor: 'select * from videos ',
+                currentLineAfterCursor: '',
+            },
+        });
+
+        expect(insertText).toBe('WHERE code IS NOT NULL;');
+    });
+
+    it('drops inline completions that introduce tables outside the selected database context', async () => {
+        const service = {
+            ...readyService('select * from orders where id = 1;'),
+            AIChatSendWithOptions: vi.fn(async () => ({ success: true, content: 'select * from orders where id = 1;' })),
+        };
+
+        const insertText = await requestQueryEditorInlineCompletion({
+            service,
+            aiContext: {
+                connectionName: 'Local MySQL',
+                sourceType: 'mysql',
+                currentDb: 'shop',
+                tables: [{ dbName: 'shop', tableName: 'videos' }],
+                columns: [{ dbName: 'shop', tableName: 'videos', name: 'code', type: 'varchar' }],
+            },
+            editorSnapshot: {
+                prefix: 'select * from videos ',
+                suffix: '',
+                currentLineBeforeCursor: 'select * from videos ',
+                currentLineAfterCursor: '',
+            },
+        });
+
+        expect(insertText).toBe('');
+    });
 });
diff --git a/frontend/src/components/queryEditor/QueryEditorAiAssist.ts b/frontend/src/components/queryEditor/QueryEditorAiAssist.ts
index 0aebc830..c32177e7 100644
--- a/frontend/src/components/queryEditor/QueryEditorAiAssist.ts
+++ b/frontend/src/components/queryEditor/QueryEditorAiAssist.ts
@@ -6,6 +6,9 @@ import type {
     CompletionColumnMeta,
     CompletionTableMeta,
 } from './QueryEditorHelpers';
+import {
+    buildQueryEditorAliasMap,
+} from './QueryEditorHelpers';
 
 export type QueryEditorAiApplyMode = 'insert' | 'replaceSelection' | 'replaceAll';
 
@@ -14,6 +17,17 @@ export interface QueryEditorAiService {
     AIGetActiveProvider?: () => Promise<string>;
     AIGetUserPromptSettings?: () => Promise<Partial<AIUserPromptSettings>>;
     AIChatSend?: (messages: QueryEditorAiMessage[], tools?: any[]) => Promise<Record<string, any>>;
+    AIChatSendWithOptions?: (
+        messages: QueryEditorAiMessage[],
+        tools?: any[],
+        options?: QueryEditorAiChatSendOptions,
+    ) => Promise<Record<string, any>>;
+}
+
+export interface QueryEditorAiChatSendOptions {
+    model?: string;
+    temperature?: number;
+    maxTokens?: number;
 }
 
 export interface QueryEditorAiMessage {
@@ -23,11 +37,18 @@ export interface QueryEditorAiMessage {
 
 export interface QueryEditorAiContext {
     connectionName?: string;
+    host?: string;
+    port?: string | number;
     sourceType?: string;
     currentDb?: string;
     visibleDbs?: string[];
     tables?: CompletionTableMeta[];
     columns?: CompletionColumnMeta[];
+    inlineSchemaScope?: 'referenced_tables' | 'current_database';
+    inlineReferencedTables?: QueryEditorAiTableReference[];
+    inlineCompletionIntent?: 'general_sql' | 'table_name' | 'column_name';
+    inlineCompletionFragment?: string;
+    inlineCompletionQualifier?: string;
 }
 
 export interface QueryEditorAiEditorSnapshot {
@@ -44,6 +65,29 @@ export interface QueryEditorAiRuntimeReadiness {
     userPromptSettings: AIUserPromptSettings;
 }
 
+export interface QueryEditorAiTableReference {
+    dbName: string;
+    tableName: string;
+    alias?: string;
+    raw: string;
+}
+
+export interface QueryEditorInlineMemoryEntry {
+    sql: string;
+}
+
+export const buildQueryEditorAiInlineSuggestOptions = () => ({
+    enabled: true,
+    mode: 'prefix' as const,
+    showToolbar: 'onHover' as const,
+    suppressSuggestions: true,
+    minShowDelay: 60,
+    // Monaco hides inline completions while the normal suggest widget is open unless this is enabled.
+    experimental: {
+        showOnSuggestConflict: 'always' as const,
+    },
+});
+
 const EMPTY_USER_PROMPT_SETTINGS: AIUserPromptSettings = {
     global: '',
     database: '',
@@ -57,18 +101,33 @@ const TEXT_TO_SQL_PREFIX_LIMIT = 5000;
 const TEXT_TO_SQL_SUFFIX_LIMIT = 1800;
 const MAX_SCHEMA_SNAPSHOT_CHARS = 7000;
 const MAX_SCHEMA_TABLES = 48;
+const MAX_INLINE_SCHEMA_TABLES = 18;
 const MAX_SCHEMA_COLUMNS_PER_TABLE = 14;
 const MAX_INLINE_INSERT_CHARS = 1800;
+const MAX_INLINE_GHOST_PREVIEW_CHARS = 220;
+const INLINE_COMPLETION_MAX_TOKENS = 192;
+const INLINE_COMPLETION_TEMPERATURE = 0.1;
 
 const SQL_CODE_FENCE_RE = /```(?:sql|mysql|postgresql|postgres|oracle|plsql|sqlite|sqlserver|mssql|tsql|clickhouse|duckdb|starrocks|tdengine)?\s*([\s\S]*?)```/i;
+const INLINE_TABLE_COMPLETION_RE = /\b(?:FROM|JOIN|UPDATE|INTO|DELETE\s+FROM|ALTER\s+TABLE|DROP\s+TABLE|TRUNCATE\s+TABLE)\s*([^\s,()]*)$/i;
+
+type QueryEditorInlineCompletionIntentDetails = {
+    intent: 'general_sql' | 'table_name' | 'column_name';
+    fragment: string;
+    qualifier: string;
+};
 
 export const getQueryEditorAiService = (): QueryEditorAiService | undefined =>
     (window as any)?.go?.aiservice?.Service;
 
+export const resolveQueryEditorInlineCompletionModel = (provider: AIProviderConfig): string =>
+    String(provider.inlineCompletionModel || provider.model || '').trim();
+
 export const resolveQueryEditorAiRuntimeReadiness = async (
     service: QueryEditorAiService | undefined,
+    options: { requireInlineCompletionModel?: boolean } = {},
 ): Promise<QueryEditorAiRuntimeReadiness> => {
-    if (!service?.AIChatSend || !service?.AIGetProviders || !service?.AIGetActiveProvider) {
+    if ((!service?.AIChatSend && !service?.AIChatSendWithOptions) || !service?.AIGetProviders || !service?.AIGetActiveProvider) {
         return {
             ready: false,
             reason: 'service_unavailable',
@@ -96,7 +155,10 @@ export const resolveQueryEditorAiRuntimeReadiness = async (
             userPromptSettings,
         };
     }
-    if (!String(provider.model || '').trim()) {
+    const selectedModel = options.requireInlineCompletionModel
+        ? resolveQueryEditorInlineCompletionModel(provider)
+        : String(provider.model || '').trim();
+    if (!selectedModel) {
         return {
             ready: false,
             reason: 'model_missing',
@@ -115,8 +177,7 @@ export const resolveQueryEditorAiRuntimeReadiness = async (
 export const shouldRequestQueryEditorInlineCompletion = (
     snapshot: QueryEditorAiEditorSnapshot,
 ): boolean => {
-    const lineAfterCursor = String(snapshot.currentLineAfterCursor || '');
-    if (lineAfterCursor.length > 0) {
+    if (!shouldAllowQueryEditorInlineMemoryCompletion(snapshot)) {
         return false;
     }
 
@@ -126,6 +187,20 @@ export const shouldRequestQueryEditorInlineCompletion = (
     if (trimmedStatement.length < 3) {
         return false;
     }
+    return true;
+};
+
+export const shouldAllowQueryEditorInlineMemoryCompletion = (
+    snapshot: QueryEditorAiEditorSnapshot,
+): boolean => {
+    const lineAfterCursor = String(snapshot.currentLineAfterCursor || '');
+    if (lineAfterCursor.length > 0) {
+        return false;
+    }
+
+    const prefix = String(snapshot.prefix || '');
+    const currentStatement = getCurrentStatementPrefix(prefix);
+    const trimmedStatement = currentStatement.trim();
     if (/[;)]\s*$/.test(trimmedStatement)) {
         return false;
     }
@@ -145,6 +220,45 @@ export const shouldRequestQueryEditorInlineCompletion = (
     return true;
 };
 
+const normalizeInlineMemoryCandidateSql = (sql: string): string => (
+    String(sql || '')
+        .replace(/\r\n?/g, '\n')
+        .trim()
+);
+
+const normalizeInlineMemoryMatchText = (sql: string): string => (
+    normalizeInlineMemoryCandidateSql(sql)
+        .replace(/\s+/g, ' ')
+        .trimStart()
+        .toLowerCase()
+);
+
+export const resolveQueryEditorInlineMemoryInsertText = ({
+    editorSnapshot,
+    memoryEntries,
+}: {
+    editorSnapshot: QueryEditorAiEditorSnapshot;
+    memoryEntries: QueryEditorInlineMemoryEntry[];
+}): string => {
+    if (!shouldAllowQueryEditorInlineMemoryCompletion(editorSnapshot)) {
+        return '';
+    }
+
+    const statementPrefix = getCurrentStatementPrefix(editorSnapshot.prefix);
+    const normalizedStatementPrefix = normalizeInlineMemoryMatchText(statementPrefix);
+    for (const entry of memoryEntries || []) {
+        const candidateSql = normalizeInlineMemoryCandidateSql(entry?.sql || '');
+        if (!candidateSql) {
+            continue;
+        }
+        if (normalizedStatementPrefix && !normalizeInlineMemoryMatchText(candidateSql).startsWith(normalizedStatementPrefix)) {
+            continue;
+        }
+        return limitInlineInsertText(resolveInlineSqlInsertText(candidateSql, editorSnapshot.prefix));
+    }
+    return '';
+};
+
 export const requestQueryEditorInlineCompletion = async ({
     service,
     aiContext,
@@ -158,26 +272,101 @@ export const requestQueryEditorInlineCompletion = async ({
         return '';
     }
 
-    const readiness = await resolveQueryEditorAiRuntimeReadiness(service);
+    const inlineIntent = resolveQueryEditorInlineCompletionIntentDetails(editorSnapshot);
+    const deterministicCompletion = resolveDeterministicInlineSchemaCompletion(aiContext, editorSnapshot, inlineIntent);
+    if (deterministicCompletion.handled && deterministicCompletion.insertText) {
+        return deterministicCompletion.insertText;
+    }
+    if (deterministicCompletion.handled) {
+        if (inlineIntent.intent === 'table_name') {
+            if (!shouldAllowInlineTableAiFallback(aiContext, inlineIntent.fragment)) {
+                return '';
+            }
+        } else if (inlineIntent.intent === 'column_name') {
+            if (!shouldAllowInlineColumnAiFallback(aiContext, editorSnapshot, inlineIntent.qualifier, inlineIntent.fragment)) {
+                return '';
+            }
+        }
+    }
+
+    const deterministicSyntaxCompletion = resolveDeterministicInlineSyntaxCompletion(editorSnapshot);
+    if (deterministicSyntaxCompletion.handled) {
+        return deterministicSyntaxCompletion.insertText;
+    }
+
+    const readiness = await resolveQueryEditorAiRuntimeReadiness(service, {
+        requireInlineCompletionModel: true,
+    });
     if (!readiness.ready || !readiness.provider) {
         return '';
     }
 
+    const inlineAiContext = buildQueryEditorInlineCompletionContext(aiContext, editorSnapshot);
     const messages = buildQueryEditorInlineCompletionMessages({
-        aiContext,
+        aiContext: inlineAiContext,
         editorSnapshot,
         userPromptSettings: readiness.userPromptSettings,
     });
-    const result = await service!.AIChatSend!(messages, []);
-    if (!result?.success || !result.content) {
+    const inlineModel = resolveQueryEditorInlineCompletionModel(readiness.provider);
+    const result = service?.AIChatSendWithOptions
+        ? await service.AIChatSendWithOptions(messages, [], {
+            model: inlineModel,
+            maxTokens: INLINE_COMPLETION_MAX_TOKENS,
+            temperature: INLINE_COMPLETION_TEMPERATURE,
+        })
+        : await service!.AIChatSend!(messages, []);
+    const responseContent = String(result?.content || result?.reasoning_content || '');
+    if (!result?.success || !responseContent.trim()) {
         return '';
     }
 
-    const sanitized = sanitizeSqlAssistantResponse(String(result.content || ''));
+    const sanitized = sanitizeSqlAssistantResponse(responseContent);
     const insertText = resolveInlineSqlInsertText(sanitized, editorSnapshot.prefix);
+    if (inlineIntent.intent === 'table_name') {
+        return limitInlineInsertText(resolveValidatedInlineTableAiInsertText(
+            inlineAiContext,
+            editorSnapshot,
+            inlineIntent.fragment,
+            insertText,
+        ));
+    }
+    if (inlineIntent.intent === 'column_name') {
+        return limitInlineInsertText(resolveValidatedInlineColumnAiInsertText(
+            inlineAiContext,
+            editorSnapshot,
+            inlineIntent.qualifier,
+            inlineIntent.fragment,
+            insertText,
+        ));
+    }
+    if (!isInlineCompletionScopedToKnownContext(insertText, editorSnapshot.prefix, inlineAiContext)) {
+        return '';
+    }
     return limitInlineInsertText(insertText);
 };
 
+export const shouldTriggerQueryEditorInlineObjectSuggestFallback = ({
+    aiContext,
+    editorSnapshot,
+}: {
+    aiContext: QueryEditorAiContext;
+    editorSnapshot: QueryEditorAiEditorSnapshot;
+}): boolean => {
+    const intent = resolveQueryEditorInlineCompletionIntentDetails(editorSnapshot);
+    if (intent.intent === 'table_name') {
+        return shouldAllowInlineTableAiFallback(aiContext, intent.fragment);
+    }
+    if (intent.intent === 'column_name') {
+        return shouldAllowInlineColumnAiFallback(
+            aiContext,
+            editorSnapshot,
+            intent.qualifier,
+            intent.fragment,
+        );
+    }
+    return false;
+};
+
 export const requestQueryEditorTextToSql = async ({
     service,
     aiContext,
@@ -219,33 +408,43 @@ export const buildQueryEditorInlineCompletionMessages = ({
     aiContext: QueryEditorAiContext;
     editorSnapshot: QueryEditorAiEditorSnapshot;
     userPromptSettings: AIUserPromptSettings;
-}): QueryEditorAiMessage[] => [
-    {
-        role: 'system',
-        content: [
-            'You are GoNavi SQL inline completion.',
-            'Return only the exact SQL text that should be inserted at the cursor.',
-            'Do not use Markdown, code fences, explanations, comments about your answer, or natural language.',
-            'Continue the current SQL instead of repeating text that already exists before the cursor.',
-            'Respect the database dialect, current database, and schema hints. Prefer concise, executable SQL.',
-        ].join('\n'),
-    },
-    ...buildCustomPromptMessages(userPromptSettings),
-    {
-        role: 'user',
-        content: [
-            buildQueryEditorAiContextBlock(aiContext),
-            'Editor snapshot:',
-            '<prefix_before_cursor>',
-            truncateHead(editorSnapshot.prefix, INLINE_PREFIX_LIMIT),
-            '</prefix_before_cursor>',
-            '<suffix_after_cursor>',
-            truncateTail(editorSnapshot.suffix, INLINE_SUFFIX_LIMIT),
-            '</suffix_after_cursor>',
-            'The cursor is at the end of prefix_before_cursor. Generate the continuation text only.',
-        ].join('\n'),
-    },
-];
+}): QueryEditorAiMessage[] => {
+    const inlineAiContext = buildQueryEditorInlineCompletionContext(aiContext, editorSnapshot);
+    return [
+        {
+            role: 'system',
+            content: [
+                'You are GoNavi SQL inline completion.',
+                'Return only the exact SQL text that should be inserted at the cursor.',
+                'Do not use Markdown, code fences, explanations, comments about your answer, or natural language.',
+                'Continue the current SQL instead of repeating text that already exists before the cursor.',
+                'Respect the selected database connection, host, database, dialect, and schema hints.',
+                'Use only tables, columns, schemas, and databases present in the schema hints or already present in the editor snapshot.',
+                'If schema hints are insufficient, generate only minimal SQL syntax and do not invent object names.',
+                'When inline_completion_intent is table_name, use only tables from the selected database context.',
+                'When inline_completion_intent is column_name, use only columns from the referenced table or alias context.',
+                'When inline_completion_intent is table_name or column_name, never output aliases, AS clauses, predicates, JOIN clauses, or commentary.',
+                'If the cursor is at an object-name position and there is no grounded schema candidate, return an empty string.',
+                'Prefer concise, executable SQL.',
+            ].join('\n'),
+        },
+        ...buildCustomPromptMessages(userPromptSettings),
+        {
+            role: 'user',
+            content: [
+                buildQueryEditorAiContextBlock(inlineAiContext),
+                'Editor snapshot:',
+                '<prefix_before_cursor>',
+                truncateHead(editorSnapshot.prefix, INLINE_PREFIX_LIMIT),
+                '</prefix_before_cursor>',
+                '<suffix_after_cursor>',
+                truncateTail(editorSnapshot.suffix, INLINE_SUFFIX_LIMIT),
+                '</suffix_after_cursor>',
+                'The cursor is at the end of prefix_before_cursor. Generate the continuation text only.',
+            ].join('\n'),
+        },
+    ];
+};
 
 export const buildQueryEditorTextToSqlMessages = ({
     aiContext,
@@ -334,27 +533,134 @@ export const resolveInlineSqlInsertText = (generatedSql: string, prefix: string)
     return generated;
 };
 
+export const resolveInlineSqlGhostPreviewText = (insertText: string): string => {
+    const raw = String(insertText || '').replace(/\r\n?/g, '\n');
+    if (!raw.trim()) {
+        return '';
+    }
+
+    const hasLeadingWhitespace = /^\s/.test(raw);
+    const singleLine = raw.replace(/\s+/g, ' ').trim();
+    if (!singleLine) {
+        return '';
+    }
+
+    const preview = singleLine.length > MAX_INLINE_GHOST_PREVIEW_CHARS
+        ? `${singleLine.slice(0, MAX_INLINE_GHOST_PREVIEW_CHARS).trimEnd()} ...`
+        : singleLine;
+    return `${hasLeadingWhitespace ? ' ' : ''}${preview}`;
+};
+
 export const buildQueryEditorAiContextBlock = (context: QueryEditorAiContext): string => {
     const sourceType = String(context.sourceType || '').trim() || 'unknown';
     const connectionName = String(context.connectionName || '').trim() || 'unknown';
+    const host = String(context.host || '').trim();
+    const port = String(context.port || '').trim();
+    const hostLabel = host ? `${host}${port ? `:${port}` : ''}` : '';
     const currentDb = String(context.currentDb || '').trim() || 'default';
     const visibleDbs = (context.visibleDbs || [])
         .map((db) => String(db || '').trim())
         .filter(Boolean)
         .slice(0, 24)
         .join(', ');
+    const referencedTables = (context.inlineReferencedTables || [])
+        .map((table) => {
+            const label = `${table.dbName ? `${table.dbName}.` : ''}${table.tableName}`;
+            return table.alias ? `${label} AS ${table.alias}` : label;
+        })
+        .filter(Boolean)
+        .join(', ');
 
     return [
         'Database context:',
         `- source_type: ${sourceType}`,
         `- connection: ${connectionName}`,
+        hostLabel ? `- host: ${hostLabel}` : '',
         `- current_database: ${currentDb}`,
         visibleDbs ? `- visible_databases: ${visibleDbs}` : '',
+        context.inlineSchemaScope ? `- schema_scope: ${context.inlineSchemaScope}` : '',
+        referencedTables ? `- current_statement_tables: ${referencedTables}` : '',
+        context.inlineCompletionIntent ? `- inline_completion_intent: ${context.inlineCompletionIntent}` : '',
+        context.inlineCompletionQualifier ? `- inline_completion_qualifier: ${context.inlineCompletionQualifier}` : '',
+        context.inlineCompletionFragment !== undefined ? `- inline_completion_fragment: ${context.inlineCompletionFragment}` : '',
         'Schema hints:',
         buildSchemaSnapshot(context),
     ].filter(Boolean).join('\n');
 };
 
+export const buildQueryEditorInlineCompletionContext = (
+    context: QueryEditorAiContext,
+    editorSnapshot: QueryEditorAiEditorSnapshot,
+): QueryEditorAiContext => {
+    const currentDb = String(context.currentDb || '').trim();
+    const statementPrefix = getCurrentStatementPrefix(editorSnapshot.prefix);
+    const intent = resolveQueryEditorInlineCompletionIntentDetails(editorSnapshot);
+    const referencedTables = collectInlineTableReferences(statementPrefix, currentDb, context.visibleDbs || []);
+
+    let nextContext: QueryEditorAiContext;
+    if (context.inlineSchemaScope) {
+        nextContext = {
+            ...context,
+            inlineReferencedTables: context.inlineReferencedTables || referencedTables,
+        };
+    } else if (referencedTables.length > 0) {
+        const tables = collectReferencedSchemaTables(context.tables || [], referencedTables);
+        nextContext = {
+            ...context,
+            tables,
+            columns: filterColumnsForTables(context.columns || [], tables, referencedTables),
+            inlineSchemaScope: 'referenced_tables',
+            inlineReferencedTables: referencedTables,
+        };
+    } else {
+        const currentDbTables = collectCurrentDatabaseTables(context.tables || [], currentDb);
+        nextContext = {
+            ...context,
+            tables: currentDbTables,
+            columns: filterColumnsForTables(context.columns || [], currentDbTables, []),
+            inlineSchemaScope: 'current_database',
+            inlineReferencedTables: [],
+        };
+    }
+
+    if (intent.intent === 'column_name') {
+        const ownerRef = resolveInlineColumnOwnerReference(context, editorSnapshot, intent.qualifier);
+        if (ownerRef) {
+            const ownerTables = collectReferencedSchemaTables(context.tables || [], [ownerRef]);
+            return {
+                ...nextContext,
+                tables: ownerTables,
+                columns: filterColumnsForTables(context.columns || [], ownerTables, [ownerRef]),
+                inlineSchemaScope: 'referenced_tables',
+                inlineReferencedTables: [ownerRef],
+                inlineCompletionIntent: intent.intent,
+                inlineCompletionFragment: intent.fragment,
+                inlineCompletionQualifier: intent.qualifier,
+            };
+        }
+    }
+
+    if (intent.intent === 'table_name') {
+        return {
+            ...nextContext,
+            tables: filterInlineTableMatches(context.tables || [], currentDb, intent.fragment),
+            columns: [],
+            inlineSchemaScope: 'current_database',
+            inlineReferencedTables: [],
+            inlineCompletionIntent: intent.intent,
+            inlineCompletionFragment: intent.fragment,
+            inlineCompletionQualifier: '',
+        };
+    }
+
+    return {
+        ...nextContext,
+        inlineCompletionIntent: intent.intent,
+        inlineCompletionFragment: intent.fragment,
+        inlineCompletionQualifier: intent.qualifier,
+    };
+};
+
 const buildCustomPromptMessages = (settings: AIUserPromptSettings): QueryEditorAiMessage[] => {
     const prompts = [
         String(settings.global || '').trim(),
@@ -396,6 +702,18 @@ const buildSchemaSnapshot = (context: QueryEditorAiContext): string => {
         .slice(0, MAX_SCHEMA_TABLES);
 
     if (!tables.length) {
+        if (context.inlineSchemaScope === 'referenced_tables') {
+            const refs = (context.inlineReferencedTables || [])
+                .map((table) => `${table.dbName ? `${table.dbName}.` : ''}${table.tableName}`)
+                .filter(Boolean)
+                .join(', ');
+            return refs
+                ? `- Referenced table metadata is unavailable for: ${refs}. Do not use any other table or column names.`
+                : '- Referenced table metadata is unavailable. Do not invent table or column names.';
+        }
+        if (context.inlineSchemaScope === 'current_database') {
+            return '- No table metadata is loaded for the current database. Do not invent table or column names.';
+        }
         return '- No table metadata is loaded yet. Use the current SQL and database name as context.';
     }
 
@@ -427,6 +745,655 @@ const buildSchemaSnapshot = (context: QueryEditorAiContext): string => {
 const schemaItemKey = (dbName: string, tableName: string): string =>
     `${String(dbName || '').trim().toLowerCase()}\u0000${String(tableName || '').trim().toLowerCase()}`;
 
+const INLINE_IDENTIFIER_PATTERN = '(?:`[^`]+`|"[^"]+"|\\[[^\\]]+\\]|[A-Za-z_][A-Za-z0-9_$]*)';
+const INLINE_IDENTIFIER_PATH_PATTERN = `${INLINE_IDENTIFIER_PATTERN}(?:\\s*\\.\\s*${INLINE_IDENTIFIER_PATTERN}){0,2}`;
+const INLINE_COLUMN_COMPLETION_RE = new RegExp(`(${INLINE_IDENTIFIER_PATTERN})\\s*\\.\\s*([^\\s,()]*)$`, 'i');
+const INLINE_TABLE_REFERENCE_RE = new RegExp(
+    `\\b(?:FROM|JOIN|UPDATE|INTO|DELETE\\s+FROM|ALTER\\s+TABLE|DROP\\s+TABLE|TRUNCATE\\s+TABLE)\\s+(${INLINE_IDENTIFIER_PATH_PATTERN})(?:\\s+(?:AS\\s+)?(${INLINE_IDENTIFIER_PATTERN}))?`,
+    'gi',
+);
+const INLINE_CTE_NAME_RE = new RegExp(
+    `(?:\\bWITH|,)\\s+(${INLINE_IDENTIFIER_PATTERN})\\s+AS\\s*\\(`,
+    'gi',
+);
+const INLINE_TABLE_FRAGMENT_SAFE_RE = /^[`"[\]A-Za-z0-9_$.]*$/;
+const INLINE_COLUMN_FRAGMENT_SAFE_RE = /^[`"[\]A-Za-z0-9_$]*$/;
+
+const INLINE_TABLE_ALIAS_RESERVED_WORDS = new Set([
+    'where', 'on', 'group', 'order', 'limit', 'having',
+    'left', 'right', 'inner', 'outer', 'full', 'cross', 'join',
+    'union', 'except', 'intersect', 'as', 'set', 'values', 'returning',
+    'add', 'rename', 'modify', 'change', 'column', 'columns', 'comment',
+    'cascade', 'restrict', 'restart', 'continue', 'identity', 'using',
+    'when', 'then',
+]);
+
+const stripInlineIdentifierQuotes = (part: string): string => {
+    const text = String(part || '').trim();
+    if (!text) return '';
+    if ((text.startsWith('`') && text.endsWith('`'))
+        || (text.startsWith('"') && text.endsWith('"'))
+        || (text.startsWith('[') && text.endsWith(']'))) {
+        return text.slice(1, -1).trim();
+    }
+    return text;
+};
+
+const normalizeInlineIdentifierPath = (value: string): string => (
+    String(value || '')
+        .split('.')
+        .map(stripInlineIdentifierQuotes)
+        .filter(Boolean)
+        .join('.')
+);
+
+const getInlineIdentifierLastPart = (value: string): string => {
+    const parts = normalizeInlineIdentifierPath(value).split('.').filter(Boolean);
+    return parts[parts.length - 1] || '';
+};
+
+const sameIdentifier = (left: string | undefined, right: string | undefined): boolean =>
+    String(left || '').trim().toLowerCase() === String(right || '').trim().toLowerCase();
+
+const splitInlineSchemaAndTable = (tableName: string): { schema: string; table: string } => {
+    const parts = normalizeInlineIdentifierPath(tableName).split('.').filter(Boolean);
+    if (parts.length < 2) {
+        return { schema: '', table: parts[0] || '' };
+    }
+    return { schema: parts.slice(0, -1).join('.'), table: parts[parts.length - 1] || '' };
+};
+
+const resolveInlineTableReference = (
+    rawTableIdent: string,
+    rawAlias: string,
+    currentDb: string,
+    visibleDbs: string[],
+): QueryEditorAiTableReference | null => {
+    const tableIdent = normalizeInlineIdentifierPath(rawTableIdent);
+    if (!tableIdent) return null;
+
+    const visibleDbByLower = new Map(
+        visibleDbs
+            .map((db) => String(db || '').trim())
+            .filter(Boolean)
+            .map((db) => [db.toLowerCase(), db] as const),
+    );
+    const parts = tableIdent.split('.').filter(Boolean);
+    let dbName = currentDb || '';
+    let tableName = tableIdent;
+    if (parts.length === 2) {
+        const firstPartDb = visibleDbByLower.get(parts[0].toLowerCase());
+        if (firstPartDb || sameIdentifier(parts[0], currentDb)) {
+            dbName = firstPartDb || currentDb;
+            tableName = parts[1];
+        }
+    } else if (parts.length >= 3) {
+        dbName = visibleDbByLower.get(parts[0].toLowerCase()) || parts[0];
+        tableName = parts.slice(1).join('.');
+    }
+
+    const alias = stripInlineIdentifierQuotes(rawAlias);
+    const normalizedAlias = alias.toLowerCase();
+    return {
+        dbName,
+        tableName,
+        alias: alias && !INLINE_TABLE_ALIAS_RESERVED_WORDS.has(normalizedAlias) ? alias : undefined,
+        raw: tableIdent,
+    };
+};
+
+const collectInlineTableReferences = (
+    sql: string,
+    currentDb: string,
+    visibleDbs: string[],
+): QueryEditorAiTableReference[] => {
+    const refs: QueryEditorAiTableReference[] = [];
+    const seen = new Set<string>();
+    INLINE_TABLE_REFERENCE_RE.lastIndex = 0;
+    let match: RegExpExecArray | null;
+    while ((match = INLINE_TABLE_REFERENCE_RE.exec(String(sql || ''))) !== null) {
+        const ref = resolveInlineTableReference(match[1] || '', match[2] || '', currentDb, visibleDbs);
+        if (!ref) continue;
+        const key = `${ref.dbName.toLowerCase()}\u0000${ref.tableName.toLowerCase()}`;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        refs.push(ref);
+    }
+    return refs;
+};
+
+const tableMatchesInlineReference = (
+    table: Pick<CompletionTableMeta, 'dbName' | 'tableName'>,
+    ref: QueryEditorAiTableReference,
+): boolean => {
+    if (ref.dbName && table.dbName && !sameIdentifier(table.dbName, ref.dbName)) {
+        return false;
+    }
+    const tableName = normalizeInlineIdentifierPath(table.tableName || '');
+    const refTableName = normalizeInlineIdentifierPath(ref.tableName || '');
+    if (sameIdentifier(tableName, refTableName)) {
+        return true;
+    }
+    const parsedTable = splitInlineSchemaAndTable(tableName);
+    const parsedRef = splitInlineSchemaAndTable(refTableName);
+    return !!parsedTable.table && sameIdentifier(parsedTable.table, parsedRef.table || refTableName);
+};
+
+const collectReferencedSchemaTables = (
+    tables: CompletionTableMeta[],
+    refs: QueryEditorAiTableReference[],
+): CompletionTableMeta[] => {
+    const result: CompletionTableMeta[] = [];
+    const seen = new Set<string>();
+    const addTable = (table: CompletionTableMeta) => {
+        const key = schemaItemKey(table.dbName, table.tableName);
+        if (seen.has(key)) return;
+        seen.add(key);
+        result.push(table);
+    };
+
+    refs.forEach((ref) => {
+        const matched = tables.filter((table) => tableMatchesInlineReference(table, ref));
+        if (matched.length > 0) {
+            matched.forEach(addTable);
+        } else {
+            addTable({ dbName: ref.dbName, tableName: ref.tableName });
+        }
+    });
+
+    return result.slice(0, MAX_INLINE_SCHEMA_TABLES);
+};
+
+const filterColumnsForTables = (
+    columns: CompletionColumnMeta[],
+    tables: CompletionTableMeta[],
+    refs: QueryEditorAiTableReference[],
+): CompletionColumnMeta[] => {
+    if (!columns.length || (!tables.length && !refs.length)) {
+        return [];
+    }
+    return columns.filter((column) => {
+        if (tables.some((table) => tableMatchesInlineReference(
+            { dbName: column.dbName, tableName: column.tableName },
+            { dbName: table.dbName, tableName: table.tableName, raw: table.tableName },
+        ))) {
+            return true;
+        }
+        return refs.some((ref) => tableMatchesInlineReference(
+            { dbName: column.dbName, tableName: column.tableName },
+            ref,
+        ));
+    });
+};
+
+const collectCurrentDatabaseTables = (
+    tables: CompletionTableMeta[],
+    currentDb: string,
+): CompletionTableMeta[] => (
+    tables
+        .filter((table) => sameIdentifier(table.dbName, currentDb))
+        .sort((left, right) => String(left.tableName || '').localeCompare(String(right.tableName || '')))
+        .slice(0, MAX_INLINE_SCHEMA_TABLES)
+);
+
+export const resolveQueryEditorInlineCompletionIntentDetails = (
+    editorSnapshot: QueryEditorAiEditorSnapshot,
+): QueryEditorInlineCompletionIntentDetails => {
+    const statementPrefix = getCurrentStatementPrefix(editorSnapshot.prefix);
+    const tableMatch = statementPrefix.match(INLINE_TABLE_COMPLETION_RE);
+    if (tableMatch) {
+        const rawFragment = String(tableMatch[1] || '').trim();
+        return {
+            intent: 'table_name',
+            fragment: INLINE_TABLE_FRAGMENT_SAFE_RE.test(rawFragment)
+                ? normalizeInlineIdentifierPath(rawFragment)
+                : '',
+            qualifier: '',
+        };
+    }
+
+    const columnMatch = statementPrefix.match(INLINE_COLUMN_COMPLETION_RE);
+    if (columnMatch) {
+        const rawFragment = String(columnMatch[2] || '').trim();
+        return {
+            intent: 'column_name',
+            fragment: INLINE_COLUMN_FRAGMENT_SAFE_RE.test(rawFragment)
+                ? stripInlineIdentifierQuotes(rawFragment).trim()
+                : '',
+            qualifier: normalizeInlineIdentifierPath(columnMatch[1] || ''),
+        };
+    }
+
+    return {
+        intent: 'general_sql',
+        fragment: '',
+        qualifier: '',
+    };
+};
+
+const filterInlineTableMatches = (
+    tables: CompletionTableMeta[],
+    currentDb: string,
+    fragment: string,
+): CompletionTableMeta[] => {
+    const normalizedFragment = normalizeInlineIdentifierPath(fragment).toLowerCase();
+    const useQualifiedName = normalizedFragment.includes('.');
+    const matched = collectCurrentDatabaseTables(tables, currentDb).filter((table) => {
+        if (!normalizedFragment) {
+            return true;
+        }
+        const normalizedTableName = normalizeInlineIdentifierPath(table.tableName || '');
+        const candidate = useQualifiedName
+            ? normalizedTableName
+            : getInlineIdentifierLastPart(normalizedTableName);
+        return candidate.toLowerCase().startsWith(normalizedFragment);
+    });
+    return matched.slice(0, MAX_INLINE_SCHEMA_TABLES);
+};
+
+const resolveInlineColumnOwnerReference = (
+    context: QueryEditorAiContext,
+    editorSnapshot: QueryEditorAiEditorSnapshot,
+    qualifier: string,
+): QueryEditorAiTableReference | null => {
+    const normalizedQualifier = normalizeInlineIdentifierPath(qualifier);
+    if (!normalizedQualifier) {
+        return null;
+    }
+
+    const currentDb = String(context.currentDb || '').trim();
+    const statementPrefix = getCurrentStatementPrefix(editorSnapshot.prefix);
+    const aliasMap = buildQueryEditorAliasMap(statementPrefix, currentDb);
+    const aliasMatch = aliasMap[normalizedQualifier.toLowerCase()];
+    if (aliasMatch) {
+        return {
+            dbName: aliasMatch.dbName,
+            tableName: aliasMatch.tableName,
+            alias: normalizedQualifier,
+            raw: normalizedQualifier,
+        };
+    }
+
+    const directTable = (context.tables || []).find((table) => {
+        if (!sameIdentifier(table.dbName, currentDb)) {
+            return false;
+        }
+        const normalizedTableName = normalizeInlineIdentifierPath(table.tableName || '');
+        return sameIdentifier(normalizedTableName, normalizedQualifier)
+            || sameIdentifier(getInlineIdentifierLastPart(normalizedTableName), normalizedQualifier);
+    });
+    if (!directTable) {
+        return null;
+    }
+    return {
+        dbName: directTable.dbName,
+        tableName: directTable.tableName,
+        raw: normalizedQualifier,
+    };
+};
+
+const resolveUniqueCompletionCandidateInsertText = (
+    candidates: string[],
+    fragment: string,
+): string => {
+    const dedupedCandidates = Array.from(new Map(
+        candidates
+            .map((candidate) => String(candidate || '').trim())
+            .filter(Boolean)
+            .map((candidate) => [candidate.toLowerCase(), candidate] as const),
+    ).values());
+    if (dedupedCandidates.length === 0) {
+        return '';
+    }
+
+    const normalizedFragment = String(fragment || '').trim();
+    if (!normalizedFragment) {
+        return dedupedCandidates.length === 1 ? dedupedCandidates[0] : '';
+    }
+
+    const exactMatch = dedupedCandidates.find((candidate) => candidate.toLowerCase() === normalizedFragment.toLowerCase());
+    if (exactMatch) {
+        return '';
+    }
+
+    const prefixMatches = dedupedCandidates.filter((candidate) => candidate.toLowerCase().startsWith(normalizedFragment.toLowerCase()));
+    if (prefixMatches.length !== 1) {
+        return '';
+    }
+    return prefixMatches[0].slice(normalizedFragment.length);
+};
+
+const collectInlineTableCandidateLabels = (
+    context: QueryEditorAiContext,
+    fragment: string,
+): string[] => {
+    const currentDb = String(context.currentDb || '').trim();
+    const useQualifiedName = normalizeInlineIdentifierPath(fragment).includes('.');
+    return filterInlineTableMatches(context.tables || [], currentDb, fragment)
+        .map((table) => {
+            const normalizedTableName = normalizeInlineIdentifierPath(table.tableName || '');
+            return useQualifiedName ? normalizedTableName : getInlineIdentifierLastPart(normalizedTableName);
+        })
+        .filter(Boolean);
+};
+
+const collectInlineColumnCandidateLabels = (
+    context: QueryEditorAiContext,
+    editorSnapshot: QueryEditorAiEditorSnapshot,
+    qualifier: string,
+): string[] => {
+    const ownerRef = resolveInlineColumnOwnerReference(context, editorSnapshot, qualifier);
+    if (!ownerRef) {
+        return [];
+    }
+
+    return (context.columns || [])
+        .filter((column) => tableMatchesInlineReference(
+            { dbName: column.dbName, tableName: column.tableName },
+            ownerRef,
+        ))
+        .map((column) => stripInlineIdentifierQuotes(column.name || '').trim())
+        .filter(Boolean);
+};
+
+const resolveValidatedInlineObjectCandidateInsertText = ({
+    candidateLabels,
+    fragment,
+    insertText,
+    prefix,
+    normalizer,
+    safePattern,
+}: {
+    candidateLabels: string[];
+    fragment: string;
+    insertText: string;
+    prefix: string;
+    normalizer: (value: string) => string;
+    safePattern: RegExp;
+}): string => {
+    const trimmedInsertText = String(insertText || '').trim();
+    if (!trimmedInsertText || !safePattern.test(trimmedInsertText)) {
+        return '';
+    }
+
+    const normalizedDirectSuggestion = normalizer(trimmedInsertText).toLowerCase();
+    const normalizedCombinedSuggestion = normalizer(`${fragment}${trimmedInsertText}`).toLowerCase();
+
+    const dedupedCandidates = Array.from(new Map(
+        candidateLabels
+            .map((candidate) => String(candidate || '').trim())
+            .filter(Boolean)
+            .map((candidate) => [normalizer(candidate).toLowerCase(), candidate] as const),
+    ).values());
+
+    const matchedCandidate = dedupedCandidates.find((candidate) => {
+        const normalizedCandidate = normalizer(candidate).toLowerCase();
+        return normalizedCandidate === normalizedDirectSuggestion
+            || normalizedCandidate === normalizedCombinedSuggestion;
+    });
+    if (!matchedCandidate) {
+        return '';
+    }
+
+    return resolveInlineSqlInsertText(matchedCandidate, prefix);
+};
+
+const shouldAllowInlineObjectAiFallback = (
+    candidateLabels: string[],
+    fragment: string,
+    normalizer: (value: string) => string,
+): boolean => {
+    const dedupedCandidates = Array.from(new Map(
+        candidateLabels
+            .map((candidate) => String(candidate || '').trim())
+            .filter(Boolean)
+            .map((candidate) => [normalizer(candidate).toLowerCase(), candidate] as const),
+    ).values());
+    if (dedupedCandidates.length === 0) {
+        return false;
+    }
+
+    const normalizedFragment = normalizer(fragment).toLowerCase();
+    if (!normalizedFragment) {
+        return true;
+    }
+    if (dedupedCandidates.some((candidate) => normalizer(candidate).toLowerCase() === normalizedFragment)) {
+        return false;
+    }
+
+    const prefixMatches = dedupedCandidates.filter((candidate) => normalizer(candidate).toLowerCase().startsWith(normalizedFragment));
+    return prefixMatches.length > 1;
+};
+
+const resolveDeterministicInlineTableInsertText = (
+    context: QueryEditorAiContext,
+    fragment: string,
+): string => {
+    const candidateLabels = collectInlineTableCandidateLabels(context, fragment);
+    return resolveUniqueCompletionCandidateInsertText(candidateLabels, normalizeInlineIdentifierPath(fragment));
+};
+
+const resolveDeterministicInlineColumnInsertText = (
+    context: QueryEditorAiContext,
+    editorSnapshot: QueryEditorAiEditorSnapshot,
+    qualifier: string,
+    fragment: string,
+): string => {
+    const candidateLabels = collectInlineColumnCandidateLabels(context, editorSnapshot, qualifier);
+    return resolveUniqueCompletionCandidateInsertText(candidateLabels, stripInlineIdentifierQuotes(fragment || '').trim());
+};
+
+const resolveValidatedInlineTableAiInsertText = (
+    context: QueryEditorAiContext,
+    editorSnapshot: QueryEditorAiEditorSnapshot,
+    fragment: string,
+    insertText: string,
+): string => resolveValidatedInlineObjectCandidateInsertText({
+    candidateLabels: collectInlineTableCandidateLabels(context, fragment),
+    fragment,
+    insertText,
+    prefix: editorSnapshot.prefix,
+    normalizer: normalizeInlineIdentifierPath,
+    safePattern: INLINE_TABLE_FRAGMENT_SAFE_RE,
+});
+
+const resolveValidatedInlineColumnAiInsertText = (
+    context: QueryEditorAiContext,
+    editorSnapshot: QueryEditorAiEditorSnapshot,
+    qualifier: string,
+    fragment: string,
+    insertText: string,
+): string => resolveValidatedInlineObjectCandidateInsertText({
+    candidateLabels: collectInlineColumnCandidateLabels(context, editorSnapshot, qualifier),
+    fragment,
+    insertText,
+    prefix: editorSnapshot.prefix,
+    normalizer: stripInlineIdentifierQuotes,
+    safePattern: INLINE_COLUMN_FRAGMENT_SAFE_RE,
+});
+
+const shouldAllowInlineTableAiFallback = (
+    context: QueryEditorAiContext,
+    fragment: string,
+): boolean => shouldAllowInlineObjectAiFallback(
+    collectInlineTableCandidateLabels(context, fragment),
+    fragment,
+    normalizeInlineIdentifierPath,
+);
+
+const shouldAllowInlineColumnAiFallback = (
+    context: QueryEditorAiContext,
+    editorSnapshot: QueryEditorAiEditorSnapshot,
+    qualifier: string,
+    fragment: string,
+): boolean => shouldAllowInlineObjectAiFallback(
+    collectInlineColumnCandidateLabels(context, editorSnapshot, qualifier),
+    fragment,
+    stripInlineIdentifierQuotes,
+);
+
+const resolveDeterministicInlineSchemaCompletion = (
+    context: QueryEditorAiContext,
+    editorSnapshot: QueryEditorAiEditorSnapshot,
+    intentDetails?: QueryEditorInlineCompletionIntentDetails,
+): { handled: boolean; insertText: string } => {
+    const intent = intentDetails || resolveQueryEditorInlineCompletionIntentDetails(editorSnapshot);
+    if (intent.intent === 'table_name') {
+        return {
+            handled: true,
+            insertText: resolveDeterministicInlineTableInsertText(context, intent.fragment),
+        };
+    }
+    if (intent.intent === 'column_name') {
+        return {
+            handled: true,
+            insertText: resolveDeterministicInlineColumnInsertText(
+                context,
+                editorSnapshot,
+                intent.qualifier,
+                intent.fragment,
+            ),
+        };
+    }
+    return {
+        handled: false,
+        insertText: '',
+    };
+};
+
+const buildKeywordSuffixInsertText = (statementPrefix: string, suffix: string): string => (
+    /\s$/.test(statementPrefix) ? suffix : ` ${suffix}`
+);
+
+const resolveDeterministicInlineSyntaxCompletion = (
+    editorSnapshot: QueryEditorAiEditorSnapshot,
+): { handled: boolean; insertText: string } => {
+    const statementPrefix = getCurrentStatementPrefix(editorSnapshot.prefix);
+    const trimmedStatement = statementPrefix.trim();
+
+    if (!trimmedStatement) {
+        return {
+            handled: false,
+            insertText: '',
+        };
+    }
+
+    if (/^SELECT(?:\s+DISTINCT)?$/i.test(trimmedStatement)) {
+        return {
+            handled: true,
+            insertText: buildKeywordSuffixInsertText(statementPrefix, '* FROM '),
+        };
+    }
+
+    if (/^SELECT\s+\*$/i.test(trimmedStatement)) {
+        return {
+            handled: true,
+            insertText: buildKeywordSuffixInsertText(statementPrefix, 'FROM '),
+        };
+    }
+
+    if (/^DELETE$/i.test(trimmedStatement)) {
+        return {
+            handled: true,
+            insertText: buildKeywordSuffixInsertText(statementPrefix, 'FROM '),
+        };
+    }
+
+    if (/^INSERT$/i.test(trimmedStatement)) {
+        return {
+            handled: true,
+            insertText: buildKeywordSuffixInsertText(statementPrefix, 'INTO '),
+        };
+    }
+
+    if (/^MERGE$/i.test(trimmedStatement)) {
+        return {
+            handled: true,
+            insertText: buildKeywordSuffixInsertText(statementPrefix, 'INTO '),
+        };
+    }
+
+    if (/^REPLACE$/i.test(trimmedStatement)) {
+        return {
+            handled: true,
+            insertText: buildKeywordSuffixInsertText(statementPrefix, 'INTO '),
+        };
+    }
+
+    if (/^ALTER$/i.test(trimmedStatement)) {
+        return {
+            handled: true,
+            insertText: buildKeywordSuffixInsertText(statementPrefix, 'TABLE '),
+        };
+    }
+
+    if (/^CREATE$/i.test(trimmedStatement)) {
+        return {
+            handled: true,
+            insertText: buildKeywordSuffixInsertText(statementPrefix, 'TABLE '),
+        };
+    }
+
+    if (/^DROP$/i.test(trimmedStatement)) {
+        return {
+            handled: true,
+            insertText: buildKeywordSuffixInsertText(statementPrefix, 'TABLE '),
+        };
+    }
+
+    if (/^TRUNCATE$/i.test(trimmedStatement)) {
+        return {
+            handled: true,
+            insertText: buildKeywordSuffixInsertText(statementPrefix, 'TABLE '),
+        };
+    }
+
+    return {
+        handled: false,
+        insertText: '',
+    };
+};
+
+const collectInlineCteNames = (sql: string): Set<string> => {
+    const names = new Set<string>();
+    INLINE_CTE_NAME_RE.lastIndex = 0;
+    let match: RegExpExecArray | null;
+    while ((match = INLINE_CTE_NAME_RE.exec(String(sql || ''))) !== null) {
+        const name = stripInlineIdentifierQuotes(match[1] || '').trim();
+        if (name) {
+            names.add(name.toLowerCase());
+        }
+    }
+    return names;
+};
+
+const isInlineCompletionScopedToKnownContext = (
+    insertText: string,
+    prefix: string,
+    context: QueryEditorAiContext,
+): boolean => {
+    const insertedTableRefs = collectInlineTableReferences(insertText, context.currentDb || '', context.visibleDbs || []);
+    if (!insertedTableRefs.length) {
+        return true;
+    }
+
+    const knownTables = context.tables || [];
+    const knownRefs = context.inlineReferencedTables || [];
+    const cteNames = collectInlineCteNames(prefix);
+
+    return insertedTableRefs.every((ref) => {
+        const refLastPart = getInlineIdentifierLastPart(ref.tableName).toLowerCase();
+        if (refLastPart && cteNames.has(refLastPart)) {
+            return true;
+        }
+        return knownTables.some((table) => tableMatchesInlineReference(table, ref))
+            || knownRefs.some((knownRef) => tableMatchesInlineReference(
+                { dbName: knownRef.dbName, tableName: knownRef.tableName },
+                ref,
+            ));
+    });
+};
+
 const getCurrentStatementPrefix = (prefix: string): string => {
     const text = String(prefix || '');
     const semicolonIndex = text.lastIndexOf(';');
diff --git a/frontend/src/i18n/catalog.test.ts b/frontend/src/i18n/catalog.test.ts
index c0581aa1..8183c22d 100644
--- a/frontend/src/i18n/catalog.test.ts
+++ b/frontend/src/i18n/catalog.test.ts
@@ -249,6 +249,8 @@ describe("i18n catalog", () => {
       "app.shortcuts.action.selectCurrentStatement.label",
       "app.shortcuts.action.sendAIChatMessage.description",
       "app.shortcuts.action.sendAIChatMessage.label",
+      "app.shortcuts.action.triggerSqlAiCompletion.description",
+      "app.shortcuts.action.triggerSqlAiCompletion.label",
       "app.shortcuts.action.switchToNextTab.description",
       "app.shortcuts.action.switchToNextTab.label",
       "app.shortcuts.action.switchToPreviousTab.description",
diff --git a/frontend/src/main.tsx b/frontend/src/main.tsx
index 51eee74f..e4256e74 100644
--- a/frontend/src/main.tsx
+++ b/frontend/src/main.tsx
@@ -20,9 +20,41 @@ const resolveDevHarnessMode = (): string => {
     }
 };
 
-if (typeof window !== 'undefined' && (!(window as any).go?.app?.App || !(window as any).go?.aiservice?.Service)) {
+if (
+    typeof window !== 'undefined'
+    && (
+        typeof (window as any).go?.app?.App?.GetSavedConnections !== 'function'
+        || typeof (window as any).go?.aiservice?.Service?.AIGetProviders !== 'function'
+    )
+) {
+    const existingRuntime = (window as any).runtime || {};
+    const existingEventsOnMultiple = existingRuntime.EventsOnMultiple;
+    (window as any).runtime = {
+        ...existingRuntime,
+        EventsOnMultiple: (...args: any[]) => {
+            const off = typeof existingEventsOnMultiple === 'function'
+                ? existingEventsOnMultiple(...args)
+                : undefined;
+            return typeof off === 'function' ? off : () => {};
+        },
+        EventsOff: typeof existingRuntime.EventsOff === 'function' ? existingRuntime.EventsOff : () => {},
+        EventsOffAll: typeof existingRuntime.EventsOffAll === 'function' ? existingRuntime.EventsOffAll : () => {},
+        EventsEmit: typeof existingRuntime.EventsEmit === 'function' ? existingRuntime.EventsEmit : () => {},
+    };
+
     const mockConnections: any[] = [];
     const mockSavedQueries: any[] = [];
+    const mockQueryTables = [
+        { table_name: 'videos', table_comment: 'sample video records' },
+        { table_name: 'users', table_comment: 'sample users' },
+    ];
+    const mockQueryColumns = [
+        { tableName: 'videos', name: 'id', type: 'bigint', comment: 'primary key' },
+        { tableName: 'videos', name: 'code', type: 'varchar', comment: 'video code' },
+        { tableName: 'videos', name: 'title', type: 'varchar', comment: 'video title' },
+        { tableName: 'users', name: 'id', type: 'bigint', comment: 'primary key' },
+        { tableName: 'users', name: 'name', type: 'varchar', comment: 'display name' },
+    ];
     const mockConnectionSecrets = new Map<string, any>();
     const mockProviders: any[] = [];
     const mockProviderSecrets = new Map<string, string>();
@@ -274,6 +306,18 @@ if (typeof window !== 'undefined' && (!(window as any).go?.app?.App || !(window
                 GetTables: async () => [],
                 GetTableData: async () => ({ columns: [], rows: [], total: 0 }),
                 GetTableColumns: async () => [],
+                DBGetDatabases: async () => ({ success: true, data: ['missav_bot'] }),
+                DBGetTables: async () => ({ success: true, data: cloneBrowserMockValue(mockQueryTables) }),
+                DBGetAllColumns: async () => ({ success: true, data: cloneBrowserMockValue(mockQueryColumns) }),
+                DBGetColumns: async (_config: any, _dbName: string, tableName: string) => ({
+                    success: true,
+                    data: cloneBrowserMockValue(
+                        mockQueryColumns
+                            .filter((column) => String(column.tableName || '').toLowerCase() === String(tableName || '').toLowerCase())
+                            .map(({ tableName: _tableName, ...column }) => column),
+                    ),
+                }),
+                DBQuery: async () => ({ success: true, data: [], columns: [] }),
                 ExecuteQuery: async () => ({ columns: [], rows: [], time: 0 }),
                 GetSavedQueries: async () => cloneBrowserMockValue(mockSavedQueries),
                 SaveQuery: async (input: any) => saveMockQuery(input),
@@ -413,6 +457,21 @@ if (typeof window !== 'undefined' && (!(window as any).go?.app?.App || !(window
                 AIGetContextLevel: async () => mockAIContextLevel,
                 AIGetBuiltinPrompts: async () => ({}),
                 AIGetUserPromptSettings: async () => cloneBrowserMockValue(mockAIUserPromptSettings),
+                AIChatSend: async () => ({
+                    success: true,
+                    content: 'SELECT * FROM `videos` LIMIT 100;',
+                }),
+                AIChatSendWithOptions: async (messages: any[], tools: any[], options: any) => {
+                    (window as any).__gonaviLastAIChatSendWithOptions = {
+                        messages: cloneBrowserMockValue(messages),
+                        tools: cloneBrowserMockValue(tools),
+                        options: cloneBrowserMockValue(options),
+                    };
+                    return {
+                        success: true,
+                        content: 'SELECT * FROM `videos` LIMIT 100;',
+                    };
+                },
                 AISaveUserPromptSettings: async (input: any) => {
                     mockAIUserPromptSettings = {
                         global: String(input?.global || ''),
diff --git a/frontend/src/types.ts b/frontend/src/types.ts
index 6fef4876..a4e19d4d 100644
--- a/frontend/src/types.ts
+++ b/frontend/src/types.ts
@@ -620,6 +620,7 @@ export interface AIProviderConfig {
   hasSecret?: boolean;
   baseUrl: string;
   model: string;
+  inlineCompletionModel?: string;
   models?: string[];
   apiFormat?: string; // custom 专用: openai | anthropic | gemini | cursor-agent | claude-cli | codebuddy-cli
   headers?: Record<string, string>;
diff --git a/frontend/src/utils/shortcuts.test.ts b/frontend/src/utils/shortcuts.test.ts
index 5903529d..9ea818f9 100644
--- a/frontend/src/utils/shortcuts.test.ts
+++ b/frontend/src/utils/shortcuts.test.ts
@@ -154,6 +154,7 @@ describe('shortcut localization', () => {
       expect(SHORTCUT_ACTION_META.runQuery.label).toBe('Run SQL');
       expect(SHORTCUT_ACTION_META.saveQuery.description).toBe('Save the current query tab; unnamed queries open the save dialog');
       expect(SHORTCUT_ACTION_META.formatSql.label).toBe('Format SQL');
+      expect(SHORTCUT_ACTION_META.triggerSqlAiCompletion.label).toBe('Trigger SQL AI Completion');
       expect(SHORTCUT_ACTION_META.toggleQueryResultsPanel.label).toBe('Toggle Results Panel');
       expect(SHORTCUT_ACTION_META.toggleQueryResultsPanel.description).toBe('Show or hide the results area below the query editor');
       expect(SHORTCUT_ACTION_META.sendAIChatMessage.description).toContain('Shift+Enter');
@@ -168,6 +169,7 @@ describe('shortcut localization', () => {
       setCurrentLanguage('zh-CN');
       expect(SHORTCUT_ACTION_META.runQuery.label).toBe('执行 SQL');
       expect(SHORTCUT_ACTION_META.formatSql.label).toBe('美化 SQL');
+      expect(SHORTCUT_ACTION_META.triggerSqlAiCompletion.label).toBe('触发 SQL AI 自动补全');
       expect(findReservedConflict('Ctrl+S')?.label).toBe('浏览器保存');
     } finally {
       setCurrentLanguage('zh-CN');
@@ -265,6 +267,54 @@ describe('IME shortcut guards', () => {
     expect(isShortcutMatch(event, 'Ctrl+Enter')).toBe(false);
   });
 
+  it('matches modifier shortcuts from KeyboardEvent.code when WebView reports Process', () => {
+    const event = {
+      key: 'Process',
+      code: 'Backslash',
+      keyCode: 220,
+      which: 220,
+      ctrlKey: false,
+      metaKey: false,
+      altKey: true,
+      shiftKey: false,
+      isComposing: false,
+      nativeEvent: {
+        code: 'Backslash',
+        keyCode: 220,
+        which: 220,
+        isComposing: false,
+      },
+    } as unknown as KeyboardEvent;
+
+    expect(isImeComposingKeyEvent(event)).toBe(false);
+    expect(eventToShortcut(event)).toBe('Alt+\\');
+    expect(isShortcutMatch(event, 'Alt+\\')).toBe(true);
+  });
+
+  it('matches modifier shortcuts from IntlBackslash layout events when WebView reports Process', () => {
+    const event = {
+      key: 'Process',
+      code: 'IntlBackslash',
+      keyCode: 226,
+      which: 226,
+      ctrlKey: false,
+      metaKey: false,
+      altKey: true,
+      shiftKey: false,
+      isComposing: false,
+      nativeEvent: {
+        code: 'IntlBackslash',
+        keyCode: 226,
+        which: 226,
+        isComposing: false,
+      },
+    } as unknown as KeyboardEvent;
+
+    expect(isImeComposingKeyEvent(event)).toBe(false);
+    expect(eventToShortcut(event)).toBe('Alt+\\');
+    expect(isShortcutMatch(event, 'Alt+\\')).toBe(true);
+  });
+
   it('treats number keys as non-shortcuts while a composition session is active', () => {
     setGlobalImeCompositionActive(true);
     const event = {
@@ -366,6 +416,18 @@ describe('shortcut defaults', () => {
     });
   });
 
+  it('registers manual SQL AI completion as a query editor shortcut', () => {
+    expect(DEFAULT_SHORTCUT_OPTIONS.triggerSqlAiCompletion).toEqual({
+      mac: { combo: 'Alt+\\', enabled: true },
+      windows: { combo: 'Alt+\\', enabled: true },
+    });
+    expect(SHORTCUT_ACTION_META.triggerSqlAiCompletion).toMatchObject({
+      label: '触发 SQL AI 自动补全',
+      scope: 'queryEditor',
+      allowInEditable: true,
+    });
+  });
+
   it('registers query results panel toggle as a query editor shortcut', () => {
     expect(DEFAULT_SHORTCUT_OPTIONS.toggleQueryResultsPanel).toEqual({
       mac: { combo: 'Meta+Shift+M', enabled: true },
@@ -581,6 +643,13 @@ describe('comboToMonacoKeyBinding', () => {
     });
   });
 
+  it('maps Alt+\\ (manual AI completion)', () => {
+    expect(comboToMonacoKeyBinding('Alt+\\', mockKeyMod, mockKeyCode)).toEqual({
+      keyMod: mockKeyMod.Alt,
+      keyCode: mockKeyCode.Oem5,
+    });
+  });
+
   it('returns null for empty combo', () => {
     expect(comboToMonacoKeyBinding('', mockKeyMod, mockKeyCode)).toBeNull();
   });
diff --git a/frontend/src/utils/shortcuts.ts b/frontend/src/utils/shortcuts.ts
index 80046330..ccfd8e7f 100644
--- a/frontend/src/utils/shortcuts.ts
+++ b/frontend/src/utils/shortcuts.ts
@@ -8,6 +8,7 @@ export type ShortcutAction =
   | 'duplicateCurrentLine'
   | 'saveQuery'
   | 'formatSql'
+  | 'triggerSqlAiCompletion'
   | 'toggleQueryResultsPanel'
   | 'sendAIChatMessage'
   | 'focusSidebarSearch'
@@ -108,6 +109,7 @@ export const SHORTCUT_ACTION_ORDER: ShortcutAction[] = [
   'duplicateCurrentLine',
   'saveQuery',
   'formatSql',
+  'triggerSqlAiCompletion',
   'toggleQueryResultsPanel',
   'sendAIChatMessage',
   'focusSidebarSearch',
@@ -174,6 +176,12 @@ const SHORTCUT_ACTION_META_DEFINITIONS: Record<ShortcutAction, ShortcutActionMet
     scope: 'queryEditor',
     allowInEditable: true,
   },
+  triggerSqlAiCompletion: {
+    labelKey: 'app.shortcuts.action.triggerSqlAiCompletion.label',
+    descriptionKey: 'app.shortcuts.action.triggerSqlAiCompletion.description',
+    scope: 'queryEditor',
+    allowInEditable: true,
+  },
   toggleQueryResultsPanel: {
     labelKey: 'app.shortcuts.action.toggleQueryResultsPanel.label',
     descriptionKey: 'app.shortcuts.action.toggleQueryResultsPanel.description',
@@ -282,6 +290,10 @@ export const DEFAULT_SHORTCUT_OPTIONS: ShortcutOptions = {
     mac: { combo: 'Alt+Shift+F', enabled: true },
     windows: { combo: 'Alt+Shift+F', enabled: true },
   },
+  triggerSqlAiCompletion: {
+    mac: { combo: 'Alt+\\', enabled: true },
+    windows: { combo: 'Alt+\\', enabled: true },
+  },
   toggleQueryResultsPanel: {
     mac: { combo: 'Meta+Shift+M', enabled: true },
     windows: { combo: 'Ctrl+Shift+M', enabled: true },
@@ -406,6 +418,54 @@ const normalizeKeyboardKey = (key: string): string => {
   return token.length > 1 ? token[0].toUpperCase() + token.slice(1) : token;
 };
 
+const KEYBOARD_CODE_ALIASES: Record<string, string> = {
+  Backslash: '\\',
+  IntlBackslash: '\\',
+  Slash: '/',
+  Comma: ',',
+  Period: '.',
+  Semicolon: ';',
+  Quote: "'",
+  BracketLeft: '[',
+  BracketRight: ']',
+  Minus: '-',
+  Equal: '=',
+  Backquote: '`',
+};
+
+const KEY_CODE_ALIASES: Record<number, string> = {
+  186: ';',
+  187: '=',
+  188: ',',
+  189: '-',
+  190: '.',
+  191: '/',
+  192: '`',
+  219: '[',
+  220: '\\',
+  226: '\\',
+  221: ']',
+  222: "'",
+};
+
+const normalizeKeyboardEventCode = (
+  event: (KeyboardEvent | ReactKeyboardEvent) & {
+    code?: string;
+    keyCode?: number;
+    which?: number;
+    nativeEvent?: { code?: string; keyCode?: number; which?: number };
+  },
+): string => {
+  const code = String(event.code || event.nativeEvent?.code || '').trim();
+  if (code) {
+    const alias = KEYBOARD_CODE_ALIASES[code];
+    if (alias) return alias;
+  }
+
+  const keyCode = Number(event.keyCode ?? event.nativeEvent?.keyCode ?? event.which ?? event.nativeEvent?.which ?? 0);
+  return KEY_CODE_ALIASES[keyCode] || '';
+};
+
 let globalImeCompositionActive = false;
 
 export const setGlobalImeCompositionActive = (active: boolean): void => {
@@ -490,15 +550,16 @@ export const isImeComposingKeyEvent = (
   const key = String(event.key || '').trim();
   const keyCode = Number(event.keyCode ?? nativeEvent?.keyCode ?? 0);
   const which = Number(event.which ?? nativeEvent?.which ?? 0);
+  const hasModifier = Boolean(event.ctrlKey || event.metaKey || event.altKey);
 
   // Primary IME indicators — reliable across all browsers/WebViews.
   if (
     globalImeCompositionActive
     || event.isComposing
     || nativeEvent?.isComposing
-    || key === 'Process'
     || keyCode === 229
     || which === 229
+    || (key === 'Process' && !hasModifier)
   ) {
     return true;
   }
@@ -512,7 +573,6 @@ export const isImeComposingKeyEvent = (
   // even when the user is pressing a shortcut (e.g. Cmd+E) while a CJK input
   // method is simply *enabled* (not actively composing).  Blocking modifier-
   // key combos would break all window-level shortcuts for CJK users.
-  const hasModifier = Boolean(event.ctrlKey || event.metaKey || event.altKey);
   if (!hasModifier && isMonacoImeInputTarget(event.target)) {
     return true;
   }
@@ -520,29 +580,70 @@ export const isImeComposingKeyEvent = (
   return false;
 };
 
-export const eventToShortcut = (event: KeyboardEvent | ReactKeyboardEvent): string => {
-  if (isImeComposingKeyEvent(event)) {
-    return '';
-  }
-  const key = normalizeKeyboardKey(event.key);
-  if (!key || MODIFIER_SET.has(key as typeof MODIFIER_ORDER[number])) {
-    return '';
-  }
-
+const resolveShortcutModifiersFromEvent = (event: KeyboardEvent | ReactKeyboardEvent): string[] => {
   const modifiers: string[] = [];
   if (event.ctrlKey) modifiers.push('Ctrl');
   if (event.metaKey) modifiers.push('Meta');
   if (event.altKey) modifiers.push('Alt');
   if (event.shiftKey) modifiers.push('Shift');
+  return modifiers;
+};
 
+const normalizeShortcutCandidate = (modifiers: string[], key: string): string => {
+  if (!key || MODIFIER_SET.has(key as typeof MODIFIER_ORDER[number])) {
+    return '';
+  }
   return normalizeShortcutCombo([...modifiers, key].join('+'));
 };
 
+const isUsableShortcutKey = (key: string): boolean => (
+  Boolean(key)
+  && !MODIFIER_SET.has(key as typeof MODIFIER_ORDER[number])
+  && key !== 'Process'
+  && key !== 'Unidentified'
+  && key !== 'Dead'
+);
+
+const eventToShortcutCandidates = (event: KeyboardEvent | ReactKeyboardEvent): string[] => {
+  if (isImeComposingKeyEvent(event)) {
+    return [];
+  }
+  const modifiers = resolveShortcutModifiersFromEvent(event);
+  const candidates: string[] = [];
+  const pushCandidate = (key: string) => {
+    const candidate = normalizeShortcutCandidate(modifiers, key);
+    if (candidate && !candidates.includes(candidate)) {
+      candidates.push(candidate);
+    }
+  };
+
+  const key = normalizeKeyboardKey(event.key);
+  if (isUsableShortcutKey(key)) {
+    pushCandidate(key);
+  }
+
+  const codeKey = normalizeKeyboardEventCode(event);
+  if (
+    codeKey
+    && (
+      !isUsableShortcutKey(key)
+      || key.length !== 1
+    )
+  ) {
+    pushCandidate(codeKey);
+  }
+
+  return candidates;
+};
+
+export const eventToShortcut = (event: KeyboardEvent | ReactKeyboardEvent): string => {
+  return eventToShortcutCandidates(event)[0] || '';
+};
+
 export const isShortcutMatch = (event: KeyboardEvent | ReactKeyboardEvent, combo: string): boolean => {
   const expected = normalizeShortcutCombo(combo);
   if (!expected) return false;
-  const actual = eventToShortcut(event);
-  return actual === expected;
+  return eventToShortcutCandidates(event).includes(expected);
 };
 
 export const getShortcutPlatform = (isMacRuntime?: boolean): ShortcutPlatform => (
diff --git a/frontend/wailsjs/go/aiservice/Service.d.ts b/frontend/wailsjs/go/aiservice/Service.d.ts
index 847aa0e1..266db5bd 100755
--- a/frontend/wailsjs/go/aiservice/Service.d.ts
+++ b/frontend/wailsjs/go/aiservice/Service.d.ts
@@ -10,6 +10,8 @@ export function AIChatSend(arg1:Array<ai.Message>,arg2:Array<ai.Tool>):Promise<R
 
 export function AIChatSendInSession(arg1:string,arg2:Array<ai.Message>,arg3:Array<ai.Tool>):Promise<Record<string, any>>;
 
+export function AIChatSendWithOptions(arg1:Array<ai.Message>,arg2:Array<ai.Tool>,arg3:ai.ChatSendOptions):Promise<Record<string, any>>;
+
 export function AIChatStream(arg1:string,arg2:Array<ai.Message>,arg3:Array<ai.Tool>):Promise<void>;
 
 export function AICheckSQL(arg1:string):Promise<ai.SafetyResult>;
diff --git a/frontend/wailsjs/go/aiservice/Service.js b/frontend/wailsjs/go/aiservice/Service.js
index 5a7f078c..5be77f54 100755
--- a/frontend/wailsjs/go/aiservice/Service.js
+++ b/frontend/wailsjs/go/aiservice/Service.js
@@ -18,6 +18,10 @@ export function AIChatSendInSession(arg1, arg2, arg3) {
   return window['go']['aiservice']['Service']['AIChatSendInSession'](arg1, arg2, arg3);
 }
 
+export function AIChatSendWithOptions(arg1, arg2, arg3) {
+  return window['go']['aiservice']['Service']['AIChatSendWithOptions'](arg1, arg2, arg3);
+}
+
 export function AIChatStream(arg1, arg2, arg3) {
   return window['go']['aiservice']['Service']['AIChatStream'](arg1, arg2, arg3);
 }
diff --git a/frontend/wailsjs/go/app/App.d.ts b/frontend/wailsjs/go/app/App.d.ts
index 1a2e1cfd..c49bd8e9 100755
--- a/frontend/wailsjs/go/app/App.d.ts
+++ b/frontend/wailsjs/go/app/App.d.ts
@@ -260,6 +260,8 @@ export function RedisDeleteKeys(arg1:connection.ConnectionConfig,arg2:Array<stri
 
 export function RedisExecuteCommand(arg1:connection.ConnectionConfig,arg2:string):Promise<connection.QueryResult>;
 
+export function RedisExportKeys(arg1:connection.ConnectionConfig,arg2:app.RedisExportKeysOptions):Promise<connection.QueryResult>;
+
 export function RedisFlushDB(arg1:connection.ConnectionConfig):Promise<connection.QueryResult>;
 
 export function RedisGetDatabases(arg1:connection.ConnectionConfig):Promise<connection.QueryResult>;
@@ -268,12 +270,16 @@ export function RedisGetServerInfo(arg1:connection.ConnectionConfig):Promise<con
 
 export function RedisGetValue(arg1:connection.ConnectionConfig,arg2:string):Promise<connection.QueryResult>;
 
+export function RedisImportKeys(arg1:connection.ConnectionConfig,arg2:app.RedisImportKeysOptions):Promise<connection.QueryResult>;
+
 export function RedisKeyExists(arg1:connection.ConnectionConfig,arg2:string):Promise<connection.QueryResult>;
 
 export function RedisListPush(arg1:connection.ConnectionConfig,arg2:string,arg3:Array<string>):Promise<connection.QueryResult>;
 
 export function RedisListSet(arg1:connection.ConnectionConfig,arg2:string,arg3:number,arg4:string):Promise<connection.QueryResult>;
 
+export function RedisPreviewImportKeys(arg1:connection.ConnectionConfig):Promise<connection.QueryResult>;
+
 export function RedisRenameKey(arg1:connection.ConnectionConfig,arg2:string,arg3:string):Promise<connection.QueryResult>;
 
 export function RedisScanKeys(arg1:connection.ConnectionConfig,arg2:string,arg3:any,arg4:number):Promise<connection.QueryResult>;
diff --git a/frontend/wailsjs/go/app/App.js b/frontend/wailsjs/go/app/App.js
index d229a372..d3847a99 100755
--- a/frontend/wailsjs/go/app/App.js
+++ b/frontend/wailsjs/go/app/App.js
@@ -510,6 +510,10 @@ export function RedisExecuteCommand(arg1, arg2) {
   return window['go']['app']['App']['RedisExecuteCommand'](arg1, arg2);
 }
 
+export function RedisExportKeys(arg1, arg2) {
+  return window['go']['app']['App']['RedisExportKeys'](arg1, arg2);
+}
+
 export function RedisFlushDB(arg1) {
   return window['go']['app']['App']['RedisFlushDB'](arg1);
 }
@@ -526,6 +530,10 @@ export function RedisGetValue(arg1, arg2) {
   return window['go']['app']['App']['RedisGetValue'](arg1, arg2);
 }
 
+export function RedisImportKeys(arg1, arg2) {
+  return window['go']['app']['App']['RedisImportKeys'](arg1, arg2);
+}
+
 export function RedisKeyExists(arg1, arg2) {
   return window['go']['app']['App']['RedisKeyExists'](arg1, arg2);
 }
@@ -538,6 +546,10 @@ export function RedisListSet(arg1, arg2, arg3, arg4) {
   return window['go']['app']['App']['RedisListSet'](arg1, arg2, arg3, arg4);
 }
 
+export function RedisPreviewImportKeys(arg1) {
+  return window['go']['app']['App']['RedisPreviewImportKeys'](arg1);
+}
+
 export function RedisRenameKey(arg1, arg2, arg3) {
   return window['go']['app']['App']['RedisRenameKey'](arg1, arg2, arg3);
 }
diff --git a/frontend/wailsjs/go/models.ts b/frontend/wailsjs/go/models.ts
index 0bbcac9a..c8918d7d 100755
--- a/frontend/wailsjs/go/models.ts
+++ b/frontend/wailsjs/go/models.ts
@@ -1,5 +1,21 @@
 export namespace ai {
-
+	
+	export class ChatSendOptions {
+	    model?: string;
+	    temperature?: number;
+	    maxTokens?: number;
+	
+	    static createFrom(source: any = {}) {
+	        return new ChatSendOptions(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.model = source["model"];
+	        this.temperature = source["temperature"];
+	        this.maxTokens = source["maxTokens"];
+	    }
+	}
 	export class MCPClientInstallResult {
 	    success: boolean;
 	    client?: string;
@@ -7,11 +23,11 @@ export namespace ai {
 	    configPath?: string;
 	    command?: string;
 	    args?: string[];
-
+	
 	    static createFrom(source: any = {}) {
 	        return new MCPClientInstallResult(source);
 	    }
-
+	
 	    constructor(source: any = {}) {
 	        if ('string' === typeof source) source = JSON.parse(source);
 	        this.success = source["success"];
@@ -275,6 +291,7 @@ export namespace ai {
 	    hasSecret?: boolean;
 	    baseUrl: string;
 	    model: string;
+	    inlineCompletionModel?: string;
 	    models?: string[];
 	    apiFormat?: string;
 	    headers?: Record<string, string>;
@@ -295,6 +312,7 @@ export namespace ai {
 	        this.hasSecret = source["hasSecret"];
 	        this.baseUrl = source["baseUrl"];
 	        this.model = source["model"];
+	        this.inlineCompletionModel = source["inlineCompletionModel"];
 	        this.models = source["models"];
 	        this.apiFormat = source["apiFormat"];
 	        this.headers = source["headers"];
@@ -452,6 +470,40 @@ export namespace app {
 	        this.totalRowsKnown = source["totalRowsKnown"];
 	    }
 	}
+	export class RedisExportKeysOptions {
+	    scope?: string;
+	    keys?: string[];
+	    pattern?: string;
+	
+	    static createFrom(source: any = {}) {
+	        return new RedisExportKeysOptions(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.scope = source["scope"];
+	        this.keys = source["keys"];
+	        this.pattern = source["pattern"];
+	    }
+	}
+	export class RedisImportKeysOptions {
+	    conflictMode?: string;
+	    scope?: string;
+	    keys?: string[];
+	    file?: string;
+	
+	    static createFrom(source: any = {}) {
+	        return new RedisImportKeysOptions(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.conflictMode = source["conflictMode"];
+	        this.scope = source["scope"];
+	        this.keys = source["keys"];
+	        this.file = source["file"];
+	    }
+	}
 	export class SecurityUpdateOptions {
 	    allowPartial?: boolean;
 	    writeBackup?: boolean;
@@ -908,11 +960,11 @@ export namespace connection {
 	    restrictStructureEdit?: boolean;
 	    restrictScriptExecution?: boolean;
 	    restrictDataImport?: boolean;
-
+	
 	    static createFrom(source: any = {}) {
 	        return new ConnectionProtectionConfig(source);
 	    }
-
+	
 	    constructor(source: any = {}) {
 	        if ('string' === typeof source) source = JSON.parse(source);
 	        this.restrictDataEdit = source["restrictDataEdit"];
@@ -1039,9 +1091,9 @@ export namespace connection {
 		        return new classs(a);
 		    }
 		    return a;
-	    }
+		}
 	}
-
+	
 	export class GlobalProxyView {
 	    enabled: boolean;
 	    type: string;
diff --git a/internal/ai/provider/openai.go b/internal/ai/provider/openai.go
index ae564697..5f76b655 100644
--- a/internal/ai/provider/openai.go
+++ b/internal/ai/provider/openai.go
@@ -217,6 +217,7 @@ func (p *OpenAIProvider) Chat(ctx context.Context, req ai.ChatRequest) (*ai.Chat
 		Model:       p.config.Model,
 		Messages:    messages,
 		Temperature: temperature,
+		MaxTokens:   req.MaxTokens,
 		Stream:      false,
 		Tools:       req.Tools,
 	}
@@ -270,6 +271,7 @@ func (p *OpenAIProvider) ChatStream(ctx context.Context, req ai.ChatRequest, cal
 		Model:       p.config.Model,
 		Messages:    messages,
 		Temperature: temperature,
+		MaxTokens:   req.MaxTokens,
 		Stream:      true,
 		Tools:       req.Tools,
 	}
diff --git a/internal/ai/provider/openai_test.go b/internal/ai/provider/openai_test.go
index 64e13701..655743f4 100644
--- a/internal/ai/provider/openai_test.go
+++ b/internal/ai/provider/openai_test.go
@@ -173,6 +173,52 @@ func TestOpenAIProvider_DefaultMaxTokens(t *testing.T) {
 	}
 }
 
+func TestOpenAIProviderChatUsesRequestMaxTokens(t *testing.T) {
+	var received openAIChatRequest
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		defer r.Body.Close()
+		if err := json.NewDecoder(r.Body).Decode(&received); err != nil {
+			t.Fatalf("decode request body failed: %v", err)
+		}
+		w.Header().Set("Content-Type", "application/json")
+		_, _ = w.Write([]byte(`{"choices":[{"message":{"content":"pong"},"finish_reason":"stop"}],"usage":{"prompt_tokens":1,"completion_tokens":1,"total_tokens":2}}`))
+	}))
+	defer server.Close()
+
+	providerInstance, err := NewOpenAIProvider(ai.ProviderConfig{
+		Type:        "openai",
+		APIKey:      "sk-test",
+		BaseURL:     server.URL,
+		Model:       "gpt-chat",
+		MaxTokens:   4096,
+		Temperature: 0.7,
+	})
+	if err != nil {
+		t.Fatalf("create provider failed: %v", err)
+	}
+
+	_, err = providerInstance.Chat(context.Background(), ai.ChatRequest{
+		Messages: []ai.Message{{
+			Role:    "user",
+			Content: "ping",
+		}},
+		MaxTokens:   192,
+		Temperature: 0.1,
+	})
+	if err != nil {
+		t.Fatalf("chat failed: %v", err)
+	}
+	if received.MaxTokens != 192 {
+		t.Fatalf("expected request max_tokens 192, got %d", received.MaxTokens)
+	}
+	if received.Temperature != 0.1 {
+		t.Fatalf("expected request temperature 0.1, got %f", received.Temperature)
+	}
+	if received.Model != "gpt-chat" {
+		t.Fatalf("expected configured model, got %q", received.Model)
+	}
+}
+
 func TestOpenAIProviderChatRetriesWithoutImagesOnHTTP400(t *testing.T) {
 	requestCount := 0
 	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
diff --git a/internal/ai/service/service.go b/internal/ai/service/service.go
index 1ae72f40..663dc7ea 100644
--- a/internal/ai/service/service.go
+++ b/internal/ai/service/service.go
@@ -3,6 +3,7 @@ package aiservice
 import (
 	"context"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"io"
 	"net/http"
@@ -220,6 +221,7 @@ func (s *Service) serviceText(key string, params map[string]any) string {
 }
 
 type localizedAIServiceError struct {
+	key     string
 	message string
 	cause   error
 }
@@ -228,6 +230,10 @@ func (e localizedAIServiceError) Error() string {
 	return e.message
 }
 
+func (e localizedAIServiceError) Key() string {
+	return e.key
+}
+
 func (e localizedAIServiceError) Unwrap() error {
 	return e.cause
 }
@@ -250,7 +256,7 @@ func serviceErrorFromText(key string, text string, cause error) error {
 	if text == key {
 		text = fmt.Sprintf("%s: %s", key, cause.Error())
 	}
-	return localizedAIServiceError{message: text, cause: cause}
+	return localizedAIServiceError{key: key, message: text, cause: cause}
 }
 
 func serviceTextFromLocalizer(localizer *i18n.Localizer, key string, params map[string]any) string {
@@ -277,6 +283,14 @@ func (s *Service) serviceError(key string, params map[string]any, cause error) e
 	return s.serviceErrorLocked(key, params, cause)
 }
 
+func localizedAIServiceErrorKey(err error) string {
+	var localizedErr localizedAIServiceError
+	if errors.As(err, &localizedErr) {
+		return localizedErr.key
+	}
+	return ""
+}
+
 func (s *Service) providerTestFailedMessage(detail string) string {
 	return s.serviceText("ai_service.backend.error.provider_test_failed", map[string]any{"detail": detail})
 }
@@ -766,6 +780,24 @@ func normalizeProviderConfig(config ai.ProviderConfig) ai.ProviderConfig {
 	return config
 }
 
+func applyChatSendOptionsToProviderConfig(config ai.ProviderConfig, options ai.ChatSendOptions) ai.ProviderConfig {
+	if model := strings.TrimSpace(options.Model); model != "" {
+		config.Model = model
+	}
+	return config
+}
+
+func normalizeChatSendOptions(options ai.ChatSendOptions) ai.ChatSendOptions {
+	options.Model = strings.TrimSpace(options.Model)
+	if options.MaxTokens < 0 {
+		options.MaxTokens = 0
+	}
+	if options.Temperature < 0 {
+		options.Temperature = 0
+	}
+	return options
+}
+
 func applyExistingRuntimeProviderSecrets(meta ai.ProviderConfig, existing ai.ProviderConfig) (ai.ProviderConfig, providerSecretBundle) {
 	existingMeta, existingBundle := splitProviderSecrets(normalizeProviderConfig(existing))
 	if strings.TrimSpace(meta.SecretRef) == "" {
@@ -1208,16 +1240,22 @@ func (s *Service) AISetContextLevel(level string) {
 
 // AIChatSend 非流式发送 AI 对话
 func (s *Service) AIChatSend(messages []ai.Message, tools []ai.Tool) map[string]interface{} {
-	return s.aiChatSend("", messages, tools, false)
+	return s.aiChatSend("", messages, tools, false, ai.ChatSendOptions{})
+}
+
+// AIChatSendWithOptions 非流式发送 AI 对话，并允许本次调用临时覆盖模型与生成参数。
+func (s *Service) AIChatSendWithOptions(messages []ai.Message, tools []ai.Tool, options ai.ChatSendOptions) map[string]interface{} {
+	return s.aiChatSend("", messages, tools, false, options)
 }
 
 // AIChatSendInSession 非流式发送 AI 对话，并在支持的 Provider 上复用会话态。
 func (s *Service) AIChatSendInSession(sessionID string, messages []ai.Message, tools []ai.Tool) map[string]interface{} {
-	return s.aiChatSend(sessionID, messages, tools, true)
+	return s.aiChatSend(sessionID, messages, tools, true, ai.ChatSendOptions{})
 }
 
-func (s *Service) aiChatSend(sessionID string, messages []ai.Message, tools []ai.Tool, allowSessionReuse bool) map[string]interface{} {
-	p, config, err := s.getActiveProviderRuntime()
+func (s *Service) aiChatSend(sessionID string, messages []ai.Message, tools []ai.Tool, allowSessionReuse bool, options ai.ChatSendOptions) map[string]interface{} {
+	options = normalizeChatSendOptions(options)
+	p, config, err := s.getActiveProviderRuntimeWithOptions(options)
 	if err != nil {
 		logger.Error(err, "AIChatSend 获取 Provider 失败：messages=%d tools=%d", len(messages), len(tools))
 		return map[string]interface{}{"success": false, "error": err.Error()}
@@ -1237,6 +1275,8 @@ func (s *Service) aiChatSend(sessionID string, messages []ai.Message, tools []ai
 			requestMessages = deltaMessages
 			resp, updatedState, err := sessionAwareProvider.ChatWithState(context.Background(), providerState, ai.ChatRequest{
 				Messages:            requestMessages,
+				Temperature:         options.Temperature,
+				MaxTokens:           options.MaxTokens,
 				Tools:               tools,
 				ImageFallbackPrompt: imageFallbackPrompt,
 				ImageOmittedNotice:  imageOmittedNotice,
@@ -1282,6 +1322,8 @@ func (s *Service) aiChatSend(sessionID string, messages []ai.Message, tools []ai
 
 	resp, err := p.Chat(context.Background(), ai.ChatRequest{
 		Messages:            requestMessages,
+		Temperature:         options.Temperature,
+		MaxTokens:           options.MaxTokens,
 		Tools:               tools,
 		ImageFallbackPrompt: imageFallbackPrompt,
 		ImageOmittedNotice:  imageOmittedNotice,
@@ -1493,10 +1535,17 @@ func (s *Service) AICheckSQL(sql string) ai.SafetyResult {
 
 func (s *Service) getActiveProvider() (provider.Provider, error) {
 	p, _, err := s.getActiveProviderRuntime()
+	if err != nil && localizedAIServiceErrorKey(err) == "ai_service.backend.error.provider_not_configured" {
+		return nil, err
+	}
 	return p, err
 }
 
 func (s *Service) getActiveProviderRuntime() (provider.Provider, ai.ProviderConfig, error) {
+	return s.getActiveProviderRuntimeWithOptions(ai.ChatSendOptions{})
+}
+
+func (s *Service) getActiveProviderRuntimeWithOptions(options ai.ChatSendOptions) (provider.Provider, ai.ProviderConfig, error) {
 	s.mu.RLock()
 	defer s.mu.RUnlock()
 	localizer := s.serviceLocalizerForLanguageLocked()
@@ -1507,13 +1556,16 @@ func (s *Service) getActiveProviderRuntime() (provider.Provider, ai.ProviderConf
 
 	for _, cfg := range s.providers {
 		if cfg.ID == s.activeProvider {
-			normalized := normalizeProviderConfig(cfg)
+			normalized := normalizeProviderConfig(applyChatSendOptionsToProviderConfig(cfg, options))
 			p, err := provider.NewProvider(normalized)
 			return p, normalized, err
 		}
 	}
 
-	return nil, ai.ProviderConfig{}, fmt.Errorf("%s", serviceTextFromLocalizer(localizer, "ai_service.backend.error.provider_not_configured", nil))
+	return nil, ai.ProviderConfig{}, localizedAIServiceError{
+		key:     "ai_service.backend.error.provider_not_configured",
+		message: serviceTextFromLocalizer(localizer, "ai_service.backend.error.provider_not_configured", nil),
+	}
 }
 
 func providerSessionKey(config ai.ProviderConfig) string {
@@ -1756,7 +1808,11 @@ func (s *Service) loadSessionFile(sessionID string) (sessionFileData, error) {
 	}
 	var sessionData sessionFileData
 	if err := json.Unmarshal(data, &sessionData); err != nil {
-		return sessionFileData{}, err
+		return sessionFileData{}, localizedAIServiceError{
+			key:     "ai_service.backend.error.session_corrupt",
+			message: s.serviceText("ai_service.backend.error.session_corrupt", nil),
+			cause:   err,
+		}
 	}
 	return sessionData, nil
 }
@@ -1844,7 +1900,12 @@ func (s *Service) AIGetSessions() []map[string]interface{} {
 func (s *Service) AILoadSession(sessionID string) map[string]interface{} {
 	sessionData, err := s.loadSessionFile(sessionID)
 	if err != nil {
-		return map[string]interface{}{"success": false, "error": s.serviceText("ai_service.backend.error.session_missing", nil)}
+		switch localizedAIServiceErrorKey(err) {
+		case "ai_service.backend.error.session_corrupt":
+			return map[string]interface{}{"success": false, "error": s.serviceText("ai_service.backend.error.session_corrupt", nil)}
+		default:
+			return map[string]interface{}{"success": false, "error": s.serviceText("ai_service.backend.error.session_missing", nil)}
+		}
 	}
 	return map[string]interface{}{
 		"success":   true,
@@ -1859,13 +1920,31 @@ func (s *Service) AILoadSession(sessionID string) map[string]interface{} {
 func (s *Service) AISaveSession(sessionID string, title string, updatedAt float64, messagesJSON string) error {
 	sessionData, err := s.loadOrCreateSessionFile(sessionID)
 	if err != nil {
-		return err
+		switch localizedAIServiceErrorKey(err) {
+		case "ai_service.backend.error.sessions_dir_create_failed",
+			"ai_service.backend.error.session_serialize_failed",
+			"ai_service.backend.error.session_write_failed",
+			"ai_service.backend.error.session_corrupt":
+			return err
+		default:
+			return s.serviceError("ai_service.backend.error.session_write_failed", nil, err)
+		}
 	}
 	sessionData.ID = sessionID
 	sessionData.Title = title
 	sessionData.UpdatedAt = int64(updatedAt)
 	sessionData.Messages = json.RawMessage(messagesJSON)
-	return s.saveSessionFile(sessionID, sessionData)
+	if err := s.saveSessionFile(sessionID, sessionData); err != nil {
+		switch localizedAIServiceErrorKey(err) {
+		case "ai_service.backend.error.sessions_dir_create_failed",
+			"ai_service.backend.error.session_serialize_failed",
+			"ai_service.backend.error.session_write_failed":
+			return err
+		default:
+			return s.serviceError("ai_service.backend.error.session_write_failed", nil, err)
+		}
+	}
+	return nil
 }
 
 // AIDeleteSession 删除会话文件
diff --git a/internal/ai/service/service_test.go b/internal/ai/service/service_test.go
index 0ecf4301..53e09c81 100644
--- a/internal/ai/service/service_test.go
+++ b/internal/ai/service/service_test.go
@@ -99,6 +99,45 @@ func TestDefaultStaticModelsForProvider_DoesNotReturnDashScopeBailianStaticModel
 	}
 }
 
+func TestApplyChatSendOptionsToProviderConfig_OverridesModelForSingleRequest(t *testing.T) {
+	config := applyChatSendOptionsToProviderConfig(ai.ProviderConfig{
+		Model: "chat-model",
+	}, ai.ChatSendOptions{
+		Model: "inline-model",
+	})
+	if config.Model != "inline-model" {
+		t.Fatalf("expected inline model override, got %q", config.Model)
+	}
+}
+
+func TestApplyChatSendOptionsToProviderConfig_KeepsConfiguredModelWhenOverrideEmpty(t *testing.T) {
+	config := applyChatSendOptionsToProviderConfig(ai.ProviderConfig{
+		Model: "chat-model",
+	}, ai.ChatSendOptions{
+		Model: "  ",
+	})
+	if config.Model != "chat-model" {
+		t.Fatalf("expected configured model to be kept, got %q", config.Model)
+	}
+}
+
+func TestNormalizeChatSendOptions_TrimsModelAndClampsNegativeNumbers(t *testing.T) {
+	options := normalizeChatSendOptions(ai.ChatSendOptions{
+		Model:       " inline-model ",
+		MaxTokens:   -1,
+		Temperature: -0.5,
+	})
+	if options.Model != "inline-model" {
+		t.Fatalf("expected trimmed model, got %q", options.Model)
+	}
+	if options.MaxTokens != 0 {
+		t.Fatalf("expected negative max tokens to be clamped, got %d", options.MaxTokens)
+	}
+	if options.Temperature != 0 {
+		t.Fatalf("expected negative temperature to be clamped, got %f", options.Temperature)
+	}
+}
+
 func TestNewProviderHealthCheckRequest_UsesMessagesEndpointForMiniMaxAnthropic(t *testing.T) {
 	req, err := newProviderHealthCheckRequest(ai.ProviderConfig{
 		Type:    "anthropic",
diff --git a/internal/ai/types.go b/internal/ai/types.go
index 1dc087e1..87ad24d7 100644
--- a/internal/ai/types.go
+++ b/internal/ai/types.go
@@ -46,6 +46,13 @@ type ChatRequest struct {
 	ImageOmittedNotice  string    `json:"-"`
 }
 
+// ChatSendOptions 表示一次对话调用的临时覆盖选项，不写回 Provider 配置。
+type ChatSendOptions struct {
+	Model       string  `json:"model,omitempty"`
+	Temperature float64 `json:"temperature,omitempty"`
+	MaxTokens   int     `json:"maxTokens,omitempty"`
+}
+
 // ChatResponse AI 对话响应
 type ChatResponse struct {
 	Content          string     `json:"content"`
@@ -73,19 +80,20 @@ type StreamChunk struct {
 
 // ProviderConfig AI Provider 配置
 type ProviderConfig struct {
-	ID          string            `json:"id"`
-	Type        string            `json:"type"` // openai | anthropic | gemini | custom
-	Name        string            `json:"name"`
-	APIKey      string            `json:"apiKey"`
-	SecretRef   string            `json:"secretRef,omitempty"`
-	HasSecret   bool              `json:"hasSecret,omitempty"`
-	BaseURL     string            `json:"baseUrl"`
-	Model       string            `json:"model"`
-	Models      []string          `json:"models,omitempty"`
-	APIFormat   string            `json:"apiFormat,omitempty"` // custom 专用: openai | anthropic | gemini | cursor-agent | claude-cli | codebuddy-cli
-	Headers     map[string]string `json:"headers,omitempty"`
-	MaxTokens   int               `json:"maxTokens"`
-	Temperature float64           `json:"temperature"`
+	ID                    string            `json:"id"`
+	Type                  string            `json:"type"` // openai | anthropic | gemini | custom
+	Name                  string            `json:"name"`
+	APIKey                string            `json:"apiKey"`
+	SecretRef             string            `json:"secretRef,omitempty"`
+	HasSecret             bool              `json:"hasSecret,omitempty"`
+	BaseURL               string            `json:"baseUrl"`
+	Model                 string            `json:"model"`
+	InlineCompletionModel string            `json:"inlineCompletionModel,omitempty"`
+	Models                []string          `json:"models,omitempty"`
+	APIFormat             string            `json:"apiFormat,omitempty"` // custom 专用: openai | anthropic | gemini | cursor-agent | claude-cli | codebuddy-cli
+	Headers               map[string]string `json:"headers,omitempty"`
+	MaxTokens             int               `json:"maxTokens"`
+	Temperature           float64           `json:"temperature"`
 }
 
 // UserPromptSettings 表示用户级自定义提示词配置
diff --git a/shared/i18n/de-DE.json b/shared/i18n/de-DE.json
index f7ec7d50..43aa1dab 100644
--- a/shared/i18n/de-DE.json
+++ b/shared/i18n/de-DE.json
@@ -1643,11 +1643,15 @@
   "ai_settings.form.model_list_placeholder": "Modell-IDs konfigurieren; leer lassen, um sie vom Server abzurufen",
   "ai_settings.form.model_list_placeholder.codebuddy": "Optional: Häufige Modelle vorab eintragen; leer lassen, damit CodeBuddy CLI oder der Dienst automatisch wählt",
   "ai_settings.form.model_list_placeholder.cursor": "Optional: Häufige Cursor-Modell-IDs vorab eintragen; leer lassen, damit automatisch das Standardmodell von Cursor gewählt wird",
+  "ai_settings.form.inline_completion_model": "Autovervollständigungsmodell",
+  "ai_settings.form.inline_completion_model_hint": "Wähle ein kleineres, schnelleres Modell für SQL-Editor-Geistervorschläge. Leer lassen, um dem Chatmodell zu folgen.",
+  "ai_settings.form.inline_completion_model_placeholder": "Chatmodell verwenden",
   "ai_settings.form.provider_name": "Anbietername",
   "ai_settings.form.provider_name_placeholder": "Beispiel: eigener OpenAI-kompatibler Endpunkt / privates Modell",
   "ai_settings.form.provider_name_required": "Bitte einen Namen eingeben",
   "ai_settings.form.section.auth_connection": "Authentifizierung und Verbindung",
   "ai_settings.form.section.basic": "Basisinformationen",
+  "ai_settings.form.section.inline_completion": "SQL-Autovervollständigung",
   "ai_settings.form.section.service_type": "Diensttyp",
   "ai_settings.mcp_http.error.control_unsupported_runtime": "Die aktuelle Laufzeit unterstützt keine Steuerung des MCP HTTP-Dienstes",
   "ai_settings.mcp_http.error.start_unsupported_version": "Diese Version unterstützt das Starten des MCP HTTP-Dienstes nicht",
@@ -2619,6 +2623,8 @@
   "app.shortcuts.action.duplicateCurrentLine.label": "Aktuelle Zeile darunter duplizieren",
   "app.shortcuts.action.formatSql.description": "SQL im aktuellen Abfrageeditor formatieren",
   "app.shortcuts.action.formatSql.label": "SQL formatieren",
+  "app.shortcuts.action.triggerSqlAiCompletion.description": "AI-Inline-Vervollständigung im aktuellen SQL-Editor manuell anfordern",
+  "app.shortcuts.action.triggerSqlAiCompletion.label": "SQL-AI-Vervollständigung auslösen",
   "app.shortcuts.action.selectCurrentStatement.description": "Zeile an der Cursorposition im Abfrageeditor auswählen und in die Zwischenablage kopieren",
   "app.shortcuts.action.selectCurrentStatement.label": "Aktuelle Zeile auswählen und kopieren",
   "app.shortcuts.action.sendAIChatMessage.description": "Aktuelle Nachricht im AI-Eingabefeld senden; Shift+Enter fügt immer einen Zeilenumbruch ein",
diff --git a/shared/i18n/en-US.json b/shared/i18n/en-US.json
index 437ecced..119eb07d 100644
--- a/shared/i18n/en-US.json
+++ b/shared/i18n/en-US.json
@@ -1643,11 +1643,15 @@
   "ai_settings.form.model_list_placeholder": "Configure model IDs; leave blank to fetch them from the server",
   "ai_settings.form.model_list_placeholder.codebuddy": "Optional: prefill common models; leave blank to let CodeBuddy CLI or the service choose automatically",
   "ai_settings.form.model_list_placeholder.cursor": "Optional: prefill common Cursor model IDs; leave blank to use Cursor's default model automatically",
+  "ai_settings.form.inline_completion_model": "Auto-completion model",
+  "ai_settings.form.inline_completion_model_hint": "Choose a smaller, faster model for SQL editor ghost completions. Leave blank to follow the chat model.",
+  "ai_settings.form.inline_completion_model_placeholder": "Follow chat model",
   "ai_settings.form.provider_name": "Provider name",
   "ai_settings.form.provider_name_placeholder": "Example: My OpenAI-compatible endpoint / private model",
   "ai_settings.form.provider_name_required": "Enter a name",
   "ai_settings.form.section.auth_connection": "Authentication & connection",
   "ai_settings.form.section.basic": "Basic information",
+  "ai_settings.form.section.inline_completion": "SQL auto-completion",
   "ai_settings.form.section.service_type": "Service type",
   "ai_settings.mcp_http.error.control_unsupported_runtime": "The current runtime does not support MCP HTTP server control",
   "ai_settings.mcp_http.error.start_unsupported_version": "This version does not support starting the MCP HTTP server",
@@ -2619,6 +2623,8 @@
   "app.shortcuts.action.duplicateCurrentLine.label": "Duplicate Current Line Below",
   "app.shortcuts.action.formatSql.description": "Format SQL in the current query editor",
   "app.shortcuts.action.formatSql.label": "Format SQL",
+  "app.shortcuts.action.triggerSqlAiCompletion.description": "Manually request AI inline completion in the current SQL editor",
+  "app.shortcuts.action.triggerSqlAiCompletion.label": "Trigger SQL AI Completion",
   "app.shortcuts.action.selectCurrentStatement.description": "Select the line at the cursor in the query editor and copy it to the clipboard",
   "app.shortcuts.action.selectCurrentStatement.label": "Select Current Line and Copy",
   "app.shortcuts.action.sendAIChatMessage.description": "Send the current message from the AI input; Shift+Enter always inserts a new line",
diff --git a/shared/i18n/ja-JP.json b/shared/i18n/ja-JP.json
index a975fc45..fd8ae9c2 100644
--- a/shared/i18n/ja-JP.json
+++ b/shared/i18n/ja-JP.json
@@ -1643,11 +1643,15 @@
   "ai_settings.form.model_list_placeholder": "モデル ID を指定します。空欄の場合はサーバーから取得します",
   "ai_settings.form.model_list_placeholder.codebuddy": "任意：よく使うモデルを事前入力できます。空欄なら CodeBuddy CLI またはサービス側で自動選択します",
   "ai_settings.form.model_list_placeholder.cursor": "任意：よく使う Cursor モデル ID を事前入力できます。空欄なら Cursor の既定モデルを自動選択します",
+  "ai_settings.form.inline_completion_model": "自動補完モデル",
+  "ai_settings.form.inline_completion_model_hint": "SQL エディタのゴースト補完には、小さく高速なモデルを選べます。空欄の場合はチャットモデルに従います。",
+  "ai_settings.form.inline_completion_model_placeholder": "チャットモデルに従う",
   "ai_settings.form.provider_name": "プロバイダー名",
   "ai_settings.form.provider_name_placeholder": "例：自前の OpenAI 互換端点 / 専用モデル",
   "ai_settings.form.provider_name_required": "名前を入力してください",
   "ai_settings.form.section.auth_connection": "認証と接続",
   "ai_settings.form.section.basic": "基本情報",
+  "ai_settings.form.section.inline_completion": "SQL 自動補完",
   "ai_settings.form.section.service_type": "サービス種別",
   "ai_settings.mcp_http.error.control_unsupported_runtime": "現在のランタイムでは MCP HTTP サービスの制御に対応していません",
   "ai_settings.mcp_http.error.start_unsupported_version": "現在のバージョンでは MCP HTTP サービスの起動に対応していません",
@@ -2619,6 +2623,8 @@
   "app.shortcuts.action.duplicateCurrentLine.label": "現在の行を下に複製",
   "app.shortcuts.action.formatSql.description": "現在のクエリエディターの SQL を整形します",
   "app.shortcuts.action.formatSql.label": "SQL を整形",
+  "app.shortcuts.action.triggerSqlAiCompletion.description": "現在の SQL エディターで AI インライン補完を手動で要求します",
+  "app.shortcuts.action.triggerSqlAiCompletion.label": "SQL AI 補完を実行",
   "app.shortcuts.action.selectCurrentStatement.description": "クエリエディターでカーソル位置の行を選択してクリップボードにコピーします",
   "app.shortcuts.action.selectCurrentStatement.label": "現在の行を選択してコピー",
   "app.shortcuts.action.sendAIChatMessage.description": "AI 入力欄の現在のメッセージを送信します。Shift+Enter は常に改行します",
diff --git a/shared/i18n/ru-RU.json b/shared/i18n/ru-RU.json
index a2120db4..a05440cf 100644
--- a/shared/i18n/ru-RU.json
+++ b/shared/i18n/ru-RU.json
@@ -1643,11 +1643,15 @@
   "ai_settings.form.model_list_placeholder": "Укажите ID моделей; оставьте пустым, чтобы получить их с сервера",
   "ai_settings.form.model_list_placeholder.codebuddy": "Необязательно: заранее укажите частые модели; если оставить пустым, CodeBuddy CLI или сервис выберет автоматически",
   "ai_settings.form.model_list_placeholder.cursor": "Необязательно: заранее укажите частые ID моделей Cursor; если оставить пустым, автоматически будет выбрана модель Cursor по умолчанию",
+  "ai_settings.form.inline_completion_model": "Модель автодополнения",
+  "ai_settings.form.inline_completion_model_hint": "Выберите более маленькую и быструю модель для серых подсказок SQL-редактора. Оставьте пустым, чтобы использовать модель чата.",
+  "ai_settings.form.inline_completion_model_placeholder": "Использовать модель чата",
   "ai_settings.form.provider_name": "Имя поставщика",
   "ai_settings.form.provider_name_placeholder": "Пример: собственная OpenAI-совместимая конечная точка / частная модель",
   "ai_settings.form.provider_name_required": "Введите имя",
   "ai_settings.form.section.auth_connection": "Аутентификация и подключение",
   "ai_settings.form.section.basic": "Основная информация",
+  "ai_settings.form.section.inline_completion": "SQL-автодополнение",
   "ai_settings.form.section.service_type": "Тип сервиса",
   "ai_settings.mcp_http.error.control_unsupported_runtime": "Текущая среда выполнения не поддерживает управление службой MCP HTTP",
   "ai_settings.mcp_http.error.start_unsupported_version": "Эта версия не поддерживает запуск службы MCP HTTP",
@@ -2619,6 +2623,8 @@
   "app.shortcuts.action.duplicateCurrentLine.label": "Дублировать текущую строку ниже",
   "app.shortcuts.action.formatSql.description": "Форматировать SQL в текущем редакторе запросов",
   "app.shortcuts.action.formatSql.label": "Форматировать SQL",
+  "app.shortcuts.action.triggerSqlAiCompletion.description": "Вручную запросить AI-автодополнение в текущем SQL-редакторе",
+  "app.shortcuts.action.triggerSqlAiCompletion.label": "Запустить AI-автодополнение SQL",
   "app.shortcuts.action.selectCurrentStatement.description": "Выбрать строку под курсором в редакторе запросов и скопировать ее в буфер обмена",
   "app.shortcuts.action.selectCurrentStatement.label": "Выбрать текущую строку и скопировать",
   "app.shortcuts.action.sendAIChatMessage.description": "Отправить текущее сообщение из поля ввода AI; Shift+Enter всегда вставляет новую строку",
diff --git a/shared/i18n/zh-CN.json b/shared/i18n/zh-CN.json
index 290b9dc9..ade85261 100644
--- a/shared/i18n/zh-CN.json
+++ b/shared/i18n/zh-CN.json
@@ -1643,11 +1643,15 @@
   "ai_settings.form.model_list_placeholder": "配置指定的模型 ID，留空则默认从服务端拉取",
   "ai_settings.form.model_list_placeholder.codebuddy": "可选：预填常用模型；留空则由 CodeBuddy CLI 或服务端自动选择",
   "ai_settings.form.model_list_placeholder.cursor": "可选：预填常用 Cursor 模型 ID；留空则由 Cursor 默认模型自动选择",
+  "ai_settings.form.inline_completion_model": "自动补全模型",
+  "ai_settings.form.inline_completion_model_hint": "建议选择更小、更快的模型用于 SQL 编辑器灰色联想。留空则跟随聊天模型。",
+  "ai_settings.form.inline_completion_model_placeholder": "跟随聊天模型",
   "ai_settings.form.provider_name": "供应商名称",
   "ai_settings.form.provider_name_placeholder": "例如：我的自建 OpenAI / 专属大模型",
   "ai_settings.form.provider_name_required": "请输入名称",
   "ai_settings.form.section.auth_connection": "认证与连接",
   "ai_settings.form.section.basic": "基本信息",
+  "ai_settings.form.section.inline_completion": "SQL 自动补全",
   "ai_settings.form.section.service_type": "服务类型",
   "ai_settings.mcp_http.error.control_unsupported_runtime": "当前运行时暂不支持 MCP HTTP 服务控制",
   "ai_settings.mcp_http.error.start_unsupported_version": "当前版本暂不支持启动 MCP HTTP 服务",
@@ -2619,6 +2623,8 @@
   "app.shortcuts.action.duplicateCurrentLine.label": "复制当前行到下一行",
   "app.shortcuts.action.formatSql.description": "格式化当前查询编辑器中的 SQL",
   "app.shortcuts.action.formatSql.label": "美化 SQL",
+  "app.shortcuts.action.triggerSqlAiCompletion.description": "在当前 SQL 编辑器中手动请求 AI 灰色自动补全",
+  "app.shortcuts.action.triggerSqlAiCompletion.label": "触发 SQL AI 自动补全",
   "app.shortcuts.action.selectCurrentStatement.description": "在查询编辑器中选中光标所在行并复制到剪贴板",
   "app.shortcuts.action.selectCurrentStatement.label": "选择当前行并复制",
   "app.shortcuts.action.sendAIChatMessage.description": "在 AI 输入框中发送当前消息，Shift+Enter 始终换行",
diff --git a/shared/i18n/zh-TW.json b/shared/i18n/zh-TW.json
index 45efb456..fce55f2d 100644
--- a/shared/i18n/zh-TW.json
+++ b/shared/i18n/zh-TW.json
@@ -1643,11 +1643,15 @@
   "ai_settings.form.model_list_placeholder": "設定指定的模型 ID，留空則預設從服務端拉取",
   "ai_settings.form.model_list_placeholder.codebuddy": "可選：預填常用模型；留空則由 CodeBuddy CLI 或服務端自動選擇",
   "ai_settings.form.model_list_placeholder.cursor": "可選：預填常用 Cursor 模型 ID；留空則由 Cursor 預設模型自動選擇",
+  "ai_settings.form.inline_completion_model": "自動補全模型",
+  "ai_settings.form.inline_completion_model_hint": "建議選擇更小、更快的模型用於 SQL 編輯器灰色聯想。留空則跟隨聊天模型。",
+  "ai_settings.form.inline_completion_model_placeholder": "跟隨聊天模型",
   "ai_settings.form.provider_name": "供應商名稱",
   "ai_settings.form.provider_name_placeholder": "例如：我的自建 OpenAI / 專屬大模型",
   "ai_settings.form.provider_name_required": "請輸入名稱",
   "ai_settings.form.section.auth_connection": "認證與連線",
   "ai_settings.form.section.basic": "基本資訊",
+  "ai_settings.form.section.inline_completion": "SQL 自動補全",
   "ai_settings.form.section.service_type": "服務類型",
   "ai_settings.mcp_http.error.control_unsupported_runtime": "目前執行階段暫不支援 MCP HTTP 服務控制",
   "ai_settings.mcp_http.error.start_unsupported_version": "目前版本暫不支援啟動 MCP HTTP 服務",
@@ -2619,6 +2623,8 @@
   "app.shortcuts.action.duplicateCurrentLine.label": "複製目前行到下一行",
   "app.shortcuts.action.formatSql.description": "格式化目前查詢編輯器中的 SQL",
   "app.shortcuts.action.formatSql.label": "美化 SQL",
+  "app.shortcuts.action.triggerSqlAiCompletion.description": "在目前 SQL 編輯器中手動請求 AI 灰色自動補全",
+  "app.shortcuts.action.triggerSqlAiCompletion.label": "觸發 SQL AI 自動補全",
   "app.shortcuts.action.selectCurrentStatement.description": "在查詢編輯器中選取游標所在行並複製到剪貼簿",
   "app.shortcuts.action.selectCurrentStatement.label": "選取目前行並複製",
   "app.shortcuts.action.sendAIChatMessage.description": "在 AI 輸入框中送出目前訊息，Shift+Enter 一律換行",