diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 9cd86e5..9f3964d 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -180,6 +180,7 @@ jobs:
     name: Docker Build & Push
     runs-on: ubuntu-latest
     needs: [quality, test]
+    if: github.event_name != 'pull_request'
     permissions:
       contents: read
       packages: write
diff --git a/.gitignore b/.gitignore
index 1bf5b94..5dcd90c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -77,6 +77,9 @@ temp/
 
 # AI model files and caches
 models/
+!pkg/ai/models/
+!pkg/ai/models/*.yaml
+!pkg/ai/models/*.go
 *.model
 *.cache
 *.pkl
diff --git a/Dockerfile b/Dockerfile
index 829e8f1..542e719 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -1,27 +1,49 @@
 # Build stage
-FROM golang:1.24-alpine AS builder
+# syntax=docker/dockerfile:1.7
+ARG BUILDPLATFORM
+ARG TARGETPLATFORM
+
+FROM --platform=$BUILDPLATFORM node:20-alpine AS frontend-builder
+WORKDIR /workspace
+
+# Copy repository contents (needed because frontend build emits to ../pkg/plugin/assets)
+COPY . .
+
+# Cache npm modules to speed up rebuilds
+RUN --mount=type=cache,target=/root/.npm npm --prefix frontend ci
+RUN npm --prefix frontend run build
+
+FROM --platform=$BUILDPLATFORM golang:1.24-alpine AS builder
+ARG TARGETOS
+ARG TARGETARCH
 
 # Install build dependencies
-RUN apk add --no-cache git ca-certificates tzdata nodejs npm
+RUN apk add --no-cache git ca-certificates tzdata
+
+# Enable module caching
+ENV GOMODCACHE=/go/pkg/mod
+ENV GOCACHE=/root/.cache/go-build
 
 # Set working directory
-WORKDIR /app
+WORKDIR /workspace
 
-# Copy all source code first (needed for go.mod replace directive)
-COPY . .
+# Copy go module files and download dependencies
+COPY go.mod go.sum ./
+RUN --mount=type=cache,target=/root/.cache/go-build \
+    --mount=type=cache,target=/go/pkg/mod \
+    go mod download
 
-# Download dependencies (replace directive requires source to be present)
-RUN go mod download
+# Copy source code
+COPY . .
 
-# Build frontend assets required for Go embed
-RUN npm ci --prefix frontend
-RUN npm run build --prefix frontend
+# Copy pre-built frontend assets
+COPY --from=frontend-builder /workspace/pkg/plugin/assets ./pkg/plugin/assets
 
-# Build the binary
-RUN CGO_ENABLED=0 GOOS=linux go build \
-    -ldflags="-s -w" \
-    -o bin/atest-ext-ai \
-    ./cmd/atest-ext-ai
+# Build the binary for the target platform
+RUN --mount=type=cache,target=/root/.cache/go-build \
+    --mount=type=cache,target=/go/pkg/mod \
+    CGO_ENABLED=0 GOOS=$TARGETOS GOARCH=$TARGETARCH \
+    go build -ldflags="-s -w" -o bin/atest-ext-ai ./cmd/atest-ext-ai
 
 # Final stage
 FROM alpine:latest
diff --git a/cmd/atest-ext-ai/main.go b/cmd/atest-ext-ai/main.go
index daf812f..46712eb 100644
--- a/cmd/atest-ext-ai/main.go
+++ b/cmd/atest-ext-ai/main.go
@@ -287,7 +287,8 @@ func cleanupSocketFile(path string) error {
 func createListener(cfg listenerConfig) (net.Listener, error) {
 	if cfg.network == "unix" {
 		dir := filepath.Dir(cfg.address)
-		if err := os.MkdirAll(dir, 0o755); err != nil { //nolint:gosec // socket directory must remain accessible to API clients
+		// #nosec G301 -- socket directory must remain accessible to API clients
+		if err := os.MkdirAll(dir, 0o755); err != nil {
 			return nil, fmt.Errorf("failed to create socket directory %s: %w", dir, err)
 		}
 
diff --git a/frontend/src/App.vue b/frontend/src/App.vue
index 45e9b29..85aa898 100644
--- a/frontend/src/App.vue
+++ b/frontend/src/App.vue
@@ -152,13 +152,14 @@ async function handleTest(updatedConfig?: AIConfig) {
   display: flex;
   flex-direction: column;
   width: 100%;
-  height: 100%;
-  max-height: 100%;
+  height: 100vh;
+  max-height: 100vh;
   min-height: 0;
   padding: clamp(16px, 4vw, 32px);
   box-sizing: border-box;
   gap: clamp(12px, 2vw, 20px);
   background: var(--atest-bg-base);
+  overflow: hidden;
 }
 
 .welcome-panel {
@@ -166,18 +167,18 @@ async function handleTest(updatedConfig?: AIConfig) {
   display: flex;
   align-items: center;
   justify-content: center;
+  overflow: auto;
 }
 
 .chat-content {
   flex: 1;
-  display: grid;
-  grid-template-rows: minmax(0, 1fr) auto;
-  gap: var(--atest-spacing-md);
+  display: flex;
+  flex-direction: column;
+  gap: 0;
   overflow: hidden;
   border-radius: var(--atest-radius-lg);
   background: var(--atest-bg-surface);
   box-shadow: var(--atest-shadow-md);
-  padding: clamp(12px, 3vw, 24px);
   min-height: 0;
   max-height: 100%;
 }
@@ -185,6 +186,8 @@ async function handleTest(updatedConfig?: AIConfig) {
 @media (max-width: 1024px) {
   .ai-chat-container {
     padding: 24px;
+    height: 100vh;
+    max-height: 100vh;
   }
 }
 
@@ -192,21 +195,20 @@ async function handleTest(updatedConfig?: AIConfig) {
   .ai-chat-container {
     padding: 20px;
     gap: 12px;
+    height: 100vh;
+    max-height: 100vh;
   }
 
   .chat-content {
     border-radius: var(--atest-radius-md);
-    padding: 16px;
   }
 }
 
 @media (max-width: 480px) {
   .ai-chat-container {
     padding: 16px;
-  }
-
-  .chat-content {
-    padding: 12px;
+    height: 100vh;
+    max-height: 100vh;
   }
 }
 </style>
diff --git a/frontend/src/components/AIChatHeader.vue b/frontend/src/components/AIChatHeader.vue
index 69b009e..f8fa035 100644
--- a/frontend/src/components/AIChatHeader.vue
+++ b/frontend/src/components/AIChatHeader.vue
@@ -41,10 +41,11 @@ const statusText = computed(() => t(`ai.status.${props.status}`))
 
 <style scoped>
 .ai-chat-header {
+  flex-shrink: 0;
   display: flex;
   justify-content: space-between;
   align-items: center;
-  padding: var(--atest-spacing-md) clamp(20px, 4vw, 28px);
+  padding: var(--atest-spacing-md) clamp(20px, 4vw, 40px);
   background: var(--atest-bg-surface);
   border-bottom: 1px solid var(--atest-border-color);
 }
diff --git a/frontend/src/components/AIChatInput.vue b/frontend/src/components/AIChatInput.vue
index 369cbb9..ad12cfb 100644
--- a/frontend/src/components/AIChatInput.vue
+++ b/frontend/src/components/AIChatInput.vue
@@ -176,11 +176,10 @@ function handleSubmit() {
 
 <style scoped>
 .chat-input {
-  padding: 20px 40px 24px;
+  flex-shrink: 0;
+  padding: clamp(16px, 3vw, 20px) clamp(20px, 4vw, 40px) clamp(20px, 3vw, 24px);
   background: var(--atest-bg-surface);
   border-top: 1px solid var(--atest-border-color);
-  box-shadow: var(--atest-shadow-sm);
-  border-radius: var(--atest-radius-md);
   display: flex;
   flex-direction: column;
   gap: var(--atest-spacing-sm);
diff --git a/frontend/src/components/AIChatMessages.vue b/frontend/src/components/AIChatMessages.vue
index 06d9562..c4ef402 100644
--- a/frontend/src/components/AIChatMessages.vue
+++ b/frontend/src/components/AIChatMessages.vue
@@ -123,14 +123,14 @@ async function copySQL(sql: string) {
 
 <style scoped>
 .chat-messages {
-  height: 100%;
+  flex: 1;
   min-height: 0;
   overflow-y: auto;
-  padding: 24px 40px;
+  overflow-x: hidden;
+  padding: clamp(12px, 3vw, 24px) clamp(20px, 4vw, 40px);
   background: var(--atest-bg-surface);
   color: var(--atest-text-primary);
-  border: 1px solid var(--atest-border-color);
-  border-radius: var(--atest-radius-md);
+  border-bottom: 1px solid var(--atest-border-color);
 }
 
 /* Empty state */
diff --git a/frontend/src/components/AISettingsPanel.vue b/frontend/src/components/AISettingsPanel.vue
index 4770cb7..1bca8b5 100644
--- a/frontend/src/components/AISettingsPanel.vue
+++ b/frontend/src/components/AISettingsPanel.vue
@@ -144,11 +144,7 @@
                           </el-option>
                         </template>
                         <template v-else>
-                          <el-option value="gpt-5" label="GPT-5 ⭐ Recommended" />
-                          <el-option value="gpt-5-mini" label="GPT-5 Mini" />
-                          <el-option value="gpt-5-nano" label="GPT-5 Nano" />
-                          <el-option value="gpt-5-pro" label="GPT-5 Pro" />
-                          <el-option value="gpt-4.1" label="GPT-4.1" />
+                          <el-option disabled value="no-models" :label="t('ai.welcome.noModels')" />
                         </template>
                       </el-select>
                       <el-button
@@ -218,8 +214,7 @@
                           </el-option>
                         </template>
                         <template v-else>
-                          <el-option value="deepseek-reasoner" label="DeepSeek Reasoner ⭐" />
-                          <el-option value="deepseek-chat" label="DeepSeek Chat" />
+                          <el-option disabled value="no-models" :label="t('ai.welcome.noModels')" />
                         </template>
                       </el-select>
                       <el-button
diff --git a/frontend/src/composables/useAIChat.ts b/frontend/src/composables/useAIChat.ts
index 243d124..e400c21 100644
--- a/frontend/src/composables/useAIChat.ts
+++ b/frontend/src/composables/useAIChat.ts
@@ -1,6 +1,6 @@
 import { ref, computed, watch } from 'vue'
 import type { AppContext, AIConfig, Message, Model, DatabaseDialect } from '@/types'
-import { loadConfig, loadConfigForProvider, saveConfig, getMockModels, generateId, type Provider } from '@/utils/config'
+import { loadConfig, loadConfigForProvider, saveConfig, generateId, type Provider } from '@/utils/config'
 import { aiService } from '@/services/aiService'
 
 /**
@@ -27,6 +27,33 @@ export function useAIChat(_context: AppContext) {
     deepseek: []
   })
 
+  const catalogCache = ref<Record<string, Model[]>>({})
+
+  async function initializeModelCatalog() {
+    try {
+      const catalog = await aiService.fetchModelCatalog()
+      const normalizedCatalog: Record<string, Model[]> = {}
+
+      Object.entries(catalog).forEach(([provider, entry]) => {
+        normalizedCatalog[provider] = entry.models || []
+      })
+
+      catalogCache.value = normalizedCatalog
+
+      for (const [provider, models] of Object.entries(normalizedCatalog)) {
+        if (!modelsByProvider.value[provider]) {
+          modelsByProvider.value[provider] = models
+        } else if ((modelsByProvider.value[provider] || []).length === 0 && models.length > 0) {
+          modelsByProvider.value[provider] = models
+        }
+      }
+    } catch (error) {
+      console.error('Failed to load model catalog', error)
+    }
+  }
+
+  void initializeModelCatalog()
+
   // Computed property to get models for current provider
   const availableModels = computed(() => {
     const key = resolveProviderKey(config.value.provider)
@@ -98,8 +125,24 @@ export function useAIChat(_context: AppContext) {
       }
     } catch (error) {
       console.error('Failed to fetch models:', error)
-      // Use mock models as fallback for this provider
-      modelsByProvider.value[storeKey] = getMockModels(storeKey)
+      const cachedFallback = catalogCache.value[storeKey]
+      if (cachedFallback && cachedFallback.length) {
+        modelsByProvider.value[storeKey] = cachedFallback
+        return
+      }
+
+      try {
+        const catalog = await aiService.fetchModelCatalog(storeKey)
+        const entry = catalog[storeKey]
+        const fallbackModels = entry?.models ?? []
+        modelsByProvider.value[storeKey] = fallbackModels
+        if (fallbackModels.length) {
+          catalogCache.value[storeKey] = fallbackModels
+        }
+      } catch (catalogError) {
+        console.error('Failed to fetch catalog fallback:', catalogError)
+        modelsByProvider.value[storeKey] = []
+      }
     }
   }
 
diff --git a/frontend/src/services/aiService.ts b/frontend/src/services/aiService.ts
index 74c8e41..3330dca 100644
--- a/frontend/src/services/aiService.ts
+++ b/frontend/src/services/aiService.ts
@@ -44,6 +44,22 @@ export const aiService = {
     return result.models || []
   },
 
+  /**
+   * Fetch model catalog metadata (either for a specific provider or all providers)
+   */
+  async fetchModelCatalog(provider?: string): Promise<Record<string, ModelCatalogEntry>> {
+    const payload = provider ? { provider } : {}
+    const result = await callAPI<{ catalog: Record<string, ModelCatalogEntry> }>('models_catalog', payload)
+    const catalog = result.catalog || {}
+
+    // Normalize provider keys to lowercase for consistent lookups
+    const normalized: Record<string, ModelCatalogEntry> = {}
+    for (const [key, entry] of Object.entries(catalog)) {
+      normalized[key.toLowerCase()] = entry
+    }
+    return normalized
+  },
+
   /**
    * Test connection to AI provider
    */
@@ -223,6 +239,15 @@ export const aiService = {
   }
 }
 
+export interface ModelCatalogEntry {
+  display_name: string
+  category: string
+  endpoint: string
+  requires_api_key: boolean
+  models: Model[]
+  tags?: string[]
+}
+
 function formatTimeout(timeout: number | undefined): string {
   const value = Number(timeout)
   if (!Number.isFinite(value) || value <= 0) {
diff --git a/frontend/src/types/index.ts b/frontend/src/types/index.ts
index d341a53..981bc94 100644
--- a/frontend/src/types/index.ts
+++ b/frontend/src/types/index.ts
@@ -42,7 +42,9 @@ export interface AIConfig {
 export interface Model {
   id: string
   name: string
-  size: string
+  size?: string
+  description?: string
+  maxTokens?: number
 }
 
 /**
diff --git a/frontend/src/utils/config.ts b/frontend/src/utils/config.ts
index dfe95ca..840c7f7 100644
--- a/frontend/src/utils/config.ts
+++ b/frontend/src/utils/config.ts
@@ -1,4 +1,4 @@
-import type { AIConfig, Model, DatabaseDialect } from '@/types'
+import type { AIConfig, DatabaseDialect } from '@/types'
 
 export type Provider = 'ollama' | 'openai' | 'deepseek' | 'local'
 
@@ -109,30 +109,6 @@ export function getDefaultConfig(provider: string): Partial<AIConfig> {
   }
 }
 
-/**
- * Get mock models when API fails
- */
-export function getMockModels(provider: string): Model[] {
-  const mocks: Record<string, Model[]> = {
-    ollama: [
-      { id: 'llama3.2:3b', name: 'Llama 3.2 3B', size: '2GB' },
-      { id: 'gemma2:9b', name: 'Gemma 2 9B', size: '5GB' }
-    ],
-    openai: [
-      { id: 'gpt-5', name: 'GPT-5 ⭐', size: 'Cloud' },
-      { id: 'gpt-5-mini', name: 'GPT-5 Mini', size: 'Cloud' },
-      { id: 'gpt-5-nano', name: 'GPT-5 Nano', size: 'Cloud' },
-      { id: 'gpt-5-pro', name: 'GPT-5 Pro', size: 'Cloud' },
-      { id: 'gpt-4.1', name: 'GPT-4.1', size: 'Cloud' }
-    ],
-    deepseek: [
-      { id: 'deepseek-chat', name: 'DeepSeek Chat', size: 'Cloud' },
-      { id: 'deepseek-reasoner', name: 'DeepSeek Reasoner', size: 'Cloud' }
-    ]
-  }
-  return mocks[provider] || []
-}
-
 /**
  * Generate unique ID
  */
diff --git a/frontend/tests/composables/useAIChat.test.ts b/frontend/tests/composables/useAIChat.test.ts
index f79a952..7df3d2c 100644
--- a/frontend/tests/composables/useAIChat.test.ts
+++ b/frontend/tests/composables/useAIChat.test.ts
@@ -7,6 +7,7 @@ import type { AppContext } from '@/types'
 vi.mock('@/services/aiService', () => ({
   aiService: {
     fetchModels: vi.fn(),
+    fetchModelCatalog: vi.fn(),
     testConnection: vi.fn(),
     generateSQL: vi.fn(),
     saveConfig: vi.fn()
@@ -22,6 +23,7 @@ describe('useAIChat', () => {
 
     // Set default mock behavior for fetchModels (called during initialization)
     vi.mocked(aiService.fetchModels).mockResolvedValue([])
+    vi.mocked(aiService.fetchModelCatalog).mockResolvedValue({})
 
     mockContext = {
       i18n: {
@@ -185,8 +187,19 @@ describe('useAIChat', () => {
       expect(availableModels.value[0].id).toBe('model1')
     })
 
-    it('should use mock models when API fails', async () => {
+    it('should use catalog models when API fails', async () => {
       vi.mocked(aiService.fetchModels).mockRejectedValue(new Error('Network error'))
+      vi.mocked(aiService.fetchModelCatalog).mockResolvedValueOnce({
+        ollama: {
+          display_name: 'Ollama',
+          category: 'local',
+          endpoint: 'http://localhost:11434',
+          requires_api_key: false,
+          models: [
+            { id: 'llama3.2:3b', name: 'Llama 3.2 3B', size: '2GB' }
+          ]
+        }
+      })
 
       const { availableModels, refreshModels } = useAIChat(mockContext)
 
diff --git a/frontend/tests/services/aiService.spec.ts b/frontend/tests/services/aiService.spec.ts
index ced0313..6c40075 100644
--- a/frontend/tests/services/aiService.spec.ts
+++ b/frontend/tests/services/aiService.spec.ts
@@ -84,4 +84,32 @@ describe('aiService', () => {
     expect(health.healthy).toBe(true)
     expect(health.provider).toBe('ollama')
   })
+
+  it('fetchModelCatalog should normalize provider keys', async () => {
+    const catalogPayload = {
+      OpenAI: {
+        display_name: 'OpenAI',
+        category: 'cloud',
+        endpoint: 'https://api.openai.com',
+        requires_api_key: true,
+        models: [
+          { id: 'gpt-5', name: 'GPT-5', description: 'Flagship', max_tokens: 200000 }
+        ]
+      }
+    }
+
+    fetchMock.mockResolvedValueOnce(
+      createFetchResponse({
+        data: [
+          { key: 'catalog', value: JSON.stringify(catalogPayload) },
+          { key: 'success', value: true }
+        ]
+      })
+    )
+
+    const catalog = await aiService.fetchModelCatalog()
+    expect(catalog.openai).toBeDefined()
+    expect(catalog.openai.models).toHaveLength(1)
+    expect(catalog.openai.models[0].id).toBe('gpt-5')
+  })
 })
diff --git a/frontend/tests/utils/config.test.ts b/frontend/tests/utils/config.test.ts
index 4ef9c09..e92b714 100644
--- a/frontend/tests/utils/config.test.ts
+++ b/frontend/tests/utils/config.test.ts
@@ -3,7 +3,6 @@ import {
   loadConfig,
   saveConfig,
   getDefaultConfig,
-  getMockModels,
   generateId
 } from '@/utils/config'
 import type { AIConfig } from '@/types'
@@ -180,34 +179,6 @@ describe('config utils', () => {
     })
   })
 
-  describe('getMockModels', () => {
-    it('should return ollama mock models', () => {
-      const models = getMockModels('ollama')
-
-      expect(models).toHaveLength(2)
-      expect(models[0].id).toBe('llama3.2:3b')
-      expect(models[0].name).toBe('Llama 3.2 3B')
-    })
-
-    it('should return openai mock models', () => {
-      const models = getMockModels('openai')
-
-      expect(models).toHaveLength(5)
-      expect(models.map(model => model.id)).toEqual([
-        'gpt-5',
-        'gpt-5-mini',
-        'gpt-5-nano',
-        'gpt-5-pro',
-        'gpt-4.1'
-      ])
-    })
-
-    it('should return empty array for unknown provider', () => {
-      const models = getMockModels('unknown')
-      expect(models).toEqual([])
-    })
-  })
-
   describe('generateId', () => {
     it('should generate unique IDs', () => {
       const id1 = generateId()
diff --git a/go.mod b/go.mod
index e175a33..9f022b1 100644
--- a/go.mod
+++ b/go.mod
@@ -11,6 +11,7 @@ require (
 	github.com/tmc/langchaingo v0.1.13
 	google.golang.org/grpc v1.76.0
 	gopkg.in/yaml.v2 v2.4.0
+	gopkg.in/yaml.v3 v3.0.1
 )
 
 require (
@@ -91,5 +92,4 @@ require (
 	google.golang.org/genproto/googleapis/api v0.0.0-20250804133106-a7a43d27e69b // indirect
 	google.golang.org/genproto/googleapis/rpc v0.0.0-20250804133106-a7a43d27e69b // indirect
 	google.golang.org/protobuf v1.36.10 // indirect
-	gopkg.in/yaml.v3 v3.0.1 // indirect
 )
diff --git a/pkg/ai/generator.go b/pkg/ai/generator.go
index 6804a92..ec0725d 100644
--- a/pkg/ai/generator.go
+++ b/pkg/ai/generator.go
@@ -26,6 +26,7 @@ import (
 	"sync"
 	"time"
 
+	"github.com/linuxsuren/atest-ext-ai/pkg/ai/models"
 	"github.com/linuxsuren/atest-ext-ai/pkg/ai/providers/universal"
 	"github.com/linuxsuren/atest-ext-ai/pkg/config"
 	"github.com/linuxsuren/atest-ext-ai/pkg/interfaces"
@@ -735,12 +736,9 @@ func createRuntimeClient(provider string, runtimeConfig map[string]any) (interfa
 		}
 
 		if config.Endpoint == "" {
-			switch normalizedProvider {
-			case "openai":
-				config.Endpoint = "https://api.openai.com"
-			case "deepseek":
-				config.Endpoint = "https://api.deepseek.com"
-			case "custom":
+			if endpoint := models.EndpointForProvider(normalizedProvider); endpoint != "" {
+				config.Endpoint = endpoint
+			} else if normalizedProvider == "custom" {
 				return nil, fmt.Errorf("endpoint is required for custom provider")
 			}
 		}
diff --git a/pkg/ai/manager.go b/pkg/ai/manager.go
index da911d7..adce837 100644
--- a/pkg/ai/manager.go
+++ b/pkg/ai/manager.go
@@ -29,6 +29,7 @@ import (
 	"time"
 
 	"github.com/linuxsuren/atest-ext-ai/pkg/ai/discovery"
+	"github.com/linuxsuren/atest-ext-ai/pkg/ai/models"
 	"github.com/linuxsuren/atest-ext-ai/pkg/ai/providers/universal"
 	"github.com/linuxsuren/atest-ext-ai/pkg/config"
 	"github.com/linuxsuren/atest-ext-ai/pkg/interfaces"
@@ -543,12 +544,9 @@ func createOpenAICompatibleClient(provider string, cfg config.AIService) (interf
 	}
 
 	if uniCfg.Endpoint == "" {
-		switch normalized {
-		case "openai":
-			uniCfg.Endpoint = "https://api.openai.com"
-		case "deepseek":
-			uniCfg.Endpoint = "https://api.deepseek.com"
-		case "custom":
+		if endpoint := models.EndpointForProvider(normalized); endpoint != "" {
+			uniCfg.Endpoint = endpoint
+		} else if normalized == "custom" {
 			return nil, fmt.Errorf("endpoint is required for custom provider")
 		}
 	}
@@ -585,41 +583,42 @@ func normalizeProviderName(provider string) string {
 
 // getOnlineProviders returns predefined online providers
 func (m *Manager) getOnlineProviders() []*ProviderInfo {
-	return []*ProviderInfo{
-		{
-			Name:      "deepseek",
-			Type:      "online",
-			Available: true,
-			Endpoint:  "https://api.deepseek.com",
-			Models: []interfaces.ModelInfo{
-				{ID: "deepseek-chat", Name: "DeepSeek Chat", Description: "DeepSeek's flagship conversational AI model", MaxTokens: 32768},
-				{ID: "deepseek-reasoner", Name: "DeepSeek Reasoner", Description: "DeepSeek's reasoning model with thinking capabilities", MaxTokens: 32768},
-			},
-			LastChecked: time.Now(),
-			Config: map[string]interface{}{
-				"requires_api_key": true,
-				"provider_type":    "online",
-			},
-		},
-		{
-			Name:      "openai",
-			Type:      "online",
-			Available: true,
-			Endpoint:  "https://api.openai.com",
-			Models: []interfaces.ModelInfo{
-				{ID: "gpt-5", Name: "GPT-5", Description: "OpenAI's flagship GPT-5 model", MaxTokens: 200000},
-				{ID: "gpt-5-mini", Name: "GPT-5 Mini", Description: "Optimized GPT-5 model for lower latency workloads", MaxTokens: 80000},
-				{ID: "gpt-5-nano", Name: "GPT-5 Nano", Description: "Cost-efficient GPT-5 variant for lightweight tasks", MaxTokens: 40000},
-				{ID: "gpt-5-pro", Name: "GPT-5 Pro", Description: "High performance GPT-5 model with extended reasoning", MaxTokens: 240000},
-				{ID: "gpt-4.1", Name: "GPT-4.1", Description: "Balanced GPT-4 series model with strong multimodal support", MaxTokens: 128000},
-			},
+	catalog, err := models.GetCatalog()
+	if err != nil {
+		logging.Logger.Warn("Failed to load model catalog", "error", err)
+		return nil
+	}
+
+	var providers []*ProviderInfo
+	for _, name := range catalog.ProviderNames() {
+		entry, ok := catalog.Provider(name)
+		if !ok {
+			continue
+		}
+
+		providerType := entry.Category
+		if providerType == "" {
+			providerType = "cloud"
+		}
+		if providerType != "cloud" && providerType != "online" {
+			continue
+		}
+
+		providers = append(providers, &ProviderInfo{
+			Name:        entry.Name,
+			Type:        providerType,
+			Available:   true,
+			Endpoint:    entry.Endpoint,
+			Models:      entry.Models,
 			LastChecked: time.Now(),
 			Config: map[string]interface{}{
-				"requires_api_key": true,
-				"provider_type":    "online",
+				"requires_api_key": entry.RequiresAPIKey,
+				"provider_type":    providerType,
 			},
-		},
+		})
 	}
+
+	return providers
 }
 
 // ===== Retry Logic =====
diff --git a/pkg/ai/models/catalog.go b/pkg/ai/models/catalog.go
new file mode 100644
index 0000000..e87aeed
--- /dev/null
+++ b/pkg/ai/models/catalog.go
@@ -0,0 +1,302 @@
+// Package models centralizes AI provider and model metadata for the plugin.
+package models
+
+import (
+	"bytes"
+	"embed"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+
+	"github.com/linuxsuren/atest-ext-ai/pkg/interfaces"
+	"github.com/linuxsuren/atest-ext-ai/pkg/logging"
+	"gopkg.in/yaml.v3"
+)
+
+const (
+	// EnvCatalogPath allows overriding the embedded catalog with an external YAML file.
+	EnvCatalogPath = "ATEST_EXT_AI_MODEL_CATALOG"
+
+	// defaultCatalogPath is the path checked on disk when no explicit override is provided.
+	defaultCatalogPath = "config/models.yaml"
+)
+
+//go:embed catalog.yaml
+var embeddedCatalogFS embed.FS
+
+var (
+	catalogOnce sync.Once
+	catalog     *Catalog
+	catalogErr  error
+)
+
+// Catalog represents the AI model catalog loaded from YAML.
+type Catalog struct {
+	providers map[string]*Provider
+}
+
+// Provider describes a provider entry in the catalog.
+type Provider struct {
+	Name           string
+	DisplayName    string
+	Category       string
+	Endpoint       string
+	RequiresAPIKey bool
+	Models         []interfaces.ModelInfo
+	Tags           []string
+}
+
+type catalogFile struct {
+	Providers map[string]catalogProvider `yaml:"providers"`
+}
+
+type catalogProvider struct {
+	DisplayName    string            `yaml:"display_name"`
+	Category       string            `yaml:"category"`
+	Endpoint       string            `yaml:"endpoint"`
+	RequiresAPIKey bool              `yaml:"requires_api_key"`
+	Tags           []string          `yaml:"tags"`
+	Models         []catalogModel    `yaml:"models"`
+	Metadata       map[string]string `yaml:"metadata"`
+}
+
+type catalogModel struct {
+	ID             string   `yaml:"id"`
+	Name           string   `yaml:"name"`
+	Description    string   `yaml:"description"`
+	MaxTokens      int      `yaml:"max_tokens"`
+	InputCostPerK  float64  `yaml:"input_cost_per_1k"`
+	OutputCostPerK float64  `yaml:"output_cost_per_1k"`
+	Capabilities   []string `yaml:"capabilities"`
+	Tags           []string `yaml:"tags"`
+}
+
+// GetCatalog returns the singleton catalog instance.
+func GetCatalog() (*Catalog, error) {
+	catalogOnce.Do(func() {
+		catalog, catalogErr = loadCatalog()
+	})
+	return catalog, catalogErr
+}
+
+// ReloadCatalog forces the catalog to be reloaded. Primarily used in tests.
+func ReloadCatalog() (*Catalog, error) {
+	catalogOnce = sync.Once{}
+	catalog = nil
+	catalogErr = nil
+	return GetCatalog()
+}
+
+// ProviderNames returns the list of provider identifiers in the catalog.
+func (c *Catalog) ProviderNames() []string {
+	names := make([]string, 0, len(c.providers))
+	for name := range c.providers {
+		names = append(names, name)
+	}
+	return names
+}
+
+// Provider returns the provider entry for the given name (case-insensitive).
+func (c *Catalog) Provider(name string) (*Provider, bool) {
+	key := normalizeName(name)
+	provider, ok := c.providers[key]
+	return provider, ok
+}
+
+// ModelsForProvider returns the catalog models for a specific provider or nil if unknown.
+func (c *Catalog) ModelsForProvider(name string) []interfaces.ModelInfo {
+	if provider, ok := c.Provider(name); ok {
+		return provider.Models
+	}
+	return nil
+}
+
+func loadCatalog() (*Catalog, error) {
+	data, err := readCatalogSource()
+	if err != nil {
+		return nil, fmt.Errorf("failed to load model catalog: %w", err)
+	}
+
+	var file catalogFile
+	if err := yaml.Unmarshal(data, &file); err != nil {
+		return nil, fmt.Errorf("failed to parse model catalog: %w", err)
+	}
+
+	if len(file.Providers) == 0 {
+		return nil, errors.New("model catalog is empty")
+	}
+
+	providers := make(map[string]*Provider, len(file.Providers))
+	for rawName, rawProvider := range file.Providers {
+		name := normalizeName(rawName)
+		if name == "" {
+			continue
+		}
+
+		models := make([]interfaces.ModelInfo, 0, len(rawProvider.Models))
+		for _, model := range rawProvider.Models {
+			if model.ID == "" || model.Name == "" {
+				logging.Logger.Warn("Skipping invalid model entry in catalog", "provider", name, "model_id", model.ID)
+				continue
+			}
+			models = append(models, interfaces.ModelInfo{
+				ID:              model.ID,
+				Name:            model.Name,
+				Description:     model.Description,
+				MaxTokens:       model.MaxTokens,
+				InputCostPer1K:  model.InputCostPerK,
+				OutputCostPer1K: model.OutputCostPerK,
+				Capabilities:    model.Capabilities,
+			})
+		}
+
+		if len(models) == 0 {
+			logging.Logger.Warn("Provider in model catalog has no valid models", "provider", name)
+		}
+
+		providers[name] = &Provider{
+			Name:           name,
+			DisplayName:    firstNonEmpty(rawProvider.DisplayName, simpleTitle(name)),
+			Category:       firstNonEmpty(rawProvider.Category, "cloud"),
+			Endpoint:       strings.TrimSpace(rawProvider.Endpoint),
+			RequiresAPIKey: rawProvider.RequiresAPIKey,
+			Models:         models,
+			Tags:           rawProvider.Tags,
+		}
+	}
+
+	return &Catalog{
+		providers: providers,
+	}, nil
+}
+
+func readCatalogSource() ([]byte, error) {
+	if envPath := strings.TrimSpace(os.Getenv(EnvCatalogPath)); envPath != "" {
+		data, err := os.ReadFile(envPath) // #nosec G304 -- path intentionally user-configurable
+		if err != nil {
+			return nil, fmt.Errorf("failed to read catalog from %s: %w", envPath, err)
+		}
+		return data, nil
+	}
+
+	if data, err := os.ReadFile(defaultCatalogPath); err == nil {
+		return data, nil
+	}
+
+	file, err := embeddedCatalogFS.Open("catalog.yaml")
+	if err != nil {
+		return nil, err
+	}
+	defer func() { _ = file.Close() }()
+
+	buf := new(bytes.Buffer)
+	if _, err := buf.ReadFrom(file); err != nil {
+		return nil, err
+	}
+
+	return buf.Bytes(), nil
+}
+
+func normalizeName(name string) string {
+	return strings.ToLower(strings.TrimSpace(name))
+}
+
+func firstNonEmpty(values ...string) string {
+	for _, value := range values {
+		if strings.TrimSpace(value) != "" {
+			return strings.TrimSpace(value)
+		}
+	}
+	return ""
+}
+
+func simpleTitle(name string) string {
+	trimmed := strings.TrimSpace(name)
+	if trimmed == "" {
+		return ""
+	}
+	if len(trimmed) == 1 {
+		return strings.ToUpper(trimmed)
+	}
+	return strings.ToUpper(trimmed[:1]) + trimmed[1:]
+}
+
+// EndpointForProvider returns the preferred endpoint for a provider, or an empty string if unknown.
+func EndpointForProvider(name string) string {
+	catalog, err := GetCatalog()
+	if err != nil {
+		return ""
+	}
+	if provider, ok := catalog.Provider(name); ok {
+		return provider.Endpoint
+	}
+	return ""
+}
+
+// RequiresAPIKey reports whether the catalog marks the provider as requiring an API key.
+func RequiresAPIKey(name string) bool {
+	catalog, err := GetCatalog()
+	if err != nil {
+		return true
+	}
+	if provider, ok := catalog.Provider(name); ok {
+		return provider.RequiresAPIKey
+	}
+	return true
+}
+
+// ProviderCatalogEntry encapsulates provider metadata for API responses.
+type ProviderCatalogEntry struct {
+	DisplayName    string                 `json:"display_name"`
+	Category       string                 `json:"category"`
+	Endpoint       string                 `json:"endpoint"`
+	RequiresAPIKey bool                   `json:"requires_api_key"`
+	Models         []interfaces.ModelInfo `json:"models"`
+	Tags           []string               `json:"tags,omitempty"`
+}
+
+// CatalogSnapshot returns a serializable snapshot of the catalog.
+func CatalogSnapshot(provider string) map[string]ProviderCatalogEntry {
+	catalog, err := GetCatalog()
+	if err != nil {
+		return map[string]ProviderCatalogEntry{}
+	}
+
+	result := make(map[string]ProviderCatalogEntry)
+	if provider != "" {
+		if entry, ok := catalog.Provider(provider); ok {
+			result[entry.Name] = providerToEntry(entry)
+		}
+		return result
+	}
+
+	for name, entry := range catalog.providers {
+		result[name] = providerToEntry(entry)
+	}
+	return result
+}
+
+func providerToEntry(provider *Provider) ProviderCatalogEntry {
+	return ProviderCatalogEntry{
+		DisplayName:    provider.DisplayName,
+		Category:       provider.Category,
+		Endpoint:       provider.Endpoint,
+		RequiresAPIKey: provider.RequiresAPIKey,
+		Models:         provider.Models,
+		Tags:           provider.Tags,
+	}
+}
+
+// CatalogFilePath returns the resolved catalog file path when an external file is used.
+func CatalogFilePath() string {
+	if envPath := strings.TrimSpace(os.Getenv(EnvCatalogPath)); envPath != "" {
+		return envPath
+	}
+	if _, err := os.Stat(defaultCatalogPath); err == nil {
+		return filepath.Clean(defaultCatalogPath)
+	}
+	return ""
+}
diff --git a/pkg/ai/models/catalog.yaml b/pkg/ai/models/catalog.yaml
new file mode 100644
index 0000000..85b3b3d
--- /dev/null
+++ b/pkg/ai/models/catalog.yaml
@@ -0,0 +1,43 @@
+providers:
+  openai:
+    display_name: "OpenAI"
+    category: "cloud"
+    endpoint: "https://api.openai.com"
+    requires_api_key: true
+    models:
+      - id: "gpt-5"
+        name: "GPT-5"
+        description: "OpenAI's flagship GPT-5 model"
+        max_tokens: 200000
+        tags:
+          - recommended
+      - id: "gpt-5-mini"
+        name: "GPT-5 Mini"
+        description: "Optimized GPT-5 model for latency-sensitive workloads"
+        max_tokens: 80000
+      - id: "gpt-5-nano"
+        name: "GPT-5 Nano"
+        description: "Cost-efficient GPT-5 variant for lightweight tasks"
+        max_tokens: 40000
+      - id: "gpt-5-pro"
+        name: "GPT-5 Pro"
+        description: "High performance GPT-5 model with extended reasoning"
+        max_tokens: 240000
+      - id: "gpt-4.1"
+        name: "GPT-4.1"
+        description: "Balanced GPT-4 series model with strong multimodal support"
+        max_tokens: 128000
+  deepseek:
+    display_name: "DeepSeek"
+    category: "cloud"
+    endpoint: "https://api.deepseek.com"
+    requires_api_key: true
+    models:
+      - id: "deepseek-chat"
+        name: "DeepSeek Chat"
+        description: "DeepSeek's flagship conversational AI model"
+        max_tokens: 32768
+      - id: "deepseek-reasoner"
+        name: "DeepSeek Reasoner"
+        description: "DeepSeek's reasoning model with advanced thinking capabilities"
+        max_tokens: 32768
diff --git a/pkg/ai/models/catalog_test.go b/pkg/ai/models/catalog_test.go
new file mode 100644
index 0000000..8d8803e
--- /dev/null
+++ b/pkg/ai/models/catalog_test.go
@@ -0,0 +1,78 @@
+package models
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestGetCatalog(t *testing.T) {
+	catalog, err := GetCatalog()
+	if err != nil {
+		t.Fatalf("failed to load catalog: %v", err)
+	}
+
+	if len(catalog.ProviderNames()) == 0 {
+		t.Fatalf("expected catalog to contain providers")
+	}
+
+	openai, ok := catalog.Provider("openai")
+	if !ok {
+		t.Fatalf("expected openai provider in catalog")
+	}
+	if len(openai.Models) == 0 {
+		t.Fatalf("expected openai to have models")
+	}
+}
+
+func TestCatalogSnapshot(t *testing.T) {
+	snapshot := CatalogSnapshot("")
+	if len(snapshot) == 0 {
+		t.Fatalf("expected catalog snapshot to have entries")
+	}
+
+	entry, ok := snapshot["openai"]
+	if !ok {
+		t.Fatalf("expected snapshot to contain openai entry")
+	}
+	if entry.Endpoint == "" {
+		t.Fatalf("expected openai endpoint to be populated")
+	}
+}
+
+func TestEndpointForProvider(t *testing.T) {
+	if endpoint := EndpointForProvider("openai"); endpoint == "" {
+		t.Fatalf("expected endpoint for openai")
+	}
+}
+
+func TestReloadWithExternalFile(t *testing.T) {
+	dir := t.TempDir()
+	path := filepath.Join(dir, "catalog.yaml")
+
+	content := []byte(`
+providers:
+  test:
+    display_name: "Test Provider"
+    category: "cloud"
+    endpoint: "https://example.com"
+    requires_api_key: false
+    models:
+      - id: "test-model"
+        name: "Test Model"
+        max_tokens: 1024
+`)
+	if err := os.WriteFile(path, content, 0o600); err != nil {
+		t.Fatalf("failed to write temp catalog: %v", err)
+	}
+
+	t.Setenv(EnvCatalogPath, path)
+	catalog, err := ReloadCatalog()
+	if err != nil {
+		t.Fatalf("failed to reload catalog: %v", err)
+	}
+
+	if _, ok := catalog.Provider("test"); !ok {
+		t.Fatalf("expected test provider from external catalog")
+	}
+}
diff --git a/pkg/ai/providers/universal/strategy_openai.go b/pkg/ai/providers/universal/strategy_openai.go
index c8e6cf3..7f4bcc0 100644
--- a/pkg/ai/providers/universal/strategy_openai.go
+++ b/pkg/ai/providers/universal/strategy_openai.go
@@ -22,6 +22,7 @@ import (
 	"io"
 	"strings"
 
+	"github.com/linuxsuren/atest-ext-ai/pkg/ai/models"
 	"github.com/linuxsuren/atest-ext-ai/pkg/interfaces"
 )
 
@@ -169,66 +170,22 @@ func (s *OpenAIStrategy) GetDefaultPaths() ProviderPaths {
 
 // GetDefaultModels returns default models for specific providers
 func (s *OpenAIStrategy) GetDefaultModels(maxTokens int) []interfaces.ModelInfo {
-	switch s.provider {
-	case "deepseek":
-		return []interfaces.ModelInfo{
-			{
-				ID:          "deepseek-chat",
-				Name:        "DeepSeek Chat",
-				Description: "DeepSeek's flagship conversational AI model",
-				MaxTokens:   32768,
-			},
-			{
-				ID:          "deepseek-reasoner",
-				Name:        "DeepSeek Reasoner",
-				Description: "DeepSeek's reasoning model with thinking capabilities",
-				MaxTokens:   32768,
-			},
-		}
-	case "openai":
-		return []interfaces.ModelInfo{
-			{
-				ID:          "gpt-5",
-				Name:        "GPT-5",
-				Description: "OpenAI's flagship GPT-5 model",
-				MaxTokens:   200000,
-			},
-			{
-				ID:          "gpt-5-mini",
-				Name:        "GPT-5 Mini",
-				Description: "Optimized GPT-5 model for latency-sensitive workloads",
-				MaxTokens:   80000,
-			},
-			{
-				ID:          "gpt-5-nano",
-				Name:        "GPT-5 Nano",
-				Description: "Cost efficient GPT-5 variant for lightweight tasks",
-				MaxTokens:   40000,
-			},
-			{
-				ID:          "gpt-5-pro",
-				Name:        "GPT-5 Pro",
-				Description: "High performance GPT-5 model with extended reasoning",
-				MaxTokens:   240000,
-			},
-			{
-				ID:          "gpt-4.1",
-				Name:        "GPT-4.1",
-				Description: "Balanced GPT-4 series model with strong multimodal support",
-				MaxTokens:   128000,
-			},
-		}
-	default:
-		// Generic fallback
-		return []interfaces.ModelInfo{
-			{
-				ID:          "default",
-				Name:        "Default Model",
-				Description: "Default model for this provider",
-				MaxTokens:   maxTokens,
-			},
+	catalog, err := models.GetCatalog()
+	if err == nil {
+		if entries := catalog.ModelsForProvider(s.provider); len(entries) > 0 {
+			return entries
 		}
 	}
+
+	// Generic fallback
+	return []interfaces.ModelInfo{
+		{
+			ID:          "default",
+			Name:        "Default Model",
+			Description: "Default model for this provider",
+			MaxTokens:   maxTokens,
+		},
+	}
 }
 
 // SupportsStreaming indicates if this provider supports streaming
diff --git a/pkg/plugin/service.go b/pkg/plugin/service.go
index d82bc58..29563f8 100644
--- a/pkg/plugin/service.go
+++ b/pkg/plugin/service.go
@@ -27,6 +27,7 @@ import (
 	"github.com/linuxsuren/api-testing/pkg/server"
 	"github.com/linuxsuren/api-testing/pkg/testing/remote"
 	"github.com/linuxsuren/atest-ext-ai/pkg/ai"
+	"github.com/linuxsuren/atest-ext-ai/pkg/ai/models"
 	"github.com/linuxsuren/atest-ext-ai/pkg/ai/providers/universal"
 	"github.com/linuxsuren/atest-ext-ai/pkg/config"
 	apperrors "github.com/linuxsuren/atest-ext-ai/pkg/errors"
@@ -364,6 +365,8 @@ func (s *AIPluginService) Query(ctx context.Context, req *server.DataQuery) (*se
 			return nil, status.Error(codes.FailedPrecondition, errMsg)
 		}
 		return s.handleGetProviders(ctx, req)
+	case "models_catalog":
+		return s.handleGetModelCatalog(ctx, req)
 	case "models":
 		// Check AI manager availability for model operations
 		if s.aiManager == nil {
@@ -1245,6 +1248,42 @@ func (s *AIPluginService) handleGetModels(ctx context.Context, req *server.DataQ
 	}, nil
 }
 
+// handleGetModelCatalog returns the static model catalog (either entire catalog or provider-specific slice)
+func (s *AIPluginService) handleGetModelCatalog(_ context.Context, req *server.DataQuery) (*server.DataQueryResult, error) {
+	var params struct {
+		Provider string `json:"provider"`
+	}
+
+	if req.Sql != "" {
+		if err := json.Unmarshal([]byte(req.Sql), &params); err != nil {
+			return nil, apperrors.ToGRPCErrorf(apperrors.ErrInvalidRequest, "invalid parameters: %v", err)
+		}
+	}
+
+	catalogSnapshot := models.CatalogSnapshot(params.Provider)
+	if len(catalogSnapshot) == 0 {
+		return nil, apperrors.ToGRPCErrorf(apperrors.ErrModelNotFound, "no catalog entries found for provider %s", params.Provider)
+	}
+
+	snapshotJSON, err := json.Marshal(catalogSnapshot)
+	if err != nil {
+		return nil, status.Errorf(codes.Internal, "failed to marshal catalog: %v", err)
+	}
+
+	result := &server.DataQueryResult{
+		Data: []*server.Pair{
+			{Key: "catalog", Value: string(snapshotJSON)},
+			{Key: "success", Value: "true"},
+		},
+	}
+
+	if params.Provider != "" {
+		result.Data = append(result.Data, &server.Pair{Key: "provider", Value: params.Provider})
+	}
+
+	return result, nil
+}
+
 // handleTestConnection tests a connection with provided configuration
 func (s *AIPluginService) handleTestConnection(ctx context.Context, req *server.DataQuery) (*server.DataQueryResult, error) {
 	logging.Logger.Debug("Handling test connection request", "sql_length", len(req.Sql))