feat: add Cerebras model provider support and SDK integration

- Add Cerebras to supported providers in README and config
- Add Cerebras icon and update icon utilities
- Integrate @cerebras/cerebras_cloud_sdk dependency
- Implement Cerebras model fetching and completion (streaming &
  non-streaming)
- Expose Cerebras in provider APIs and server logic
- Refactor debounce sync utility for dynamic import

Author: lancewilhelm

README.md

@@ -21,6 +21,7 @@ A clean and simple front-end for large-language models.
   - OpenAI
   - Gemini
   - Anthropic
+  - Cerebras
 - Themes and fun things
 
 ## Usage
@@ -44,6 +45,7 @@ To use a remote provider api for llm inference, you can set an environmental var
 - `NUXT_OPENAI_API_KEY` for OpenAI
 - `NUXT_GEMINI_API_KEY` for Gemini
 - `NUXT_ANTHROPIC_API_KEY` for Anthropic
+- `NUXT_CEREBRAS_API_KEY` for Cerebras
 
 ##### Example
 
@@ -100,6 +102,7 @@ AUTH_SECRET=
 OPENAI_API_KEY=
 GEMINI_API_KEY=
 ANTHROPIC_API_KEY=
+CEREBRAS_API_KEY=
 ```
 
 4. Run the app

app/assets/icons/cerebras.svg

@@ -7,6 +7,7 @@ export function getModelProviderIcon(provider?: string) {
     openai: "simple-icons:openai",
     anthropic: "simple-icons:anthropic",
     lmstudio: "local:lmstudio",
+    cerebras: "local:cerebras",
   };
   return modelIcons[provider] || "";
 }

app/utils/icon.ts

@@ -10,6 +10,7 @@ export const providers: ProviderMeta[] = [
   { id: "openai", displayName: "OpenAI", icon: "simple-icons:openai" },
   { id: "gemini", displayName: "Gemini", icon: "simple-icons:googlegemini" },
   { id: "anthropic", displayName: "Anthropic", icon: "simple-icons:anthropic" },
+  { id: "cerebras", displayName: "Cerebras", icon: "local:cerebras" },
   {
     id: "lmstudio",
     displayName: "LM Studio",

app/utils/llm/providers.ts

@@ -1,13 +1,24 @@
-import { useSyncStore } from "~/stores/sync";
 import { debounce } from "../debounce";
 
 const DEBOUNCE_MS = 500;
 
-const _triggerSync = () => {
-  const sync = useSyncStore();
-  if (!sync.isSyncing) {
-    sync.sync();
+let _debouncedSync: (() => void) | null = null;
+
+export const triggerDebouncedSync = () => {
+  // Lazy initialization to avoid store access during module load
+  if (!_debouncedSync) {
+    const _triggerSync = () => {
+      // Import store only when actually needed using dynamic import
+      import("~/stores/sync").then(({ useSyncStore }) => {
+        const sync = useSyncStore();
+        if (!sync.isSyncing) {
+          sync.sync();
+        }
+      });
+    };
+
+    _debouncedSync = debounce(_triggerSync, DEBOUNCE_MS);
   }
-};
 
-export const triggerDebouncedSync = debounce(_triggerSync, DEBOUNCE_MS);
+  _debouncedSync();
+};

app/utils/sync/debounce.ts

@@ -36,6 +36,7 @@ export default defineNuxtConfig({
     openaiApiKey: process.env.OPENAI_API_KEY || "",
     geminiApiKey: process.env.GEMINI_API_KEY || "",
     anthropicApiKey: process.env.ANTHROPIC_API_KEY || "",
+    cerebrasApiKey: process.env.CEREBRAS_API_KEY || "",
     public: {
       debug: false,
       appVersion: "",

nuxt.config.ts

@@ -20,6 +20,7 @@
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.40.1",
+    "@cerebras/cerebras_cloud_sdk": "^1.46.0",
     "@google/genai": "^0.12.0",
     "@lancedb/lancedb": "^0.19.0",
     "@libsql/client": "^0.15.4",

package.json

@@ -3,6 +3,8 @@ import { auth } from "@/utils/auth";
 import { globalSettings } from "~/utils/db/schema";
 import { and, eq, type InferSelectModel } from "drizzle-orm";
 import type { GlobalSettings } from "~/stores/globalSettings";
+import { getLMStudioClient } from "~~/server/utils/llm/completionLMStudio";
+import { cloudDb } from "~~/server/utils/db/cloud";
 
 export default defineEventHandler(async (event) => {
   logger.debug("GET /api/providers");
@@ -35,6 +37,10 @@ export default defineEventHandler(async (event) => {
   if (config.anthropicApiKey) {
     providers.push("anthropic");
   }
+  // Cerebras
+  if (config.cerebrasApiKey) {
+    providers.push("cerebras");
+  }
   // LM Studio
   const lmStudio = getLMStudioClient();
   const lmStudioVersion = await lmStudio.system.getLMStudioVersion();

pnpm-lock.yaml

@@ -0,0 +1,157 @@
+import { logger } from "~/utils/logger";
+import Cerebras from "@cerebras/cerebras_cloud_sdk";
+import type { LocalMessage, Usage, Model } from "~/utils/db/local";
+
+// Client generator
+export function getCerebrasClient() {
+  const config = useRuntimeConfig();
+  const apiKey = config.cerebrasApiKey;
+  if (!apiKey) {
+    throw new Error("Missing CEREBRAS_API_KEY");
+  }
+  return new Cerebras({ apiKey });
+}
+
+// Fetch models
+export async function fetchCerebrasModels() {
+  const cerebras = getCerebrasClient();
+
+  try {
+    const modelsList = await cerebras.models.list();
+    const models: Model[] = modelsList.data.map((model) => ({
+      name: model.id,
+      displayName:
+        model.id.charAt(0).toUpperCase() +
+        model.id.slice(1).replace(/[-.]/g, " "),
+      provider: "cerebras",
+    }));
+
+    return models;
+  } catch (error) {
+    logger.error(error, "GET /api/models/cerebras: Error fetching models");
+    throw new Error("Failed to fetch models");
+  }
+}
+
+// Non-streaming completion
+export async function completionCerebras({
+  history,
+  model,
+  systemPrompt,
+}: {
+  history: LocalMessage[];
+  model: string;
+  systemPrompt: string;
+}) {
+  const cerebras = getCerebrasClient();
+
+  try {
+    const formattedMessages = history.map((msg) => ({
+      role: msg.role as "user" | "assistant",
+      content: msg.content,
+    }));
+
+    const params = {
+      messages: [
+        { role: "system" as const, content: systemPrompt },
+        ...formattedMessages,
+      ],
+      model,
+    };
+
+    const completion = await cerebras.chat.completions.create(params);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const content = (completion as any).choices[0]?.message?.content;
+    return content;
+  } catch (error) {
+    logger.error(error, "Error getting completion from Cerebras");
+    throw new Error("Internal server error");
+  }
+}
+
+// Streaming completion
+export async function streamCerebras({
+  history,
+  model,
+  systemPrompt,
+}: {
+  history: LocalMessage[];
+  model: string;
+  systemPrompt: string;
+}): Promise<ReadableStream> {
+  const cerebras = getCerebrasClient();
+  const encoder = new TextEncoder();
+
+  const stream = new ReadableStream({
+    async start(controller) {
+      try {
+        const formattedMessages = [
+          { role: "system" as const, content: systemPrompt },
+          ...history.map((msg) => ({
+            role: msg.role as "user" | "assistant",
+            content: msg.content,
+          })),
+        ];
+
+        const queryStartTime = performance.now();
+        let timeToFirstToken = 0;
+        let responseStartTime = 0;
+
+        const completion = await cerebras.chat.completions.create({
+          model: model,
+          messages: formattedMessages,
+          stream: true,
+        });
+
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        let usageChunk: any;
+        for await (const chunk of completion) {
+          if (!timeToFirstToken) {
+            timeToFirstToken = performance.now() - queryStartTime;
+            responseStartTime = performance.now();
+          }
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          const text = (chunk as any).choices[0]?.delta?.content || "";
+          controller.enqueue(
+            encoder.encode(
+              `event: messageChunk\ndata: ${JSON.stringify(text)}\n\n`,
+            ),
+          );
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          if ((chunk as any).usage) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            usageChunk = (chunk as any).usage;
+          }
+        }
+
+        if (usageChunk) {
+          const completionTime = performance.now() - responseStartTime;
+          const usage: Usage | Partial<Usage> = {
+            promptTokens: usageChunk.prompt_tokens,
+            completionTokens: usageChunk.completion_tokens,
+            totalTokens: usageChunk.total_tokens,
+            completionTime,
+            tokensPerSecond:
+              (usageChunk.completion_tokens / completionTime) * 1000,
+            timeToFirstToken,
+            temperature: 1,
+          };
+          controller.enqueue(
+            encoder.encode(`event: usage\ndata: ${JSON.stringify(usage)}\n\n`),
+          );
+        }
+      } catch (error) {
+        logger.error(error, "Error streaming Cerebras");
+        controller.enqueue(
+          encoder.encode(
+            `event: error\ndata: Error streaming Cerebras: ${error}\n\n`,
+          ),
+        );
+      } finally {
+        controller.close();
+      }
+    },
+  });
+
+  return stream;
+}