diff --git a/.env.example b/.env.example
index b86a2105d..c24cd6ef5 100644
--- a/.env.example
+++ b/.env.example
@@ -22,6 +22,10 @@ AUTH_TRUST_HOST=true
 
 OPENAI_API_KEY=your-openai-api-key-here
 
+# Local OpenAI-compatible server (LM Studio, llama.cpp, vLLM, etc.)
+OPENAI_COMPAT_BASE_URL=http://127.0.0.1:1234
+OPENAI_COMPAT_API_KEY=
+
 # DeepSeek API Key - get from https://platform.deepseek.com
 DEEPSEEK_API_KEY=your-deepseek-api-key-here
 
diff --git a/__tests__/aiSettings.spec.ts b/__tests__/aiSettings.spec.ts
new file mode 100644
index 000000000..14f9e41bc
--- /dev/null
+++ b/__tests__/aiSettings.spec.ts
@@ -0,0 +1,12 @@
+vi.mock("@/lib/db", () => ({ default: {} }));
+
+import { AiProvider } from "@/models/ai.model";
+import { getDefaultModelForProvider } from "@/lib/scraper/automation-run/aiSettings";
+
+describe("getDefaultModelForProvider", () => {
+  it("requires an explicit model for openai-compatible", () => {
+    expect(() =>
+      getDefaultModelForProvider(AiProvider.OPENAI_COMPATIBLE),
+    ).toThrow("Select a model for the OpenAI-compatible provider");
+  });
+});
diff --git a/__tests__/api-key-resolver.spec.ts b/__tests__/api-key-resolver.spec.ts
index 98252b9c2..70d01fe00 100644
--- a/__tests__/api-key-resolver.spec.ts
+++ b/__tests__/api-key-resolver.spec.ts
@@ -123,3 +123,38 @@ describe("resolveApiKey", () => {
     expect(mockFindUnique).not.toHaveBeenCalled();
   });
 });
+
+describe("resolveApiKey – openai-compatible-key", () => {
+  const OLD_ENV = process.env;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    process.env = { ...OLD_ENV };
+    delete process.env.OPENAI_COMPAT_API_KEY;
+  });
+
+  afterAll(() => {
+    process.env = OLD_ENV;
+  });
+
+  it("returns a stored key", async () => {
+    mockFindUnique.mockResolvedValue({
+      id: "k-compat",
+      encryptedKey: "cipher",
+      iv: "saltiv",
+    });
+
+    const result = await resolveApiKey("user-1", "openai-compatible-key");
+
+    expect(result).toBe("decrypted(cipher,saltiv)");
+  });
+
+  it("falls back to OPENAI_COMPAT_API_KEY", async () => {
+    mockFindUnique.mockResolvedValue(null);
+    process.env.OPENAI_COMPAT_API_KEY = "env-compat-key";
+
+    const result = await resolveApiKey("user-1", "openai-compatible-key");
+
+    expect(result).toBe("env-compat-key");
+  });
+});
diff --git a/__tests__/openai-compatible-models-route.spec.ts b/__tests__/openai-compatible-models-route.spec.ts
new file mode 100644
index 000000000..ec5152fa4
--- /dev/null
+++ b/__tests__/openai-compatible-models-route.spec.ts
@@ -0,0 +1,57 @@
+vi.mock("@/auth", () => ({ auth: vi.fn() }));
+vi.mock("@/lib/api-key-resolver", () => ({ resolveApiKey: vi.fn() }));
+vi.mock("@/lib/telemetry", () => ({ log: { error: vi.fn() } }));
+vi.mock("next/server", () => ({
+  NextResponse: {
+    json: (data: unknown, init?: { status?: number }) => ({
+      status: init?.status ?? 200,
+      json: async () => data,
+    }),
+  },
+}));
+
+import { GET } from "@/app/api/ai/openai-compatible/models/route";
+import { auth } from "@/auth";
+import { resolveApiKey } from "@/lib/api-key-resolver";
+
+describe("GET /api/ai/openai-compatible/models", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    (auth as any).mockResolvedValue({ user: { id: "user-1" } });
+  });
+
+  it("returns 500 when no base URL is configured", async () => {
+    (resolveApiKey as any).mockResolvedValue(undefined);
+
+    const response = await GET();
+    const data = await response.json();
+
+    expect(response.status).toBe(500);
+    expect(data.error).toContain("base URL not configured");
+  });
+
+  it("lists models from the local /v1/models endpoint", async () => {
+    (resolveApiKey as any).mockImplementation(
+      async (_userId: string | undefined, provider: string) => {
+        if (provider === "openai-compatible") return "http://127.0.0.1:1234/";
+        if (provider === "openai-compatible-key") return "sk-local";
+        return undefined;
+      },
+    );
+    const mockModels = { data: [{ id: "local-model" }] };
+    global.fetch = vi.fn().mockResolvedValue({
+      ok: true,
+      json: async () => mockModels,
+    });
+
+    const response = await GET();
+    const data = await response.json();
+
+    expect(response.status).toBe(200);
+    expect(data).toEqual(mockModels);
+    expect(global.fetch).toHaveBeenCalledWith(
+      "http://127.0.0.1:1234/v1/models",
+      { headers: { Authorization: "Bearer sk-local" } },
+    );
+  });
+});
diff --git a/__tests__/provider-registry-server.spec.ts b/__tests__/provider-registry-server.spec.ts
index 968eb3a50..5bfe6dbe4 100644
--- a/__tests__/provider-registry-server.spec.ts
+++ b/__tests__/provider-registry-server.spec.ts
@@ -145,3 +145,35 @@ describe("PROVIDER_FACTORIES – openrouter", () => {
     );
   });
 });
+
+describe("PROVIDER_VERIFIERS – openai-compatible", () => {
+  it("verifies a base URL without an API key", async () => {
+    global.fetch = vi.fn().mockResolvedValue({ ok: true, status: 200 });
+
+    const result = await PROVIDER_VERIFIERS["openai-compatible"](
+      "http://127.0.0.1:1234",
+    );
+
+    expect(result).toEqual({ success: true });
+    expect(global.fetch).toHaveBeenCalledWith(
+      "http://127.0.0.1:1234/v1/models",
+      expect.objectContaining({ headers: {} }),
+    );
+  });
+
+  it("sends a Bearer token when given { baseURL, apiKey }", async () => {
+    global.fetch = vi.fn().mockResolvedValue({ ok: true, status: 200 });
+
+    await PROVIDER_VERIFIERS["openai-compatible"]({
+      baseURL: "http://127.0.0.1:1234/",
+      apiKey: "sk-local",
+    });
+
+    expect(global.fetch).toHaveBeenCalledWith(
+      "http://127.0.0.1:1234/v1/models",
+      expect.objectContaining({
+        headers: { Authorization: "Bearer sk-local" },
+      }),
+    );
+  });
+});
diff --git a/__tests__/provider-registry.spec.ts b/__tests__/provider-registry.spec.ts
index 8915e92aa..0ee505d4a 100644
--- a/__tests__/provider-registry.spec.ts
+++ b/__tests__/provider-registry.spec.ts
@@ -5,15 +5,16 @@ describe("AI_PROVIDERS", () => {
     expect(AI_PROVIDERS).toContain("openrouter");
   });
 
-  it("contains exactly 5 providers", () => {
-    expect(AI_PROVIDERS).toHaveLength(5);
+  it("contains exactly 6 providers", () => {
+    expect(AI_PROVIDERS).toHaveLength(6);
   });
 
-  it("contains ollama, openai, deepseek, openrouter, gemini", () => {
+  it("contains ollama, openai, openai-compatible, deepseek, openrouter, gemini", () => {
     expect(AI_PROVIDERS).toEqual(
       expect.arrayContaining([
         "ollama",
         "openai",
+        "openai-compatible",
         "deepseek",
         "openrouter",
         "gemini",
@@ -134,3 +135,19 @@ describe("PROVIDER_REGISTRY – openrouter entry", () => {
     });
   });
 });
+
+describe("PROVIDER_REGISTRY – openai-compatible entry", () => {
+  const entry = PROVIDER_REGISTRY["openai-compatible"];
+
+  it("uses a non-sensitive base URL", () => {
+    expect(entry.credentialType).toBe("base-url");
+    expect(entry.keyConfig.sensitive).toBe(false);
+    expect(entry.modelsEndpoint).toBe("openai-compatible/models");
+  });
+
+  it("parses OpenAI-style model lists", () => {
+    expect(
+      entry.parseModelsResponse!({ data: [{ id: "local-model" }] }),
+    ).toEqual(["local-model"]);
+  });
+});
diff --git a/__tests__/providers.spec.ts b/__tests__/providers.spec.ts
index 3cda27c59..23c9933d6 100644
--- a/__tests__/providers.spec.ts
+++ b/__tests__/providers.spec.ts
@@ -11,11 +11,18 @@ vi.mock("@/lib/ai/provider-registry.server", () => ({
     ollama: vi.fn(),
     gemini: vi.fn(),
   },
+  openaiCompatibleRoot: (url: string) =>
+    url.replace(/\/+$/, "").replace(/\/v1$/i, ""),
+}));
+
+vi.mock("@ai-sdk/openai", () => ({
+  createOpenAI: vi.fn(),
 }));
 
 import { getModel } from "@/lib/ai/providers";
 import { resolveApiKey } from "@/lib/api-key-resolver";
 import { PROVIDER_FACTORIES } from "@/lib/ai/provider-registry.server";
+import { createOpenAI } from "@ai-sdk/openai";
 
 describe("getModel – openrouter", () => {
   const mockModelInstance = { modelId: "openai/gpt-4o" };
@@ -87,3 +94,40 @@ describe("getModel – provider validation", () => {
     ).resolves.toBeDefined();
   });
 });
+
+describe("getModel – openai-compatible", () => {
+  const mockModelInstance = { modelId: "local-model" };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    const mockChat = vi.fn().mockReturnValue(mockModelInstance);
+    (createOpenAI as any).mockReturnValue({ chat: mockChat });
+    (resolveApiKey as any).mockImplementation(
+      async (_userId: string | undefined, provider: string) => {
+        if (provider === "openai-compatible") return "http://127.0.0.1:1234";
+        if (provider === "openai-compatible-key") return "sk-local";
+        return undefined;
+      },
+    );
+  });
+
+  it("builds a Chat Completions client from base URL and optional API key", async () => {
+    const result = await getModel("openai-compatible", "local-model", "user-1");
+
+    expect(createOpenAI).toHaveBeenCalledWith({
+      baseURL: "http://127.0.0.1:1234/v1",
+      apiKey: "sk-local",
+      name: "openai-compatible",
+    });
+    expect((createOpenAI as any).mock.results[0].value.chat).toHaveBeenCalledWith(
+      "local-model",
+    );
+    expect(result).toBe(mockModelInstance);
+  });
+
+  it("throws when no model is selected", async () => {
+    await expect(getModel("openai-compatible", "", "user-1")).rejects.toThrow(
+      "Select a model for the OpenAI-compatible provider",
+    );
+  });
+});
diff --git a/__tests__/verify-api-key-route.spec.ts b/__tests__/verify-api-key-route.spec.ts
index 372e2bf2b..8a981f69d 100644
--- a/__tests__/verify-api-key-route.spec.ts
+++ b/__tests__/verify-api-key-route.spec.ts
@@ -18,6 +18,9 @@ vi.mock("@/lib/ai/provider-registry.server", () => ({
     get openai() {
       return mockVerifier;
     },
+    get "openai-compatible"() {
+      return mockVerifier;
+    },
   },
 }));
 
@@ -106,4 +109,21 @@ describe("POST /api/settings/api-keys/verify", () => {
     expect(data.error).toBe("Invalid API key");
     expect(data.reason).toBeUndefined();
   });
+
+  it("passes openai-compatible credentials as { baseURL, apiKey }", async () => {
+    mockVerifier.mockResolvedValue({ success: true });
+
+    await POST(
+      req({
+        provider: "openai-compatible",
+        key: "http://127.0.0.1:1234",
+        apiKey: "sk-local",
+      }),
+    );
+
+    expect(mockVerifier).toHaveBeenCalledWith({
+      baseURL: "http://127.0.0.1:1234",
+      apiKey: "sk-local",
+    });
+  });
 });
diff --git a/src/app/api/ai/openai-compatible/models/route.ts b/src/app/api/ai/openai-compatible/models/route.ts
new file mode 100644
index 000000000..5e3aef888
--- /dev/null
+++ b/src/app/api/ai/openai-compatible/models/route.ts
@@ -0,0 +1,50 @@
+import { auth } from "@/auth";
+import { NextResponse } from "next/server";
+import { resolveApiKey } from "@/lib/api-key-resolver";
+import { openaiCompatibleRoot } from "@/lib/ai/provider-registry.server";
+import { log } from "@/lib/telemetry";
+
+export async function GET() {
+  try {
+    const session = await auth();
+    const userId = session?.user?.id;
+
+    const baseURL = await resolveApiKey(userId, "openai-compatible");
+    if (!baseURL) {
+      return NextResponse.json(
+        { error: "OpenAI-compatible base URL not configured" },
+        { status: 500 },
+      );
+    }
+
+    const apiKey = await resolveApiKey(userId, "openai-compatible-key");
+    const headers: Record<string, string> = {};
+    if (apiKey) {
+      headers.Authorization = `Bearer ${apiKey}`;
+    }
+
+    const response = await fetch(
+      `${openaiCompatibleRoot(baseURL)}/v1/models`,
+      { headers },
+    );
+
+    if (!response.ok) {
+      return NextResponse.json(
+        { error: `Failed to fetch models: ${response.status}` },
+        { status: response.status },
+      );
+    }
+
+    const data = await response.json();
+    return NextResponse.json(data);
+  } catch (error) {
+    log.error("Error fetching models", {
+      provider: "openai-compatible",
+      error: String(error),
+    });
+    return NextResponse.json(
+      { error: "Failed to fetch models from OpenAI-compatible endpoint" },
+      { status: 502 },
+    );
+  }
+}
diff --git a/src/app/api/settings/api-keys/verify/route.ts b/src/app/api/settings/api-keys/verify/route.ts
index 2269e0401..37961ba24 100644
--- a/src/app/api/settings/api-keys/verify/route.ts
+++ b/src/app/api/settings/api-keys/verify/route.ts
@@ -8,7 +8,8 @@ export async function POST(req: NextRequest) {
     return NextResponse.json({ success: false, error: "Not authenticated" }, { status: 401 });
   }
 
-  const { provider, key } = await req.json();
+  const body = await req.json();
+  const { provider, key, apiKey } = body;
 
   if (!provider || !key) {
     return NextResponse.json(
@@ -26,7 +27,9 @@ export async function POST(req: NextRequest) {
   }
 
   try {
-    const result = await verifier(key);
+    const verifyKey =
+      provider === "openai-compatible" ? { baseURL: key, apiKey } : key;
+    const result = await verifier(verifyKey);
     return NextResponse.json(result);
   } catch (error) {
     const message = error instanceof Error ? error.message : "Verification failed";
diff --git a/src/components/settings/ApiKeySettings.tsx b/src/components/settings/ApiKeySettings.tsx
index f09ae93df..d6183e09d 100644
--- a/src/components/settings/ApiKeySettings.tsx
+++ b/src/components/settings/ApiKeySettings.tsx
@@ -68,6 +68,7 @@ function ApiKeySettings() {
     null,
   );
   const [inputValue, setInputValue] = useState("");
+  const [openaiCompatApiKey, setOpenaiCompatApiKey] = useState("");
   const [verifying, setVerifying] = useState(false);
   const [deleting, setDeleting] = useState<string | null>(null);
   const [ollamaConnected, setOllamaConnected] = useState<boolean | null>(null);
@@ -119,10 +120,14 @@ function ApiKeySettings() {
 
     setVerifying(true);
     try {
+      const verifyBody =
+        provider === "openai-compatible"
+          ? { provider, key: inputValue, apiKey: openaiCompatApiKey || undefined }
+          : { provider, key: inputValue };
       const verifyRes = await fetch("/api/settings/api-keys/verify", {
         method: "POST",
         headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ provider, key: inputValue }),
+        body: JSON.stringify(verifyBody),
       });
       const verifyData = await verifyRes.json();
 
@@ -136,18 +141,32 @@ function ApiKeySettings() {
       }
 
       const providerConfig = PROVIDERS.find((p) => p.id === provider);
-      const saveResult = await saveApiKey({
+      const saveBaseResult = await saveApiKey({
         provider,
         key: inputValue,
         sensitive: providerConfig?.sensitive ?? true,
       });
-      if (saveResult.success) {
+
+      let saveKeyResult: { success: boolean; message?: string } | null = null;
+      if (provider === "openai-compatible" && openaiCompatApiKey.trim()) {
+        saveKeyResult = await saveApiKey({
+          provider: "openai-compatible-key",
+          key: openaiCompatApiKey,
+          sensitive: true,
+        });
+      }
+
+      if (saveBaseResult.success && (!saveKeyResult || saveKeyResult.success)) {
         toastSuccess(`${PROVIDERS.find((p) => p.id === provider)?.name} key verified and saved.`, "API key saved");
         setEditingProvider(null);
         setInputValue("");
+        setOpenaiCompatApiKey("");
         await fetchKeys();
       } else {
-        toastError(saveResult.message || "Failed to save API key", "Save failed");
+        toastError(
+          saveBaseResult.message || saveKeyResult?.message || "Failed to save API key",
+          "Save failed",
+        );
       }
     } catch (error) {
       console.error("Error saving API key:", error);
@@ -160,12 +179,17 @@ function ApiKeySettings() {
   const handleDelete = async (provider: ApiKeyProvider) => {
     setDeleting(provider);
     try {
-      const result = await deleteApiKey(provider);
-      if (result.success) {
+      const results = await Promise.all([
+        deleteApiKey(provider),
+        ...(provider === "openai-compatible"
+          ? [deleteApiKey("openai-compatible-key")]
+          : []),
+      ]);
+      if (results.every((r) => r.success)) {
         toastSuccess(`${PROVIDERS.find((p) => p.id === provider)?.name} key removed.`, "API key deleted");
         await fetchKeys();
       } else {
-        toastError(result.message || "Failed to delete API key");
+        toastError("Failed to delete API key");
       }
     } catch (error) {
       console.error("Error deleting API key:", error);
@@ -177,6 +201,7 @@ function ApiKeySettings() {
   const handleCancel = () => {
     setEditingProvider(null);
     setInputValue("");
+    setOpenaiCompatApiKey("");
   };
 
   if (isLoading) {
@@ -237,6 +262,18 @@ function ApiKeySettings() {
                   ) : (
                     <Badge variant="secondary">Not configured</Badge>
                   )}
+                  {provider.id === "openai-compatible" && (
+                    <div className="ml-2">
+                      {keys.find((k) => k.provider === "openai-compatible-key") ? (
+                        <Badge className="bg-green-100 text-green-800 dark:bg-green-900 dark:text-green-200">
+                          <CheckCircle className="h-3 w-3 mr-1" />
+                          API Key
+                        </Badge>
+                      ) : (
+                        <Badge variant="outline">No API Key</Badge>
+                      )}
+                    </div>
+                  )}
                 </div>
               </CardHeader>
               {provider.id === "ollama" && (
@@ -290,6 +327,21 @@ function ApiKeySettings() {
                         className="mt-1"
                       />
                     </div>
+                    {provider.id === "openai-compatible" && (
+                      <div>
+                        <Label htmlFor={`key-${provider.id}-api`}>
+                          API Key (optional)
+                        </Label>
+                        <Input
+                          id={`key-${provider.id}-api`}
+                          type="password"
+                          placeholder="sk-..."
+                          value={openaiCompatApiKey}
+                          onChange={(e) => setOpenaiCompatApiKey(e.target.value)}
+                          className="mt-1"
+                        />
+                      </div>
+                    )}
                     <div className="flex gap-2">
                       <Button
                         size="sm"
diff --git a/src/lib/ai/provider-registry.server.ts b/src/lib/ai/provider-registry.server.ts
index 3910d2168..c326c6b5c 100644
--- a/src/lib/ai/provider-registry.server.ts
+++ b/src/lib/ai/provider-registry.server.ts
@@ -19,9 +19,17 @@ export const PROVIDER_FACTORIES: Record<
   gemini: (apiKey, model) => createGoogleGenerativeAI({ apiKey })(model),
 };
 
+export type ProviderVerifierInput =
+  | string
+  | { baseURL: string; apiKey?: string };
+
+export function openaiCompatibleRoot(baseURL: string): string {
+  return baseURL.replace(/\/+$/, "").replace(/\/v1$/i, "");
+}
+
 export const PROVIDER_VERIFIERS: Record<
   string,
-  (key: string) => Promise<{ success: boolean; error?: string }>
+  (key: ProviderVerifierInput) => Promise<{ success: boolean; error?: string }>
 > = {
   openai: async (key) => {
     const res = await fetch("https://api.openai.com/v1/models", {
@@ -39,6 +47,28 @@ export const PROVIDER_VERIFIERS: Record<
     return { success: true };
   },
 
+  "openai-compatible": async (key) => {
+    const params = typeof key === "object" ? key : { baseURL: key };
+    const root = openaiCompatibleRoot(params.baseURL);
+    const headers: Record<string, string> = {};
+    if (params.apiKey) {
+      headers.Authorization = `Bearer ${params.apiKey}`;
+    }
+    const res = await fetch(`${root}/v1/models`, {
+      headers,
+      signal: AbortSignal.timeout(APP_CONSTANTS.AI_VERIFY_TIMEOUT_MS),
+    });
+    if (!res.ok)
+      return {
+        success: false,
+        error:
+          res.status === 401
+            ? "Invalid API key"
+            : `OpenAI-compatible endpoint returned ${res.status}`,
+      };
+    return { success: true };
+  },
+
   // /api/v1/key is the authenticated endpoint. /models is public and answers
   // 200 to any key, so verifying against it passes anything pasted in.
   openrouter: async (key) => {
@@ -74,7 +104,10 @@ export const PROVIDER_VERIFIERS: Record<
   },
 
   ollama: async (key) => {
-    const baseUrl = key.replace(/\/+$/, "");
+    const baseUrl = (typeof key === "string" ? key : key.baseURL).replace(
+      /\/+$/,
+      "",
+    );
     try {
       const res = await fetch(`${baseUrl}/api/tags`, {
         signal: AbortSignal.timeout(APP_CONSTANTS.AI_OLLAMA_LIST_TIMEOUT_MS),
diff --git a/src/lib/ai/provider-registry.ts b/src/lib/ai/provider-registry.ts
index 97f3aa305..b7a3c7538 100644
--- a/src/lib/ai/provider-registry.ts
+++ b/src/lib/ai/provider-registry.ts
@@ -61,6 +61,26 @@ export const PROVIDER_REGISTRY: Record<string, ProviderRegistryEntry> = {
     },
   },
 
+  "openai-compatible": {
+    id: "openai-compatible",
+    displayName: "OpenAI Compatible",
+    credentialType: "base-url",
+    category: "local",
+    envVar: "OPENAI_COMPAT_BASE_URL",
+    defaultCredential: "http://127.0.0.1:1234",
+    modelsEndpoint: "openai-compatible/models",
+    parseModelsResponse: (data) => data.data?.map((m: any) => m.id) ?? [],
+    requiresRunningCheck: false,
+    supportsKeepAlive: false,
+    keyConfig: {
+      placeholder: "http://127.0.0.1:1234",
+      inputType: "text",
+      description:
+        "Base URL for a local OpenAI-compatible server (LM Studio, llama.cpp, vLLM). Optional API key is set separately.",
+      sensitive: false,
+    },
+  },
+
   deepseek: {
     id: "deepseek",
     displayName: "DeepSeek",
@@ -117,7 +137,14 @@ export const PROVIDER_REGISTRY: Record<string, ProviderRegistryEntry> = {
   },
 };
 
-export const AI_PROVIDERS = ["ollama", "openai", "deepseek", "openrouter", "gemini"] as const;
+export const AI_PROVIDERS = [
+  "ollama",
+  "openai",
+  "openai-compatible",
+  "deepseek",
+  "openrouter",
+  "gemini",
+] as const;
 export type AiProviderId = (typeof AI_PROVIDERS)[number];
 
 export function getAiProviders(): ProviderRegistryEntry[] {
diff --git a/src/lib/ai/providers.ts b/src/lib/ai/providers.ts
index d88c6cfcf..233f44648 100644
--- a/src/lib/ai/providers.ts
+++ b/src/lib/ai/providers.ts
@@ -1,8 +1,18 @@
 import { resolveApiKey } from "@/lib/api-key-resolver";
 import { PROVIDER_REGISTRY } from "@/lib/ai/provider-registry";
-import { PROVIDER_FACTORIES } from "@/lib/ai/provider-registry.server";
+import {
+  openaiCompatibleRoot,
+  PROVIDER_FACTORIES,
+} from "@/lib/ai/provider-registry.server";
+import { createOpenAI } from "@ai-sdk/openai";
 
-export type ProviderType = "openai" | "ollama" | "deepseek" | "openrouter" | "gemini";
+export type ProviderType =
+  | "openai"
+  | "openai-compatible"
+  | "ollama"
+  | "deepseek"
+  | "openrouter"
+  | "gemini";
 
 export async function getModel(
   provider: ProviderType,
@@ -12,12 +22,28 @@ export async function getModel(
   const entry = PROVIDER_REGISTRY[provider];
   if (!entry) throw new Error(`Unknown AI provider: ${provider}`);
 
-  const factory = PROVIDER_FACTORIES[provider];
-  if (!factory) throw new Error(`No factory for provider: ${provider}`);
-
   const credential = await resolveApiKey(userId, provider);
   if (!credential)
     throw new Error(`${entry.displayName} credential not configured`);
 
+  if (provider === "openai-compatible") {
+    if (!modelName) {
+      throw new Error("Select a model for the OpenAI-compatible provider");
+    }
+    const apiKey = await resolveApiKey(userId, "openai-compatible-key");
+    const root = openaiCompatibleRoot(credential);
+    // Local OpenAI-compatible servers (llama.cpp, llama-swap, LM Studio)
+    // implement Chat Completions. createOpenAI()(model) uses the Responses
+    // API, whose stream (text-delta without text-start) fails in agent chat.
+    return createOpenAI({
+      baseURL: `${root}/v1`,
+      apiKey: apiKey || "",
+      name: "openai-compatible",
+    }).chat(modelName);
+  }
+
+  const factory = PROVIDER_FACTORIES[provider];
+  if (!factory) throw new Error(`No factory for provider: ${provider}`);
+
   return factory(credential, modelName);
 }
diff --git a/src/lib/api-key-resolver.ts b/src/lib/api-key-resolver.ts
index b582edf6a..7e8b562f1 100644
--- a/src/lib/api-key-resolver.ts
+++ b/src/lib/api-key-resolver.ts
@@ -4,6 +4,10 @@ import db from "@/lib/db";
 import { decrypt } from "@/lib/encryption";
 import { PROVIDER_REGISTRY } from "@/lib/ai/provider-registry";
 
+const EXTRA_ENV_VARS: Record<string, string> = {
+  "openai-compatible-key": "OPENAI_COMPAT_API_KEY",
+};
+
 export async function resolveApiKey(
   userId: string | undefined,
   provider: string,
@@ -35,6 +39,12 @@ export async function resolveApiKey(
     if (value) return value;
   }
 
+  const extraEnvVar = EXTRA_ENV_VARS[provider];
+  if (extraEnvVar) {
+    const value = process.env[extraEnvVar];
+    if (value) return value;
+  }
+
   if (entry?.defaultCredential) return entry.defaultCredential;
 
   return undefined;
diff --git a/src/lib/scraper/automation-run/aiSettings.ts b/src/lib/scraper/automation-run/aiSettings.ts
index 077f9cebd..80ff88281 100644
--- a/src/lib/scraper/automation-run/aiSettings.ts
+++ b/src/lib/scraper/automation-run/aiSettings.ts
@@ -29,6 +29,8 @@ export function getDefaultModelForProvider(provider: AiProvider): string {
       return OllamaModel.QWEN3_5_9B;
     case AiProvider.OPENAI:
       return OpenaiModel.GPT4O_MINI;
+    case AiProvider.OPENAI_COMPATIBLE:
+      throw new Error("Select a model for the OpenAI-compatible provider");
     case AiProvider.DEEPSEEK:
       return DeepseekModel.DEEPSEEK_CHAT;
     case AiProvider.GEMINI:
diff --git a/src/models/ai.model.ts b/src/models/ai.model.ts
index 2466faaad..906565f71 100644
--- a/src/models/ai.model.ts
+++ b/src/models/ai.model.ts
@@ -17,6 +17,7 @@ export interface AiModel {
 export enum AiProvider {
   OLLAMA = "ollama",
   OPENAI = "openai",
+  OPENAI_COMPATIBLE = "openai-compatible",
   DEEPSEEK = "deepseek",
   GEMINI = "gemini",
   OPENROUTER = "openrouter",
diff --git a/src/models/apiKey.model.ts b/src/models/apiKey.model.ts
index 3afc0aaeb..63692fe2c 100644
--- a/src/models/apiKey.model.ts
+++ b/src/models/apiKey.model.ts
@@ -1,4 +1,11 @@
-export type ApiKeyProvider = "openai" | "deepseek" | "openrouter" | "ollama";
+export type ApiKeyProvider =
+  | "openai"
+  | "openai-compatible"
+  // Optional API key for openai-compatible; not a real provider, avoids a schema change.
+  | "openai-compatible-key"
+  | "deepseek"
+  | "openrouter"
+  | "ollama";
 
 export interface ApiKeyRecord {
   id: string;
diff --git a/src/models/apiKey.schema.ts b/src/models/apiKey.schema.ts
index 997517067..65a8961f3 100644
--- a/src/models/apiKey.schema.ts
+++ b/src/models/apiKey.schema.ts
@@ -1,7 +1,15 @@
 import { z } from "zod";
 
 export const apiKeySaveSchema = z.object({
-  provider: z.enum(["openai", "deepseek", "openrouter", "ollama", "gemini"]),
+  provider: z.enum([
+    "openai",
+    "openai-compatible",
+    "openai-compatible-key",
+    "deepseek",
+    "openrouter",
+    "ollama",
+    "gemini",
+  ]),
   key: z.string().min(1, "API key is required"),
   label: z.string().optional(),
   sensitive: z.boolean().default(true),